自学教程：C++ syswarn函数代码示例

static intget_phys(void){	int padsz = 0;	int res;	int phyblk;	struct mtop mb;	char scbuf[MAXBLK];	/*	 * move to the file mark, and then back up one record and read it.	 * this should tell us the physical record size the tape is using.	 */	if (lstrval == 1) {		/*		 * we know we are at file mark when we get back a 0 from		 * read()		 */		while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)			padsz += res;		if (res < 0) {			syswarn(1, errno, "Unable to locate tape filemark.");			return(-1);		}	}	/*	 * move backwards over the file mark so we are at the end of the	 * last record.	 */	mb.mt_op = MTBSF;	mb.mt_count = 1;	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {		syswarn(1, errno, "Unable to backspace over tape filemark.");		return(-1);	}	/*	 * move backwards so we are in front of the last record and read it to	 * get physical tape blocksize.	 */	mb.mt_op = MTBSR;	mb.mt_count = 1;	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {		syswarn(1, errno, "Unable to backspace over last tape block.");		return(-1);	}	if ((phyblk = read(arfd, scbuf, sizeof(scbuf))) <= 0) {		syswarn(1, errno, "Cannot determine archive tape blocksize.");		return(-1);	}	/*	 * read forward to the file mark, then back up in front of the filemark	 * (this is a bit paranoid, but should be safe to do).	 */	while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)		;	if (res < 0) {		syswarn(1, errno, "Unable to locate tape filemark.");		return(-1);	}	mb.mt_op = MTBSF;	mb.mt_count = 1;	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {		syswarn(1, errno, "Unable to backspace over tape filemark.");		return(-1);	}	/*	 * set lstrval so we know that the filemark has not been seen	 */	lstrval = 1;	/*	 * return if there was no padding	 */	if (padsz == 0)		return(phyblk);	/*	 * make sure we can move backwards over the padding. (this should	 * never fail).	 */	if (padsz % phyblk) {		paxwarn(1, "Tape drive unable to backspace requested amount");		return(-1);	}	/*	 * move backwards over the padding so the head is where it was when	 * we were first called (if required).	 */	mb.mt_op = MTBSR;	mb.mt_count = padsz/phyblk;	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {		syswarn(1,errno,"Unable to backspace tape over %d pad blocks",		    mb.mt_count);		return(-1);	}//.........这里部分代码省略.........

intar_open(const char *name){	struct mtget mb;	if (arfd != -1)		(void)close(arfd);	arfd = -1;	can_unlnk = did_io = io_ok = invld_rec = 0;	artyp = ISREG;	flcnt = 0;	/*	 * open based on overall operation mode	 */	switch (act) {	case LIST:	case EXTRACT:		if (name == NULL) {			arfd = STDIN_FILENO;			arcname = stdn;		} else if ((arfd = open(name, EXT_MODE, DMOD)) < 0)			syswarn(0, errno, "Failed open to read on %s", name);		if (arfd != -1 && gzip_program != NULL)			ar_start_gzip(arfd, gzip_program, 0);		break;	case ARCHIVE:		if (name == NULL) {			arfd = STDOUT_FILENO;			arcname = stdo;		} else if ((arfd = open(name, AR_MODE, DMOD)) < 0)			syswarn(0, errno, "Failed open to write on %s", name);		else			can_unlnk = 1;		if (arfd != -1 && gzip_program != NULL)			ar_start_gzip(arfd, gzip_program, 1);		break;	case APPND:		if (name == NULL) {			arfd = STDOUT_FILENO;			arcname = stdo;		} else if ((arfd = open(name, APP_MODE, DMOD)) < 0)			syswarn(0, errno, "Failed open to read/write on %s",				name);		break;	case COPY:		/*		 * arfd not used in COPY mode		 */		arcname = none;		lstrval = 1;		return(0);	}	if (arfd < 0)		return(-1);	if (chdname != NULL)		if (chdir(chdname) != 0) {			syswarn(1, errno, "Failed chdir to %s", chdname);			return(-1);		}	/*	 * set up is based on device type	 */	if (fstat(arfd, &arsb) < 0) {		syswarn(0, errno, "Failed stat on %s", arcname);		(void)close(arfd);		arfd = -1;		can_unlnk = 0;		return(-1);	}	if (S_ISDIR(arsb.st_mode)) {		paxwarn(0, "Cannot write an archive on top of a directory %s",		    arcname);		(void)close(arfd);		arfd = -1;		can_unlnk = 0;		return(-1);	}	if (S_ISCHR(arsb.st_mode))		artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE;	else if (S_ISBLK(arsb.st_mode))		artyp = ISBLK;	else if ((lseek(arfd, (off_t)0L, SEEK_CUR) == -1) && (errno == ESPIPE))		artyp = ISPIPE;	else		artyp = ISREG;	/*	 * make sure we beyond any doubt that we only can unlink regular files	 * we created	 */	if (artyp != ISREG)		can_unlnk = 0;	/*	 * if we are writing, we are done	 */	if (act == ARCHIVE) {		blksz = rdblksz = wrblksz;//.........这里部分代码省略.........

static intgen_init(void){	struct rlimit reslimit;	struct sigaction n_hand;	struct sigaction o_hand;	/*	 * Really needed to handle large archives. We can run out of memory for	 * internal tables really fast when we have a whole lot of files...	 */	if (getrlimit(RLIMIT_DATA , &reslimit) == 0){		reslimit.rlim_cur = reslimit.rlim_max;		(void)setrlimit(RLIMIT_DATA , &reslimit);	}	/*	 * should file size limits be waived? if the os limits us, this is	 * needed if we want to write a large archive	 */	if (getrlimit(RLIMIT_FSIZE , &reslimit) == 0){		reslimit.rlim_cur = reslimit.rlim_max;		(void)setrlimit(RLIMIT_FSIZE , &reslimit);	}	/*	 * increase the size the stack can grow to	 */	if (getrlimit(RLIMIT_STACK , &reslimit) == 0){		reslimit.rlim_cur = reslimit.rlim_max;		(void)setrlimit(RLIMIT_STACK , &reslimit);	}	/*	 * not really needed, but doesn't hurt	 */	if (getrlimit(RLIMIT_RSS , &reslimit) == 0){		reslimit.rlim_cur = reslimit.rlim_max;		(void)setrlimit(RLIMIT_RSS , &reslimit);	}	/*	 * signal handling to reset stored directory times and modes. Since	 * we deal with broken pipes via failed writes we ignore it. We also	 * deal with any file size limit thorough failed writes. Cpu time	 * limits are caught and a cleanup is forced.	 */	if ((sigemptyset(&s_mask) < 0) || (sigaddset(&s_mask, SIGTERM) < 0) ||	    (sigaddset(&s_mask,SIGINT) < 0)||(sigaddset(&s_mask,SIGHUP) < 0) ||	    (sigaddset(&s_mask,SIGPIPE) < 0)||(sigaddset(&s_mask,SIGQUIT)<0) ||	    (sigaddset(&s_mask,SIGXCPU) < 0)||(sigaddset(&s_mask,SIGXFSZ)<0)) {		paxwarn(1, "Unable to set up signal mask");		return(-1);	}	memset(&n_hand, 0, sizeof n_hand);	n_hand.sa_mask = s_mask;	n_hand.sa_flags = 0;	n_hand.sa_handler = sig_cleanup;	if ((sigaction(SIGHUP, &n_hand, &o_hand) < 0) &&	    (o_hand.sa_handler == SIG_IGN) &&	    (sigaction(SIGHUP, &o_hand, &o_hand) < 0))		goto out;	if ((sigaction(SIGTERM, &n_hand, &o_hand) < 0) &&	    (o_hand.sa_handler == SIG_IGN) &&	    (sigaction(SIGTERM, &o_hand, &o_hand) < 0))		goto out;	if ((sigaction(SIGINT, &n_hand, &o_hand) < 0) &&	    (o_hand.sa_handler == SIG_IGN) &&	    (sigaction(SIGINT, &o_hand, &o_hand) < 0))		goto out;	if ((sigaction(SIGQUIT, &n_hand, &o_hand) < 0) &&	    (o_hand.sa_handler == SIG_IGN) &&	    (sigaction(SIGQUIT, &o_hand, &o_hand) < 0))		goto out;	if ((sigaction(SIGXCPU, &n_hand, &o_hand) < 0) &&	    (o_hand.sa_handler == SIG_IGN) &&	    (sigaction(SIGXCPU, &o_hand, &o_hand) < 0))		goto out;	n_hand.sa_handler = SIG_IGN;	if ((sigaction(SIGPIPE, &n_hand, &o_hand) < 0) ||	    (sigaction(SIGXFSZ, &n_hand, &o_hand) < 0))		goto out;	return(0);    out:	syswarn(1, errno, "Unable to set up signal handler");	return(-1);}

intnext_file(ARCHD *arcn){    int cnt;    time_t atime;    time_t mtime;    /*     * ftree_sel() might have set the ftree_skip flag if the user has the     * -n option and a file was selected from this file arg tree. (-n says     * only one member is matched for each pattern) ftree_skip being 1     * forces us to go to the next arg now.     */    if (ftree_skip) {        /*         * clear and go to next arg         */        ftree_skip = 0;        if (ftree_arg() < 0)            return(-1);    }    /*     * loop until we get a valid file to process     */    for (;;) {        if ((ftent = fts_read(ftsp)) == NULL) {            if (errno)                syswarn(1, errno, "next_file");            /*             * out of files in this tree, go to next arg, if none             * we are done             */            if (ftree_arg() < 0)                return(-1);            continue;        }        /*         * handle each type of fts_read() flag         */        switch (ftent->fts_info) {        case FTS_D:        case FTS_DEFAULT:        case FTS_F:        case FTS_SL:        case FTS_SLNONE:            /*             * these are all ok             */            break;        case FTS_DP:            /*             * already saw this directory. If the user wants file             * access times reset, we use this to restore the             * access time for this directory since this is the             * last time we will see it in this file subtree             * remember to force the time (this is -t on a read             * directory, not a created directory).             */            if (!tflag || (get_atdir(ftent->fts_statp->st_dev,                                     ftent->fts_statp->st_ino, &mtime, &atime) < 0))                continue;            set_ftime(ftent->fts_path, mtime, atime, 1);            continue;        case FTS_DC:            /*             * fts claims a file system cycle             */            paxwarn(1,"File system cycle found at %s",ftent->fts_path);            continue;        case FTS_DNR:            syswarn(1, ftent->fts_errno,                    "Unable to read directory %s", ftent->fts_path);            continue;        case FTS_ERR:            syswarn(1, ftent->fts_errno,                    "File system traversal error");            continue;        case FTS_NS:        case FTS_NSOK:            syswarn(1, ftent->fts_errno,                    "Unable to access %s", ftent->fts_path);            continue;        }        /*         * ok got a file tree node to process. copy info into arcn         * structure (initialize as required)         */        arcn->skip = 0;        arcn->pad = 0;        arcn->ln_nlen = 0;        arcn->ln_name[0] = '/0';        memcpy(&arcn->sb, ftent->fts_statp, sizeof(arcn->sb));        /*         * file type based set up and copy into the arcn struct         * SIDE NOTE:         * we try to reset the access time on all files and directories//.........这里部分代码省略.........

static intmk_link(char *to, struct stat *to_sb, char *from, int ign){	struct stat sb;	int oerrno;	/*	 * if from file exists, it has to be unlinked to make the link. If the	 * file exists and -k is set, skip it quietly	 */	if (lstat(from, &sb) == 0) {		if (kflag)			return(0);		/*		 * make sure it is not the same file, protect the user		 */		if ((to_sb->st_dev==sb.st_dev)&&(to_sb->st_ino == sb.st_ino)) {			paxwarn(1, "Unable to link file %s to itself", to);			return(-1);;		}		/*		 * try to get rid of the file, based on the type		 */		if (S_ISDIR(sb.st_mode)) {			if (rmdir(from) < 0) {				syswarn(1, errno, "Unable to remove %s", from);				return(-1);			}		} else if (unlink(from) < 0) {			if (!ign) {				syswarn(1, errno, "Unable to remove %s", from);				return(-1);			}			return(1);		}	}	/*	 * from file is gone (or did not exist), try to make the hard link.	 * if it fails, check the path and try it again (if chk_path() says to	 * try again)	 */	for (;;) {		if (link(to, from) == 0)			break;		oerrno = errno;		if (!nodirs && chk_path(from, to_sb->st_uid, to_sb->st_gid) == 0)			continue;		if (!ign) {			syswarn(1, oerrno, "Could not link to %s from %s", to,			    from);			return(-1);		}		return(1);	}	/*	 * all right the link was made	 */	return(0);}

intfile_write(int fd, char *str, int cnt, int *rem, int *isempt, int sz,	char *name){	char *pt;	char *end;	int wcnt;	char *st = str;	/*	 * while we have data to process	 */	while (cnt) {		if (!*rem) {			/*			 * We are now at the start of file system block again			 * (or what we think one is...). start looking for			 * empty blocks again			 */			*isempt = 1;			*rem = sz;		}		/*		 * only examine up to the end of the current file block or		 * remaining characters to write, whatever is smaller		 */		wcnt = MIN(cnt, *rem);		cnt -= wcnt;		*rem -= wcnt;		if (*isempt) {			/*			 * have not written to this block yet, so we keep			 * looking for zero's			 */			pt = st;			end = st + wcnt;			/*			 * look for a zero filled buffer			 */			while ((pt < end) && (*pt == '/0'))				++pt;			if (pt == end) {				/*				 * skip, buf is empty so far				 */				if (fd > -1 &&				    lseek(fd, (off_t)wcnt, SEEK_CUR) < 0) {					syswarn(1,errno,"File seek on %s",					    name);					return(-1);				}				st = pt;				continue;			}			/*			 * drat, the buf is not zero filled			 */			*isempt = 0;		}		/*		 * have non-zero data in this file system block, have to write		 */		if (fd == -1) {			/* GNU hack */			if (gnu_hack_string)				err(1, "WARNING! Major Internal Error! GNU hack Failing!");			gnu_hack_string = malloc(wcnt + 1);			if (gnu_hack_string == NULL) {				paxwarn(1, "Out of memory");				return(-1);			}			memcpy(gnu_hack_string, st, wcnt);			gnu_hack_string[wcnt] = '/0';		} else if (write(fd, st, wcnt) != wcnt) {			syswarn(1, errno, "Failed write to file %s", name);			return(-1);		}		st += wcnt;	}	return(st - str);}

intchk_ftime(ARCHD *arcn){	FTM *pt;	int namelen;	u_int indx;	char ckname[PAXPATHLEN+1];	/*	 * no info, go ahead and add to archive	 */	if (ftab == NULL)		return(0);	/*	 * hash the pathname and look up in table	 */	namelen = arcn->nlen;	indx = st_hash(arcn->name, namelen, F_TAB_SZ);	if ((pt = ftab[indx]) != NULL) {		/*		 * the hash chain is not empty, walk down looking for match		 * only read up the path names if the lengths match, speeds		 * up the search a lot		 */		while (pt != NULL) {			if (pt->namelen == namelen) {				/*				 * potential match, have to read the name				 * from the scratch file.				 */				if (lseek(ffd,pt->seek,SEEK_SET) != pt->seek) {					syswarn(1, errno,					    "Failed ftime table seek");					return(-1);				}				if (read(ffd, ckname, namelen) != namelen) {					syswarn(1, errno,					    "Failed ftime table read");					return(-1);				}				/*				 * if the names match, we are done				 */				if (!strncmp(ckname, arcn->name, namelen))					break;			}			/*			 * try the next entry on the chain			 */			pt = pt->fow;		}		if (pt != NULL) {			/*			 * found the file, compare the times, save the newer			 */			if (arcn->sb.st_mtime > pt->mtime) {				/*				 * file is newer				 */				pt->mtime = arcn->sb.st_mtime;				return(0);			}			/*			 * file is older			 */			return(1);		}	}	/*	 * not in table, add it	 */	if ((pt = (FTM *)malloc(sizeof(FTM))) != NULL) {		/*		 * add the name at the end of the scratch file, saving the		 * offset. add the file to the head of the hash chain		 */		if ((pt->seek = lseek(ffd, (off_t)0, SEEK_END)) >= 0) {			if (write(ffd, arcn->name, namelen) == namelen) {				pt->mtime = arcn->sb.st_mtime;				pt->namelen = namelen;				pt->fow = ftab[indx];				ftab[indx] = pt;				return(0);			}			syswarn(1, errno, "Failed write to file time table");		} else			syswarn(1, errno, "Failed seek on file time table");	} else		paxwarn(1, "File time table ran out of memory");	if (pt != NULL)		free(pt);	return(-1);}

intrd_wrfile(ARCHD *arcn, int ofd, off_t *left){    int cnt = 0;    off_t size = arcn->sb.st_size;    int res = 0;    char *fnm = arcn->name;    int isem = 1;    int rem;    int sz = MINFBSZ;    struct stat sb;    u_long crc = 0L;    /*     * pass the blocksize of the file being written to the write routine,     * if the size is zero, use the default MINFBSZ     */    if (fstat(ofd, &sb) == 0) {        if (sb.st_blksize > 0)            sz = (int)sb.st_blksize;    } else        syswarn(0,errno,"Unable to obtain block size for file %s",fnm);    rem = sz;    *left = 0L;    /*     * Copy the archive to the file the number of bytes specified. We have     * to assume that we want to recover file holes as none of the archive     * formats can record the location of file holes.     */    while (size > 0L) {        cnt = bufend - bufpt;        /*         * if we get a read error, we do not want to skip, as we may         * miss a header, so we do not set left, but if we get a write         * error, we do want to skip over the unprocessed data.         */        if ((cnt <= 0) && ((cnt = buf_fill()) <= 0))            break;        cnt = MIN(cnt, size);        if ((res = file_write(ofd,bufpt,cnt,&rem,&isem,sz,fnm)) <= 0) {            *left = size;            break;        }        if (docrc) {            /*             * update the actual crc value             */            cnt = res;            while (--cnt >= 0)                crc += *bufpt++ & 0xff;        } else            bufpt += res;        size -= res;    }    /*     * if the last block has a file hole (all zero), we must make sure this     * gets updated in the file. We force the last block of zeros to be     * written. just closing with the file offset moved forward may not put     * a hole at the end of the file.     */    if (isem && (arcn->sb.st_size > 0L))        file_flush(ofd, fnm, isem);    /*     * if we failed from archive read, we do not want to skip     */    if ((size > 0L) && (*left == 0L))        return(-1);    /*     * some formats record a crc on file data. If so, then we compare the     * calculated crc to the crc stored in the archive     */    if (docrc && (size == 0L) && (arcn->crc != crc))        paxwarn(1,"Actual crc does not match expected crc %s",arcn->name);    return(0);}

//.........这里部分代码省略.........		case FTS_SL:		case FTS_SLNONE:			/*			 * these are all ok			 */			break;		case FTS_DP:			/*			 * already saw this directory. If the user wants file			 * access times reset, we use this to restore the			 * access time for this directory since this is the			 * last time we will see it in this file subtree			 * remember to force the time (this is -t on a read			 * directory, not a created directory).			 */			if (!tflag || (get_atdir(#ifdef NET2_FTS			    ftent->fts_statb.st_dev, ftent->fts_statb.st_ino,#else			    ftent->fts_statp->st_dev, ftent->fts_statp->st_ino,#endif			    &mtime, &atime) < 0))				continue;			set_ftime(ftent->fts_path, mtime, atime, 1);			continue;		case FTS_DC:			/*			 * fts claims a file system cycle			 */			tty_warn(1,"File system cycle found at %s",			    ftent->fts_path);			continue;		case FTS_DNR:			syswarn(1, FTS_ERRNO(ftent),			    "Unable to read directory %s", ftent->fts_path);			continue;		case FTS_ERR:			syswarn(1, FTS_ERRNO(ftent),			    "File system traversal error");			continue;		case FTS_NS:		case FTS_NSOK:			syswarn(1, FTS_ERRNO(ftent),			    "Unable to access %s", ftent->fts_path);			continue;		}#ifndef SMALL got_ftent:#endif	/* SMALL */		/*		 * ok got a file tree node to process. copy info into arcn		 * structure (initialize as required)		 */		arcn->skip = 0;		arcn->pad = 0;		arcn->ln_nlen = 0;		arcn->ln_name[0] = '/0';#ifdef NET2_FTS		arcn->sb = ftent->fts_statb;#else		arcn->sb = *(ftent->fts_statp);#endif		/*		 * file type based set up and copy into the arcn struct

/* * A wrapper around fwrite that checks the return status and reports an error * if the write failed.  This is probably futile for stderr, since reporting * the error will probably also fail, but we can try. */static voidfwrite_checked(const void *data, size_t size, size_t nmemb, FILE *stream){    if (fwrite(data, size, nmemb, stream) != nmemb)        syswarn("local write of command output failed");}

intmain(int argc, char **argv){	const char *tmpdir;	size_t tdlen;	/* may not be a constant, thus initialising early */	listf = stderr;	now = time(NULL);	/*	 * Keep a reference to cwd, so we can always come back home.	 */	cwdfd = binopen2(BO_CLEXEC, ".", O_RDONLY);	if (cwdfd < 0) {		syswarn(1, errno, "Cannot open current working directory.");		return(exit_val);	}	/*	 * Where should we put temporary files?	 */	if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '/0')		tmpdir = _PATH_TMP;	tdlen = strlen(tmpdir);	while (tdlen > 0 && tmpdir[tdlen - 1] == '/')		tdlen--;	tempfile = malloc(tdlen + 1 + sizeof(_TFILE_BASE));	if (tempfile == NULL) {		paxwarn(1, "%s for %s", "Out of memory",		    "temp file name");		return (exit_val);	}	if (tdlen)		memcpy(tempfile, tmpdir, tdlen);	tempbase = tempfile + tdlen;	*tempbase++ = '/';#if HAVE_SETPGENT	/*	 * keep passwd and group files open for faster lookups.	 */	setpassent(1);	setgroupent(1);#endif	/*	 * parse options, determine operational mode, general init	 */	options(argc, argv);	if ((gen_init() < 0) || (tty_init() < 0))		return(exit_val);#if HAVE_PLEDGE	/*	 * pmode needs to restore setugid bits when extracting or copying,	 * so can't pledge at all then.	 */	if (pmode == 0 || (act != EXTRACT && act != COPY)) {		if (pledge("stdio rpath wpath cpath fattr dpath getpw proc exec tape",		    NULL) == -1)			err(1, "pledge");		/* Copy mode, or no gzip -- don't need to fork/exec. */		if (compress_program == NULL || act == COPY) {			if (pledge("stdio rpath wpath cpath fattr dpath getpw tape",			    NULL) == -1)				err(1, "pledge");		}	}#endif	/* make list fd independent and line-buffered */	if ((listfd = dup(fileno(listf))) < 0 ||	    !(listf = fdopen(listfd, "wb"))) {		syswarn(1, errno, "Cannot open list file descriptor");		return (exit_val);	}	if (fcntl(listfd, F_SETFD, FD_CLOEXEC) == -1)		syswarn(0, errno, "%s on list file descriptor",		    "Failed to set the close-on-exec flag");	setlinebuf(listf);	/*	 * select a primary operation mode	 */	switch (act) {	case EXTRACT:		extract();		break;	case ARCHIVE:		archive();		break;	case APPND:		if (compress_program != NULL)			errx(1, "cannot compress while appending");		append();		break;	case COPY://.........这里部分代码省略.........

/* * Take the amount of memory to allocate in bytes as a command-line argument * and call test_malloc with that amount of memory. */intmain(int argc, char *argv[]){    size_t size, max;    size_t limit = 0;    int willfail = 0;    unsigned char code;    if (argc < 3)        die("Usage error.  Type, size, and limit must be given.");    errno = 0;    size = strtol(argv[2], 0, 10);    if (size == 0 && errno != 0)        sysdie("Invalid size");    errno = 0;    limit = strtol(argv[3], 0, 10);    if (limit == 0 && errno != 0)        sysdie("Invalid limit");    /* If the code is capitalized, install our customized error handler. */    code = argv[1][0];    if (isupper(code)) {        xmalloc_error_handler = test_handler;        code = tolower(code);    }    /*     * Decide if the allocation should fail.  If it should, set willfail to 2,     * so that if it unexpectedly succeeds, we exit with a status indicating     * that the test should be skipped.     */    max = size;    if (code == 's' || code == 'n' || code == 'a' || code == 'v') {        max += size;        if (limit > 0)            limit += size;    }    if (limit > 0 && max > limit)        willfail = 2;    /*     * If a memory limit was given and we can set memory limits, set it.     * Otherwise, exit 2, signalling to the driver that the test should be     * skipped.  We do this here rather than in the driver due to some     * pathological problems with Linux (setting ulimit in the shell caused     * the shell to die).     */    if (limit > 0) {#if HAVE_SETRLIMIT && defined(RLIMIT_AS)        struct rlimit rl;        void *tmp;        size_t test_size;        rl.rlim_cur = limit;        rl.rlim_max = limit;        if (setrlimit(RLIMIT_AS, &rl) < 0) {            syswarn("Can't set data limit to %lu", (unsigned long) limit);            exit(2);        }        if (size < limit || code == 'r' || code == 'y') {            test_size = (code == 'r' || code == 'y') ? 10 : size;            if (test_size == 0)                test_size = 1;            tmp = malloc(test_size);            if (tmp == NULL) {                syswarn("Can't allocate initial memory of %lu (limit %lu)",                        (unsigned long) test_size, (unsigned long) limit);                exit(2);            }            free(tmp);        }#else        warn("Data limits aren't supported.");        exit(2);#endif    }    switch (code) {    case 'c': exit(test_calloc(size) ? willfail : 1);    case 'm': exit(test_malloc(size) ? willfail : 1);    case 'r': exit(test_realloc(size) ? willfail : 1);    case 'y': exit(test_reallocarray(4, size / 4) ? willfail : 1);    case 's': exit(test_strdup(size) ? willfail : 1);    case 'n': exit(test_strndup(size) ? willfail : 1);    case 'a': exit(test_asprintf(size) ? willfail : 1);    case 'v': exit(test_vasprintf(size) ? willfail : 1);    default:        die("Unknown mode %c", argv[1][0]);        break;    }    exit(1);}

intlist(void){	ARCHD *arcn;	int res;	time_t now;	arcn = &archd;	/*	 * figure out archive type; pass any format specific options to the	 * archive option processing routine; call the format init routine. We	 * also save current time for ls_list() so we do not make a system	 * call for each file we need to print. If verbose (vflag) start up	 * the name and group caches.	 */	if ((get_arc() < 0) || ((*frmt->options)() < 0) ||	    ((*frmt->st_rd)() < 0))		return 1;	now = time(NULL);	/*	 * step through the archive until the format says it is done	 */	while (next_head(arcn) == 0) {		if (arcn->type == PAX_GLL || arcn->type == PAX_GLF) {			/*			 * we need to read, to get the real filename			 */			off_t cnt;			if (!(*frmt->rd_data)(arcn, -arcn->type, &cnt))				(void)rd_skip(cnt + arcn->pad);			continue;		}		/*		 * check for pattern, and user specified options match.		 * When all patterns are matched we are done.		 */		if ((res = pat_match(arcn)) < 0)			break;		if ((res == 0) && (sel_chk(arcn) == 0)) {			/*			 * pattern resulted in a selected file			 */			if (pat_sel(arcn) < 0)				break;			/*			 * modify the name as requested by the user if name			 * survives modification, do a listing of the file			 */			if ((res = mod_name(arcn, RENM)) < 0)				break;			if (res == 0) {				if (arcn->name[0] == '/' && !check_Aflag()) {					memmove(arcn->name, arcn->name + 1, 					    strlen(arcn->name));				}				ls_list(arcn, now, stdout);			}			/*			 * if there's an error writing to stdout then we must			 * stop now -- we're probably writing to a pipe that			 * has been closed by the reader.			 */			if (ferror(stdout)) {				syswarn(1, errno, "Listing incomplete.");				break;			}		}		/*		 * skip to next archive format header using values calculated		 * by the format header read routine		 */		if (rd_skip(arcn->skip + arcn->pad) == 1)			break;	}	/*	 * all done, let format have a chance to cleanup, and make sure that	 * the patterns supplied by the user were all matched	 */	(void)(*frmt->end_rd)();	(void)sigprocmask(SIG_BLOCK, &s_mask, NULL);	ar_close();	pat_chk();	return 0;}

static voidwr_archive(ARCHD *arcn, int is_app){    int res;    int hlk;    int wr_one;    off_t cnt;    int (*wrf)();    int fd = -1;    time_t now;    /*     * if this format supports hard link storage, start up the database     * that detects them.     */    if (((hlk = frmt->hlk) == 1) && (lnk_start() < 0))        return;    /*     * start up the file traversal code and format specific write     */    if ((ftree_start() < 0) || ((*frmt->st_wr)() < 0))        return;    wrf = frmt->wr;    /*     * When we are doing interactive rename, we store the mapping of names     * so we can fix up hard links files later in the archive.     */    if (iflag && (name_start() < 0))        return;    /*     * if this is not append, and there are no files, we do not write a     * trailer     */    wr_one = is_app;    now = time(NULL);    /*     * while there are files to archive, process them one at at time     */    while (next_file(arcn) == 0) {        /*         * check if this file meets user specified options match.         */        if (sel_chk(arcn) != 0)            continue;        fd = -1;        if (uflag) {            /*             * only archive if this file is newer than a file with             * the same name that is already stored on the archive             */            if ((res = chk_ftime(arcn)) < 0)                break;            if (res > 0)                continue;        }        /*         * this file is considered selected now. see if this is a hard         * link to a file already stored         */        ftree_sel(arcn);        if (hlk && (chk_lnk(arcn) < 0))            break;        if ((arcn->type == PAX_REG) || (arcn->type == PAX_HRG) ||                (arcn->type == PAX_CTG)) {            /*             * we will have to read this file. by opening it now we             * can avoid writing a header to the archive for a file             * we were later unable to read (we also purge it from             * the link table).             */            if ((fd = open(arcn->org_name, O_RDONLY, 0)) < 0) {                syswarn(1,errno, "Unable to open %s to read",                        arcn->org_name);                purg_lnk(arcn);                continue;            }        }        /*         * Now modify the name as requested by the user         */        if ((res = mod_name(arcn)) < 0) {            /*             * name modification says to skip this file, close the             * file and purge link table entry             */            rdfile_close(arcn, &fd);            purg_lnk(arcn);            break;        }        if ((res > 0) || (docrc && (set_crc(arcn, fd) < 0))) {            /*//.........这里部分代码省略.........

voidcp_file(ARCHD *arcn, int fd1, int fd2){    int cnt;    off_t cpcnt = 0L;    int res = 0;    char *fnm = arcn->name;    int no_hole = 0;    int isem = 1;    int rem;    int sz = MINFBSZ;    struct stat sb;    /*     * check for holes in the source file. If none, we will use regular     * write instead of file write.     */    if (((off_t)(arcn->sb.st_blocks * BLKMULT)) >= arcn->sb.st_size)        ++no_hole;    /*     * pass the blocksize of the file being written to the write routine,     * if the size is zero, use the default MINFBSZ     */    if (fstat(fd2, &sb) == 0) {        if (sb.st_blksize > 0)            sz = sb.st_blksize;    } else        syswarn(0,errno,"Unable to obtain block size for file %s",fnm);    rem = sz;    /*     * read the source file and copy to destination file until EOF     */    for(;;) {        if ((cnt = read(fd1, buf, blksz)) <= 0)            break;        if (no_hole)            res = write(fd2, buf, cnt);        else            res = file_write(fd2, buf, cnt, &rem, &isem, sz, fnm);        if (res != cnt)            break;        cpcnt += cnt;    }    /*     * check to make sure the copy is valid.     */    if (res < 0)        syswarn(1, errno, "Failed write during copy of %s to %s",                arcn->org_name, arcn->name);    else if (cpcnt != arcn->sb.st_size)        paxwarn(1, "File %s changed size during copy to %s",                arcn->org_name, arcn->name);    else if (fstat(fd1, &sb) < 0)        syswarn(1, errno, "Failed stat of %s", arcn->org_name);    else if (arcn->sb.st_mtime != sb.st_mtime)        paxwarn(1, "File %s was modified during copy to %s",                arcn->org_name, arcn->name);    /*     * if the last block has a file hole (all zero), we must make sure this     * gets updated in the file. We force the last block of zeros to be     * written. just closing with the file offset moved forward may not put     * a hole at the end of the file.     */    if (!no_hole && isem && (arcn->sb.st_size > 0L))        file_flush(fd2, fnm, isem);    return;}

voidcopy(void){    ARCHD *arcn;    int res;    int fddest;    char *dest_pt;    int dlen;    int drem;    int fdsrc = -1;    struct stat sb;    ARCHD archd;    char dirbuf[PAXPATHLEN+1];    arcn = &archd;    /*     * set up the destination dir path and make sure it is a directory. We     * make sure we have a trailing / on the destination     */    dlen = strlcpy(dirbuf, dirptr, sizeof(dirbuf));    if (dlen >= sizeof(dirbuf) ||            (dlen == sizeof(dirbuf) - 1 && dirbuf[dlen - 1] != '/')) {        paxwarn(1, "directory name is too long %s", dirptr);        return;    }    dest_pt = dirbuf + dlen;    if (*(dest_pt-1) != '/') {        *dest_pt++ = '/';        *dest_pt = '/0';        ++dlen;    }    drem = PAXPATHLEN - dlen;    if (stat(dirptr, &sb) < 0) {        syswarn(1, errno, "Cannot access destination directory %s",                dirptr);        return;    }    if (!S_ISDIR(sb.st_mode)) {        paxwarn(1, "Destination is not a directory %s", dirptr);        return;    }    /*     * start up the hard link table; file traversal routines and the     * modification time and access mode database     */    if ((lnk_start() < 0) || (ftree_start() < 0) || (dir_start() < 0))        return;    /*     * When we are doing interactive rename, we store the mapping of names     * so we can fix up hard links files later in the archive.     */    if (iflag && (name_start() < 0))        return;    /*     * set up to cp file trees     */    cp_start();    /*     * while there are files to archive, process them     */    while (next_file(arcn) == 0) {        fdsrc = -1;        /*         * check if this file meets user specified options         */        if (sel_chk(arcn) != 0)            continue;        /*         * if there is already a file in the destination directory with         * the same name and it is newer, skip the one stored on the         * archive.         * NOTE: this test is done BEFORE name modifications as         * specified by pax. this can be confusing to the user who         * might expect the test to be done on an existing file AFTER         * the name mod. In honesty the pax spec is probably flawed in         * this respect         */        if (uflag || Dflag) {            /*             * create the destination name             */            if (strlcpy(dest_pt, arcn->name + (*arcn->name == '/'),                        drem + 1) > drem) {                paxwarn(1, "Destination pathname too long %s",                        arcn->name);                continue;            }            /*             * if existing file is same age or newer skip             */            res = lstat(dirbuf, &sb);            *dest_pt = '/0';//.........这里部分代码省略.........

intar_next(void){	static char *arcbuf;	char buf[PAXPATHLEN+2];	sigset_t o_mask;	/*	 * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so	 * things like writing EOF etc will be done) (Watch out ar_close() can	 * also be called via a signal handler, so we must prevent a race.	 */	if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) < 0)		syswarn(0, errno, "Unable to set signal mask");	ar_close();	if (sigprocmask(SIG_SETMASK, &o_mask, NULL) < 0)		syswarn(0, errno, "Unable to restore signal mask");	if (done || !wr_trail || strcmp(NM_TAR, argv0) == 0)		return(-1);	tty_prnt("/nATTENTION! %s archive volume change required./n", argv0);	/*	 * if i/o is on stdin or stdout, we cannot reopen it (we do not know	 * the name), the user will be forced to type it in.	 */	if (strcmp(arcname, stdo) && strcmp(arcname, stdn) && (artyp != ISREG)	    && (artyp != ISPIPE)) {		if (artyp == ISTAPE) {			tty_prnt("%s ready for archive tape volume: %d/n",				arcname, arvol);			tty_prnt("Load the NEXT TAPE on the tape drive");		} else {			tty_prnt("%s ready for archive volume: %d/n",				arcname, arvol);			tty_prnt("Load the NEXT STORAGE MEDIA (if required)");		}		if ((act == ARCHIVE) || (act == APPND))			tty_prnt(" and make sure it is WRITE ENABLED./n");		else			tty_prnt("/n");		for(;;) {			tty_prnt("Type /"y/" to continue, /"./" to quit %s,",				argv0);			tty_prnt(" or /"s/" to switch to new device./nIf you");			tty_prnt(" cannot change storage media, type /"s/"/n");			tty_prnt("Is the device ready and online? > ");			if ((tty_read(buf,sizeof(buf))<0) || !strcmp(buf,".")){				done = 1;				lstrval = -1;				tty_prnt("Quitting %s!/n", argv0);				vfpart = 0;				return(-1);			}			if ((buf[0] == '/0') || (buf[1] != '/0')) {				tty_prnt("%s unknown command, try again/n",buf);				continue;			}			switch (buf[0]) {			case 'y':			case 'Y':				/*				 * we are to continue with the same device				 */				if (ar_open(arcname) >= 0)					return(0);				tty_prnt("Cannot re-open %s, try again/n",					arcname);				continue;			case 's':			case 'S':				/*				 * user wants to open a different device				 */				tty_prnt("Switching to a different archive/n");				break;			default:				tty_prnt("%s unknown command, try again/n",buf);				continue;			}			break;		}	} else		tty_prnt("Ready for archive volume: %d/n", arvol);	/*	 * have to go to a different archive	 */	for (;;) {		tty_prnt("Input archive name or /"./" to quit %s./n", argv0);		tty_prnt("Archive name > ");		if ((tty_read(buf, sizeof(buf)) < 0) || !strcmp(buf, ".")) {			done = 1;//.........这里部分代码省略.........

intnode_creat(ARCHD *arcn){	int res;	int ign = 0;	int oerrno;	int pass = 0;	mode_t file_mode;	struct stat sb;	char target[MAXPATHLEN];	char *nm = arcn->name;	int len;	/*	 * create node based on type, if that fails try to unlink the node and	 * try again. finally check the path and try again. As noted in the	 * file and link creation routines, this method seems to exhibit the	 * best performance in general use workloads.	 */	file_mode = arcn->sb.st_mode & FILEBITS;	for (;;) {		switch(arcn->type) {		case PAX_DIR:			/*			 * If -h (or -L) was given in tar-mode, follow the			 * potential symlink chain before trying to create the			 * directory.			 */			if (strcmp(NM_TAR, argv0) == 0 && Lflag) {				while (lstat(nm, &sb) == 0 &&				    S_ISLNK(sb.st_mode)) {					len = readlink(nm, target,					    sizeof target - 1);					if (len == -1) {						syswarn(0, errno,						   "cannot follow symlink %s in chain for %s",						    nm, arcn->name);						res = -1;						goto badlink;					}					target[len] = '/0';					nm = target;				}			}			res = mkdir(nm, file_mode);badlink:			if (ign)				res = 0;			break;		case PAX_CHR:			file_mode |= S_IFCHR;			res = mknod(nm, file_mode, arcn->sb.st_rdev);			break;		case PAX_BLK:			file_mode |= S_IFBLK;			res = mknod(nm, file_mode, arcn->sb.st_rdev);			break;		case PAX_FIF:			res = mkfifo(nm, file_mode);			break;		case PAX_SCK:			/*			 * Skip sockets, operation has no meaning under BSD			 */			paxwarn(0,			    "%s skipped. Sockets cannot be copied or extracted",			    nm);			return(-1);		case PAX_SLK:			res = symlink(arcn->ln_name, nm);			break;		case PAX_CTG:		case PAX_HLK:		case PAX_HRG:		case PAX_REG:		default:			/*			 * we should never get here			 */			paxwarn(0, "%s has an unknown file type, skipping",				nm);			return(-1);		}		/*		 * if we were able to create the node break out of the loop,		 * otherwise try to unlink the node and try again. if that		 * fails check the full path and try a final time.		 */		if (res == 0)			break;		/*		 * we failed to make the node		 */		oerrno = errno;		if ((ign = unlnk_exist(nm, arcn->type)) < 0)			return(-1);//.........这里部分代码省略.........

intar_read(char *buf, int cnt){	int res = 0;	/*	 * if last i/o was in error, no more reads until reset or new volume	 */	if (lstrval <= 0)		return(lstrval);	/*	 * how we read must be based on device type	 */	switch (artyp) {	case ISTAPE:		if ((res = read(arfd, buf, cnt)) > 0) {			/*			 * CAUTION: tape systems may not always return the same			 * sized records so we leave blksz == MAXBLK. The			 * physical record size that a tape drive supports is			 * very hard to determine in a uniform and portable			 * manner.			 */			io_ok = 1;			if (res != rdblksz) {				/*				 * Record size changed. If this is happens on				 * any record after the first, we probably have				 * a tape drive which has a fixed record size				 * we are getting multiple records in a single				 * read). Watch out for record blocking that				 * violates pax spec (must be a multiple of				 * BLKMULT).				 */				rdblksz = res;				if (rdblksz % BLKMULT)					invld_rec = 1;			}			return(res);		}		break;	case ISREG:	case ISBLK:	case ISCHR:	case ISPIPE:	default:		/*		 * Files are so easy to deal with. These other things cannot		 * be trusted at all. So when we are dealing with character		 * devices and pipes we just take what they have ready for us		 * and return. Trying to do anything else with them runs the		 * risk of failure.		 */		if ((res = read(arfd, buf, cnt)) > 0) {			io_ok = 1;			return(res);		}		break;	}	/*	 * We are in trouble at this point, something is broken...	 */	lstrval = res;	if (res < 0)		syswarn(1, errno, "Failed read on archive volume %d", arvol);	else		paxwarn(0, "End of archive volume %d reached", arvol);	return(res);}

intmain(int argc, char *argv[]){	const char *tmpdir;	size_t tdlen;	(void) setlocale(LC_ALL, "");	listf = stderr;	/*	 * Keep a reference to cwd, so we can always come back home.	 */	cwdfd = open(".", O_RDONLY);	if (cwdfd < 0) {		syswarn(0, errno, "Can't open current working directory.");		return(exit_val);	}	/*	 * Where should we put temporary files?	 */	if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '/0')		tmpdir = _PATH_TMP;	tdlen = strlen(tmpdir);	while(tdlen > 0 && tmpdir[tdlen - 1] == '/')		tdlen--;	tempfile = malloc(tdlen + 1 + sizeof(_TFILE_BASE));	if (tempfile == NULL) {		paxwarn(1, "Cannot allocate memory for temp file name.");		return(exit_val);	}	if (tdlen)		memcpy(tempfile, tmpdir, tdlen);	tempbase = tempfile + tdlen;	*tempbase++ = '/';	/*	 * parse options, determine operational mode, general init	 */	options(argc, argv);	if ((gen_init() < 0) || (tty_init() < 0))		return(exit_val);	/*	 * select a primary operation mode	 */	switch(act) {	case EXTRACT:		extract();		break;	case ARCHIVE:		archive();		break;	case APPND:		if (gzip_program != NULL)			err(1, "can not gzip while appending");		append();		break;	case COPY:		copy();		break;	default:	case LIST:		list();		break;	}	return(exit_val);}

//.........这里部分代码省略.........	 */	if (lstrval <= 0)		return(lstrval);	if ((res = write(arfd, buf, bsz)) == bsz) {		wr_trail = 1;		io_ok = 1;		return(bsz);	}	/*	 * write broke, see what we can do with it. We try to send any partial	 * writes that may violate pax spec to the next archive volume.	 */	if (res < 0)		lstrval = res;	else		lstrval = 0;	switch (artyp) {	case ISREG:		if ((res > 0) && (res % BLKMULT)) {			/*		 	 * try to fix up partial writes which are not BLKMULT			 * in size by forcing the runt record to next archive			 * volume		 	 */			if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)				break;			cpos -= (off_t)res;			if (ftruncate(arfd, cpos) < 0)				break;			res = lstrval = 0;			break;		}		if (res >= 0)			break;		/*		 * if file is out of space, handle it like a return of 0		 */		if ((errno == ENOSPC) || (errno == EFBIG) || (errno == EDQUOT))			res = lstrval = 0;		break;	case ISTAPE:	case ISCHR:	case ISBLK:		if (res >= 0)			break;		if (errno == EACCES) {			paxwarn(0, "Write failed, archive is write protected.");			res = lstrval = 0;			return(0);		}		/*		 * see if we reached the end of media, if so force a change to		 * the next volume		 */		if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO))			res = lstrval = 0;		break;	case ISPIPE:	default:		/*		 * we cannot fix errors to these devices		 */		break;	}	/*	 * Better tell the user the bad news...	 * if this is a block aligned archive format, we may have a bad archive	 * if the format wants the header to start at a BLKMULT boundary. While	 * we can deal with the mis-aligned data, it violates spec and other	 * archive readers will likely fail. If the format is not block	 * aligned, the user may be lucky (and the archive is ok).	 */	if (res >= 0) {		if (res > 0)			wr_trail = 1;		io_ok = 1;	}	/*	 * If we were trying to rewrite the trailer and it didn't work, we	 * must quit right away.	 */	if (!wr_trail && (res <= 0)) {		paxwarn(1,"Unable to append, trailer re-write failed. Quitting.");		return(res);	}	if (res == 0)		paxwarn(0, "End of archive volume %d reached", arvol);	else if (res < 0)		syswarn(1, errno, "Failed write to archive volume: %d", arvol);	else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0))		paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED");	else		paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED");	return(res);}

static intftree_arg(void){    /*     * close off the current file tree     */    if (ftsp != NULL) {        (void)fts_close(ftsp);        ftsp = NULL;    }    /*     * keep looping until we get a valid file tree to process. Stop when we     * reach the end of the list (or get an eof on stdin)     */    for (;;) {        if (fthead == NULL) {            /*             * the user didn't supply any args, get the file trees             * to process from stdin;             */            if (getpathname(farray[0], PAXPATHLEN+1) == NULL)                return(-1);        } else {            /*             * the user supplied the file args as arguments to pax             */            if (ftcur == NULL)                ftcur = fthead;            else if ((ftcur = ftcur->fow) == NULL)                return(-1);            if (ftcur->chflg) {                /* First fchdir() back... */                if (fchdir(cwdfd) < 0) {                    syswarn(1, errno,                            "Can't fchdir to starting directory");                    return(-1);                }                if (chdir(ftcur->fname) < 0) {                    syswarn(1, errno, "Can't chdir to %s",                            ftcur->fname);                    return(-1);                }                continue;            } else                farray[0] = ftcur->fname;        }        /*         * watch it, fts wants the file arg stored in a array of char         * ptrs, with the last one a null. we use a two element array         * and set farray[0] to point at the buffer with the file name         * in it. We cannot pass all the file args to fts at one shot         * as we need to keep a handle on which file arg generates what         * files (the -n and -d flags need this). If the open is         * successful, return a 0.         */        if ((ftsp = fts_open(farray, ftsopts, NULL)) != NULL)            break;    }    return(0);}

intar_rev(off_t sksz){	off_t cpos;	struct mtop mb;	int phyblk;	/*	 * make sure we do not have try to reverse on a flawed archive	 */	if (lstrval < 0)		return(lstrval);	switch(artyp) {	case ISPIPE:		if (sksz <= 0)			break;		/*		 * cannot go backwards on these critters		 */		paxwarn(1, "Reverse positioning on pipes is not supported.");		lstrval = -1;		return(-1);	case ISREG:	case ISBLK:	case ISCHR:	default:		if (sksz <= 0)			break;		/*		 * For things other than files, backwards movement has a very		 * high probability of failure as we really do not know the		 * true attributes of the device we are talking to (the device		 * may not even have the ability to lseek() in any direction).		 * First we figure out where we are in the archive.		 */		if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) {			syswarn(1, errno,			   "Unable to obtain current archive byte offset");			lstrval = -1;			return(-1);		}		/*		 * we may try to go backwards past the start when the archive		 * is only a single record. If this happens and we are on a		 * multi volume archive, we need to go to the end of the		 * previous volume and continue our movement backwards from		 * there.		 */		if ((cpos -= sksz) < (off_t)0L) {			if (arvol > 1) {				/*				 * this should never happen				 */				paxwarn(1,"Reverse position on previous volume.");				lstrval = -1;				return(-1);			}			cpos = (off_t)0L;		}		if (lseek(arfd, cpos, SEEK_SET) < 0) {			syswarn(1, errno, "Unable to seek archive backwards");			lstrval = -1;			return(-1);		}		break;	case ISTAPE:		/*	 	 * Calculate and move the proper number of PHYSICAL tape		 * blocks. If the sksz is not an even multiple of the physical		 * tape size, we cannot do the move (this should never happen).		 * (We also cannot handler trailers spread over two vols).		 * get_phys() also makes sure we are in front of the filemark.	 	 */		if ((phyblk = get_phys()) <= 0) {			lstrval = -1;			return(-1);		}		/*		 * make sure future tape reads only go by physical tape block		 * size (set rdblksz to the real size).		 */		rdblksz = phyblk;		/*		 * if no movement is required, just return (we must be after		 * get_phys() so the physical blocksize is properly set)		 */		if (sksz <= 0)			break;		/*		 * ok we have to move. Make sure the tape drive can do it.		 */		if (sksz % phyblk) {			paxwarn(1,			    "Tape drive unable to backspace requested amount");//.........这里部分代码省略.........

//.........这里部分代码省略.........		 */		if ((Yflag || Zflag) && ((lstat(arcn->name, &sb) == 0))) {			if (Yflag && Zflag) {				if ((arcn->sb.st_mtime <= sb.st_mtime) &&				    (arcn->sb.st_ctime <= sb.st_ctime)) {					(void)rd_skip(arcn->skip + arcn->pad);					continue;				}			} else if (Yflag) {				if (arcn->sb.st_ctime <= sb.st_ctime) {					(void)rd_skip(arcn->skip + arcn->pad);					continue;				}			} else if (arcn->sb.st_mtime <= sb.st_mtime) {				(void)rd_skip(arcn->skip + arcn->pad);				continue;			}		}		if (vflag) {			if (vflag > 1)				ls_list(arcn, now, listf);			else {				(void)safe_print(arcn->name, listf);				vfpart = 1;			}		}		/*		 * if required, chdir around.		 */		if ((arcn->pat != NULL) && (arcn->pat->chdname != NULL))			if (chdir(arcn->pat->chdname) != 0)				syswarn(1, errno, "Cannot chdir to %s",				    arcn->pat->chdname);		/*		 * all ok, extract this member based on type		 */		if ((arcn->type != PAX_REG) && (arcn->type != PAX_CTG)) {			/*			 * process archive members that are not regular files.			 * throw out padding and any data that might follow the			 * header (as determined by the format).			 */			if ((arcn->type == PAX_HLK) || (arcn->type == PAX_HRG))				res = lnk_creat(arcn);			else				res = node_creat(arcn);			(void)rd_skip(arcn->skip + arcn->pad);			if (res < 0)				purg_lnk(arcn);			if (vflag && vfpart) {				(void)putc('/n', listf);				vfpart = 0;			}			goto popd;		}		/*		 * we have a file with data here. If we can not create it, skip		 * over the data and purge the name from hard link table		 */		if ((fd = file_creat(arcn)) < 0) {			(void)rd_skip(arcn->skip + arcn->pad);

/* * Receive request packet and verify the integrity and format of the reply. * This routine is REQUIRED to sanitize the request packet.  All other program * routines can expect that the packet is safe to read once it is passed on. * * Returns a newly-allocated lbcd_request struct on success and NULL on * failure. */static struct request *request_recv(struct lbcd_config *config, socket_type fd){    struct sockaddr_storage addr;    struct sockaddr *sockaddr;    socklen_t addrlen;    ssize_t result;    char raw[LBCD_MAXMESG];    char source[INET6_ADDRSTRLEN] = "UNKNOWN";    struct lbcd_request *packet;    unsigned int protocol, id, operation, nservices, i;    size_t expected;    struct request *request;    char *service;    /* Receive the UDP packet from the wire. */    addrlen = sizeof(addr);    sockaddr = (struct sockaddr *) &addr;    result = recvfrom(fd, raw, sizeof(raw), 0, sockaddr, &addrlen);    if (result <= 0) {        syswarn("cannot receive packet");        return NULL;    }    /* Format the client address for logging. */    if (!network_sockaddr_sprint(source, sizeof(source), sockaddr))        syswarn("cannot convert client address to string");    /* Ensure the packet is large enough to contain the header. */    if ((size_t) result < sizeof(struct lbcd_header)) {        warn("client %s: short packet received (length %lu)", source,             (unsigned long) result);        return NULL;    }    /* Extract the header fields. */    packet = (struct lbcd_request *) raw;    protocol  = ntohs(packet->h.version);    id        = ntohs(packet->h.id);    operation = ntohs(packet->h.op);    nservices = ntohs(packet->h.status);    /* Now, ensure the request packet is exactly the correct size. */    expected = sizeof(struct lbcd_header);    if (protocol == 3) {        if (nservices > LBCD_MAX_SERVICES) {            warn("client %s: too many services in request (%u)", source,                 nservices);            return NULL;        }        expected += nservices * sizeof(lbcd_name_type);    }    if ((size_t) result != expected) {        warn("client %s: incorrect packet size (%lu != %lu)", source,             (unsigned long) result, (unsigned long) expected);        return NULL;    }    /* The packet appears valid.  Create the request struct. */    request = xcalloc(1, sizeof(struct request));    request->source    = xstrdup(source);    request->addrlen   = addrlen;    request->addr      = xmalloc(addrlen);    memcpy(request->addr, &addr, addrlen);    request->protocol  = protocol;    request->id        = id;    request->operation = operation;    request->services  = vector_new();    /* Check protocol number. */    if (protocol != 2 && protocol != 3) {        warn("client %s: protocol version %u unsupported", source, protocol);        send_status(request, fd, LBCD_STATUS_VERSION);        goto fail;    }    /*     * Protocol version 3 takes a client-supplied list of services, with the     * number of client-provided services given in the otherwise-unused status     * field of the request header.     */    if (request->protocol == 3)        for (i = 0; i < nservices; i++) {            service = xstrndup(packet->names[i], sizeof(lbcd_name_type));            if (!service_allowed(config, service)) {                warn("client %s: service %s not allowed", source, service);                send_status(request, fd, LBCD_STATUS_ERROR);                free(service);                goto fail;            }            vector_add(request->services, service);            free(service);//.........这里部分代码省略.........