|
|
@@ -0,0 +1,7185 @@
|
|
|
+
|
|
|
+ * cpio - copy file archives in and out
|
|
|
+ *
|
|
|
+ * Gunnar Ritter, Freiburg i. Br., Germany, April 2003.
|
|
|
+ */
|
|
|
+
|
|
|
+ * Copyright (c) 2003 Gunnar Ritter
|
|
|
+ *
|
|
|
+ * This software is provided 'as-is', without any express or implied
|
|
|
+ * warranty. In no event will the authors be held liable for any damages
|
|
|
+ * arising from the use of this software.
|
|
|
+ *
|
|
|
+ * Permission is granted to anyone to use this software for any purpose,
|
|
|
+ * including commercial applications, and to alter it and redistribute
|
|
|
+ * it freely, subject to the following restrictions:
|
|
|
+ *
|
|
|
+ * 1. The origin of this software must not be misrepresented; you must not
|
|
|
+ * claim that you wrote the original software. If you use this software
|
|
|
+ * in a product, an acknowledgment in the product documentation would be
|
|
|
+ * appreciated but is not required.
|
|
|
+ *
|
|
|
+ * 2. Altered source versions must be plainly marked as such, and must not be
|
|
|
+ * misrepresented as being the original software.
|
|
|
+ *
|
|
|
+ * 3. This notice may not be removed or altered from any source distribution.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ * Sccsid @(#)cpio.c 1.304 (gritter) 2/14/09
|
|
|
+ */
|
|
|
+
|
|
|
+#include <sys/types.h>
|
|
|
+#include <sys/stat.h>
|
|
|
+#ifdef __linux__
|
|
|
+#if !defined (__UCLIBC__) && !defined (__dietlibc__)
|
|
|
+#include <linux/fs.h>
|
|
|
+#endif
|
|
|
+#include <linux/fd.h>
|
|
|
+#undef WNOHANG
|
|
|
+#undef WUNTRACED
|
|
|
+#undef P_ALL
|
|
|
+#undef P_PID
|
|
|
+#undef P_PGID
|
|
|
+#ifdef __dietlibc__
|
|
|
+#undef NR_OPEN
|
|
|
+#undef PATH_MAX
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+#include <sys/wait.h>
|
|
|
+#include <fcntl.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <malloc.h>
|
|
|
+#include <string.h>
|
|
|
+#include <unistd.h>
|
|
|
+#include <signal.h>
|
|
|
+#include "sigset.h"
|
|
|
+#include <time.h>
|
|
|
+#include <utime.h>
|
|
|
+#include <pwd.h>
|
|
|
+#include <grp.h>
|
|
|
+#include <limits.h>
|
|
|
+#include <stdio.h>
|
|
|
+#include <libgen.h>
|
|
|
+#include <errno.h>
|
|
|
+#include <inttypes.h>
|
|
|
+#include <stdarg.h>
|
|
|
+#include <locale.h>
|
|
|
+#include <ctype.h>
|
|
|
+#include "memalign.h"
|
|
|
+
|
|
|
+int sysv3;
|
|
|
+
|
|
|
+#if USE_ZLIB
|
|
|
+#include <zlib.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#if USE_BZLIB
|
|
|
+#include <bzlib.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <sys/ioctl.h>
|
|
|
+
|
|
|
+#if defined (__linux__) || defined (__sun) || defined (__FreeBSD__) || \
|
|
|
+ defined (__hpux) || defined (_AIX) || defined (__NetBSD__) || \
|
|
|
+ defined (__OpenBSD__) || defined (__DragonFly__) || defined (__APPLE__)
|
|
|
+#include <sys/mtio.h>
|
|
|
+#else
|
|
|
+#include <sys/scsi.h>
|
|
|
+#include <sys/st01.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <iblok.h>
|
|
|
+#include <sfile.h>
|
|
|
+#include <atoll.h>
|
|
|
+
|
|
|
+#ifdef _AIX
|
|
|
+#include <sys/sysmacros.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef major
|
|
|
+#include <sys/mkdev.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#include "cpio.h"
|
|
|
+#include "blast.h"
|
|
|
+
|
|
|
+#ifdef __GLIBC__
|
|
|
+#ifdef _IO_putc_unlocked
|
|
|
+#undef putc
|
|
|
+#define putc(c, f) _IO_putc_unlocked(c, f)
|
|
|
+#undef putchar
|
|
|
+#define putchar(c) _IO_putc_unlocked(c, stdout)
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ * The cpio code assumes that all following S_IFMT bits are the same as
|
|
|
+ * those of the mode fields in cpio headers. The only real Unix system
|
|
|
+ * known to deviate from this de facto standard is UNICOS which uses
|
|
|
+ * 0130000 for S_IFLNK. But this software does not run on UNICOS for
|
|
|
+ * a variety of other reasons anyway, so this should not be of much
|
|
|
+ * concern.
|
|
|
+ */
|
|
|
+#if S_IFIFO != 0010000 || \
|
|
|
+ S_IFCHR != 0020000 || \
|
|
|
+ S_IFDIR != 0040000 || \
|
|
|
+ S_IFBLK != 0060000 || \
|
|
|
+ S_IFREG != 0100000 || \
|
|
|
+ S_IFLNK != 0120000 || \
|
|
|
+ S_IFSOCK!= 0140000 || \
|
|
|
+ S_IFMT != 0170000
|
|
|
+#error non-standard S_IFMT bits
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ * File types that are not present on all systems but that we want to
|
|
|
+ * recognize nevertheless.
|
|
|
+ */
|
|
|
+#ifndef S_IFDOOR
|
|
|
+#define S_IFDOOR 0150000
|
|
|
+#endif
|
|
|
+#ifndef S_IFNAM
|
|
|
+#define S_IFNAM 0050000
|
|
|
+#endif
|
|
|
+#ifndef S_INSEM
|
|
|
+#define S_INSEM 0x1
|
|
|
+#endif
|
|
|
+#ifndef S_INSHD
|
|
|
+#define S_INSHD 0x2
|
|
|
+#endif
|
|
|
+#ifndef S_IFNWK
|
|
|
+#define S_IFNWK 0110000
|
|
|
+#endif
|
|
|
+
|
|
|
+#if defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
|
|
|
+ defined (__DragonFly__) || defined (__APPLE__)
|
|
|
+
|
|
|
+ * For whatever reason, FreeBSD casts the return values of major() and
|
|
|
+ * minor() to signed values so that normal limit comparisons will fail.
|
|
|
+ */
|
|
|
+static unsigned long
|
|
|
+mymajor(long dev)
|
|
|
+{
|
|
|
+ return major(dev) & 0xFFFFFFFFUL;
|
|
|
+}
|
|
|
+#undef major
|
|
|
+#define major(a) mymajor(a)
|
|
|
+static unsigned long
|
|
|
+myminor(long dev)
|
|
|
+{
|
|
|
+ return minor(dev) & 0xFFFFFFFFUL;
|
|
|
+}
|
|
|
+#undef minor
|
|
|
+#define minor(a) myminor(a)
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ * Device and inode counts in cpio formats are too small to store the
|
|
|
+ * information used to detect hard links on today's systems. Keep track
|
|
|
+ * of all devices and inodes and store fake counts in the archive.
|
|
|
+ */
|
|
|
+struct ilink {
|
|
|
+ struct ilink *l_nxt;
|
|
|
+ char *l_nam;
|
|
|
+ size_t l_siz;
|
|
|
+};
|
|
|
+
|
|
|
+struct islot {
|
|
|
+ struct islot *i_lln;
|
|
|
+ struct islot *i_rln;
|
|
|
+ struct ilink *i_lnk;
|
|
|
+ struct stat *i_st;
|
|
|
+ char *i_name;
|
|
|
+ ino_t i_ino;
|
|
|
+ uint32_t i_fino;
|
|
|
+ nlink_t i_nlk;
|
|
|
+};
|
|
|
+
|
|
|
+struct dslot {
|
|
|
+ struct dslot *d_nxt;
|
|
|
+ struct islot *d_isl;
|
|
|
+ uint32_t d_cnt;
|
|
|
+ uint32_t d_fake;
|
|
|
+ dev_t d_dev;
|
|
|
+};
|
|
|
+
|
|
|
+union types2 {
|
|
|
+ uint8_t byte[2];
|
|
|
+ uint16_t sword;
|
|
|
+};
|
|
|
+
|
|
|
+union types4 {
|
|
|
+ uint8_t byte[4];
|
|
|
+ uint16_t sword[2];
|
|
|
+ uint32_t lword;
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+ * Store and retrieve integers in a defined endian order.
|
|
|
+ */
|
|
|
+static uint16_t
|
|
|
+ple16(const char *cp)
|
|
|
+{
|
|
|
+ return (uint16_t)(cp[0]&0377) +
|
|
|
+ ((uint16_t)(cp[1]&0377) << 8);
|
|
|
+}
|
|
|
+
|
|
|
+static uint16_t
|
|
|
+pbe16(const char *cp)
|
|
|
+{
|
|
|
+ return (uint16_t)(cp[1]&0377) +
|
|
|
+ ((uint16_t)(cp[0]&0377) << 8);
|
|
|
+}
|
|
|
+
|
|
|
+static uint32_t
|
|
|
+ple32(const char *cp)
|
|
|
+{
|
|
|
+ return (uint32_t)(cp[0]&0377) +
|
|
|
+ ((uint32_t)(cp[1]&0377) << 8) +
|
|
|
+ ((uint32_t)(cp[2]&0377) << 16) +
|
|
|
+ ((uint32_t)(cp[3]&0377) << 24);
|
|
|
+}
|
|
|
+
|
|
|
+static uint32_t
|
|
|
+pbe32(const char *cp)
|
|
|
+{
|
|
|
+ return (uint32_t)(cp[3]&0377) +
|
|
|
+ ((uint32_t)(cp[2]&0377) << 8) +
|
|
|
+ ((uint32_t)(cp[1]&0377) << 16) +
|
|
|
+ ((uint32_t)(cp[0]&0377) << 24);
|
|
|
+}
|
|
|
+
|
|
|
+static uint32_t
|
|
|
+pme32(const char *cp)
|
|
|
+{
|
|
|
+ return (uint32_t)(cp[2]&0377) +
|
|
|
+ ((uint32_t)(cp[3]&0377) << 8) +
|
|
|
+ ((uint32_t)(cp[0]&0377) << 16) +
|
|
|
+ ((uint32_t)(cp[1]&0377) << 24);
|
|
|
+}
|
|
|
+
|
|
|
+static uint64_t
|
|
|
+ple64(const char *cp)
|
|
|
+{
|
|
|
+ return (uint64_t)(cp[0]&0377) +
|
|
|
+ ((uint64_t)(cp[1]&0377) << 8) +
|
|
|
+ ((uint64_t)(cp[2]&0377) << 16) +
|
|
|
+ ((uint64_t)(cp[3]&0377) << 24) +
|
|
|
+ ((uint64_t)(cp[4]&0377) << 32) +
|
|
|
+ ((uint64_t)(cp[5]&0377) << 40) +
|
|
|
+ ((uint64_t)(cp[6]&0377) << 48) +
|
|
|
+ ((uint64_t)(cp[7]&0377) << 56);
|
|
|
+}
|
|
|
+
|
|
|
+static uint64_t
|
|
|
+pbe64(const char *cp)
|
|
|
+{
|
|
|
+ return (uint64_t)(cp[7]&0377) +
|
|
|
+ ((uint64_t)(cp[6]&0377) << 8) +
|
|
|
+ ((uint64_t)(cp[5]&0377) << 16) +
|
|
|
+ ((uint64_t)(cp[4]&0377) << 24) +
|
|
|
+ ((uint64_t)(cp[3]&0377) << 32) +
|
|
|
+ ((uint64_t)(cp[2]&0377) << 40) +
|
|
|
+ ((uint64_t)(cp[1]&0377) << 48) +
|
|
|
+ ((uint64_t)(cp[0]&0377) << 56);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+le16p(uint16_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[0] = (n&0x00ff);
|
|
|
+ cp[1] = (n&0xff00) >> 8;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+be16p(uint16_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[1] = (n&0x00ff);
|
|
|
+ cp[0] = (n&0xff00) >> 8;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+le32p(uint32_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[0] = (n&0x000000ff);
|
|
|
+ cp[1] = (n&0x0000ff00) >> 8;
|
|
|
+ cp[2] = (n&0x00ff0000) >> 16;
|
|
|
+ cp[3] = (n&0xff000000) >> 24;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+be32p(uint32_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[3] = (n&0x000000ff);
|
|
|
+ cp[2] = (n&0x0000ff00) >> 8;
|
|
|
+ cp[1] = (n&0x00ff0000) >> 16;
|
|
|
+ cp[0] = (n&0xff000000) >> 24;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+me32p(uint32_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[2] = (n&0x000000ff);
|
|
|
+ cp[3] = (n&0x0000ff00) >> 8;
|
|
|
+ cp[0] = (n&0x00ff0000) >> 16;
|
|
|
+ cp[1] = (n&0xff000000) >> 24;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+le64p(uint64_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[0] = (n&0x00000000000000ffLL);
|
|
|
+ cp[1] = (n&0x000000000000ff00LL) >> 8;
|
|
|
+ cp[2] = (n&0x0000000000ff0000LL) >> 16;
|
|
|
+ cp[3] = (n&0x00000000ff000000LL) >> 24;
|
|
|
+ cp[4] = (n&0x000000ff00000000LL) >> 32;
|
|
|
+ cp[5] = (n&0x0000ff0000000000LL) >> 40;
|
|
|
+ cp[6] = (n&0x00ff000000000000LL) >> 48;
|
|
|
+ cp[7] = (n&0xff00000000000000LL) >> 56;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+be64p(uint64_t n, char *cp)
|
|
|
+{
|
|
|
+ cp[7] = (n&0x00000000000000ffLL);
|
|
|
+ cp[6] = (n&0x000000000000ff00LL) >> 8;
|
|
|
+ cp[5] = (n&0x0000000000ff0000LL) >> 16;
|
|
|
+ cp[4] = (n&0x00000000ff000000LL) >> 24;
|
|
|
+ cp[3] = (n&0x000000ff00000000LL) >> 32;
|
|
|
+ cp[2] = (n&0x0000ff0000000000LL) >> 40;
|
|
|
+ cp[1] = (n&0x00ff000000000000LL) >> 48;
|
|
|
+ cp[0] = (n&0xff00000000000000LL) >> 56;
|
|
|
+}
|
|
|
+
|
|
|
+#define TNAMSIZ 100
|
|
|
+#define TPFXSIZ 155
|
|
|
+#define TMAGSIZ 6
|
|
|
+#define TTIMSIZ 12
|
|
|
+
|
|
|
+
|
|
|
+ * Structure of an archive header.
|
|
|
+ */
|
|
|
+union bincpio {
|
|
|
+ char data[4096];
|
|
|
+#define SIZEOF_hdr_cpio 26
|
|
|
+ struct hdr_cpio {
|
|
|
+ char c_magic[2];
|
|
|
+ char c_dev[2];
|
|
|
+ char c_ino[2];
|
|
|
+ char c_mode[2];
|
|
|
+ char c_uid[2];
|
|
|
+ char c_gid[2];
|
|
|
+ char c_nlink[2];
|
|
|
+ char c_rdev[2];
|
|
|
+ char c_mtime[4];
|
|
|
+ char c_namesize[2];
|
|
|
+ char c_filesize[4];
|
|
|
+ } Hdr;
|
|
|
+#define SIZEOF_cray_hdr 152
|
|
|
+ struct cray_hdr {
|
|
|
+ char C_magic[8];
|
|
|
+ char C_dev[8];
|
|
|
+ char C_ino[8];
|
|
|
+ char C_mode[8];
|
|
|
+ char C_uid[8];
|
|
|
+ char C_gid[8];
|
|
|
+ char C_nlink[8];
|
|
|
+ char C_rdev[8];
|
|
|
+
|
|
|
+ * The C_param field was introduced with
|
|
|
+ * UNICOS 6 and is simply not present in
|
|
|
+ * the earlier format. Following fields
|
|
|
+ * are the same for both revisions again.
|
|
|
+ */
|
|
|
+#define CRAY_PARAMSZ (8*8)
|
|
|
+ char C_param[CRAY_PARAMSZ];
|
|
|
+ char C_mtime[8];
|
|
|
+ char C_namesize[8];
|
|
|
+ char C_filesize[8];
|
|
|
+ } Crayhdr;
|
|
|
+#define SIZEOF_c_hdr 76
|
|
|
+ struct c_hdr {
|
|
|
+ char c_magic[6];
|
|
|
+ char c_dev[6];
|
|
|
+ char c_ino[6];
|
|
|
+ char c_mode[6];
|
|
|
+ char c_uid[6];
|
|
|
+ char c_gid[6];
|
|
|
+ char c_nlink[6];
|
|
|
+ char c_rdev[6];
|
|
|
+ char c_mtime[11];
|
|
|
+ char c_namesz[6];
|
|
|
+ char c_filesz[11];
|
|
|
+ } Cdr;
|
|
|
+#define SIZEOF_d_hdr 86
|
|
|
+ struct d_hdr {
|
|
|
+ char d_magic[6];
|
|
|
+ char d_dev[6];
|
|
|
+ char d_ino[6];
|
|
|
+ char d_mode[6];
|
|
|
+ char d_uid[6];
|
|
|
+ char d_gid[6];
|
|
|
+ char d_nlink[6];
|
|
|
+ char d_rmaj[8];
|
|
|
+ char d_rmin[8];
|
|
|
+ char d_mtime[11];
|
|
|
+ char d_namesz[6];
|
|
|
+ char d_filesz[11];
|
|
|
+ } Ddr;
|
|
|
+#define SIZEOF_Exp_cpio_hdr 110
|
|
|
+ struct Exp_cpio_hdr {
|
|
|
+ char E_magic[6];
|
|
|
+ char E_ino[8];
|
|
|
+ char E_mode[8];
|
|
|
+ char E_uid[8];
|
|
|
+ char E_gid[8];
|
|
|
+ char E_nlink[8];
|
|
|
+ char E_mtime[8];
|
|
|
+ char E_filesize[8];
|
|
|
+ char E_maj[8];
|
|
|
+ char E_min[8];
|
|
|
+ char E_rmaj[8];
|
|
|
+ char E_rmin[8];
|
|
|
+ char E_namesize[8];
|
|
|
+ char E_chksum[8];
|
|
|
+ } Edr;
|
|
|
+ struct tar_header {
|
|
|
+ char t_name[TNAMSIZ];
|
|
|
+ char t_mode[8];
|
|
|
+ char t_uid[8];
|
|
|
+ char t_gid[8];
|
|
|
+ char t_size[12];
|
|
|
+ char t_mtime[TTIMSIZ];
|
|
|
+ char t_chksum[8];
|
|
|
+ char t_linkflag;
|
|
|
+ char t_linkname[TNAMSIZ];
|
|
|
+ char t_magic[TMAGSIZ];
|
|
|
+ char t_version[2];
|
|
|
+ char t_uname[32];
|
|
|
+ char t_gname[32];
|
|
|
+ char t_devmajor[8];
|
|
|
+ char t_devminor[8];
|
|
|
+ char t_prefix[TPFXSIZ];
|
|
|
+ } Tdr;
|
|
|
+#define SIZEOF_bar_header 84
|
|
|
+ struct bar_header {
|
|
|
+ char b_mode[8];
|
|
|
+ char b_uid[8];
|
|
|
+ char b_gid[8];
|
|
|
+ char b_size[12];
|
|
|
+ char b_mtime[12];
|
|
|
+ char b_chksum[8];
|
|
|
+ char b_rdev[8];
|
|
|
+ char b_linkflag;
|
|
|
+ char b_bar_magic[2];
|
|
|
+ char b_volume_num[4];
|
|
|
+ char b_compressed;
|
|
|
+ char b_date[12];
|
|
|
+ } Bdr;
|
|
|
+#define SIZEOF_zip_header 30
|
|
|
+ struct zip_header {
|
|
|
+ char z_signature[4];
|
|
|
+ char z_version[2];
|
|
|
+ char z_gflag[2];
|
|
|
+ char z_cmethod[2];
|
|
|
+ char z_modtime[2];
|
|
|
+ char z_moddate[2];
|
|
|
+ char z_crc32[4];
|
|
|
+ char z_csize[4];
|
|
|
+ char z_nsize[4];
|
|
|
+ char z_namelen[2];
|
|
|
+ char z_extralen[2];
|
|
|
+ } Zdr;
|
|
|
+};
|
|
|
+
|
|
|
+#define BCUT 0177777
|
|
|
+#define OCUT 0777777
|
|
|
+#define ECUT 0xFFFFFFFFUL
|
|
|
+
|
|
|
+static const char trailer[] = "TRAILER!!!";
|
|
|
+
|
|
|
+
|
|
|
+ * Structure of per-file extra data for zip format.
|
|
|
+ */
|
|
|
+union zextra {
|
|
|
+ char data[1];
|
|
|
+#define SIZEOF_zextra_gn 4
|
|
|
+ struct zextra_gn {
|
|
|
+ char ze_gn_tag[2];
|
|
|
+ char ze_gn_tsize[2];
|
|
|
+ } Ze_gn;
|
|
|
+#define SIZEOF_zextra_64 32
|
|
|
+#define SIZEOF_zextra_64_a 28
|
|
|
+#define SIZEOF_zextra_64_b 20
|
|
|
+ struct zextra_64 {
|
|
|
+ char ze_64_tag[2];
|
|
|
+ char ze_64_tsize[2];
|
|
|
+ char ze_64_nsize[8];
|
|
|
+ char ze_64_csize[8];
|
|
|
+ char ze_64_reloff[8];
|
|
|
+ char ze_64_startn[4];
|
|
|
+ } Ze_64;
|
|
|
+#define SIZEOF_zextra_pk 16
|
|
|
+ struct zextra_pk {
|
|
|
+ char ze_pk_tag[2];
|
|
|
+ char ze_pk_tsize[2];
|
|
|
+ char ze_pk_atime[4];
|
|
|
+ char ze_pk_mtime[4];
|
|
|
+ char ze_pk_uid[2];
|
|
|
+ char ze_pk_gid[2];
|
|
|
+ } Ze_pk;
|
|
|
+#define SIZEOF_zextra_ek 17
|
|
|
+ struct zextra_et {
|
|
|
+ char ze_et_tag[2];
|
|
|
+ char ze_et_tsize[2];
|
|
|
+ char ze_et_flags[1];
|
|
|
+ char ze_et_mtime[4];
|
|
|
+ char ze_et_atime[4];
|
|
|
+ char ze_et_ctime[4];
|
|
|
+ } Ze_et;
|
|
|
+#define SIZEOF_zextra_i1 16
|
|
|
+ struct zextra_i1 {
|
|
|
+ char ze_i1_tag[2];
|
|
|
+ char ze_i1_tsize[2];
|
|
|
+ char ze_i1_atime[4];
|
|
|
+ char ze_i1_mtime[4];
|
|
|
+ char ze_i1_uid[2];
|
|
|
+ char ze_i1_gid[2];
|
|
|
+ } Ze_i1;
|
|
|
+#define SIZEOF_zextra_i2 8
|
|
|
+ struct zextra_i2 {
|
|
|
+ char ze_i2_tag[2];
|
|
|
+ char ze_i2_tsize[2];
|
|
|
+ char ze_i2_uid[2];
|
|
|
+ char ze_i2_gid[2];
|
|
|
+ } Ze_i2;
|
|
|
+#define SIZEOF_zextra_as 16
|
|
|
+ struct zextra_as {
|
|
|
+ char ze_as_tag[2];
|
|
|
+ char ze_as_tsize[2];
|
|
|
+ char ze_as_crc[4];
|
|
|
+ char ze_as_mode[2];
|
|
|
+ char ze_as_sizdev[4];
|
|
|
+ char ze_as_uid[2];
|
|
|
+ char ze_as_gid[2];
|
|
|
+ } Ze_as;
|
|
|
+#define SIZEOF_zextra_cp 40
|
|
|
+ struct zextra_cp {
|
|
|
+ char ze_cp_tag[2];
|
|
|
+ char ze_cp_tsize[2];
|
|
|
+ char ze_cp_dev[4];
|
|
|
+ char ze_cp_ino[4];
|
|
|
+ char ze_cp_mode[4];
|
|
|
+ char ze_cp_uid[4];
|
|
|
+ char ze_cp_gid[4];
|
|
|
+ char ze_cp_nlink[4];
|
|
|
+ char ze_cp_rdev[4];
|
|
|
+ char ze_cp_mtime[4];
|
|
|
+ char ze_cp_atime[4];
|
|
|
+ } Ze_cp;
|
|
|
+};
|
|
|
+
|
|
|
+static struct zipstuff {
|
|
|
+ struct zipstuff *zs_next;
|
|
|
+ char *zs_name;
|
|
|
+ long long zs_size;
|
|
|
+ long long zs_relative;
|
|
|
+ long long zs_csize;
|
|
|
+ uint32_t zs_crc32;
|
|
|
+ time_t zs_mtime;
|
|
|
+ enum cmethod zs_cmethod;
|
|
|
+ int zs_gflag;
|
|
|
+ mode_t zs_mode;
|
|
|
+} *zipbulk;
|
|
|
+
|
|
|
+
|
|
|
+ * Structure of the central zip directory at the end of the file. This
|
|
|
+ * (obligatory) part of a zip file is written by this implementation,
|
|
|
+ * but is completely ignored on copy-in. This means that we miss the
|
|
|
+ * mode_t stored in zc_extralen if zc_versionmade[1] is 3 (Unix). We
|
|
|
+ * have to do this since it contains the S_IFMT bits, thus telling us
|
|
|
+ * whether something is a symbolic link and resulting in different
|
|
|
+ * behavior - but as the input had to be seekable in order to do this,
|
|
|
+ * we had to store entire archives in temporary files if input came
|
|
|
+ * from a pipe to be consistent.
|
|
|
+ */
|
|
|
+#define SIZEOF_zipcentral 46
|
|
|
+struct zipcentral {
|
|
|
+ char zc_signature[4];
|
|
|
+ char zc_versionmade[2];
|
|
|
+ char zc_versionextr[2];
|
|
|
+ char zc_gflag[2];
|
|
|
+ char zc_cmethod[2];
|
|
|
+ char zc_modtime[2];
|
|
|
+ char zc_moddate[2];
|
|
|
+ char zc_crc32[4];
|
|
|
+ char zc_csize[4];
|
|
|
+ char zc_nsize[4];
|
|
|
+ char zc_namelen[2];
|
|
|
+ char zc_extralen[2];
|
|
|
+ char zc_commentlen[2];
|
|
|
+ char zc_disknstart[2];
|
|
|
+ char zc_internal[2];
|
|
|
+ char zc_external[4];
|
|
|
+ char zc_relative[4];
|
|
|
+};
|
|
|
+
|
|
|
+#define SIZEOF_zip64end 56
|
|
|
+struct zip64end {
|
|
|
+ char z6_signature[4];
|
|
|
+ char z6_recsize[8];
|
|
|
+ char z6_versionmade[2];
|
|
|
+ char z6_versionextr[2];
|
|
|
+ char z6_thisdiskn[4];
|
|
|
+ char z6_alldiskn[4];
|
|
|
+ char z6_thisentries[8];
|
|
|
+ char z6_allentries[8];
|
|
|
+ char z6_dirsize[8];
|
|
|
+ char z6_startsize[8];
|
|
|
+};
|
|
|
+
|
|
|
+#define SIZEOF_zip64loc 20
|
|
|
+struct zip64loc {
|
|
|
+ char z4_signature[4];
|
|
|
+ char z4_startno[4];
|
|
|
+ char z4_reloff[8];
|
|
|
+ char z4_alldiskn[4];
|
|
|
+};
|
|
|
+
|
|
|
+#define SIZEOF_zipend 22
|
|
|
+struct zipend {
|
|
|
+ char ze_signature[4];
|
|
|
+ char ze_thisdiskn[2];
|
|
|
+ char ze_alldiskn[2];
|
|
|
+ char ze_thisentries[2];
|
|
|
+ char ze_allentries[2];
|
|
|
+ char ze_dirsize[4];
|
|
|
+ char ze_startsize[4];
|
|
|
+ char ze_commentlen[2];
|
|
|
+};
|
|
|
+
|
|
|
+#define SIZEOF_zipddesc 16
|
|
|
+struct zipddesc {
|
|
|
+ char zd_signature[4];
|
|
|
+ char zd_crc32[4];
|
|
|
+ char zd_csize[4];
|
|
|
+ char zd_nsize[4];
|
|
|
+};
|
|
|
+
|
|
|
+#define SIZEOF_zipddesc64 24
|
|
|
+struct zipddesc64 {
|
|
|
+ char zd_signature[4];
|
|
|
+ char zd_crc32[4];
|
|
|
+ char zd_csize[8];
|
|
|
+ char zd_nsize[8];
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+ * Magic numbers and strings.
|
|
|
+ */
|
|
|
+static const uint16_t mag_bin = 070707;
|
|
|
+
|
|
|
+static const char mag_asc[6] = "070701";
|
|
|
+static const char mag_crc[6] = "070702";
|
|
|
+static const char mag_odc[6] = "070707";
|
|
|
+static const long mag_sco = 0x7ffffe00;
|
|
|
+
|
|
|
+static const char mag_ustar[6] = "ustar\0";
|
|
|
+static const char mag_gnutar[8] = "ustar \0";
|
|
|
+static const char mag_bar[2] = "V\0";
|
|
|
+
|
|
|
+static const char mag_zipctr[4] = "PK\1\2";
|
|
|
+static const char mag_zipsig[4] = "PK\3\4";
|
|
|
+static const char mag_zipend[4] = "PK\5\6";
|
|
|
+static const char mag_zip64e[4] = "PK\6\6";
|
|
|
+static const char mag_zip64l[4] = "PK\6\7";
|
|
|
+static const char mag_zipdds[4] = "PK\7\10";
|
|
|
+#define mag_zip64f 0x0001
|
|
|
+#define mag_zipcpio 0x0707
|
|
|
+
|
|
|
+
|
|
|
+ * Fields for the extended pax header.
|
|
|
+ */
|
|
|
+static enum paxrec {
|
|
|
+ PR_NONE = 0000,
|
|
|
+ PR_ATIME = 0001,
|
|
|
+ PR_GID = 0002,
|
|
|
+ PR_LINKPATH = 0004,
|
|
|
+ PR_MTIME = 0010,
|
|
|
+ PR_PATH = 0020,
|
|
|
+ PR_SIZE = 0040,
|
|
|
+ PR_UID = 0100,
|
|
|
+ PR_SUN_DEVMAJOR = 0200,
|
|
|
+ PR_SUN_DEVMINOR = 0400
|
|
|
+} paxrec, globrec;
|
|
|
+
|
|
|
+
|
|
|
+ * Prototype structure, collecting user-defined information
|
|
|
+ * about a file.
|
|
|
+ */
|
|
|
+struct prototype {
|
|
|
+ mode_t pt_mode;
|
|
|
+ uid_t pt_uid;
|
|
|
+ gid_t pt_gid;
|
|
|
+ time_t pt_atime;
|
|
|
+ time_t pt_mtime;
|
|
|
+ dev_t pt_rdev;
|
|
|
+ enum {
|
|
|
+ PT_NONE = 0000,
|
|
|
+ PT_TYPE = 0001,
|
|
|
+ PT_OWNER = 0002,
|
|
|
+ PT_GROUP = 0004,
|
|
|
+ PT_MODE = 0010,
|
|
|
+ PT_ATIME = 0020,
|
|
|
+ PT_MTIME = 0040,
|
|
|
+ PT_RDEV = 0100
|
|
|
+ } pt_spec;
|
|
|
+};
|
|
|
+
|
|
|
+static struct stat globst;
|
|
|
+
|
|
|
+
|
|
|
+ * This sets a sanity check limit on path names. If a longer path name
|
|
|
+ * occurs in an archive, it is treated as corrupt. This is because no
|
|
|
+ * known Unix system can handle path names of arbitrary length; limits
|
|
|
+ * are typically between 1024 and 4096. Trying to extract longer path
|
|
|
+ * names would fail anyway and will cpio eventually fail to allocate
|
|
|
+ * memory.
|
|
|
+ */
|
|
|
+#define SANELIMIT 0177777
|
|
|
+
|
|
|
+char *progname;
|
|
|
+static struct dslot *devices;
|
|
|
+static struct dslot *markeddevs;
|
|
|
+static char *blkbuf;
|
|
|
+int blksiz;
|
|
|
+static int blktop;
|
|
|
+static int curpos;
|
|
|
+static uint32_t fakedev;
|
|
|
+static uint32_t fakeino;
|
|
|
+static uint32_t harddev;
|
|
|
+static unsigned long long maxsize;
|
|
|
+static unsigned long long maxrdev;
|
|
|
+static unsigned long long maxmajor;
|
|
|
+static unsigned long long maxminor;
|
|
|
+static unsigned long long maxuid;
|
|
|
+static unsigned long long maxgid;
|
|
|
+static unsigned long long maxnlink;
|
|
|
+static int mt;
|
|
|
+static int mfl;
|
|
|
+static struct stat mtst;
|
|
|
+int aflag;
|
|
|
+int Aflag;
|
|
|
+int bflag;
|
|
|
+int Bflag;
|
|
|
+int cflag;
|
|
|
+int Cflag;
|
|
|
+int dflag;
|
|
|
+int Dflag;
|
|
|
+int eflag;
|
|
|
+int cray_eflag;
|
|
|
+const char *Eflag;
|
|
|
+int fflag;
|
|
|
+int Hflag;
|
|
|
+const char *Iflag;
|
|
|
+int kflag;
|
|
|
+int Kflag;
|
|
|
+int lflag;
|
|
|
+int Lflag;
|
|
|
+int mflag;
|
|
|
+const char *Mflag;
|
|
|
+const char *Oflag;
|
|
|
+int Pflag;
|
|
|
+int rflag;
|
|
|
+const char *Rflag;
|
|
|
+static uid_t Ruid;
|
|
|
+static gid_t Rgid;
|
|
|
+int sflag;
|
|
|
+int Sflag;
|
|
|
+int tflag;
|
|
|
+int uflag;
|
|
|
+int hp_Uflag;
|
|
|
+int vflag;
|
|
|
+int Vflag;
|
|
|
+int sixflag;
|
|
|
+int action;
|
|
|
+long long errcnt;
|
|
|
+static unsigned long long maxpath;
|
|
|
+static uint32_t maxino;
|
|
|
+static uid_t myuid;
|
|
|
+static gid_t mygid;
|
|
|
+static long long blocks;
|
|
|
+static long long bytes;
|
|
|
+static long long nwritten;
|
|
|
+static off_t aoffs;
|
|
|
+static off_t poffs;
|
|
|
+static int tapeblock = -1;
|
|
|
+struct glist *patterns;
|
|
|
+static int tty;
|
|
|
+static const char *cur_ofile;
|
|
|
+static const char *cur_tfile;
|
|
|
+static mode_t umsk;
|
|
|
+static int zipclevel;
|
|
|
+static struct islot *inull;
|
|
|
+int printsev;
|
|
|
+static int compressed_bar;
|
|
|
+static int formatforced;
|
|
|
+static long long lineno;
|
|
|
+
|
|
|
+int pax_dflag;
|
|
|
+int pax_kflag;
|
|
|
+int pax_nflag;
|
|
|
+int pax_sflag;
|
|
|
+int pax_uflag;
|
|
|
+int pax_Xflag;
|
|
|
+static enum {
|
|
|
+ PO_NONE = 0,
|
|
|
+ PO_LINKDATA = 01,
|
|
|
+ PO_TIMES = 02,
|
|
|
+} pax_oflag;
|
|
|
+
|
|
|
+static void copyout(int (*)(const char *, struct stat *));
|
|
|
+static size_t ofiles_cpio(char **, size_t *);
|
|
|
+static void dooutp(void);
|
|
|
+static int outfile(const char *, struct stat *);
|
|
|
+static int addfile(const char *, struct stat *, uint32_t, uint32_t, int,
|
|
|
+ const char *);
|
|
|
+static void iflush(struct islot *, uint32_t);
|
|
|
+static void lflush(void);
|
|
|
+static int bigendian(void);
|
|
|
+static void getbuf(char **, size_t *, size_t);
|
|
|
+static void prdot(int);
|
|
|
+static void newmedia(int);
|
|
|
+static void mclose(void);
|
|
|
+static ssize_t mwrite(int);
|
|
|
+static void bwrite(const char *, size_t);
|
|
|
+static void bflush(void);
|
|
|
+static int sum(int, const char *, struct stat *, char *);
|
|
|
+static int rstime(const char *, struct stat *, const char *);
|
|
|
+static struct islot *isplay(ino_t, struct islot *);
|
|
|
+static struct islot *ifind(ino_t, struct islot **);
|
|
|
+static void iput(struct islot *, struct islot **);
|
|
|
+static struct dslot *dfind(struct dslot **, dev_t);
|
|
|
+static void done(int);
|
|
|
+static void dopass(const char *);
|
|
|
+static int passdata(struct file *, const char *, int);
|
|
|
+static int passfile(const char *, struct stat *);
|
|
|
+static int filein(struct file *, int (*)(struct file *, const char *, int),
|
|
|
+ char *);
|
|
|
+static int linkunlink(const char *, const char *);
|
|
|
+static void tunlink(char **);
|
|
|
+static int filet(struct file *, int (*)(struct file *, const char *, int));
|
|
|
+static void filev(struct file *);
|
|
|
+static int typec(struct stat *);
|
|
|
+static void permbits(mode_t);
|
|
|
+static void prtime_cpio(time_t);
|
|
|
+static void getpath(const char *, char **, char **, size_t *, size_t *);
|
|
|
+static void setpath(const char *, char **, char **,
|
|
|
+ size_t, size_t *, size_t *);
|
|
|
+static int imdir(char *);
|
|
|
+static int setattr(const char *, struct stat *);
|
|
|
+static int setowner(const char *, struct stat *);
|
|
|
+static int canlink(const char *, struct stat *, int);
|
|
|
+static void doinp(void);
|
|
|
+static void storelink(struct file *);
|
|
|
+static void flushlinks(struct file *);
|
|
|
+static void flushnode(struct islot *, struct file *);
|
|
|
+static void flushrest(int);
|
|
|
+static void flushtree(struct islot *, int);
|
|
|
+static int inpone(struct file *, int);
|
|
|
+static int readhdr(struct file *, union bincpio *);
|
|
|
+static void whathdr(void);
|
|
|
+static int infile(struct file *);
|
|
|
+static int skipfile(struct file *);
|
|
|
+static int skipdata(struct file *f,
|
|
|
+ int (*)(struct file *, const char *, int));
|
|
|
+static int indata(struct file *, const char *, int);
|
|
|
+static int totrailer(void);
|
|
|
+static long long rdoct(const char *, int);
|
|
|
+static long long rdhex(const char *, int);
|
|
|
+static ssize_t mread(void);
|
|
|
+static void mstat(void);
|
|
|
+static int skippad(unsigned long long, int);
|
|
|
+static int allzero(const char *, int);
|
|
|
+static const char *getuser(uid_t);
|
|
|
+static const char *getgroup(gid_t);
|
|
|
+static struct glist *want(struct file *, struct glist **);
|
|
|
+static void patfile(void);
|
|
|
+static int ckodd(long long, int, const char *, const char *);
|
|
|
+static int rname(char **, size_t *);
|
|
|
+static int redirect(const char *, const char *);
|
|
|
+static char *tnameof(struct tar_header *, char *);
|
|
|
+static int tmkname(struct tar_header *, const char *);
|
|
|
+static void tlinkof(struct tar_header *, struct file *);
|
|
|
+static int tmklink(struct tar_header *, const char *);
|
|
|
+static int tlflag(struct stat *);
|
|
|
+static void tchksum(union bincpio *);
|
|
|
+static int tcssum(union bincpio *, int);
|
|
|
+static int trdsum(union bincpio *);
|
|
|
+static mode_t tifmt(int);
|
|
|
+static void bchksum(union bincpio *);
|
|
|
+static int bcssum(union bincpio *);
|
|
|
+static void blinkof(const char *, struct file *, int);
|
|
|
+static void dump_barhdr(void);
|
|
|
+static int zcreat(const char *, mode_t);
|
|
|
+static int zclose(int);
|
|
|
+static void markdev(dev_t);
|
|
|
+static int marked(dev_t);
|
|
|
+static void cantsup(int, const char *);
|
|
|
+static void onint(int);
|
|
|
+static int zipread(struct file *, const char *, int, int);
|
|
|
+static void zipreaddesc(struct file *);
|
|
|
+static int cantunzip(struct file *, const char *);
|
|
|
+static time_t gdostime(const char *, const char *);
|
|
|
+static void mkdostime(time_t, char *, char *);
|
|
|
+static ssize_t ziprxtra(struct file *, struct zip_header *);
|
|
|
+static void ziptrailer(void);
|
|
|
+static void zipdefer(const char *, struct stat *, long long,
|
|
|
+ uint32_t, long long, const struct zip_header *);
|
|
|
+static int zipwrite(int, const char *, struct stat *,
|
|
|
+ union bincpio *, size_t, uint32_t, uint32_t,
|
|
|
+ uint32_t *, long long *);
|
|
|
+static int zipwtemp(int, const char *, struct stat *,
|
|
|
+ union bincpio *, size_t, uint32_t, uint32_t,
|
|
|
+ uint32_t *, long long *);
|
|
|
+#if USE_ZLIB
|
|
|
+static int zipwdesc(int, const char *, struct stat *,
|
|
|
+ union bincpio *, size_t, uint32_t, uint32_t,
|
|
|
+ uint32_t *, long long *);
|
|
|
+#endif
|
|
|
+static int zipwxtra(const char *, struct stat *, uint32_t, uint32_t);
|
|
|
+static void zipinfo(struct file *);
|
|
|
+static void readK2hdr(struct file *);
|
|
|
+static int readgnuname(char **, size_t *, long);
|
|
|
+static void writegnuname(const char *, long, int);
|
|
|
+static void tgetpax(struct tar_header *, struct file *);
|
|
|
+static enum paxrec tgetrec(char **, char **, char **);
|
|
|
+static void wrpax(const char *, const char *, struct stat *);
|
|
|
+static void addrec(char **, long *, long *,
|
|
|
+ const char *, const char *, long long);
|
|
|
+static void paxnam(struct tar_header *, const char *);
|
|
|
+static char *sequence(void);
|
|
|
+static char *joinpath(const char *, char *);
|
|
|
+static int utf8(const char *);
|
|
|
+static char *getproto(char *, struct prototype *);
|
|
|
+
|
|
|
+size_t (*ofiles)(char **, size_t *) = ofiles_cpio;
|
|
|
+void (*prtime)(time_t) = prtime_cpio;
|
|
|
+
|
|
|
+int
|
|
|
+main(int argc, char **argv)
|
|
|
+{
|
|
|
+ myuid = getuid();
|
|
|
+ mygid = getgid();
|
|
|
+ umask(umsk = umask(0));
|
|
|
+ progname = basename(argv[0]);
|
|
|
+ setlocale(LC_CTYPE, "");
|
|
|
+ setlocale(LC_TIME, "");
|
|
|
+ inull = scalloc(1, sizeof *inull);
|
|
|
+ inull->i_lln = inull->i_rln = inull;
|
|
|
+ flags(argc, argv);
|
|
|
+ switch (action) {
|
|
|
+ case 'i':
|
|
|
+ if (sigset(SIGINT, SIG_IGN) != SIG_IGN)
|
|
|
+ sigset(SIGINT, onint);
|
|
|
+ doinp();
|
|
|
+ break;
|
|
|
+ case 'o':
|
|
|
+ dooutp();
|
|
|
+ break;
|
|
|
+ case 'p':
|
|
|
+ if (sigset(SIGINT, SIG_IGN) != SIG_IGN)
|
|
|
+ sigset(SIGINT, onint);
|
|
|
+ dopass(argv[optind]);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ else if (Vflag)
|
|
|
+ prdot(1);
|
|
|
+ if (pax != PAX_TYPE_CPIO)
|
|
|
+ pax_onexit();
|
|
|
+ fprintf(stderr, "%llu blocks\n", blocks + ((bytes + 0777) >> 9));
|
|
|
+ mclose();
|
|
|
+ if (errcnt && sysv3 == 0)
|
|
|
+ fprintf(stderr, "%llu error(s)\n", errcnt);
|
|
|
+ return errcnt ? sysv3 ? 1 : 2 : 0;
|
|
|
+}
|
|
|
+
|
|
|
+static size_t
|
|
|
+ofiles_cpio(char **name, size_t *namsiz)
|
|
|
+{
|
|
|
+ static struct iblok *ip;
|
|
|
+
|
|
|
+ if (ip == NULL)
|
|
|
+ ip = ib_alloc(0, 0);
|
|
|
+ return ib_getlin(ip, name, namsiz, srealloc);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read the file name list for -o and -p and do initial processing
|
|
|
+ * for each name.
|
|
|
+ */
|
|
|
+static void
|
|
|
+copyout(int (*copyfn)(const char *, struct stat *))
|
|
|
+{
|
|
|
+ char *name = NULL, *np;
|
|
|
+ size_t namsiz = 0, namlen;
|
|
|
+ struct stat st;
|
|
|
+ struct prototype pt;
|
|
|
+
|
|
|
+ while ((namlen = ofiles(&name, &namsiz)) != 0) {
|
|
|
+ lineno++;
|
|
|
+ if (name[namlen-1] == '\n')
|
|
|
+ name[--namlen] = '\0';
|
|
|
+ if (Pflag)
|
|
|
+ np = getproto(name, &pt);
|
|
|
+ else
|
|
|
+ np = name;
|
|
|
+ while (np[0] == '.' && np[1] == '/') {
|
|
|
+ np += 2;
|
|
|
+ while (*np == '/')
|
|
|
+ np++;
|
|
|
+ if (*np == '\0') {
|
|
|
+ np = name;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (lstat(np, &st) < 0) {
|
|
|
+ if (Pflag && *np && ((pt.pt_spec &
|
|
|
+ (PT_TYPE|PT_OWNER|PT_GROUP|PT_MODE|PT_RDEV) &&
|
|
|
+ ((pt.pt_mode&S_IFMT) == S_IFBLK ||
|
|
|
+ (pt.pt_mode&S_IFMT) == S_IFCHR)) ||
|
|
|
+ (pt.pt_spec &
|
|
|
+ (PT_TYPE|PT_OWNER|PT_GROUP|PT_MODE) &&
|
|
|
+ ((pt.pt_mode&S_IFMT) == S_IFDIR ||
|
|
|
+ (pt.pt_mode&S_IFMT) == S_IFIFO ||
|
|
|
+ (pt.pt_mode&S_IFMT) == S_IFREG)))) {
|
|
|
+ memset(&st, 0, sizeof st);
|
|
|
+ st.st_mode = pt.pt_mode;
|
|
|
+ st.st_blksize = 4096;
|
|
|
+ st.st_nlink = 1;
|
|
|
+ goto missingok;
|
|
|
+ }
|
|
|
+ else if (sysv3 < 0)
|
|
|
+ msg(2, 0, "< %s > ?\n", np);
|
|
|
+ else if (sysv3 > 0)
|
|
|
+ msg(2, 0, "Cannot obtain information "
|
|
|
+ "about file: \"%s\".\n",
|
|
|
+ np);
|
|
|
+ else
|
|
|
+ emsg(2, "Error with lstat of \"%s\"", np);
|
|
|
+ errcnt++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ missingok:
|
|
|
+ if (Lflag && (st.st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ if (stat(np, &st) < 0) {
|
|
|
+ emsg(2, "Cannot follow \"%s\"", np);
|
|
|
+ errcnt++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ * These file types are essentially useless in an archive
|
|
|
+ * since they are recreated by any process that needs them.
|
|
|
+ * We thus ignore them and do not even issue a warning,
|
|
|
+ * because that would only displace more important messages
|
|
|
+ * on a terminal and confuse people who just want to copy
|
|
|
+ * directory hierarchies.--But for pax, POSIX.1-2001 requires
|
|
|
+ * us to fail!
|
|
|
+ */
|
|
|
+ if ((st.st_mode&S_IFMT) == S_IFSOCK ||
|
|
|
+ (st.st_mode&S_IFMT) == S_IFDOOR) {
|
|
|
+ if (pax >= PAX_TYPE_PAX2001) {
|
|
|
+ msg(2, 0, "Cannot handle %s \"%s\".\n",
|
|
|
+ (st.st_mode&S_IFMT) == S_IFSOCK ?
|
|
|
+ "socket" : "door", np);
|
|
|
+ errcnt++;
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (Pflag) {
|
|
|
+ if (pt.pt_spec & PT_TYPE)
|
|
|
+ if ((st.st_mode&S_IFMT) != (pt.pt_mode&S_IFMT))
|
|
|
+ msg(4, 0, "line %lld: types "
|
|
|
+ "do not match\n", lineno);
|
|
|
+ if (pt.pt_spec & PT_OWNER)
|
|
|
+ st.st_uid = pt.pt_uid;
|
|
|
+ if (pt.pt_spec & PT_GROUP)
|
|
|
+ st.st_gid = pt.pt_gid;
|
|
|
+ if (pt.pt_spec & PT_MODE) {
|
|
|
+ st.st_mode &= ~(mode_t)07777;
|
|
|
+ st.st_mode |= pt.pt_mode;
|
|
|
+ }
|
|
|
+ if (pt.pt_spec & PT_ATIME)
|
|
|
+ st.st_atime = pt.pt_atime;
|
|
|
+ if (pt.pt_spec & PT_MTIME)
|
|
|
+ st.st_mtime = pt.pt_mtime;
|
|
|
+ if (pt.pt_spec & PT_RDEV) {
|
|
|
+ if ((st.st_mode&S_IFMT) != S_IFBLK &&
|
|
|
+ (st.st_mode&S_IFMT) != S_IFCHR)
|
|
|
+ msg(4, 0, "line %lld: device type "
|
|
|
+ "specified for non-device "
|
|
|
+ "file\n", lineno);
|
|
|
+ st.st_rdev = pt.pt_rdev;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (pax_track(np, st.st_mtime) == 0)
|
|
|
+ continue;
|
|
|
+ if ((fmttype == FMT_ZIP ||
|
|
|
+ fmttype & TYP_BAR ||
|
|
|
+ fmttype == FMT_GNUTAR)
|
|
|
+ && (st.st_mode&S_IFMT) == S_IFDIR &&
|
|
|
+ name[namlen-1] != '/') {
|
|
|
+ if (namlen+2 >= namsiz) {
|
|
|
+ size_t diff = np - name;
|
|
|
+ name = srealloc(name, namsiz = namlen+2);
|
|
|
+ np = &name[diff];
|
|
|
+ }
|
|
|
+ name[namlen++] = '/';
|
|
|
+ name[namlen] = '\0';
|
|
|
+ }
|
|
|
+ errcnt += copyfn(np, &st);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Execution for -o.
|
|
|
+ */
|
|
|
+static void
|
|
|
+dooutp(void)
|
|
|
+{
|
|
|
+ if (Oflag) {
|
|
|
+ if ((mt = Aflag ? open(Oflag, O_RDWR, 0666) :
|
|
|
+ creat(Oflag, 0666)) < 0) {
|
|
|
+ if (sysv3) {
|
|
|
+ emsg(013, "Cannot open <%s> for %s.", Oflag,
|
|
|
+ Aflag ? "append" : "output");
|
|
|
+ done(1);
|
|
|
+ } else
|
|
|
+ msg(3, -2, "Cannot open \"%s\" for %s\n", Oflag,
|
|
|
+ Aflag ? "append" : "output");
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ mt = dup(1);
|
|
|
+ mstat();
|
|
|
+ blkbuf = svalloc(blksiz, 1);
|
|
|
+ if (Aflag) {
|
|
|
+ if (totrailer() != 0)
|
|
|
+ return;
|
|
|
+ } else if (fmttype == FMT_NONE)
|
|
|
+ fmttype = bigendian() ? FMT_BINBE : FMT_BINLE;
|
|
|
+ if (fmttype & TYP_BINARY) {
|
|
|
+ maxino = 0177777;
|
|
|
+ fakeino = 0177777;
|
|
|
+ maxpath = 256;
|
|
|
+ if (fmttype & TYP_SGI) {
|
|
|
+ maxsize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxmajor = 037777;
|
|
|
+ maxminor = 0777777;
|
|
|
+ } else {
|
|
|
+ maxsize = 0x7FFFFFFFLL;
|
|
|
+ maxrdev = 0177777;
|
|
|
+ }
|
|
|
+ maxuid = 0177777;
|
|
|
+ maxgid = 0177777;
|
|
|
+ maxnlink = 0177777;
|
|
|
+ } else if (fmttype == FMT_ODC) {
|
|
|
+ maxino = 0777777;
|
|
|
+ fakeino = 0777777;
|
|
|
+ maxpath = 256;
|
|
|
+ maxsize = 077777777777LL;
|
|
|
+ maxrdev = 0777777;
|
|
|
+ maxuid = 0777777;
|
|
|
+ maxgid = 0777777;
|
|
|
+ maxnlink = 0777777;
|
|
|
+ } else if (fmttype == FMT_DEC) {
|
|
|
+ maxino = 0777777;
|
|
|
+ fakeino = 0777777;
|
|
|
+ maxpath = 256;
|
|
|
+ maxsize = 077777777777LL;
|
|
|
+ maxmajor = 077777777;
|
|
|
+ maxminor = 077777777;
|
|
|
+ maxuid = 0777777;
|
|
|
+ maxgid = 0777777;
|
|
|
+ maxnlink = 0777777;
|
|
|
+ } else if (fmttype & TYP_NCPIO) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = 1024;
|
|
|
+ maxsize = fmttype&TYP_SCO ? 0x7FFFFFFFFFFFFFFFLL : 0xFFFFFFFFUL;
|
|
|
+ maxmajor = 0xFFFFFFFFUL;
|
|
|
+ maxminor = 0xFFFFFFFFUL;
|
|
|
+ maxuid = 0xFFFFFFFFUL;
|
|
|
+ maxgid = 0xFFFFFFFFUL;
|
|
|
+ maxnlink = 0xFFFFFFFFUL;
|
|
|
+ } else if (fmttype & TYP_CRAY) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = SANELIMIT;
|
|
|
+ maxsize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxrdev = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxuid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxgid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ } else if (fmttype == FMT_GNUTAR) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = SANELIMIT;
|
|
|
+ maxsize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxmajor = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxminor = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxuid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxgid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ } else if (fmttype & TYP_PAX) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = SANELIMIT;
|
|
|
+ maxsize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxmajor = fmttype==FMT_SUN ? 0x7FFFFFFFFFFFFFFFLL : 07777777;
|
|
|
+ maxminor = fmttype==FMT_SUN ? 0x7FFFFFFFFFFFFFFFLL : 07777777;
|
|
|
+ maxuid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxgid = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ if (pax_oflag & PO_TIMES)
|
|
|
+ globrec |= PR_ATIME|PR_MTIME;
|
|
|
+ } else if (fmttype & TYP_BAR) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = 512 - SIZEOF_bar_header - 1;
|
|
|
+ maxsize = 077777777777LL;
|
|
|
+ maxrdev = 07777777;
|
|
|
+ maxuid = 07777777;
|
|
|
+ maxgid = 07777777;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ if (nwritten == 0)
|
|
|
+ dump_barhdr();
|
|
|
+ } else if (fmttype & TYP_USTAR) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = 256;
|
|
|
+ maxsize = 077777777777LL;
|
|
|
+ maxmajor = 07777777;
|
|
|
+ maxminor = 07777777;
|
|
|
+ maxuid = 07777777;
|
|
|
+ maxgid = 07777777;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ } else if (fmttype & TYP_OTAR) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = 99;
|
|
|
+ maxsize = 077777777777LL;
|
|
|
+ maxuid = 07777777;
|
|
|
+ maxgid = 07777777;
|
|
|
+ maxnlink = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ } else if (fmttype == FMT_ZIP) {
|
|
|
+ maxino = 0xFFFFFFFFUL;
|
|
|
+ fakeino = 0xFFFFFFFFUL;
|
|
|
+ maxpath = 60000;
|
|
|
+ maxsize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ maxrdev = 0xFFFFFFFFUL;
|
|
|
+ maxuid = 0xFFFFFFFFUL;
|
|
|
+ maxgid = 0xFFFFFFFFUL;
|
|
|
+ maxnlink = 0xFFFFFFFFUL;
|
|
|
+ } else
|
|
|
+ abort();
|
|
|
+ fakedev = 0177777;
|
|
|
+ harddev = 1;
|
|
|
+ copyout(outfile);
|
|
|
+ if (fmttype & TYP_NCPIO)
|
|
|
+ lflush();
|
|
|
+ if (fmttype & TYP_CPIO) {
|
|
|
+ struct stat st;
|
|
|
+
|
|
|
+ memset(&st, 0, sizeof st);
|
|
|
+ st.st_nlink = 1;
|
|
|
+ outfile(trailer, &st);
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_TAR) {
|
|
|
+ char b[512];
|
|
|
+
|
|
|
+ memset(b, 0, sizeof b);
|
|
|
+ bwrite(b, sizeof b);
|
|
|
+ bwrite(b, sizeof b);
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_ZIP)
|
|
|
+ ziptrailer();
|
|
|
+ bflush();
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Handle a single file for -o, do sanity checks and detect hard links.
|
|
|
+ */
|
|
|
+static int
|
|
|
+outfile(const char *file, struct stat *st)
|
|
|
+{
|
|
|
+ uint32_t dev, ino;
|
|
|
+ size_t pathsz;
|
|
|
+
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG)
|
|
|
+ if (mtst.st_dev == st->st_dev && mtst.st_ino == st->st_ino)
|
|
|
+ return 0;
|
|
|
+ if (st->st_size > maxsize) {
|
|
|
+ msg(2, 0, "Size of %c%s%c >%lluGB. Not dumped\n",
|
|
|
+ sysv3 ? '<' : '"',
|
|
|
+ file,
|
|
|
+ sysv3 ? '>' : '"',
|
|
|
+ (maxsize+1) / (1024*1024*1024));
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (((st->st_mode&S_IFMT)==S_IFBLK||(st->st_mode&S_IFMT)==S_IFCHR) &&
|
|
|
+ (maxrdev &&
|
|
|
+ (unsigned long long)st->st_rdev > maxrdev ||
|
|
|
+ maxmajor &&
|
|
|
+ (unsigned long long)major(st->st_rdev) > maxmajor ||
|
|
|
+ maxminor &&
|
|
|
+ (unsigned long long)minor(st->st_rdev) > maxminor)) {
|
|
|
+ cantsup(1, file);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if ((unsigned long long)st->st_uid > maxuid) {
|
|
|
+ if (cray_eflag) {
|
|
|
+ cantsup(1, file);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ cantsup(0, file);
|
|
|
+ st->st_uid = 60001;
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG && st->st_mode & 0111)
|
|
|
+ st->st_mode &= ~(mode_t)S_ISUID;
|
|
|
+ if ((unsigned long long)st->st_gid > maxgid) {
|
|
|
+ st->st_gid = 60001;
|
|
|
+ if ((st->st_mode&S_IFMT)==S_IFREG && st->st_mode&0010)
|
|
|
+ st->st_mode &= ~(mode_t)S_ISGID;
|
|
|
+ }
|
|
|
+ } else if ((unsigned long long)st->st_gid > maxgid) {
|
|
|
+ if (cray_eflag) {
|
|
|
+ cantsup(1, file);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ cantsup(0, file);
|
|
|
+ st->st_gid = 60001;
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG && st->st_mode & 0010)
|
|
|
+ st->st_mode &= ~(mode_t)S_ISGID;
|
|
|
+ }
|
|
|
+ if ((pathsz = strlen(file)) > maxpath) {
|
|
|
+ msg(2, 0, "%s: file name too long\n", file);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ * Detect hard links and compute fake inode counts. The mechanism
|
|
|
+ * is as follows: If a file has more than one link, a fake device
|
|
|
+ * number starting at one is used for its device, and a fake inode
|
|
|
+ * number is used starting at one too.
|
|
|
+ *
|
|
|
+ * The information on links of directories is useless, so it is
|
|
|
+ * dropped and handled like a file with a single link only: Fake
|
|
|
+ * devices are allocated just below the format's limit, fake
|
|
|
+ * i-nodes the same.
|
|
|
+ *
|
|
|
+ * This way even the binary cpio format can have up to ~4G files.
|
|
|
+ */
|
|
|
+ if (maxino && st->st_nlink > 1 && (st->st_mode&S_IFMT) != S_IFDIR) {
|
|
|
+ struct dslot *ds, *dp;
|
|
|
+ struct islot *ip;
|
|
|
+
|
|
|
+ dev = 1;
|
|
|
+ ds = devices;
|
|
|
+ dp = NULL;
|
|
|
+nextdev:
|
|
|
+ for (; ds; dp = ds, ds = ds->d_nxt, dev++ )
|
|
|
+ if (ds->d_dev == st->st_dev)
|
|
|
+ break;
|
|
|
+ if (markeddevs && marked(dev)) {
|
|
|
+ dev++;
|
|
|
+ goto nextdev;
|
|
|
+ }
|
|
|
+ if (dev >= fakedev)
|
|
|
+ msg(4, 1, "Too many devices in archive, exiting\n");
|
|
|
+ if (ds == NULL) {
|
|
|
+ ds = scalloc(1, sizeof *ds);
|
|
|
+ ds->d_dev = st->st_dev;
|
|
|
+ ds->d_fake = dev;
|
|
|
+ if (devices == NULL)
|
|
|
+ devices = ds;
|
|
|
+ else
|
|
|
+ dp->d_nxt = ds;
|
|
|
+ }
|
|
|
+ harddev = dev;
|
|
|
+ if ((ip = ifind(st->st_ino, &ds->d_isl)) == NULL) {
|
|
|
+ if (ds->d_cnt >= maxino) {
|
|
|
+
|
|
|
+ dev++, dp = ds, ds = ds->d_nxt;
|
|
|
+ goto nextdev;
|
|
|
+ }
|
|
|
+ ip = scalloc(1, sizeof *ip);
|
|
|
+ ip->i_ino = st->st_ino;
|
|
|
+ ip->i_fino = ++ds->d_cnt;
|
|
|
+ ip->i_nlk = st->st_nlink;
|
|
|
+ if (fmttype & TYP_TAR)
|
|
|
+ ip->i_name = sstrdup(file);
|
|
|
+ if (fmttype & TYP_NCPIO) {
|
|
|
+ ip->i_st = smalloc(sizeof *ip->i_st);
|
|
|
+ *ip->i_st = *st;
|
|
|
+ }
|
|
|
+ iput(ip, &ds->d_isl);
|
|
|
+ }
|
|
|
+ ino = ip->i_fino;
|
|
|
+ if (fmttype & TYP_NCPIO) {
|
|
|
+
|
|
|
+ * In SVR4 ascii cpio format, files with multiple
|
|
|
+ * links are stored with a zero size except for the
|
|
|
+ * last link, which contains the actual file content.
|
|
|
+ * As one cannot know which is the last link in
|
|
|
+ * advance since some links may be outside the
|
|
|
+ * archive content, all links have to be collected
|
|
|
+ * and written out at once.
|
|
|
+ */
|
|
|
+ struct ilink *il, *ik;
|
|
|
+
|
|
|
+ switch (ip->i_nlk) {
|
|
|
+ case 1:
|
|
|
+
|
|
|
+ * This was the last link to a file. Write
|
|
|
+ * all previous links and break to write
|
|
|
+ * the actual file content. Free the pointers
|
|
|
+ * in islot; islot remains within the tree
|
|
|
+ * with a remaining link count of zero.
|
|
|
+ */
|
|
|
+ ip->i_nlk--;
|
|
|
+ free(ip->i_st);
|
|
|
+ ip->i_st = NULL;
|
|
|
+ for (il = ip->i_lnk, ik = NULL; il;
|
|
|
+ ik = il, il = il->l_nxt,
|
|
|
+ ik ? free(ik), 0 : 0) {
|
|
|
+ errcnt += addfile(il->l_nam, st,
|
|
|
+ dev, ino, 1, 0);
|
|
|
+ free(il->l_nam);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 0:
|
|
|
+
|
|
|
+ * This file got a link during operation, or
|
|
|
+ * -L was specified and we encountered a link
|
|
|
+ * more than once. Start with a fresh link
|
|
|
+ * count again.
|
|
|
+ */
|
|
|
+ ip->i_nlk = st->st_nlink;
|
|
|
+ ip->i_lnk = NULL;
|
|
|
+ ip->i_st = smalloc(sizeof *ip->i_st);
|
|
|
+ *ip->i_st = *st;
|
|
|
+
|
|
|
+ default:
|
|
|
+
|
|
|
+ * There are more links to this file. Store
|
|
|
+ * only the name and return.
|
|
|
+ */
|
|
|
+ ip->i_nlk--;
|
|
|
+ if (ip->i_lnk) {
|
|
|
+ for (il = ip->i_lnk; il->l_nxt;
|
|
|
+ il = il->l_nxt);
|
|
|
+ il->l_nxt = scalloc(1,sizeof*il->l_nxt);
|
|
|
+ il = il->l_nxt;
|
|
|
+ } else {
|
|
|
+ ip->i_lnk = scalloc(1,sizeof*ip->i_lnk);
|
|
|
+ il = ip->i_lnk;
|
|
|
+ }
|
|
|
+ il->l_nam = smalloc(pathsz + 1);
|
|
|
+ strcpy(il->l_nam, file);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ } else if (fmttype & TYP_TAR) {
|
|
|
+ if (strcmp(ip->i_name, file))
|
|
|
+ return addfile(file, st, dev, ino, 1,
|
|
|
+ ip->i_name);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ dev = fakedev;
|
|
|
+ while (markeddevs && marked(dev))
|
|
|
+ dev--;
|
|
|
+ if ((ino = fakeino--) == 0) {
|
|
|
+ if (--dev <= harddev)
|
|
|
+ msg(4, 1, "Too many devices in archive, "
|
|
|
+ "exiting\n");
|
|
|
+ fakedev = dev;
|
|
|
+ ino = maxino;
|
|
|
+ fakeino = ino - 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return addfile(file, st, dev, ino, 0, 0);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Add a single file to the archive with -o.
|
|
|
+ */
|
|
|
+static int
|
|
|
+addfile(const char *realfile, struct stat *st,
|
|
|
+ uint32_t dev, uint32_t ino, int zerolink, const char *linkname)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+ int fd = -1;
|
|
|
+ long long size;
|
|
|
+ int pad, i;
|
|
|
+ ssize_t rsz = 0, wsz = 0, hsz, fsz, psz;
|
|
|
+ long long remsz, relative, nlink;
|
|
|
+ long long Kbase = 0, Krest = 0, Ksize = 0;
|
|
|
+ struct hdr_cpio K2hdr;
|
|
|
+ uint32_t crc = 0;
|
|
|
+ long long csize = 0;
|
|
|
+ char *file;
|
|
|
+ char *symblink = NULL;
|
|
|
+ int failure = 1;
|
|
|
+
|
|
|
+ file = sstrdup(realfile);
|
|
|
+ if (pax != PAX_TYPE_CPIO && strcmp(file, trailer)) {
|
|
|
+ size_t junk = 0;
|
|
|
+ if (pax_sflag && pax_sname(&file, &junk) == 0)
|
|
|
+ goto cleanup;
|
|
|
+ if (rflag && rname(&file, &junk) == 0)
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ fsz = strlen(file);
|
|
|
+ relative = nwritten;
|
|
|
+ memset(bc.data, 0, sizeof bc.data);
|
|
|
+ if (fmttype == FMT_PAX && pax_oflag & PO_LINKDATA &&
|
|
|
+ (st->st_mode&S_IFMT) == S_IFREG)
|
|
|
+ size = st->st_size;
|
|
|
+ else if (zerolink)
|
|
|
+ size = 0;
|
|
|
+ else if ((st->st_mode&S_IFMT) == S_IFREG)
|
|
|
+ size = st->st_size;
|
|
|
+ else if ((st->st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ i = st->st_size ? st->st_size : PATH_MAX;
|
|
|
+ symblink = smalloc(i+1);
|
|
|
+ if ((size = readlink(realfile, symblink, i)) < 0) {
|
|
|
+ emsg(3, "Cannot read symbolic link \"%s\"", realfile);
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ symblink[size] = '\0';
|
|
|
+ } else
|
|
|
+ size = 0;
|
|
|
+ nlink = ((unsigned long long)st->st_nlink>maxnlink ?
|
|
|
+ maxnlink : st->st_nlink);
|
|
|
+ if (fmttype & TYP_NCPIO) {
|
|
|
+ long size1;
|
|
|
+ if (fmttype & TYP_SCO && size >= mag_sco) {
|
|
|
+ char *ofile = file;
|
|
|
+ size1 = mag_sco;
|
|
|
+ fsz += 22;
|
|
|
+ file = smalloc(fsz + 1);
|
|
|
+ snprintf(file, fsz + 1, "%s%csize=%016llx",
|
|
|
+ ofile, 0, size);
|
|
|
+ free(ofile);
|
|
|
+ } else
|
|
|
+ size1 = size;
|
|
|
+ pad = 4;
|
|
|
+ sprintf(bc.data, "%*.*s%08lx%08lx%08lx%08lx%08lx%08lx"
|
|
|
+ "%08lx%08lx%08lx%08lx%08lx%08lx%08lx",
|
|
|
+ (int)(fmttype&TYP_CRC? sizeof mag_crc:sizeof mag_asc),
|
|
|
+ (int)(fmttype&TYP_CRC? sizeof mag_crc:sizeof mag_asc),
|
|
|
+ fmttype & TYP_CRC ? mag_crc : mag_asc,
|
|
|
+ (long)ino & ECUT,
|
|
|
+ (long)st->st_mode & ECUT,
|
|
|
+ (long)st->st_uid & ECUT,
|
|
|
+ (long)st->st_gid & ECUT,
|
|
|
+ (long)nlink & ECUT,
|
|
|
+ (long)st->st_mtime & ECUT,
|
|
|
+ (long)size1 & ECUT,
|
|
|
+ (long)major(dev) & ECUT,
|
|
|
+ (long)minor(dev) & ECUT,
|
|
|
+ (long)major(st->st_rdev) & ECUT,
|
|
|
+ (long)minor(st->st_rdev) & ECUT,
|
|
|
+ (long)++fsz,
|
|
|
+ 0L);
|
|
|
+ hsz = SIZEOF_Exp_cpio_hdr;
|
|
|
+ if ((psz = (hsz + fsz) % pad) != 0)
|
|
|
+ psz = pad - psz;
|
|
|
+ } else if (fmttype == FMT_ODC) {
|
|
|
+ pad = 1;
|
|
|
+ sprintf(bc.data, "%*.*s%06lo%06lo%06lo%06lo%06lo%06lo%06lo"
|
|
|
+ "%011lo%06lo%011lo",
|
|
|
+ (int)sizeof mag_odc, (int)sizeof mag_odc, mag_odc,
|
|
|
+ (long)dev & OCUT,
|
|
|
+ (long)ino & OCUT,
|
|
|
+ (long)st->st_mode & OCUT,
|
|
|
+ (long)st->st_uid & OCUT,
|
|
|
+ (long)st->st_gid & OCUT,
|
|
|
+ (long)nlink & OCUT,
|
|
|
+ (long)st->st_rdev & OCUT,
|
|
|
+ (long)st->st_mtime,
|
|
|
+ (long)++fsz,
|
|
|
+ (long)size);
|
|
|
+ hsz = SIZEOF_c_hdr;
|
|
|
+ if ((psz = (hsz + fsz) % pad) != 0)
|
|
|
+ psz = pad - psz;
|
|
|
+ } else if (fmttype == FMT_DEC) {
|
|
|
+ pad = 1;
|
|
|
+ sprintf(bc.data, "%*.*s%06lo%06lo%06lo%06lo%06lo%06lo"
|
|
|
+ "%08lo%08lo%011lo%06lo%011lo",
|
|
|
+ (int)sizeof mag_odc, (int)sizeof mag_odc, mag_odc,
|
|
|
+ (long)dev & OCUT,
|
|
|
+ (long)ino & OCUT,
|
|
|
+ (long)st->st_mode & OCUT,
|
|
|
+ (long)st->st_uid & OCUT,
|
|
|
+ (long)st->st_gid & OCUT,
|
|
|
+ (long)nlink & OCUT,
|
|
|
+ (long)major(st->st_rdev) & 077777777,
|
|
|
+ (long)minor(st->st_rdev) & 077777777,
|
|
|
+ (long)st->st_mtime,
|
|
|
+ (long)++fsz,
|
|
|
+ (long)size);
|
|
|
+ hsz = SIZEOF_d_hdr;
|
|
|
+ if ((psz = (hsz + fsz) % pad) != 0)
|
|
|
+ psz = pad - psz;
|
|
|
+ } else if (fmttype & TYP_BINARY) {
|
|
|
+
|
|
|
+ * To avoid gcc's stupid 'comparison is always false due to
|
|
|
+ * limited range of data type' warning.
|
|
|
+ */
|
|
|
+ unsigned long long gcccrap;
|
|
|
+ pad = 2;
|
|
|
+ if (fmttype & TYP_BE) {
|
|
|
+ be16p(mag_bin, bc.Hdr.c_magic);
|
|
|
+ be16p(dev, bc.Hdr.c_dev);
|
|
|
+ be16p(ino, bc.Hdr.c_ino);
|
|
|
+ be16p(st->st_mode, bc.Hdr.c_mode);
|
|
|
+ be16p(st->st_uid, bc.Hdr.c_uid);
|
|
|
+ be16p(st->st_gid, bc.Hdr.c_gid);
|
|
|
+ be16p(nlink, bc.Hdr.c_nlink);
|
|
|
+ be16p(st->st_rdev, bc.Hdr.c_rdev);
|
|
|
+ be32p(st->st_mtime, bc.Hdr.c_mtime);
|
|
|
+ be16p(++fsz, bc.Hdr.c_namesize);
|
|
|
+ } else {
|
|
|
+ le16p(mag_bin, bc.Hdr.c_magic);
|
|
|
+ le16p(dev, bc.Hdr.c_dev);
|
|
|
+ le16p(ino, bc.Hdr.c_ino);
|
|
|
+ le16p(st->st_mode, bc.Hdr.c_mode);
|
|
|
+ le16p(st->st_uid, bc.Hdr.c_uid);
|
|
|
+ le16p(st->st_gid, bc.Hdr.c_gid);
|
|
|
+ le16p(nlink, bc.Hdr.c_nlink);
|
|
|
+ le16p(st->st_rdev, bc.Hdr.c_rdev);
|
|
|
+ me32p(st->st_mtime, bc.Hdr.c_mtime);
|
|
|
+ le16p(++fsz, bc.Hdr.c_namesize);
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_SGI && size > 0x7FFFFFFFLL) {
|
|
|
+ Krest = size & 0x7FFFFFFFLL;
|
|
|
+ Kbase = size - Krest;
|
|
|
+ Ksize = 0x100000000LL - (Kbase >> 31);
|
|
|
+ if (fmttype & TYP_BE)
|
|
|
+ be32p(Ksize, bc.Hdr.c_filesize);
|
|
|
+ else
|
|
|
+ me32p(Ksize, bc.Hdr.c_filesize);
|
|
|
+ K2hdr = bc.Hdr;
|
|
|
+ if (fmttype & TYP_BE)
|
|
|
+ be32p(Krest, K2hdr.c_filesize);
|
|
|
+ else
|
|
|
+ me32p(Krest, K2hdr.c_filesize);
|
|
|
+ } else {
|
|
|
+ if (fmttype & TYP_BE)
|
|
|
+ be32p(size, bc.Hdr.c_filesize);
|
|
|
+ else
|
|
|
+ me32p(size, bc.Hdr.c_filesize);
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_SGI &&
|
|
|
+ (((st->st_mode&S_IFMT) == S_IFBLK ||
|
|
|
+ (st->st_mode&S_IFMT) == S_IFCHR) &&
|
|
|
+ ((unsigned long long)major(st->st_rdev)>0xFF ||
|
|
|
+ (unsigned long long)minor(st->st_rdev)>0xFF) ||
|
|
|
+ (gcccrap = st->st_rdev) > 0177777)) {
|
|
|
+ uint32_t rdev;
|
|
|
+ rdev = (minor(st->st_rdev) & 0x0003FFFF) +
|
|
|
+ ((major(st->st_rdev)<<18) & 0xFFFC0000);
|
|
|
+ if (fmttype & TYP_BE) {
|
|
|
+ be16p(0xFFFF, bc.Hdr.c_rdev);
|
|
|
+ be32p(rdev, bc.Hdr.c_filesize);
|
|
|
+ } else {
|
|
|
+ le16p(0xFFFF, bc.Hdr.c_rdev);
|
|
|
+ me32p(rdev, bc.Hdr.c_filesize);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ hsz = SIZEOF_hdr_cpio;
|
|
|
+ psz = (hsz + fsz) % 2;
|
|
|
+ } else if (fmttype & TYP_CRAY) {
|
|
|
+ int diff5 = fmttype==FMT_CRAY5 ? CRAY_PARAMSZ : 0;
|
|
|
+ mode_t mo;
|
|
|
+ pad = 1;
|
|
|
+ be64p(mag_bin, bc.Crayhdr.C_magic);
|
|
|
+ be64p(dev, bc.Crayhdr.C_dev);
|
|
|
+ be64p(ino, bc.Crayhdr.C_ino);
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFLNK)
|
|
|
+ mo = st->st_mode&07777|0130000;
|
|
|
+ else
|
|
|
+ mo = st->st_mode;
|
|
|
+ be64p(mo, bc.Crayhdr.C_mode);
|
|
|
+ be64p(st->st_uid, bc.Crayhdr.C_uid);
|
|
|
+ be64p(st->st_gid, bc.Crayhdr.C_gid);
|
|
|
+ be64p(nlink, bc.Crayhdr.C_nlink);
|
|
|
+ be64p(st->st_rdev, bc.Crayhdr.C_rdev);
|
|
|
+ be64p(st->st_mtime, bc.Crayhdr.C_mtime - diff5);
|
|
|
+ be64p(++fsz, bc.Crayhdr.C_namesize - diff5);
|
|
|
+ be64p(size, bc.Crayhdr.C_filesize - diff5);
|
|
|
+ hsz = SIZEOF_cray_hdr - diff5;
|
|
|
+ psz = 0;
|
|
|
+ } else if (fmttype & TYP_BAR) {
|
|
|
+ int c, n = 0;
|
|
|
+ pad = 512;
|
|
|
+ sprintf(bc.Bdr.b_mode, "%7.7o",(int)st->st_mode&(07777|S_IFMT));
|
|
|
+ sprintf(bc.Bdr.b_uid, "%7.7lo", (long)st->st_uid);
|
|
|
+ sprintf(bc.Bdr.b_gid, "%7.7lo", (long)st->st_gid);
|
|
|
+ sprintf(bc.Bdr.b_size, "%11.11llo",
|
|
|
+ (st->st_mode&S_IFMT) == S_IFREG && !zerolink ?
|
|
|
+ (long long)st->st_size&077777777777LL : 0LL);
|
|
|
+ sprintf(bc.Bdr.b_mtime, "%11.11lo", (long)st->st_mtime);
|
|
|
+ sprintf(bc.Bdr.b_rdev, "%7.7lo", (long)st->st_rdev);
|
|
|
+ strcpy(&bc.data[SIZEOF_bar_header], file);
|
|
|
+ c = tlflag(st);
|
|
|
+ if (zerolink == 0) {
|
|
|
+ bc.Bdr.b_linkflag = c;
|
|
|
+ if (c == '2') {
|
|
|
+ strncpy(&bc.data[SIZEOF_bar_header+fsz+1],
|
|
|
+ symblink,
|
|
|
+ 512-SIZEOF_bar_header-fsz);
|
|
|
+ n = size;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ bc.Bdr.b_linkflag = '1';
|
|
|
+ strncpy(&bc.data[SIZEOF_bar_header+fsz+1], linkname,
|
|
|
+ 512-SIZEOF_bar_header-fsz-1);
|
|
|
+ n = strlen(linkname);
|
|
|
+ }
|
|
|
+ if (n > 512-SIZEOF_bar_header-fsz-1) {
|
|
|
+ msg(3, 0, "%s: linked name too long\n", realfile);
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ bchksum(&bc);
|
|
|
+ hsz = 512;
|
|
|
+ psz = 0;
|
|
|
+ fsz = 0;
|
|
|
+ } else if (fmttype & TYP_TAR) {
|
|
|
+ const char *cp;
|
|
|
+ int c;
|
|
|
+
|
|
|
+ * Many SVR4 cpio derivatives expect the mode field
|
|
|
+ * to contain S_IFMT bits. The meaning of these bits
|
|
|
+ * in the mode field of the ustar header is left
|
|
|
+ * unspecified by IEEE Std 1003.1, 1996, 10.1.1.
|
|
|
+ */
|
|
|
+ int mmask = fmttype == FMT_USTAR || fmttype == FMT_PAX ?
|
|
|
+ 07777 : 07777|S_IFMT;
|
|
|
+
|
|
|
+ paxrec = globrec;
|
|
|
+ pad = 512;
|
|
|
+ if (tmkname(&bc.Tdr, file) != 0)
|
|
|
+ goto cleanup;
|
|
|
+ sprintf(bc.Tdr.t_mode, "%7.7o", (int)st->st_mode & mmask);
|
|
|
+ if (fmttype == FMT_GNUTAR && st->st_uid > 07777777) {
|
|
|
+ be64p(st->st_uid, bc.Tdr.t_uid);
|
|
|
+ bc.Tdr.t_uid[0] |= 0200;
|
|
|
+ } else {
|
|
|
+ sprintf(bc.Tdr.t_uid, "%7.7lo",
|
|
|
+ (long)st->st_uid&07777777);
|
|
|
+ if (fmttype & TYP_PAX && st->st_uid > 07777777)
|
|
|
+ paxrec |= PR_UID;
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_GNUTAR && st->st_gid > 07777777) {
|
|
|
+ be64p(st->st_gid, bc.Tdr.t_gid);
|
|
|
+ bc.Tdr.t_gid[0] |= 0200;
|
|
|
+ } else {
|
|
|
+ sprintf(bc.Tdr.t_gid, "%7.7lo",
|
|
|
+ (long)st->st_gid&07777777);
|
|
|
+ if (fmttype & TYP_PAX && st->st_gid > 07777777)
|
|
|
+ paxrec |= PR_GID;
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_GNUTAR && (st->st_mode&S_IFMT) == S_IFREG &&
|
|
|
+ st->st_size > 077777777777LL && !zerolink) {
|
|
|
+ bc.Tdr.t_size[0] = '\200';
|
|
|
+ be64p(st->st_size, &bc.Tdr.t_size[4]);
|
|
|
+ } else {
|
|
|
+ sprintf(bc.Tdr.t_size, "%11.11llo",
|
|
|
+ (st->st_mode&S_IFMT) == S_IFREG &&
|
|
|
+ (!zerolink || fmttype == FMT_PAX &&
|
|
|
+ pax_oflag & PO_LINKDATA) ?
|
|
|
+ (long long)st->st_size&077777777777LL : 0LL);
|
|
|
+ if (fmttype & TYP_PAX &&
|
|
|
+ (st->st_mode&S_IFMT) == S_IFREG &&
|
|
|
+ st->st_size > 077777777777LL &&
|
|
|
+ (!zerolink || fmttype == FMT_PAX &&
|
|
|
+ pax_oflag & PO_LINKDATA))
|
|
|
+ paxrec |= PR_SIZE;
|
|
|
+ }
|
|
|
+ sprintf(bc.Tdr.t_mtime, "%11.11lo", (long)st->st_mtime);
|
|
|
+ if ((c = tlflag(st)) < 0) {
|
|
|
+ if ((st->st_mode&S_IFMT) != S_IFDIR) {
|
|
|
+ msg(2, 0, "%s is not a file. Not dumped\n",
|
|
|
+ realfile);
|
|
|
+ errcnt++;
|
|
|
+ } else
|
|
|
+ failure = 0;
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ if (zerolink == 0) {
|
|
|
+ bc.Tdr.t_linkflag = c;
|
|
|
+ if (c == '2') {
|
|
|
+ if (tmklink(&bc.Tdr, symblink) != 0)
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ bc.Tdr.t_linkflag = '1';
|
|
|
+ if (tmklink(&bc.Tdr, linkname) != 0)
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_USTAR) {
|
|
|
+ if (fmttype == FMT_GNUTAR)
|
|
|
+ strcpy(bc.Tdr.t_magic, mag_gnutar);
|
|
|
+ else {
|
|
|
+ strcpy(bc.Tdr.t_magic, mag_ustar);
|
|
|
+ bc.Tdr.t_version[0] = bc.Tdr.t_version[1] = '0';
|
|
|
+ }
|
|
|
+ if ((cp = getuser(st->st_uid)) != NULL)
|
|
|
+ sprintf(bc.Tdr.t_uname, "%.31s", cp);
|
|
|
+ else
|
|
|
+ msg(1, 0, "could not get passwd information "
|
|
|
+ "for %s\n", realfile);
|
|
|
+ if ((cp = getgroup(st->st_gid)) != NULL)
|
|
|
+ sprintf(bc.Tdr.t_gname, "%.31s", cp);
|
|
|
+ else
|
|
|
+ msg(1, 0, "could not get group information "
|
|
|
+ "for %s\n", realfile);
|
|
|
+ if (fmttype == FMT_GNUTAR &&
|
|
|
+ (unsigned long long)major(st->st_rdev)
|
|
|
+ > 077777777) {
|
|
|
+ be64p(major(st->st_rdev), bc.Tdr.t_devmajor);
|
|
|
+ bc.Tdr.t_devmajor[0] |= 0200;
|
|
|
+ } else {
|
|
|
+ if (fmttype == FMT_SUN &&
|
|
|
+ (unsigned long long)major(st->st_rdev)
|
|
|
+ > 077777777 &&
|
|
|
+ ((st->st_mode&S_IFMT)==S_IFBLK||
|
|
|
+ (st->st_mode&S_IFMT)==S_IFCHR))
|
|
|
+ paxrec |= PR_SUN_DEVMAJOR;
|
|
|
+ sprintf(bc.Tdr.t_devmajor, "%7.7o",
|
|
|
+ (int)major(st->st_rdev)&07777777);
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_GNUTAR &&
|
|
|
+ (unsigned long long)minor(st->st_rdev)
|
|
|
+ > 077777777) {
|
|
|
+ be64p(minor(st->st_rdev), bc.Tdr.t_devminor);
|
|
|
+ bc.Tdr.t_devminor[0] |= 0200;
|
|
|
+ } else {
|
|
|
+ if (fmttype == FMT_SUN &&
|
|
|
+ (unsigned long long)minor(st->st_rdev)
|
|
|
+ > 077777777 &&
|
|
|
+ ((st->st_mode&S_IFMT)==S_IFBLK||
|
|
|
+ (st->st_mode&S_IFMT)==S_IFCHR))
|
|
|
+ paxrec |= PR_SUN_DEVMINOR;
|
|
|
+ sprintf(bc.Tdr.t_devminor, "%7.7o",
|
|
|
+ (int)minor(st->st_rdev)&07777777);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ tchksum(&bc);
|
|
|
+ hsz = 512;
|
|
|
+ psz = 0;
|
|
|
+ fsz = 0;
|
|
|
+ } else if (fmttype == FMT_ZIP) {
|
|
|
+ pad = 1;
|
|
|
+ memcpy(bc.Zdr.z_signature, mag_zipsig, sizeof mag_zipsig);
|
|
|
+ bc.Zdr.z_version[0] = 10;
|
|
|
+ mkdostime(st->st_mtime, bc.Zdr.z_modtime, bc.Zdr.z_moddate);
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG ||
|
|
|
+ (st->st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ le32p(size, bc.Zdr.z_csize);
|
|
|
+ le32p(size, bc.Zdr.z_nsize);
|
|
|
+ csize = size;
|
|
|
+ }
|
|
|
+ le16p(fsz, bc.Zdr.z_namelen);
|
|
|
+ le16p(SIZEOF_zextra_cp, bc.Zdr.z_extralen);
|
|
|
+ hsz = SIZEOF_zip_header;
|
|
|
+ psz = 0;
|
|
|
+ } else
|
|
|
+ abort();
|
|
|
+
|
|
|
+ * Start writing the file to the archive.
|
|
|
+ */
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG && st->st_size != 0 &&
|
|
|
+ (zerolink == 0 || fmttype == FMT_PAX &&
|
|
|
+ pax_oflag & PO_LINKDATA)) {
|
|
|
+ char *buf;
|
|
|
+ size_t bufsize;
|
|
|
+ int readerr = 0;
|
|
|
+
|
|
|
+ if ((fd = open(realfile, O_RDONLY)) < 0) {
|
|
|
+ if (sysv3 < 0)
|
|
|
+ msg(0, 0, "< %s > ?\n", realfile);
|
|
|
+ else if (sysv3 > 0)
|
|
|
+ fprintf(stderr, "<%s> ?\n", realfile);
|
|
|
+ else
|
|
|
+ msg(0, 0, "\"%s\" ?\n", realfile);
|
|
|
+ goto cleanup;
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_ZIP) {
|
|
|
+ if (zipwrite(fd, file, st, &bc, fsz, dev, ino,
|
|
|
+ &crc, &csize) < 0)
|
|
|
+ goto cleanup2;
|
|
|
+ goto done;
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_CRC)
|
|
|
+ if (sum(fd, realfile, st, bc.Edr.E_chksum) < 0)
|
|
|
+ goto cleanup2;
|
|
|
+ if (fmttype & TYP_PAX && paxrec != PR_NONE)
|
|
|
+ wrpax(file, symblink?symblink:linkname, st);
|
|
|
+ bwrite(bc.data, hsz);
|
|
|
+ if (fsz)
|
|
|
+ bwrite(file, fsz);
|
|
|
+ if (psz)
|
|
|
+ bwrite(&bc.data[hsz], psz);
|
|
|
+ if (Kbase)
|
|
|
+ remsz = Kbase;
|
|
|
+ else
|
|
|
+ remsz = st->st_size;
|
|
|
+ getbuf(&buf, &bufsize, st->st_blksize);
|
|
|
+ again: while (remsz > 0) {
|
|
|
+ if (fd < 0 || (rsz = read(fd, &buf[wsz],
|
|
|
+ bufsize - wsz)) < 0) {
|
|
|
+ if (readerr == 0) {
|
|
|
+ emsg(3, "Cannot read \"%s\"", realfile);
|
|
|
+ if (fd >= 0)
|
|
|
+ errcnt++;
|
|
|
+ readerr = 1;
|
|
|
+ }
|
|
|
+ if (fd >= 0 && lseek(fd, bufsize - wsz,
|
|
|
+ SEEK_CUR) < 0) {
|
|
|
+ close(fd);
|
|
|
+ fd = -1;
|
|
|
+ }
|
|
|
+ rsz = bufsize - wsz;
|
|
|
+ if (rsz > remsz)
|
|
|
+ rsz = remsz;
|
|
|
+ memset(&buf[wsz], 0, rsz);
|
|
|
+ }
|
|
|
+ if (rsz > remsz)
|
|
|
+ rsz = remsz;
|
|
|
+ wsz += rsz;
|
|
|
+ remsz -= rsz;
|
|
|
+ bwrite(buf, wsz);
|
|
|
+ memset(buf, 0, wsz);
|
|
|
+ size = wsz;
|
|
|
+ wsz = 0;
|
|
|
+ }
|
|
|
+ wsz = size;
|
|
|
+ if (Kbase) {
|
|
|
+ if ((i = Ksize % pad) != 0)
|
|
|
+ bwrite(&bc.data[hsz], i);
|
|
|
+ bwrite((char *)&K2hdr, hsz);
|
|
|
+ if (fsz)
|
|
|
+ bwrite(file, fsz);
|
|
|
+ if (psz)
|
|
|
+ bwrite(&bc.data[hsz], psz);
|
|
|
+ remsz = Krest;
|
|
|
+ Kbase = 0;
|
|
|
+ wsz = 0;
|
|
|
+ goto again;
|
|
|
+ } else if (Ksize)
|
|
|
+ wsz = Krest;
|
|
|
+ } else if ((fmttype == FMT_ZIP || fmttype & TYP_CPIO) &&
|
|
|
+ (st->st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ wsz = size;
|
|
|
+ if (fmttype == FMT_ZIP) {
|
|
|
+ crc = zipcrc(0, (unsigned char *)symblink, wsz);
|
|
|
+ le32p(crc, bc.Zdr.z_crc32);
|
|
|
+ bwrite(bc.data, SIZEOF_zip_header);
|
|
|
+ bwrite(file, fsz);
|
|
|
+ zipwxtra(file, st, dev, ino);
|
|
|
+ bwrite(symblink, wsz);
|
|
|
+ } else {
|
|
|
+ bwrite(bc.data, hsz);
|
|
|
+ if (fsz)
|
|
|
+ bwrite(file, fsz);
|
|
|
+ if (psz)
|
|
|
+ bwrite(&bc.data[hsz], psz);
|
|
|
+ bwrite(symblink, wsz);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (fmttype & TYP_PAX && paxrec != PR_NONE)
|
|
|
+ wrpax(file, symblink?symblink:linkname, st);
|
|
|
+ bwrite(bc.data, hsz);
|
|
|
+ if (fsz)
|
|
|
+ bwrite(file, fsz);
|
|
|
+ if (psz)
|
|
|
+ bwrite(&bc.data[hsz], psz);
|
|
|
+ if (fmttype == FMT_ZIP)
|
|
|
+ zipwxtra(file, st, dev, ino);
|
|
|
+ }
|
|
|
+done: if (fmttype == FMT_ZIP) {
|
|
|
+ zipdefer(file, st, relative, crc, csize, &bc.Zdr);
|
|
|
+ }
|
|
|
+ if ((i = wsz % pad) != 0)
|
|
|
+ bwrite(&bc.data[hsz], pad - i);
|
|
|
+ if (vflag && strcmp(file, trailer))
|
|
|
+ fprintf(stderr, "%s\n", file);
|
|
|
+ else if (Vflag)
|
|
|
+ prdot(0);
|
|
|
+ failure = 0;
|
|
|
+cleanup2:
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFREG) {
|
|
|
+ if (fd >= 0)
|
|
|
+ close(fd);
|
|
|
+ if (aflag)
|
|
|
+ errcnt += rstime(realfile, st, "access");
|
|
|
+ }
|
|
|
+cleanup:
|
|
|
+ free(file);
|
|
|
+ free(symblink);
|
|
|
+ return failure;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Flush a SVR4 cpio format inode tree for -o.
|
|
|
+ */
|
|
|
+static void
|
|
|
+iflush(struct islot *ip, uint32_t dev)
|
|
|
+{
|
|
|
+ if (ip == inull)
|
|
|
+ return;
|
|
|
+ iflush(ip->i_lln, dev);
|
|
|
+ iflush(ip->i_rln, dev);
|
|
|
+ if (ip->i_nlk > 0 && ip->i_st) {
|
|
|
+ struct ilink *il;
|
|
|
+
|
|
|
+ for (il = ip->i_lnk; il->l_nxt; il = il->l_nxt)
|
|
|
+ errcnt += addfile(il->l_nam, ip->i_st,
|
|
|
+ dev, ip->i_fino, 1, 0);
|
|
|
+ errcnt += addfile(il->l_nam, ip->i_st, dev, ip->i_fino, 0, 0);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Flush the SVR4 cpio link forest for -o.
|
|
|
+ */
|
|
|
+static void
|
|
|
+lflush(void)
|
|
|
+{
|
|
|
+ struct dslot *ds;
|
|
|
+
|
|
|
+ for (ds = devices; ds; ds = ds->d_nxt)
|
|
|
+ iflush(ds->d_isl, ds->d_fake);
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+setfmt(char *s)
|
|
|
+{
|
|
|
+ int i, j;
|
|
|
+
|
|
|
+ struct {
|
|
|
+ const char *ucs;
|
|
|
+ const char *lcs;
|
|
|
+ int type;
|
|
|
+ int bits;
|
|
|
+ } fs[] = {
|
|
|
+ { "NEWC", "newc", FMT_ASC, 00 },
|
|
|
+ { "SCO", "sco", FMT_SCOASC, 00 },
|
|
|
+ { "CRC", "crc", FMT_CRC, 00 },
|
|
|
+ { "SCOCRC", "scocrc", FMT_SCOCRC, 00 },
|
|
|
+ { "ODC", "odc", FMT_ODC, 00 },
|
|
|
+ { "DEC", "dec", FMT_DEC, 00 },
|
|
|
+ { "BIN", "bin", FMT_NONE, 00 },
|
|
|
+ { "BBS", "bbs", TYP_BE, 00 },
|
|
|
+ { "SGI", "sgi", FMT_SGIBE, 00 },
|
|
|
+ { "CRAY", "cray", FMT_CRAY, 00 },
|
|
|
+ { "CRAY5", "cray5", FMT_CRAY5, 00 },
|
|
|
+ { "TAR", "tar", FMT_TAR, 00 },
|
|
|
+ { "USTAR", "ustar", FMT_USTAR, 00 },
|
|
|
+ { "PAX:", "pax:", FMT_PAX, 00 },
|
|
|
+ { "SUN", "sun", FMT_SUN, 00 },
|
|
|
+ { "GNU", "gnu", FMT_GNUTAR, 00 },
|
|
|
+ { "OTAR", "otar", FMT_OTAR, 00 },
|
|
|
+ { "BAR", "bar", FMT_BAR, 00 },
|
|
|
+ { "ZIP:", "zip:", FMT_ZIP, 00 },
|
|
|
+ { NULL, NULL, 0, 00 }
|
|
|
+ };
|
|
|
+ for (i = 0; fs[i].ucs; i++) {
|
|
|
+ for (j = 0; s[j] &&
|
|
|
+ (s[j] == fs[i].ucs[j] || s[j] == fs[i].lcs[j]);
|
|
|
+ j++)
|
|
|
+ if (fs[i].ucs[j] == ':')
|
|
|
+ break;
|
|
|
+ if (s[j] == '\0' &&
|
|
|
+ (fs[i].ucs[j] == '\0' || fs[i].ucs[j] == ':') ||
|
|
|
+ s[j] == ':' && fs[i].ucs[j] == ':') {
|
|
|
+ fmttype = fs[i].type;
|
|
|
+ if (fmttype == FMT_ZIP && s[j] == ':') {
|
|
|
+#if USE_ZLIB
|
|
|
+ if (strcmp(&s[j+1], "en") == 0)
|
|
|
+ zipclevel = 00;
|
|
|
+ else if (strcmp(&s[j+1], "ex") == 0)
|
|
|
+ zipclevel = 01;
|
|
|
+ else if (strcmp(&s[j+1], "ef") == 0)
|
|
|
+ zipclevel = 02;
|
|
|
+ else if (strcmp(&s[j+1], "es") == 0)
|
|
|
+ zipclevel = 03;
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ if (strcmp(&s[j+1], "e0") == 0)
|
|
|
+ zipclevel = 04;
|
|
|
+ else
|
|
|
+#if USE_BZLIB
|
|
|
+ if (strcmp(&s[j+1], "bz2") == 0)
|
|
|
+ zipclevel = 07;
|
|
|
+ else
|
|
|
+#endif
|
|
|
+ continue;
|
|
|
+ } else if (fmttype == FMT_NONE)
|
|
|
+ fmttype = bigendian() ? FMT_BINBE : FMT_BINLE;
|
|
|
+ else if (fmttype == TYP_BE)
|
|
|
+ fmttype = bigendian() ? FMT_BINLE : FMT_BINBE;
|
|
|
+ else if (fmttype == FMT_PAX && s[j] == ':') {
|
|
|
+ if (pax_options(&s[j+1], 0) < 0)
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ msg(3, 0, "Invalid header \"%s\" specified.\n", s);
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+bigendian(void)
|
|
|
+{
|
|
|
+ union {
|
|
|
+ char u_c[2];
|
|
|
+ int16_t u_i;
|
|
|
+ } u;
|
|
|
+ u.u_i = 1;
|
|
|
+ return u.u_c[1] == 1;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+setreassign(const char *s)
|
|
|
+{
|
|
|
+ struct passwd *pwd;
|
|
|
+ int val = 0;
|
|
|
+
|
|
|
+ if (myuid != 0) {
|
|
|
+ msg(3, 0, "R option only valid for super-user.\n");
|
|
|
+ val = -1;
|
|
|
+ }
|
|
|
+ if ((pwd = getpwnam(s)) == NULL) {
|
|
|
+ msg(3, 0, "\"%s\" is not a valid user id\n", s);
|
|
|
+ val = -1;
|
|
|
+ } else {
|
|
|
+ Ruid = pwd->pw_uid;
|
|
|
+ Rgid = pwd->pw_gid;
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+void *
|
|
|
+srealloc(void *m, size_t n)
|
|
|
+{
|
|
|
+ if ((m = realloc(m, n)) == NULL) {
|
|
|
+ write(2, "Out of memory.\n", 15);
|
|
|
+ _exit(sysv3 ? 2 : 3);
|
|
|
+ }
|
|
|
+ return m;
|
|
|
+}
|
|
|
+
|
|
|
+void *
|
|
|
+smalloc(size_t n)
|
|
|
+{
|
|
|
+ return srealloc(NULL, n);
|
|
|
+}
|
|
|
+
|
|
|
+void *
|
|
|
+scalloc(size_t nmemb, size_t size)
|
|
|
+{
|
|
|
+ void *vp;
|
|
|
+
|
|
|
+ if ((vp = calloc(nmemb, size)) == NULL) {
|
|
|
+ write(2, "Out of memory.\n", 15);
|
|
|
+ _exit(sysv3 ? 2 : 3);
|
|
|
+ }
|
|
|
+ return vp;
|
|
|
+}
|
|
|
+
|
|
|
+void *
|
|
|
+svalloc(size_t n, int force)
|
|
|
+{
|
|
|
+ static long pagesize;
|
|
|
+ void *vp;
|
|
|
+
|
|
|
+ if (pagesize == 0)
|
|
|
+ if ((pagesize = sysconf(_SC_PAGESIZE)) < 0)
|
|
|
+ pagesize = 4096;
|
|
|
+ if ((vp = memalign(pagesize, n)) == NULL && force) {
|
|
|
+ write(2, "Out of memory.\n", 15);
|
|
|
+ _exit(sysv3 ? 2 : 3);
|
|
|
+ }
|
|
|
+ return vp;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * A single static buffer is used for intermediate copying from file
|
|
|
+ * data to the tape buffer and vice versa, for creating checksums, and
|
|
|
+ * for data transfer with -p.
|
|
|
+ */
|
|
|
+static void
|
|
|
+getbuf(char **bufp, size_t *sizep, size_t best)
|
|
|
+{
|
|
|
+ static char *buf;
|
|
|
+ static size_t size;
|
|
|
+
|
|
|
+ if (size != best) {
|
|
|
+ if (buf)
|
|
|
+ free(buf);
|
|
|
+ size = best;
|
|
|
+ if (size == 0 || (buf = svalloc(size, 0)) == NULL)
|
|
|
+ buf = svalloc(size = 512, 1);
|
|
|
+ }
|
|
|
+ *bufp = buf;
|
|
|
+ *sizep = size;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+sevprnt(int sev)
|
|
|
+{
|
|
|
+ if (printsev) switch (sev) {
|
|
|
+ case 1:
|
|
|
+ fprintf(stderr, "INFORM: ");
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ fprintf(stderr, "WARNING: ");
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ fprintf(stderr, "ERROR: ");
|
|
|
+ break;
|
|
|
+ case 4:
|
|
|
+ fprintf(stderr, "HALT: ");
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+msg(int sev, int err, const char *fmt, ...)
|
|
|
+{
|
|
|
+ va_list ap;
|
|
|
+
|
|
|
+
|
|
|
+ * The error message should appear near the file it refers to.
|
|
|
+ */
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ else if (Vflag)
|
|
|
+ prdot(1);
|
|
|
+ if (sysv3 >= 0 && sev >= (printsev ? 0 : -1))
|
|
|
+ fprintf(stderr, "%s: ", progname);
|
|
|
+ sevprnt(sev);
|
|
|
+ va_start(ap, fmt);
|
|
|
+ vfprintf(stderr, fmt, ap);
|
|
|
+ va_end(ap);
|
|
|
+ if (err > 0)
|
|
|
+ done(err);
|
|
|
+ else if (err == -2) {
|
|
|
+ if (sysv3)
|
|
|
+ done(1);
|
|
|
+ usage();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+emsg(int sev, const char *fmt, ...)
|
|
|
+{
|
|
|
+ char _fmt[60];
|
|
|
+ int i, fl = sev & 030, n;
|
|
|
+ va_list ap;
|
|
|
+
|
|
|
+ sev &= ~030;
|
|
|
+ i = errno;
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ else if (Vflag)
|
|
|
+ prdot(1);
|
|
|
+ fprintf(stderr, "%s: ", progname);
|
|
|
+ sevprnt(sev);
|
|
|
+ va_start(ap, fmt);
|
|
|
+ if (sysv3) {
|
|
|
+ if (fmt[(n=strlen(fmt))-1] == '"' && fmt[n-2] == 's' &&
|
|
|
+ fmt[n-3] == '%' && fmt[n-4] == '"' &&
|
|
|
+ n < sizeof _fmt) {
|
|
|
+ strcpy(_fmt, fmt);
|
|
|
+ _fmt[n-1] = '>';
|
|
|
+ _fmt[n-4] = '<';
|
|
|
+ fmt = _fmt;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ vfprintf(stderr, fmt, ap);
|
|
|
+ va_end(ap);
|
|
|
+ if (sysv3 > 0 && sev >= 0 && fl & 010)
|
|
|
+ fprintf(stderr, "\n\t%s\n", strerror(i));
|
|
|
+ else if (sysv3 < 0) {
|
|
|
+ if (fl & 020)
|
|
|
+ putc('\n', stderr);
|
|
|
+ else
|
|
|
+ fprintf(stderr, " (errno:%d)\n", i);
|
|
|
+ } else
|
|
|
+ fprintf(stderr, ", errno %d, %s\n", i, strerror(i));
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+prdot(int flush)
|
|
|
+{
|
|
|
+ static int column;
|
|
|
+
|
|
|
+ if (flush && column != 0 || column >= 50) {
|
|
|
+ write(action == 'o' && !Oflag ? 2 : 1, "\n", 1);
|
|
|
+ column = 0;
|
|
|
+ }
|
|
|
+ if (!flush) {
|
|
|
+ write(action == 'o' && !Oflag ? 2 : 1, ".", 1);
|
|
|
+ column++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Ask the user for new media if applicable, or exit.
|
|
|
+ */
|
|
|
+static void
|
|
|
+newmedia(int err)
|
|
|
+{
|
|
|
+ static int mediacnt = 1;
|
|
|
+ static char answer[PATH_MAX+1];
|
|
|
+ const char *mesf = action == 'i' ?
|
|
|
+ (Iflag && !sysv3 ? Iflag : "input") :
|
|
|
+ (Oflag && !sysv3 ? Oflag : "output");
|
|
|
+ char c;
|
|
|
+ int i, j;
|
|
|
+
|
|
|
+ if (mfl == 0 && close(mt) < 0) {
|
|
|
+ emsg(3, "Close error on \"%s\"", mesf);
|
|
|
+ errcnt++;
|
|
|
+ }
|
|
|
+ mfl = -1;
|
|
|
+ if ((mtst.st_mode&S_IFMT)!=S_IFCHR && (mtst.st_mode&S_IFMT)!=S_IFBLK ||
|
|
|
+ Dflag) {
|
|
|
+ if (action == 'o') {
|
|
|
+ switch (err) {
|
|
|
+ case 0:
|
|
|
+ break;
|
|
|
+ case EFBIG:
|
|
|
+ msg(3, 0, "ulimit reached for output file.\n");
|
|
|
+ break;
|
|
|
+ case ENOSPC:
|
|
|
+ msg(3, 0, "No space left for output file.\n");
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ msg(3, 0, "I/O error - cannot continue, "
|
|
|
+ "errno %d, %s\n",
|
|
|
+ err, strerror(err));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (err == ENOSPC || err == ENXIO || err == 0)
|
|
|
+ msg(-2, 0, sysv3 ? "Reached end of medium on %s.\a\n" :
|
|
|
+ "End of medium on \"%s\".\a\n", mesf);
|
|
|
+ else
|
|
|
+ msg(3, 0, "I/O error on \"%s\", errno %d, %s\a\n", mesf,
|
|
|
+ err, strerror(err));
|
|
|
+ mediacnt++;
|
|
|
+ while (mfl < 0) {
|
|
|
+ if (Iflag || Oflag)
|
|
|
+ msg(-2, 0, Mflag ? Mflag :
|
|
|
+ "Change to part %d and press "
|
|
|
+ "RETURN key. [q] ", mediacnt);
|
|
|
+ else
|
|
|
+ msg(-2, 0, sysv3 ? "If you want to go on, "
|
|
|
+ "type device/file name when ready.\n" :
|
|
|
+ "To continue, type device/file name "
|
|
|
+ "when ready.\n");
|
|
|
+ if (tty == 0)
|
|
|
+ if ((tty = open("/dev/tty", O_RDWR)) < 0 ||
|
|
|
+ fcntl(tty, F_SETFD, FD_CLOEXEC) < 0) {
|
|
|
+ cantrt: errcnt++;
|
|
|
+ msg(4, 1, "Cannot read tty.\n");
|
|
|
+ }
|
|
|
+ i = 0;
|
|
|
+ while ((j = read(tty, &c, 1)) == 1 && c != '\n')
|
|
|
+ if (i < sizeof answer - 1)
|
|
|
+ answer[i++] = c;
|
|
|
+ if (j != 1)
|
|
|
+ goto cantrt;
|
|
|
+ answer[i] = 0;
|
|
|
+ if (Iflag || Oflag) {
|
|
|
+ if (answer[0] == '\0')
|
|
|
+ snprintf(answer, sizeof answer, Iflag ? Iflag :
|
|
|
+ Oflag);
|
|
|
+ else if (answer[0] == 'q')
|
|
|
+ exit(errcnt != 0 ? sysv3 ? 1 : 2 : 0);
|
|
|
+ else if (Iflag)
|
|
|
+ Iflag = sstrdup(answer);
|
|
|
+ else if (Oflag)
|
|
|
+ Oflag = sstrdup(answer);
|
|
|
+ } else if (answer[0] == '\0')
|
|
|
+ return;
|
|
|
+ if ((mt = action == 'i' ? open(answer, O_RDONLY) :
|
|
|
+ creat(answer, 0666)) < 0) {
|
|
|
+ if (sysv3)
|
|
|
+ msg(-2, 0, "That didn't work, "
|
|
|
+ "cannot open \"%s\"\n%s\n",
|
|
|
+ answer, strerror(errno));
|
|
|
+ else
|
|
|
+ emsg(3, "Cannot open \"%s\"", answer);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ mfl = 0;
|
|
|
+ }
|
|
|
+ mstat();
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+mclose(void)
|
|
|
+{
|
|
|
+ if (action == 'o' && mt >= 0 && close(mt) < 0) {
|
|
|
+ emsg(3, "Close error on \"%s\"",
|
|
|
+ Oflag && !sysv3 ? Oflag : "output");
|
|
|
+ errcnt++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Write the archive buffer to tape.
|
|
|
+ */
|
|
|
+static ssize_t
|
|
|
+mwrite(int max)
|
|
|
+{
|
|
|
+ ssize_t wo, wt = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ if ((wo = write(mt, blkbuf + wt, (max?max:blksiz) - wt)) < 0) {
|
|
|
+ if (errno == EINTR) {
|
|
|
+ continue;
|
|
|
+ } else {
|
|
|
+ newmedia(errno);
|
|
|
+ if (mfl == 0) {
|
|
|
+ if (fmttype & TYP_BAR)
|
|
|
+ dump_barhdr();
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ poffs += wo;
|
|
|
+ wt += wo;
|
|
|
+ } while (wt < (max?max:blksiz));
|
|
|
+ blocks += wt >> 9;
|
|
|
+ bytes += wt & 0777;
|
|
|
+ return wt;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Buffered writes to tape.
|
|
|
+ */
|
|
|
+static void
|
|
|
+bwrite(const char *data, size_t sz)
|
|
|
+{
|
|
|
+ size_t di;
|
|
|
+
|
|
|
+ nwritten += sz;
|
|
|
+ while (curpos + sz > blksiz) {
|
|
|
+ di = blksiz - curpos;
|
|
|
+ sz -= di;
|
|
|
+ memcpy(&blkbuf[curpos], data, di);
|
|
|
+ mwrite(0);
|
|
|
+ data += di;
|
|
|
+ curpos = 0;
|
|
|
+ }
|
|
|
+ memcpy(&blkbuf[curpos], data, sz);
|
|
|
+ curpos += sz;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Flush the tape write buffer.
|
|
|
+ */
|
|
|
+static void
|
|
|
+bflush(void)
|
|
|
+{
|
|
|
+ if (curpos) {
|
|
|
+ memset(&blkbuf[curpos], 0, blksiz - curpos);
|
|
|
+ mwrite(fmttype==FMT_ZIP && (mtst.st_mode&S_IFMT) == S_IFREG ?
|
|
|
+ curpos : 0);
|
|
|
+ }
|
|
|
+ curpos = 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * CRC format checksum calculation with -i.
|
|
|
+ */
|
|
|
+static int
|
|
|
+sum(int fd, const char *fn, struct stat *sp, char *tg)
|
|
|
+{
|
|
|
+ char *buf;
|
|
|
+ size_t bufsize;
|
|
|
+ uint32_t size = sp->st_size, sum = 0;
|
|
|
+ ssize_t rd;
|
|
|
+ char c;
|
|
|
+
|
|
|
+ getbuf(&buf, &bufsize, sp->st_blksize);
|
|
|
+
|
|
|
+ * Unfortunately, SVR4 cpio derivatives (as on Solaris 8 and
|
|
|
+ * UnixWare 2.1) compute the checksum of signed char values,
|
|
|
+ * whereas GNU cpio and the pax implementations of AT&T and
|
|
|
+ * BSD use unsigned chars. Since there is no 'open' standard
|
|
|
+ * for the SVR4 CRC format, the SVR4 implementation should be
|
|
|
+ * taken as a de facto reference and we thus create SVR4 type
|
|
|
+ * checksums.
|
|
|
+ */
|
|
|
+ while ((rd = read(fd, buf, size>bufsize ? bufsize : size )) > 0) {
|
|
|
+ size -= rd;
|
|
|
+ do
|
|
|
+ sum += ((signed char *)buf)[--rd];
|
|
|
+ while (rd);
|
|
|
+ }
|
|
|
+ if (rd < 0) {
|
|
|
+ msg(3, 0, "Error computing checksum\n");
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
|
|
|
+ emsg(3, "Cannot reset file after checksum");
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ c = tg[8];
|
|
|
+ sprintf(tg, "%08lx", (long)sum);
|
|
|
+ tg[8] = c;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+rstime(const char *fn, struct stat *st, const char *which)
|
|
|
+{
|
|
|
+ struct utimbuf utb;
|
|
|
+
|
|
|
+ utb.actime = st->st_atime;
|
|
|
+ utb.modtime = st->st_mtime;
|
|
|
+ if (pax != PAX_TYPE_CPIO &&
|
|
|
+ (pax_preserve&(PAX_P_ATIME|PAX_P_MTIME)) != 0 &&
|
|
|
+ (pax_preserve&PAX_P_EVERY) == 0) {
|
|
|
+ struct stat xst;
|
|
|
+ if (stat(fn, &xst) < 0)
|
|
|
+ goto fail;
|
|
|
+ if (pax_preserve&PAX_P_ATIME)
|
|
|
+ utb.actime = xst.st_atime;
|
|
|
+ if (pax_preserve&PAX_P_MTIME)
|
|
|
+ utb.modtime = xst.st_mtime;
|
|
|
+ }
|
|
|
+ if (utime(fn, &utb) < 0) {
|
|
|
+ fail: emsg(2, "Unable to reset %s time for \"%s\"", which, fn);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Top-down splay function for inode tree.
|
|
|
+ */
|
|
|
+static struct islot *
|
|
|
+isplay(ino_t ino, struct islot *x)
|
|
|
+{
|
|
|
+ struct islot hdr;
|
|
|
+ struct islot *leftmax, *rightmin;
|
|
|
+ struct islot *y;
|
|
|
+
|
|
|
+ hdr.i_lln = hdr.i_rln = inull;
|
|
|
+ leftmax = rightmin = &hdr;
|
|
|
+ inull->i_ino = ino;
|
|
|
+ while (ino != x->i_ino) {
|
|
|
+ if (ino < x->i_ino) {
|
|
|
+ if (ino < x->i_lln->i_ino) {
|
|
|
+ y = x->i_lln;
|
|
|
+ x->i_lln = y->i_rln;
|
|
|
+ y->i_rln = x;
|
|
|
+ x = y;
|
|
|
+ }
|
|
|
+ if (x->i_lln == inull)
|
|
|
+ break;
|
|
|
+ rightmin->i_lln = x;
|
|
|
+ rightmin = x;
|
|
|
+ x = x->i_lln;
|
|
|
+ } else {
|
|
|
+ if (ino > x->i_rln->i_ino) {
|
|
|
+ y = x->i_rln;
|
|
|
+ x->i_rln = y->i_lln;
|
|
|
+ y->i_lln = x;
|
|
|
+ x = y;
|
|
|
+ }
|
|
|
+ if (x->i_rln == inull)
|
|
|
+ break;
|
|
|
+ leftmax->i_rln = x;
|
|
|
+ leftmax = x;
|
|
|
+ x = x->i_rln;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ leftmax->i_rln = x->i_lln;
|
|
|
+ rightmin->i_lln = x->i_rln;
|
|
|
+ x->i_lln = hdr.i_rln;
|
|
|
+ x->i_rln = hdr.i_lln;
|
|
|
+ inull->i_ino = !ino;
|
|
|
+ return x;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Find the inode number ino.
|
|
|
+ */
|
|
|
+static struct islot *
|
|
|
+ifind(ino_t ino, struct islot **it)
|
|
|
+{
|
|
|
+ if (*it == NULL)
|
|
|
+ return NULL;
|
|
|
+ *it = isplay(ino, *it);
|
|
|
+ return (*it)->i_ino == ino ? *it : NULL;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Put ik into the tree.
|
|
|
+ */
|
|
|
+static void
|
|
|
+iput(struct islot *ik, struct islot **it)
|
|
|
+{
|
|
|
+ if ((*it) == NULL) {
|
|
|
+ ik->i_lln = ik->i_rln = inull;
|
|
|
+ (*it) = ik;
|
|
|
+ } else {
|
|
|
+
|
|
|
+
|
|
|
+ if (ik->i_ino < (*it)->i_ino) {
|
|
|
+ ik->i_lln = (*it)->i_lln;
|
|
|
+ ik->i_rln = (*it);
|
|
|
+ (*it)->i_lln = inull;
|
|
|
+ (*it) = ik;
|
|
|
+ } else if ((*it)->i_ino < ik->i_ino) {
|
|
|
+ ik->i_rln = (*it)->i_rln;
|
|
|
+ ik->i_lln = (*it);
|
|
|
+ (*it)->i_rln = inull;
|
|
|
+ (*it) = ik;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Find the device dev or add it to the device/inode forest if not
|
|
|
+ * already present.
|
|
|
+ */
|
|
|
+static struct dslot *
|
|
|
+dfind(struct dslot **root, dev_t dev)
|
|
|
+{
|
|
|
+ struct dslot *ds, *dp;
|
|
|
+
|
|
|
+ for (ds = *root, dp = NULL; ds; dp = ds, ds = ds->d_nxt)
|
|
|
+ if (ds->d_dev == dev)
|
|
|
+ break;
|
|
|
+ if (ds == NULL) {
|
|
|
+ ds = scalloc(1, sizeof *ds);
|
|
|
+ ds->d_dev = dev;
|
|
|
+ if (*root == NULL)
|
|
|
+ *root = ds;
|
|
|
+ else
|
|
|
+ dp->d_nxt = ds;
|
|
|
+ }
|
|
|
+ return ds;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Exit on fatal error conditions.
|
|
|
+ */
|
|
|
+static void
|
|
|
+done(int i)
|
|
|
+{
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ errcnt += i;
|
|
|
+ mclose();
|
|
|
+ if (errcnt && !sysv3)
|
|
|
+ fprintf(stderr, "%llu errors\n", errcnt);
|
|
|
+ exit(sysv3 ? 2 : 3);
|
|
|
+}
|
|
|
+
|
|
|
+static char *pcopy, *pcend;
|
|
|
+static size_t psz, pslen, pss;
|
|
|
+
|
|
|
+
|
|
|
+ * Execution for -p.
|
|
|
+ */
|
|
|
+static void
|
|
|
+dopass(const char *target)
|
|
|
+{
|
|
|
+ struct stat st;
|
|
|
+
|
|
|
+ if (access(target, W_OK) < 0) {
|
|
|
+ emsg(033, sysv3 ? "cannot write in <%s>" :
|
|
|
+ "Error during access() of \"%s\"", target);
|
|
|
+ if (sysv3)
|
|
|
+ done(1);
|
|
|
+ usage();
|
|
|
+ }
|
|
|
+ if (stat(target, &st) < 0) {
|
|
|
+ emsg(023, "Error during stat() of \"%s\"", target);
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ if ((st.st_mode&S_IFMT) != S_IFDIR)
|
|
|
+ msg(3, 1, sysv3 ? "<%s> not a directory.\n" :
|
|
|
+ "\"%s\" is not a directory\n", target);
|
|
|
+ getpath(target, &pcopy, &pcend, &psz, &pslen);
|
|
|
+ copyout(passfile);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Callback for sfile().
|
|
|
+ */
|
|
|
+
|
|
|
+void
|
|
|
+writerr(void *vp, int count, int written)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Copy file data of regular files with -p.
|
|
|
+ */
|
|
|
+static int
|
|
|
+passdata(struct file *f, const char *tgt, int tfd)
|
|
|
+{
|
|
|
+ char *buf;
|
|
|
+ size_t bufsize;
|
|
|
+ ssize_t rd = 0;
|
|
|
+
|
|
|
+ if (f->f_fd < 0)
|
|
|
+ return 0;
|
|
|
+#ifdef __linux__
|
|
|
+ if (f->f_st.st_size > 0) {
|
|
|
+ long long sent;
|
|
|
+
|
|
|
+ sent = sfile(tfd, f->f_fd, f->f_st.st_mode, f->f_st.st_size);
|
|
|
+ blocks += (sent + 0777) >> 9;
|
|
|
+ if (sent == f->f_st.st_size)
|
|
|
+ return 0;
|
|
|
+ if (sent < 0)
|
|
|
+ goto rerr;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ getbuf(&buf, &bufsize, f->f_st.st_blksize);
|
|
|
+ while ((rd = read(f->f_fd, buf, bufsize)) > 0) {
|
|
|
+ blocks += (rd + 0777) >> 9;
|
|
|
+ if (write(tfd, buf, rd) != rd) {
|
|
|
+ emsg(3, "Cannot write \"%s\"", tgt);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (rd < 0) {
|
|
|
+#ifdef __linux__
|
|
|
+ rerr:
|
|
|
+#endif
|
|
|
+ emsg(3, "Cannot read \"%s\"", f->f_name);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Handle a single file for -p.
|
|
|
+ */
|
|
|
+static int
|
|
|
+passfile(const char *fn, struct stat *st)
|
|
|
+{
|
|
|
+ struct file f;
|
|
|
+ ssize_t sz;
|
|
|
+ int val;
|
|
|
+ char *newfn;
|
|
|
+ size_t newsz = 0;
|
|
|
+
|
|
|
+ newfn = sstrdup(fn);
|
|
|
+ if (pax != PAX_TYPE_CPIO) {
|
|
|
+ if (pax_sflag && pax_sname(&newfn, &newsz) == 0)
|
|
|
+ return 0;
|
|
|
+ if (rflag && rname(&newfn, &newsz) == 0)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ setpath(newfn, &pcopy, &pcend, pslen, &psz, &pss);
|
|
|
+ free(newfn);
|
|
|
+ memset(&f, 0, sizeof f);
|
|
|
+ f.f_name = sstrdup(fn);
|
|
|
+ f.f_nsiz = strlen(fn) + 1;
|
|
|
+ f.f_st = *st;
|
|
|
+ f.f_fd = -1;
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ sz = st->st_size ? st->st_size : PATH_MAX;
|
|
|
+ f.f_lnam = smalloc(sz+1);
|
|
|
+ if ((sz = readlink(fn, f.f_lnam, sz+1)) < 0) {
|
|
|
+ emsg(3, "Cannot read symbolic link \"%s\"", fn);
|
|
|
+ free(f.f_lnam);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ f.f_lnam[sz] = '\0';
|
|
|
+ } else if ((st->st_mode&S_IFMT) == S_IFREG) {
|
|
|
+ if ((f.f_fd = open(fn, O_RDONLY)) < 0) {
|
|
|
+ if (sysv3)
|
|
|
+ msg(2, 0, "Cannot open file \"%s\".\n", fn);
|
|
|
+ else
|
|
|
+ emsg(2, "Cannot open \"%s\", skipped", fn);
|
|
|
+ if (st->st_size != 0)
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ val = filein(&f, passdata, pcopy);
|
|
|
+ if (f.f_lnam)
|
|
|
+ free(f.f_lnam);
|
|
|
+ free(f.f_name);
|
|
|
+ if (f.f_fd >= 0)
|
|
|
+ close(f.f_fd);
|
|
|
+ if (val <= 1 && aflag && (st->st_mode&S_IFMT) == S_IFREG)
|
|
|
+ errcnt += rstime(fn, st, "access");
|
|
|
+ return val != 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Processing of a single file common to -i and -p. Return value: 0 if
|
|
|
+ * successful, 1 at failure if data was read, 2 at failure if no data
|
|
|
+ * was read.
|
|
|
+ */
|
|
|
+static int
|
|
|
+filein(struct file *f, int (*copydata)(struct file *, const char *, int),
|
|
|
+ char *tgt)
|
|
|
+{
|
|
|
+ struct stat nst;
|
|
|
+ char *temp = NULL;
|
|
|
+ size_t len;
|
|
|
+ int fd, i, j, new;
|
|
|
+ int failure = 2;
|
|
|
+
|
|
|
+ if (fmttype == FMT_ZIP && (f->f_st.st_mode&S_IFMT) != S_IFREG &&
|
|
|
+ (f->f_st.st_mode&S_IFMT) != S_IFLNK &&
|
|
|
+ (f->f_csize > 0 || f->f_gflag & FG_DESC))
|
|
|
+ skipfile(f);
|
|
|
+ if ((new = lstat(tgt, &nst)) == 0) {
|
|
|
+ if (action == 'p' && f->f_st.st_dev == nst.st_dev &&
|
|
|
+ f->f_st.st_ino == nst.st_ino) {
|
|
|
+ msg(3, 0, sysv3 ?
|
|
|
+ "Attempt to pass file to self!\n" :
|
|
|
+ "Attempt to pass a file to itself.\n");
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == S_IFDIR) {
|
|
|
+ if ((nst.st_mode&S_IFMT) == S_IFDIR)
|
|
|
+ return setattr(tgt, &f->f_st);
|
|
|
+ rmdir(tgt);
|
|
|
+ } else {
|
|
|
+ if (pax_kflag) {
|
|
|
+ failure = 0;
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ if (uflag == 0 && f->f_st.st_mtime <= nst.st_mtime) {
|
|
|
+ if (pax == PAX_TYPE_CPIO)
|
|
|
+ msg(-1, 0, sysv3 ?
|
|
|
+ "current <%s> newer or same age\n" :
|
|
|
+ "Existing \"%s\" same age or newer\n",
|
|
|
+ tgt);
|
|
|
+ else
|
|
|
+ failure = 0;
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (imdir(tgt) < 0)
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ if (Vflag && !vflag)
|
|
|
+ prdot(0);
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) != S_IFDIR && lflag) {
|
|
|
+ if (Lflag) {
|
|
|
+ char *symblink, *name;
|
|
|
+ struct stat xst;
|
|
|
+ name = f->f_name;
|
|
|
+ for (;;) {
|
|
|
+ if (lstat(name, &xst) < 0) {
|
|
|
+ emsg(3, "Cannot lstat \"%s\"", name);
|
|
|
+ if (name != f->f_name)
|
|
|
+ free(name);
|
|
|
+ goto cantlink;
|
|
|
+ }
|
|
|
+ if ((xst.st_mode&S_IFMT) != S_IFLNK)
|
|
|
+ break;
|
|
|
+ i = xst.st_size ? xst.st_size : PATH_MAX;
|
|
|
+ symblink = smalloc(i+1);
|
|
|
+ if ((j = readlink(name, symblink, i)) < 0) {
|
|
|
+ emsg(3, "Cannot read symbolic link "
|
|
|
+ "\"%s\"", name);
|
|
|
+ free(symblink);
|
|
|
+ if (name != f->f_name)
|
|
|
+ free(name);
|
|
|
+ goto cantlink;
|
|
|
+ }
|
|
|
+ symblink[j] = '\0';
|
|
|
+ symblink = joinpath(name, symblink);
|
|
|
+ if (name != f->f_name)
|
|
|
+ free(name);
|
|
|
+ name = symblink;
|
|
|
+ }
|
|
|
+ if (linkunlink(name, tgt) == 0) {
|
|
|
+ if (vflag)
|
|
|
+ fprintf(stderr, "%s\n", tgt);
|
|
|
+ if (name != f->f_name)
|
|
|
+ free(name);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (name != f->f_name)
|
|
|
+ free(name);
|
|
|
+ } else if (linkunlink(f->f_name, tgt) == 0) {
|
|
|
+ if (vflag)
|
|
|
+ fprintf(stderr, "%s\n", tgt);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+cantlink: errcnt += 1;
|
|
|
+ }
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) != S_IFDIR && f->f_st.st_nlink > 1 &&
|
|
|
+ (fmttype & TYP_CPIO || fmttype == FMT_ZIP
|
|
|
+ || action == 'p') &&
|
|
|
+ (i = canlink(tgt, &f->f_st, 1)) != 0) {
|
|
|
+ if (i < 0)
|
|
|
+ goto skip;
|
|
|
+
|
|
|
+ * At this point, hard links in SVR4 cpio format have
|
|
|
+ * been reordered and data is associated with the first
|
|
|
+ * link; remaining links have st_size == 0 so don't
|
|
|
+ * overwrite the data here.
|
|
|
+ */
|
|
|
+ if (fmttype & TYP_NCPIO && f->f_st.st_size == 0 ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) != S_IFREG) {
|
|
|
+ if (vflag)
|
|
|
+ fprintf(stderr, "%s\n", f->f_name);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ * Make sure we can creat() this file later.
|
|
|
+ */
|
|
|
+ chmod(tgt, 0600);
|
|
|
+ } else if (fmttype & TYP_TAR && f->f_st.st_nlink > 1) {
|
|
|
+ if (linkunlink(f->f_lnam, f->f_name) == 0) {
|
|
|
+ if (fmttype & TYP_USTAR && f->f_st.st_size > 0)
|
|
|
+ chmod(tgt, 0600);
|
|
|
+ else {
|
|
|
+ if (vflag)
|
|
|
+ fprintf(stderr, "%s\n", f->f_name);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ } else if (new == 0 && (f->f_st.st_mode&S_IFMT) != S_IFDIR) {
|
|
|
+ len = strlen(tgt);
|
|
|
+ temp = smalloc(len + 7);
|
|
|
+ strcpy(temp, tgt);
|
|
|
+ strcpy(&temp[len], "XXXXXX");
|
|
|
+ if ((fd = mkstemp(temp)) < 0 || close(fd) < 0) {
|
|
|
+ emsg(3, "Cannot create temporary file");
|
|
|
+ if (fd < 0) {
|
|
|
+ free(temp);
|
|
|
+ temp = NULL;
|
|
|
+ }
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ cur_ofile = tgt;
|
|
|
+ cur_tfile = temp;
|
|
|
+ if (rename(tgt, temp) < 0) {
|
|
|
+ emsg(3, "Cannot rename current \"%s\"", tgt);
|
|
|
+ tunlink(&temp);
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ switch (f->f_st.st_mode & S_IFMT) {
|
|
|
+ case S_IFDIR:
|
|
|
+ if (!dflag) {
|
|
|
+ if (action == 'p')
|
|
|
+ msg(-1, 0, "Use -d option to copy \"%s\"\n",
|
|
|
+ f->f_name);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ if (mkdir(tgt, 0777) < 0 && errno != EEXIST) {
|
|
|
+ emsg(-1, "Cannot create directory \"%s\"", tgt);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case S_IFLNK:
|
|
|
+ if (symlink(f->f_lnam, tgt) < 0) {
|
|
|
+ emsg(3, "Cannot create \"%s\"", tgt);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case S_IFREG:
|
|
|
+ if (temp && f->f_fd < 0)
|
|
|
+ goto restore;
|
|
|
+ cur_ofile = tgt;
|
|
|
+ if ((fd = (compressed_bar ? zcreat : creat)(tgt,
|
|
|
+ f->f_st.st_mode & 0777)) < 0) {
|
|
|
+ emsg(3, "Cannot create \"%s\"", tgt);
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ failure = 1;
|
|
|
+ if (copydata(f, tgt, fd) != 0) {
|
|
|
+ close(fd);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ if ((compressed_bar ? zclose : close)(fd) < 0) {
|
|
|
+ emsg(3, "Close error on \"%s\"", tgt);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case S_IFBLK:
|
|
|
+ case S_IFCHR:
|
|
|
+ case S_IFIFO:
|
|
|
+ case S_IFNAM:
|
|
|
+ case S_IFNWK:
|
|
|
+ if (mknod(tgt, f->f_st.st_mode&(S_IFMT|0777),
|
|
|
+ f->f_st.st_rdev) < 0) {
|
|
|
+ emsg(3, "Cannot mknod() \"%s\"", tgt);
|
|
|
+ goto restore;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ msg(-1, 0, "Impossible file type\n");
|
|
|
+ goto skip;
|
|
|
+ }
|
|
|
+ if (vflag)
|
|
|
+ fprintf(stderr, "%s\n", f->f_name);
|
|
|
+ tunlink(&temp);
|
|
|
+ return setattr(tgt, &f->f_st);
|
|
|
+skip: if (copydata == indata)
|
|
|
+ skipdata(f, copydata);
|
|
|
+restore:
|
|
|
+ if (temp) {
|
|
|
+ if (rename(temp, tgt) < 0) {
|
|
|
+ emsg(3, "Cannot recover original version of \"%s\"",
|
|
|
+ tgt);
|
|
|
+ tunlink(&temp);
|
|
|
+ } else
|
|
|
+ fprintf(stderr, "Restoring existing \"%s\"\n", tgt);
|
|
|
+ cur_tfile = cur_ofile = NULL;
|
|
|
+ }
|
|
|
+ return failure;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+linkunlink(const char *path1, const char *path2)
|
|
|
+{
|
|
|
+ int twice = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ if (link(path1, path2) == 0) {
|
|
|
+ if (vflag && pax == PAX_TYPE_CPIO)
|
|
|
+ printf("%s linked to %s\n", path1, path2);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (errno == EEXIST && unlink(path2) < 0)
|
|
|
+ emsg(3, sysv3 ? "cannot unlink <%s>" :
|
|
|
+ "Error cannot unlink \"%s\"", path2);
|
|
|
+ } while (twice++ == 0);
|
|
|
+ emsg(023, sysv3 ? "Cannot link <%s> & <%s>" :
|
|
|
+ "Cannot link \"%s\" and \"%s\"", path1, path2);
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+tunlink(char **fn)
|
|
|
+{
|
|
|
+ cur_tfile = cur_ofile = NULL;
|
|
|
+ if (*fn) {
|
|
|
+ if (unlink(*fn) < 0)
|
|
|
+ emsg(3, "Cannot unlink() temp file \"%s\"", *fn);
|
|
|
+ free(*fn);
|
|
|
+ *fn = NULL;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * For -it[v] option.
|
|
|
+ */
|
|
|
+static int
|
|
|
+filet(struct file *f, int (*copydata)(struct file *, const char *, int))
|
|
|
+{
|
|
|
+ if (vflag && (
|
|
|
+ (fmttype == FMT_ZIP && f->f_gflag & FG_DESC &&
|
|
|
+ (f->f_cmethod == C_DEFLATED || f->f_cmethod == C_ENHDEFLD) &&
|
|
|
+ (f->f_gflag & FG_CRYPT) == 0) ||
|
|
|
+ f->f_Kbase)) {
|
|
|
+
|
|
|
+ * Need to read zip data descriptor located after the
|
|
|
+ * file contents in order to know the file size. Or
|
|
|
+ * need to read second header of -K archive.
|
|
|
+ */
|
|
|
+ int i;
|
|
|
+ i = skipdata(f, copydata);
|
|
|
+ filev(f);
|
|
|
+ return i;
|
|
|
+ }
|
|
|
+ if (vflag)
|
|
|
+ filev(f);
|
|
|
+ else
|
|
|
+ puts(f->f_name);
|
|
|
+ return skipdata(f, copydata);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+filev(struct file *f)
|
|
|
+{
|
|
|
+ const char *cp;
|
|
|
+ long c;
|
|
|
+
|
|
|
+ if (pax == PAX_TYPE_CPIO && fmttype & TYP_TAR && f->f_st.st_nlink > 1)
|
|
|
+ printf("%s linked to %s\n", f->f_lnam, f->f_name);
|
|
|
+ if (sysv3)
|
|
|
+ printf("%-6o", (int)f->f_st.st_mode&(07777|S_IFMT));
|
|
|
+ else {
|
|
|
+ c = typec(&f->f_st);
|
|
|
+ putchar(c);
|
|
|
+ permbits(f->f_st.st_mode);
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_ZIP && vflag > 1)
|
|
|
+ zipinfo(f);
|
|
|
+ else {
|
|
|
+ if (sysv3 == 0)
|
|
|
+ printf(" %3d", fmttype&TYP_TAR &&
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFLNK ?
|
|
|
+ 2 : (int)f->f_st.st_nlink);
|
|
|
+ if ((cp = getuser(f->f_st.st_uid)) != NULL)
|
|
|
+ printf(sysv3 ? " %-6s" : " %-8s", cp);
|
|
|
+ else
|
|
|
+ printf(sysv3 ? " %-6lu" : " %-8lu",
|
|
|
+ (long)f->f_st.st_uid);
|
|
|
+ if (sysv3 == 0) {
|
|
|
+ if ((cp = getgroup(f->f_st.st_gid)) != NULL)
|
|
|
+ printf(" %-8s", cp);
|
|
|
+ else
|
|
|
+ printf(" %-8lu", (long)f->f_st.st_gid);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (sysv3 || (f->f_st.st_mode&S_IFMT)!=S_IFCHR &&
|
|
|
+ (f->f_st.st_mode&S_IFMT)!=S_IFBLK &&
|
|
|
+ (f->f_st.st_mode&S_IFMT)!=S_IFNAM &&
|
|
|
+ (f->f_st.st_mode&S_IFMT)!=S_IFNWK)
|
|
|
+ printf(pax != PAX_TYPE_CPIO ? "%8llu" :
|
|
|
+ sysv3 ? "%7llu" : " %-7llu", f->f_dsize);
|
|
|
+ else
|
|
|
+ printf(" %3lu,%3lu", (long)f->f_rmajor, (long)f->f_rminor);
|
|
|
+ prtime(f->f_st.st_mtime);
|
|
|
+ printf("%s", f->f_name);
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == S_IFLNK)
|
|
|
+ printf(" -> %s", f->f_lnam);
|
|
|
+ if (pax != PAX_TYPE_CPIO && (f->f_st.st_mode&S_IFMT) != S_IFDIR &&
|
|
|
+ f->f_st.st_nlink>1) {
|
|
|
+ if (fmttype & TYP_TAR)
|
|
|
+ printf(" == %s", f->f_lnam);
|
|
|
+ else
|
|
|
+ canlink(f->f_name, &f->f_st, 0);
|
|
|
+ }
|
|
|
+ putchar('\n');
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+typec(struct stat *st)
|
|
|
+{
|
|
|
+ switch (st->st_mode&S_IFMT) {
|
|
|
+ case S_IFREG:
|
|
|
+ return '-';
|
|
|
+ case S_IFDIR:
|
|
|
+ return 'd';
|
|
|
+ case S_IFLNK:
|
|
|
+ return 'l';
|
|
|
+ case S_IFCHR:
|
|
|
+ return 'c';
|
|
|
+ case S_IFBLK:
|
|
|
+ return 'b';
|
|
|
+ case S_IFIFO:
|
|
|
+ return 'p';
|
|
|
+ case S_IFNWK:
|
|
|
+ return 'n';
|
|
|
+ case S_IFNAM:
|
|
|
+ switch (st->st_rdev) {
|
|
|
+ case S_INSEM:
|
|
|
+ return 's';
|
|
|
+ case S_INSHD:
|
|
|
+ return 'm';
|
|
|
+ }
|
|
|
+
|
|
|
+ default:
|
|
|
+ msg(-1, 0, "Impossible file type\n");
|
|
|
+ errcnt++;
|
|
|
+ return '-';
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+permbits(mode_t mode)
|
|
|
+{
|
|
|
+ mode_t mask = 0700, shft = 6;
|
|
|
+
|
|
|
+ while (mask) {
|
|
|
+ if (((mode & mask) >> shft) & 04)
|
|
|
+ putchar('r');
|
|
|
+ else
|
|
|
+ putchar('-');
|
|
|
+ if (((mode & mask) >> shft) & 02)
|
|
|
+ putchar('w');
|
|
|
+ else
|
|
|
+ putchar('-');
|
|
|
+ if (mask == 0700 && mode & 04000)
|
|
|
+ putchar('s');
|
|
|
+ else if (mask == 0070 && (mode & 02010) == 02010)
|
|
|
+ putchar('s');
|
|
|
+ else if (mask == 0070 && mode & 02000)
|
|
|
+ putchar('l');
|
|
|
+ else if (mask == 0007 && mode & 01000)
|
|
|
+ putchar('t');
|
|
|
+ else if (((mode & mask) >> shft) & 01)
|
|
|
+ putchar('x');
|
|
|
+ else
|
|
|
+ putchar('-');
|
|
|
+ mask >>= 3;
|
|
|
+ shft -= 3;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+prtime_cpio(time_t t)
|
|
|
+{
|
|
|
+ char b[30];
|
|
|
+
|
|
|
+ strftime(b, sizeof b, sysv3 ? "%b %e %H:%M:%S %Y" : "%b %e %H:%M %Y",
|
|
|
+ localtime(&t));
|
|
|
+ printf(sysv3 ? " %s " : " %s, ", b);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Prepare path to add names of files below it later.
|
|
|
+ */
|
|
|
+static void
|
|
|
+getpath(const char *path, char **file, char **filend, size_t *sz, size_t *slen)
|
|
|
+{
|
|
|
+ *sz = 14 + strlen(path) + 2;
|
|
|
+ *file = smalloc(*sz);
|
|
|
+ *filend = *file;
|
|
|
+ if (path[0] == '/' && path[1] == '\0')
|
|
|
+ *(*filend)++ = '/';
|
|
|
+ else {
|
|
|
+ const char *cp = path;
|
|
|
+ while ((*(*filend)++ = *cp++) != '\0');
|
|
|
+ (*filend)[-1] = '/';
|
|
|
+ }
|
|
|
+ *slen = *filend - *file;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Concatenate base (prepared with getpath()) and file.
|
|
|
+ */
|
|
|
+static void
|
|
|
+setpath(const char *base, char **file, char **filend,
|
|
|
+ size_t slen, size_t *sz, size_t *ss)
|
|
|
+{
|
|
|
+ if (slen + (*ss = strlen(base)) >= *sz) {
|
|
|
+ *sz += slen + *ss + 15;
|
|
|
+ *file = srealloc(*file, *sz);
|
|
|
+ *filend = &(*file)[slen];
|
|
|
+ }
|
|
|
+ strcpy(*filend, base);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Create intermediate directories with -m.
|
|
|
+ */
|
|
|
+static int
|
|
|
+imdir(char *fn)
|
|
|
+{
|
|
|
+ struct stat st;
|
|
|
+ char *cp;
|
|
|
+ int dfl = dflag != 0;
|
|
|
+
|
|
|
+ for (cp = fn; *cp == '/'; cp++);
|
|
|
+ do {
|
|
|
+ while (*cp && *cp != '/')
|
|
|
+ cp++;
|
|
|
+ if (*cp == '/') {
|
|
|
+ *cp = '\0';
|
|
|
+ if (stat(fn, &st) < 0) {
|
|
|
+ if (dfl) {
|
|
|
+ if (mkdir(fn, 0777) < 0) {
|
|
|
+ *cp = '/';
|
|
|
+ emsg(-1, "Cannot create "
|
|
|
+ "directory for \"%s\"",
|
|
|
+ fn);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ msg(-1, 0, sysv3 ?
|
|
|
+ "missing 'd' option\n" :
|
|
|
+ "Missing -d option\n");
|
|
|
+ dfl = 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ *cp = '/';
|
|
|
+ while (*cp == '/')
|
|
|
+ cp++;
|
|
|
+ }
|
|
|
+ } while (*cp);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Set file attributes and make sure that suid/sgid bits are only restored
|
|
|
+ * if the owner is the same as on the tape.
|
|
|
+ */
|
|
|
+static int
|
|
|
+setattr(const char *fn, struct stat *st)
|
|
|
+{
|
|
|
+ mode_t mode = st->st_mode & 07777;
|
|
|
+ uid_t uid = Rflag ? Ruid : myuid;
|
|
|
+ gid_t gid = Rflag ? Rgid : mygid;
|
|
|
+
|
|
|
+ if ((pax != PAX_TYPE_CPIO || myuid == 0) &&
|
|
|
+ (pax == PAX_TYPE_CPIO ||
|
|
|
+ pax_preserve&(PAX_P_OWNER|PAX_P_EVERY))) {
|
|
|
+ if (setowner(fn, st) != 0)
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (pax != PAX_TYPE_CPIO &&
|
|
|
+ (pax_preserve&(PAX_P_OWNER|PAX_P_EVERY)) == 0)
|
|
|
+ mode &= ~(mode_t)(S_ISUID|S_ISGID);
|
|
|
+ if (myuid != 0 || Rflag) {
|
|
|
+ if (st->st_uid != uid || st->st_gid != gid) {
|
|
|
+ mode &= ~(mode_t)S_ISUID;
|
|
|
+ if ((st->st_mode&S_IFMT) != S_IFDIR && mode & 0010)
|
|
|
+ mode &= ~(mode_t)S_ISGID;
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFDIR && st->st_gid!=gid)
|
|
|
+ mode &= ~(mode_t)S_ISGID;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if ((st->st_mode&S_IFMT) == S_IFLNK)
|
|
|
+ return 0;
|
|
|
+ if (hp_Uflag)
|
|
|
+ mode &= ~umsk|S_IFMT;
|
|
|
+ if (pax != PAX_TYPE_CPIO &&
|
|
|
+ (pax_preserve&(PAX_P_MODE|PAX_P_OWNER|PAX_P_EVERY))==0)
|
|
|
+ mode &= 01777|S_IFMT;
|
|
|
+ if ((pax == PAX_TYPE_CPIO || pax_preserve&(PAX_P_MODE|PAX_P_EVERY)) &&
|
|
|
+ chmod(fn, mode) < 0) {
|
|
|
+ emsg(2, "Cannot chmod() \"%s\"", fn);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (pax != PAX_TYPE_CPIO ?
|
|
|
+ (pax_preserve&(PAX_P_ATIME|PAX_P_MTIME|PAX_P_EVERY)) !=
|
|
|
+ (PAX_P_ATIME|PAX_P_MTIME) : mflag)
|
|
|
+ return rstime(fn, st, "modification");
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+setowner(const char *fn, struct stat *st)
|
|
|
+{
|
|
|
+ uid_t uid = Rflag ? Ruid : myuid ? myuid : st->st_uid;
|
|
|
+ gid_t gid = Rflag ? Rgid : st->st_gid;
|
|
|
+
|
|
|
+ if (((st->st_mode&S_IFMT)==S_IFLNK?lchown:chown)(fn, uid, gid) < 0) {
|
|
|
+ emsg(2, "Cannot chown() \"%s\"", fn);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (pax >= PAX_TYPE_PAX2001 && myuid && myuid != st->st_uid &&
|
|
|
+ pax_preserve & (PAX_P_OWNER|PAX_P_EVERY)) {
|
|
|
+
|
|
|
+ * Do not even try to preserve user ownership in this case.
|
|
|
+ * It would either fail, or, without _POSIX_CHOWN_RESTRICTED,
|
|
|
+ * leave us with a file we do not own and which we thus could
|
|
|
+ * not chmod() later.
|
|
|
+ */
|
|
|
+ errno = EPERM;
|
|
|
+ emsg(2, "Cannot chown() \"%s\"", fn);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * For -i and -p: Check if device/inode have been created already and
|
|
|
+ * if so, link path (or print the link name).
|
|
|
+ */
|
|
|
+static int
|
|
|
+canlink(const char *path, struct stat *st, int really)
|
|
|
+{
|
|
|
+ struct dslot *ds;
|
|
|
+ struct islot *ip;
|
|
|
+
|
|
|
+ ds = dfind(&devices, st->st_dev);
|
|
|
+ if ((ip = ifind(st->st_ino, &ds->d_isl)) == NULL ||
|
|
|
+ ip->i_name == NULL) {
|
|
|
+ if (ip == NULL) {
|
|
|
+ ip = scalloc(1, sizeof *ip);
|
|
|
+ ip->i_ino = st->st_ino;
|
|
|
+ if ((fmttype&(TYP_NCPIO|TYP_TAR)) == 0)
|
|
|
+ ip->i_nlk = st->st_nlink;
|
|
|
+ iput(ip, &ds->d_isl);
|
|
|
+ }
|
|
|
+ ip->i_name = sstrdup(path);
|
|
|
+ } else {
|
|
|
+ if ((fmttype&(TYP_NCPIO|TYP_TAR)) == 0) {
|
|
|
+
|
|
|
+ * If an archive inode has more links than given in
|
|
|
+ * st_nlink, write a new disk inode. See the comments
|
|
|
+ * to storelink() for the rationale.
|
|
|
+ */
|
|
|
+ if (--ip->i_nlk == 0) {
|
|
|
+ free(ip->i_name);
|
|
|
+ ip->i_name = sstrdup(path);
|
|
|
+ ip->i_nlk = st->st_nlink;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (really) {
|
|
|
+
|
|
|
+ * If there was file data before the last link with
|
|
|
+ * SVR4 cpio formats, do not create a hard link.
|
|
|
+ */
|
|
|
+ if (fmttype & TYP_NCPIO && ip->i_nlk == 0)
|
|
|
+ return 0;
|
|
|
+ if (linkunlink(ip->i_name, path) == 0)
|
|
|
+ return 1;
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+ } else {
|
|
|
+ printf(" == %s", ip->i_name);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Execution for -i.
|
|
|
+ */
|
|
|
+static void
|
|
|
+doinp(void)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+ struct file f;
|
|
|
+ int n;
|
|
|
+
|
|
|
+ memset(&f, 0, sizeof f);
|
|
|
+ if (Eflag)
|
|
|
+ patfile();
|
|
|
+ if (Iflag) {
|
|
|
+ if ((mt = open(Iflag, O_RDONLY)) < 0) {
|
|
|
+ if (sysv3) {
|
|
|
+ emsg(3, "Cannot open <%s> for input.", Iflag);
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ msg(3, -2, "Cannot open \"%s\" for input\n",
|
|
|
+ Iflag);
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ mt = dup(0);
|
|
|
+ mstat();
|
|
|
+ blkbuf = svalloc(blksiz, 1);
|
|
|
+ if ((n = mread()) == 0)
|
|
|
+ unexeoa();
|
|
|
+ else if (n < 0) {
|
|
|
+ emsg(3, "Read error on \"%s\"",
|
|
|
+ Iflag && !sysv3 ? Iflag : "input");
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ if (kflag == 0 && sixflag == 0)
|
|
|
+ fmttype = FMT_NONE;
|
|
|
+ if (fmttype == FMT_NONE)
|
|
|
+ whathdr();
|
|
|
+ else
|
|
|
+ formatforced = 1;
|
|
|
+ while (readhdr(&f, &bc) == 0) {
|
|
|
+ if (fmttype & TYP_NCPIO && f.f_st.st_nlink > 1 &&
|
|
|
+ (f.f_st.st_mode&S_IFMT) != S_IFDIR) {
|
|
|
+ if (f.f_st.st_size != 0)
|
|
|
+ flushlinks(&f);
|
|
|
+ else
|
|
|
+ storelink(&f);
|
|
|
+ } else
|
|
|
+ inpone(&f, 1);
|
|
|
+ f.f_Kbase = f.f_Krest = f.f_Ksize = 0;
|
|
|
+ f.f_oflag = 0;
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_NCPIO)
|
|
|
+ flushrest(f.f_pad);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * SVR4 cpio link handling with -i; called if we assume that more links
|
|
|
+ * to this file will follow.
|
|
|
+ */
|
|
|
+static void
|
|
|
+storelink(struct file *f)
|
|
|
+{
|
|
|
+ struct dslot *ds;
|
|
|
+ struct islot *ip;
|
|
|
+ struct ilink *il, *iz;
|
|
|
+
|
|
|
+ ds = dfind(&devices, f->f_st.st_dev);
|
|
|
+ if ((ip = ifind(f->f_st.st_ino, &ds->d_isl)) == NULL) {
|
|
|
+ ip = scalloc(1, sizeof *ip);
|
|
|
+ ip->i_ino = f->f_st.st_ino;
|
|
|
+ ip->i_nlk = f->f_st.st_nlink;
|
|
|
+ ip->i_st = smalloc(sizeof *ip->i_st);
|
|
|
+ *ip->i_st = f->f_st;
|
|
|
+ iput(ip, &ds->d_isl);
|
|
|
+ } else {
|
|
|
+ if (ip->i_nlk == 0) {
|
|
|
+
|
|
|
+ * More links to an inode than given in the first
|
|
|
+ * st_nlink occurence are found within this archive.
|
|
|
+ * This happens if -L was specified and soft links
|
|
|
+ * point to a file with multiple hard links. We do
|
|
|
+ * the same as SVR4 cpio implementations here and
|
|
|
+ * associate these links with a new inode, since it
|
|
|
+ * is related to the way a file with a single hard
|
|
|
+ * link but referenced by soft links is unpacked.
|
|
|
+ */
|
|
|
+ ip->i_nlk = f->f_st.st_nlink;
|
|
|
+ if (ip->i_name)
|
|
|
+ free(ip->i_name);
|
|
|
+ ip->i_name = NULL;
|
|
|
+ ip->i_st = smalloc(sizeof *ip->i_st);
|
|
|
+ *ip->i_st = f->f_st;
|
|
|
+ } else if (ip->i_nlk <= 2) {
|
|
|
+
|
|
|
+ * We get here if
|
|
|
+ * - a file with multiple links is empty;
|
|
|
+ * - a broken implementation has stored file data
|
|
|
+ * before the last link;
|
|
|
+ * - a linked file has been added to the archive later
|
|
|
+ * again (does not happen with our implementation).
|
|
|
+ */
|
|
|
+ flushnode(ip, f);
|
|
|
+ return;
|
|
|
+ } else
|
|
|
+ ip->i_nlk--;
|
|
|
+ }
|
|
|
+ for (il = ip->i_lnk, iz = NULL; il; il = il->l_nxt)
|
|
|
+ iz = il;
|
|
|
+ il = scalloc(1, sizeof *il);
|
|
|
+ il->l_siz = strlen(f->f_name) + 1;
|
|
|
+ il->l_nam = smalloc(il->l_siz);
|
|
|
+ strcpy(il->l_nam, f->f_name);
|
|
|
+ if (iz)
|
|
|
+ iz->l_nxt = il;
|
|
|
+ else
|
|
|
+ ip->i_lnk = il;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Flush all links of a file with SVR4 cpio format and -i.
|
|
|
+ */
|
|
|
+static void
|
|
|
+flushlinks(struct file *f)
|
|
|
+{
|
|
|
+ struct dslot *ds;
|
|
|
+ struct islot *ip;
|
|
|
+
|
|
|
+ ds = dfind(&devices, f->f_st.st_dev);
|
|
|
+ ip = ifind(f->f_st.st_ino, &ds->d_isl);
|
|
|
+ flushnode(ip, f);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Data of a multi-linked file shall be transferred now for SVR4 cpio
|
|
|
+ * format and -i.
|
|
|
+ */
|
|
|
+static void
|
|
|
+flushnode(struct islot *ip, struct file *f)
|
|
|
+{
|
|
|
+ struct file nf;
|
|
|
+ struct ilink *il, *iz;
|
|
|
+
|
|
|
+ f->f_dsize = f->f_st.st_size;
|
|
|
+ if (ip && ip->i_nlk > 0) {
|
|
|
+
|
|
|
+ * Write out the file data with the first link the user
|
|
|
+ * wants to be extracted, but show the same display size
|
|
|
+ * for all links.
|
|
|
+ */
|
|
|
+ for (il = ip->i_lnk, iz = NULL; il;
|
|
|
+ iz = il, il = il->l_nxt, iz ? free(iz), 0 : 0) {
|
|
|
+ memset(&nf, 0, sizeof nf);
|
|
|
+ nf.f_name = il->l_nam;
|
|
|
+ nf.f_nsiz = il->l_siz;
|
|
|
+ nf.f_st = f->f_st;
|
|
|
+ nf.f_chksum = f->f_chksum;
|
|
|
+ nf.f_pad = f->f_pad;
|
|
|
+ nf.f_dsize = f->f_dsize;
|
|
|
+ if (inpone(&nf, 0) == 0) {
|
|
|
+ f->f_chksum = 0;
|
|
|
+ f->f_st.st_size = 0;
|
|
|
+ }
|
|
|
+ free(il->l_nam);
|
|
|
+ }
|
|
|
+ ip->i_lnk = NULL;
|
|
|
+ if (ip->i_st)
|
|
|
+ free(ip->i_st);
|
|
|
+ ip->i_st = NULL;
|
|
|
+ }
|
|
|
+ if (f->f_name)
|
|
|
+ inpone(f, 1);
|
|
|
+ if (ip) {
|
|
|
+ if (ip->i_nlk <= 2 && ip->i_name) {
|
|
|
+ free(ip->i_name);
|
|
|
+ ip->i_name = NULL;
|
|
|
+ }
|
|
|
+ ip->i_nlk = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * This writes all remaining multiply linked files, i. e. those with
|
|
|
+ * st_size == 0 and st_nlink > number of links within the archive.
|
|
|
+ */
|
|
|
+static void
|
|
|
+flushrest(int pad)
|
|
|
+{
|
|
|
+ struct dslot *ds;
|
|
|
+
|
|
|
+ for (ds = devices; ds; ds = ds->d_nxt)
|
|
|
+ if (ds->d_isl != NULL)
|
|
|
+ flushtree(ds->d_isl, pad);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+flushtree(struct islot *ip, int pad)
|
|
|
+{
|
|
|
+ struct file f;
|
|
|
+
|
|
|
+ if (ip == inull)
|
|
|
+ return;
|
|
|
+ flushtree(ip->i_lln, pad);
|
|
|
+ flushtree(ip->i_rln, pad);
|
|
|
+ if (ip->i_nlk > 0 && ip->i_st) {
|
|
|
+ memset(&f, 0, sizeof f);
|
|
|
+ f.f_st = *ip->i_st;
|
|
|
+ f.f_pad = pad;
|
|
|
+ flushnode(ip, &f);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * See if the user wants to have this file with -i, and extract it or
|
|
|
+ * skip its data on the tape.
|
|
|
+ */
|
|
|
+static int
|
|
|
+inpone(struct file *f, int shallskip)
|
|
|
+{
|
|
|
+ struct glist *gp = NULL, *gb = NULL;
|
|
|
+ int val = -1, selected = 0;
|
|
|
+
|
|
|
+ if ((patterns == NULL || (gp = want(f, &gb)) != NULL ^ fflag) &&
|
|
|
+ pax_track(f->f_name, f->f_st.st_mtime)) {
|
|
|
+ selected = 1;
|
|
|
+ if ((pax_sflag == 0 || pax_sname(&f->f_name, &f->f_nsiz)) &&
|
|
|
+ (rflag == 0 || rname(&f->f_name, &f->f_nsiz))) {
|
|
|
+ errcnt += infile(f);
|
|
|
+ val = 0;
|
|
|
+ }
|
|
|
+ } else if (shallskip)
|
|
|
+ errcnt += skipfile(f);
|
|
|
+ if (gp != NULL && selected) {
|
|
|
+ gp->g_gotcha = 1;
|
|
|
+ if (gp->g_nxt && gp->g_nxt->g_art)
|
|
|
+ gp->g_nxt->g_gotcha = 1;
|
|
|
+ else if (gp->g_art && gb)
|
|
|
+ gb->g_gotcha = 1;
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read the header for a file with -i. Return values: 0 okay, 1 end of
|
|
|
+ * archive, -1 failure.
|
|
|
+ */
|
|
|
+static int
|
|
|
+readhdr(struct file *f, union bincpio *bp)
|
|
|
+{
|
|
|
+ long namlen, l1, l2, rd, hsz;
|
|
|
+ static long attempts;
|
|
|
+ long long skipped = 0;
|
|
|
+
|
|
|
+ if (fmttype & TYP_TAR) {
|
|
|
+ if (f->f_name)
|
|
|
+ f->f_name[0] = '\0';
|
|
|
+ if (f->f_lnam)
|
|
|
+ f->f_lnam[0] = '\0';
|
|
|
+ }
|
|
|
+ paxrec = globrec;
|
|
|
+retry: f->f_st = globst;
|
|
|
+retry2: if (fmttype & TYP_BINARY) {
|
|
|
+ hsz = SIZEOF_hdr_cpio;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if ((fmttype&TYP_BE ? pbe16(bp->Hdr.c_magic) :
|
|
|
+ ple16(bp->Hdr.c_magic)) != mag_bin)
|
|
|
+ goto badhdr;
|
|
|
+ if (fmttype & TYP_BE) {
|
|
|
+ f->f_st.st_dev = pbe16(bp->Hdr.c_dev)&0177777;
|
|
|
+ f->f_st.st_ino = pbe16(bp->Hdr.c_ino)&0177777;
|
|
|
+ f->f_st.st_mode = pbe16(bp->Hdr.c_mode);
|
|
|
+ } else {
|
|
|
+ f->f_st.st_dev = ple16(bp->Hdr.c_dev)&0177777;
|
|
|
+ f->f_st.st_ino = ple16(bp->Hdr.c_ino)&0177777;
|
|
|
+ f->f_st.st_mode = ple16(bp->Hdr.c_mode);
|
|
|
+ }
|
|
|
+ if (sixflag) {
|
|
|
+
|
|
|
+ * relevant Unix 6th Edition style mode bits
|
|
|
+ * (according to /usr/sys/inode.h, untested:)
|
|
|
+ *
|
|
|
+ * 060000 IFMT type of file
|
|
|
+ * 040000 IFDIR directory
|
|
|
+ * 020000 IFCHR character special
|
|
|
+ * 060000 IFBLK block special, 0 is regular
|
|
|
+ * 007777 permission bits as today
|
|
|
+ */
|
|
|
+ f->f_st.st_mode &= 067777;
|
|
|
+ if ((f->f_st.st_mode & 060000) == 0)
|
|
|
+ f->f_st.st_mode |= S_IFREG;
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_BE) {
|
|
|
+ f->f_st.st_uid = pbe16(bp->Hdr.c_uid)&0177777;
|
|
|
+ f->f_st.st_gid = pbe16(bp->Hdr.c_gid)&0177777;
|
|
|
+ f->f_st.st_nlink = pbe16(bp->Hdr.c_nlink)&0177777;
|
|
|
+ f->f_st.st_mtime = pbe32(bp->Hdr.c_mtime);
|
|
|
+ f->f_st.st_rdev = pbe16(bp->Hdr.c_rdev);
|
|
|
+ namlen = pbe16(bp->Hdr.c_namesize);
|
|
|
+ f->f_st.st_size = pbe32(bp->Hdr.c_filesize)&0xFFFFFFFF;
|
|
|
+ } else {
|
|
|
+ f->f_st.st_uid = ple16(bp->Hdr.c_uid)&0177777;
|
|
|
+ f->f_st.st_gid = ple16(bp->Hdr.c_gid)&0177777;
|
|
|
+ f->f_st.st_nlink = ple16(bp->Hdr.c_nlink)&0177777;
|
|
|
+ f->f_st.st_mtime = pme32(bp->Hdr.c_mtime);
|
|
|
+ f->f_st.st_rdev = ple16(bp->Hdr.c_rdev);
|
|
|
+ namlen = ple16(bp->Hdr.c_namesize);
|
|
|
+ f->f_st.st_size = pme32(bp->Hdr.c_filesize)&0xFFFFFFFF;
|
|
|
+ }
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ if ((f->f_st.st_rdev&0xFFFF) == 0xFFFF &&
|
|
|
+ f->f_st.st_size > 0 &&
|
|
|
+ ((f->f_st.st_mode&S_IFMT) == S_IFBLK ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFCHR &&
|
|
|
+ (!formatforced || fmttype & TYP_SGI))) {
|
|
|
+ fmttype |= TYP_SGI;
|
|
|
+ f->f_rmajor = (f->f_st.st_size&0xFFFC0000)>>18;
|
|
|
+ f->f_rminor = f->f_st.st_size&0x0003FFFF;
|
|
|
+ f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
|
|
|
+ f->f_st.st_size = 0;
|
|
|
+ }
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == S_IFREG &&
|
|
|
+ f->f_st.st_size&0x80000000 &&
|
|
|
+ (!formatforced || fmttype & TYP_SGI)) {
|
|
|
+ fmttype |= TYP_SGI;
|
|
|
+ f->f_Ksize = f->f_st.st_size&0xFFFFFFFF;
|
|
|
+ f->f_Kbase = (0x100000000LL-f->f_st.st_size) *
|
|
|
+ 0x80000000;
|
|
|
+ f->f_st.st_size = 0;
|
|
|
+ }
|
|
|
+ f->f_pad = 2;
|
|
|
+ rd = SIZEOF_hdr_cpio;
|
|
|
+ } else if (fmttype == FMT_ODC) {
|
|
|
+ hsz = SIZEOF_c_hdr;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if(memcmp(bp->Cdr.c_magic, mag_odc, sizeof mag_odc))
|
|
|
+ goto badhdr;
|
|
|
+ f->f_st.st_dev = rdoct(bp->Cdr.c_dev, 6);
|
|
|
+ f->f_st.st_ino = rdoct(bp->Cdr.c_ino, 6);
|
|
|
+ f->f_st.st_mode = rdoct(bp->Cdr.c_mode, 6);
|
|
|
+ f->f_st.st_uid = rdoct(bp->Cdr.c_uid, 6);
|
|
|
+ f->f_st.st_gid = rdoct(bp->Cdr.c_gid, 6);
|
|
|
+ f->f_st.st_nlink = rdoct(bp->Cdr.c_nlink, 6);
|
|
|
+ f->f_st.st_rdev = rdoct(bp->Cdr.c_rdev, 6);
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ f->f_st.st_mtime = rdoct(bp->Cdr.c_mtime, 11);
|
|
|
+ namlen = rdoct(bp->Cdr.c_namesz, 6);
|
|
|
+ f->f_st.st_size = rdoct(bp->Cdr.c_filesz, 11);
|
|
|
+ f->f_pad = 1;
|
|
|
+ rd = SIZEOF_c_hdr;
|
|
|
+ } else if (fmttype == FMT_DEC) {
|
|
|
+ hsz = SIZEOF_d_hdr;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if(memcmp(bp->Ddr.d_magic, mag_odc, sizeof mag_odc))
|
|
|
+ goto badhdr;
|
|
|
+ f->f_st.st_dev = rdoct(bp->Ddr.d_dev, 6);
|
|
|
+ f->f_st.st_ino = rdoct(bp->Ddr.d_ino, 6);
|
|
|
+ f->f_st.st_mode = rdoct(bp->Ddr.d_mode, 6);
|
|
|
+ f->f_st.st_uid = rdoct(bp->Ddr.d_uid, 6);
|
|
|
+ f->f_st.st_gid = rdoct(bp->Ddr.d_gid, 6);
|
|
|
+ f->f_st.st_nlink = rdoct(bp->Ddr.d_nlink, 6);
|
|
|
+ f->f_rmajor = rdoct(bp->Ddr.d_rmaj, 8);
|
|
|
+ f->f_rminor = rdoct(bp->Ddr.d_rmin, 8);
|
|
|
+ f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
|
|
|
+ f->f_st.st_mtime = rdoct(bp->Ddr.d_mtime, 11);
|
|
|
+ namlen = rdoct(bp->Ddr.d_namesz, 6);
|
|
|
+ f->f_st.st_size = rdoct(bp->Ddr.d_filesz, 11);
|
|
|
+ f->f_pad = 1;
|
|
|
+ rd = SIZEOF_d_hdr;
|
|
|
+ } else if (fmttype & TYP_NCPIO) {
|
|
|
+ hsz = SIZEOF_Exp_cpio_hdr;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if (memcmp(bp->Edr.E_magic, mag_asc, sizeof mag_asc) &&
|
|
|
+ memcmp(bp->Edr.E_magic, mag_crc, sizeof mag_crc))
|
|
|
+ goto badhdr;
|
|
|
+ f->f_st.st_ino = rdhex(bp->Edr.E_ino, 8);
|
|
|
+ f->f_st.st_mode = rdhex(bp->Edr.E_mode, 8);
|
|
|
+ f->f_st.st_uid = rdhex(bp->Edr.E_uid, 8);
|
|
|
+ f->f_st.st_gid = rdhex(bp->Edr.E_gid, 8);
|
|
|
+ f->f_st.st_nlink = rdhex(bp->Edr.E_nlink, 8);
|
|
|
+ f->f_st.st_mtime = rdhex(bp->Edr.E_mtime, 8);
|
|
|
+ f->f_st.st_size = rdhex(bp->Edr.E_filesize, 8);
|
|
|
+ l1 = rdhex(bp->Edr.E_maj, 8);
|
|
|
+ l2 = rdhex(bp->Edr.E_min, 8);
|
|
|
+ f->f_st.st_dev = makedev(l1, l2);
|
|
|
+ f->f_rmajor = rdhex(bp->Edr.E_rmaj, 8);
|
|
|
+ f->f_rminor = rdhex(bp->Edr.E_rmin, 8);
|
|
|
+ f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
|
|
|
+ namlen = rdhex(bp->Edr.E_namesize, 8);
|
|
|
+ f->f_chksum = rdhex(bp->Edr.E_chksum, 8);
|
|
|
+ f->f_pad = 4;
|
|
|
+ rd = SIZEOF_Exp_cpio_hdr;
|
|
|
+ } else if (fmttype & TYP_CRAY) {
|
|
|
+ int diff5 = fmttype==FMT_CRAY5 ? CRAY_PARAMSZ : 0;
|
|
|
+ hsz = SIZEOF_cray_hdr - diff5;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if (pbe64(bp->Crayhdr.C_magic) != mag_bin)
|
|
|
+ goto badhdr;
|
|
|
+ f->f_st.st_dev = pbe64(bp->Crayhdr.C_dev);
|
|
|
+ f->f_st.st_ino = pbe64(bp->Crayhdr.C_ino);
|
|
|
+ f->f_st.st_mode = pbe64(bp->Crayhdr.C_mode);
|
|
|
+
|
|
|
+ * Some of the S_IFMT bits on Cray UNICOS 9 differ from
|
|
|
+ * the common Unix values, namely:
|
|
|
+ *
|
|
|
+ * S_IFLNK 0130000 symbolic link
|
|
|
+ * S_IFOFD 0110000 off line, with data
|
|
|
+ * S_IFOFL 0120000 off line, with no data
|
|
|
+ *
|
|
|
+ * We treat the latter ones as regular files.
|
|
|
+ */
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == 0130000)
|
|
|
+ f->f_st.st_mode = f->f_st.st_mode&07777|S_IFLNK;
|
|
|
+ else if ((f->f_st.st_mode&S_IFMT) == 0110000 ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == 0120000)
|
|
|
+ f->f_st.st_mode = f->f_st.st_mode&07777|S_IFREG;
|
|
|
+ f->f_st.st_uid = pbe64(bp->Crayhdr.C_uid);
|
|
|
+ f->f_st.st_gid = pbe64(bp->Crayhdr.C_gid);
|
|
|
+ f->f_st.st_nlink = pbe64(bp->Crayhdr.C_nlink);
|
|
|
+ f->f_st.st_mtime = pbe64(bp->Crayhdr.C_mtime - diff5);
|
|
|
+ f->f_st.st_rdev = pbe64(bp->Crayhdr.C_rdev);
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ f->f_st.st_size = pbe64(bp->Crayhdr.C_filesize - diff5);
|
|
|
+ namlen = pbe64(bp->Crayhdr.C_namesize - diff5);
|
|
|
+ f->f_pad = 1;
|
|
|
+ rd = SIZEOF_cray_hdr - diff5;
|
|
|
+ } else if (fmttype & TYP_BAR) {
|
|
|
+ hsz = 512;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if (bp->data[SIZEOF_bar_header] == '\0') {
|
|
|
+ if (kflag && !allzero(bp->data, hsz))
|
|
|
+ goto badhdr;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (trdsum(bp) != 0 && kflag == 0)
|
|
|
+ goto badhdr;
|
|
|
+ bp->data[512] = bp->data[513] = '\0';
|
|
|
+ if (f->f_name == NULL || f->f_name[0] == '\0') {
|
|
|
+ if (f->f_nsiz < 512) {
|
|
|
+ free(f->f_name);
|
|
|
+ f->f_name = smalloc(f->f_nsiz = 512);
|
|
|
+ }
|
|
|
+ strcpy(f->f_name, &bp->data[SIZEOF_bar_header]);
|
|
|
+ }
|
|
|
+ namlen = strlen(f->f_name) + 1;
|
|
|
+ f->f_st.st_mode = rdoct(bp->Bdr.b_mode, 8);
|
|
|
+ f->f_st.st_uid = rdoct(bp->Bdr.b_uid, 8);
|
|
|
+ f->f_st.st_gid = rdoct(bp->Bdr.b_gid, 8);
|
|
|
+ f->f_st.st_size = rdoct(bp->Bdr.b_size, 12);
|
|
|
+ f->f_st.st_mtime = rdoct(bp->Bdr.b_mtime, 12);
|
|
|
+ f->f_st.st_rdev = rdoct(bp->Bdr.b_rdev, 8);
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ switch (bp->Bdr.b_linkflag) {
|
|
|
+ case '0':
|
|
|
+ f->f_st.st_mode &= 07777;
|
|
|
+ if (f->f_name[namlen-2] == '/')
|
|
|
+ f->f_st.st_mode |= S_IFDIR;
|
|
|
+ else
|
|
|
+ f->f_st.st_mode |= S_IFREG;
|
|
|
+ break;
|
|
|
+ case '1':
|
|
|
+ if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
|
|
|
+ blinkof(bp->data, f, namlen);
|
|
|
+ f->f_st.st_nlink = 2;
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == 0)
|
|
|
+ f->f_st.st_mode |= S_IFREG;
|
|
|
+ break;
|
|
|
+ case '2':
|
|
|
+ if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
|
|
|
+ blinkof(bp->data, f, namlen);
|
|
|
+ f->f_st.st_mode &= 07777;
|
|
|
+ f->f_st.st_mode |= S_IFLNK;
|
|
|
+ }
|
|
|
+ f->f_pad = 512;
|
|
|
+ rd = 512;
|
|
|
+ } else if (fmttype & TYP_TAR) {
|
|
|
+ hsz = 512;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if (bp->Tdr.t_name[0] == '\0') {
|
|
|
+ if (kflag && !allzero(bp->data, hsz))
|
|
|
+ goto badhdr;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_GNUTAR) {
|
|
|
+ if (memcmp(bp->Tdr.t_magic, mag_gnutar, 8))
|
|
|
+ goto badhdr;
|
|
|
+ } else if (fmttype & TYP_USTAR) {
|
|
|
+ if (memcmp(bp->Tdr.t_magic, mag_ustar, 6))
|
|
|
+ goto badhdr;
|
|
|
+ }
|
|
|
+ if (trdsum(bp) != 0 && kflag == 0)
|
|
|
+ goto badhdr;
|
|
|
+ if ((fmttype & TYP_PAX) == 0 && (fmttype == FMT_GNUTAR ||
|
|
|
+ strcmp(bp->Tdr.t_name, "././@LongLink") == 0)) {
|
|
|
+ switch (bp->Tdr.t_linkflag) {
|
|
|
+ case 'L':
|
|
|
+ if (readgnuname(&f->f_name, &f->f_nsiz,
|
|
|
+ rdoct(bp->Tdr.t_size, 12)) < 0)
|
|
|
+ goto badhdr;
|
|
|
+ goto retry;
|
|
|
+ case 'K':
|
|
|
+ if (readgnuname(&f->f_lnam, &f->f_lsiz,
|
|
|
+ rdoct(bp->Tdr.t_size, 12)) < 0)
|
|
|
+ goto badhdr;
|
|
|
+ goto retry;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_USTAR && fmttype != FMT_GNUTAR) {
|
|
|
+ switch (bp->Tdr.t_linkflag) {
|
|
|
+ case 'g':
|
|
|
+ case 'x':
|
|
|
+ if (formatforced && fmttype != FMT_PAX)
|
|
|
+ break;
|
|
|
+ fmttype = FMT_PAX;
|
|
|
+ tgetpax(&bp->Tdr, f);
|
|
|
+ goto retry2;
|
|
|
+ case 'X':
|
|
|
+ if (formatforced && fmttype != FMT_SUN)
|
|
|
+ break;
|
|
|
+ fmttype = FMT_SUN;
|
|
|
+ tgetpax(&bp->Tdr, f);
|
|
|
+ goto retry2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (f->f_name == NULL || f->f_name[0] == '\0') {
|
|
|
+ if (f->f_nsiz < TNAMSIZ+TPFXSIZ+2) {
|
|
|
+ free(f->f_name);
|
|
|
+ f->f_name= smalloc(f->f_nsiz=TNAMSIZ+TPFXSIZ+2);
|
|
|
+ }
|
|
|
+ tnameof(&bp->Tdr, f->f_name);
|
|
|
+ }
|
|
|
+ namlen = strlen(f->f_name) + 1;
|
|
|
+ f->f_st.st_mode = rdoct(bp->Tdr.t_mode, 8) & 07777;
|
|
|
+ if (paxrec & PR_UID)
|
|
|
+ ;
|
|
|
+ else if (fmttype == FMT_GNUTAR && bp->Tdr.t_uid[0] & 0200)
|
|
|
+ f->f_st.st_uid = pbe64(bp->Tdr.t_uid) &
|
|
|
+ 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ else
|
|
|
+ f->f_st.st_uid = rdoct(bp->Tdr.t_uid, 8);
|
|
|
+ if (paxrec & PR_GID)
|
|
|
+ ;
|
|
|
+ else if (fmttype == FMT_GNUTAR && bp->Tdr.t_gid[0] & 0200)
|
|
|
+ f->f_st.st_gid = pbe64(bp->Tdr.t_gid) &
|
|
|
+ 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ else
|
|
|
+ f->f_st.st_gid = rdoct(bp->Tdr.t_gid, 8);
|
|
|
+ if (paxrec & PR_SIZE)
|
|
|
+ ;
|
|
|
+ else if (fmttype == FMT_GNUTAR && bp->Tdr.t_size[0] == '\200')
|
|
|
+ f->f_st.st_size = pbe64(&bp->Tdr.t_size[4]);
|
|
|
+ else
|
|
|
+ f->f_st.st_size = rdoct(bp->Tdr.t_size, 12);
|
|
|
+ if ((paxrec & PR_MTIME) == 0)
|
|
|
+ f->f_st.st_mtime = rdoct(bp->Tdr.t_mtime, TTIMSIZ);
|
|
|
+ if (bp->Tdr.t_linkflag == '1') {
|
|
|
+ if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
|
|
|
+ tlinkof(&bp->Tdr, f);
|
|
|
+ f->f_st.st_mode |= S_IFREG;
|
|
|
+ f->f_st.st_nlink = 2;
|
|
|
+ } else if (bp->Tdr.t_linkflag == '2') {
|
|
|
+ if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
|
|
|
+ tlinkof(&bp->Tdr, f);
|
|
|
+ f->f_st.st_mode |= S_IFLNK;
|
|
|
+ } else if (tflag == 0 && (f->f_name)[namlen-2] == '/')
|
|
|
+ f->f_st.st_mode |= S_IFDIR;
|
|
|
+ else
|
|
|
+ f->f_st.st_mode |= tifmt(bp->Tdr.t_linkflag);
|
|
|
+ if (paxrec & PR_SUN_DEVMAJOR)
|
|
|
+ ;
|
|
|
+ else if (fmttype == FMT_GNUTAR && bp->Tdr.t_devmajor[0] & 0200)
|
|
|
+ f->f_rmajor = pbe64(bp->Tdr.t_devmajor) &
|
|
|
+ 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ else
|
|
|
+ f->f_rmajor = rdoct(bp->Tdr.t_devmajor, 8);
|
|
|
+ if (paxrec & PR_SUN_DEVMINOR)
|
|
|
+ ;
|
|
|
+ else if (fmttype == FMT_GNUTAR && bp->Tdr.t_devminor[0] & 0200)
|
|
|
+ f->f_rminor = pbe64(bp->Tdr.t_devminor) &
|
|
|
+ 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ else
|
|
|
+ f->f_rminor = rdoct(bp->Tdr.t_devminor, 8);
|
|
|
+ f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
|
|
|
+ f->f_pad = 512;
|
|
|
+ rd = 512;
|
|
|
+ } else if (fmttype == FMT_ZIP) {
|
|
|
+ hsz = SIZEOF_zip_header;
|
|
|
+ if (attempts == 0 && bread(bp->data, hsz) != hsz)
|
|
|
+ unexeoa();
|
|
|
+ if (memcmp(bp->Zdr.z_signature, mag_zipctr,
|
|
|
+ sizeof mag_zipctr) == 0 ||
|
|
|
+ memcmp(bp->Zdr.z_signature, mag_zipend,
|
|
|
+ sizeof mag_zipend) == 0 ||
|
|
|
+ memcmp(bp->Zdr.z_signature, mag_zip64e,
|
|
|
+ sizeof mag_zip64e) == 0 ||
|
|
|
+ memcmp(bp->Zdr.z_signature, mag_zip64l,
|
|
|
+ sizeof mag_zip64l) == 0)
|
|
|
+ return 1;
|
|
|
+ if (memcmp(bp->Zdr.z_signature, mag_zipsig, sizeof mag_zipsig))
|
|
|
+ goto badhdr;
|
|
|
+ f->f_st.st_uid = myuid;
|
|
|
+ f->f_st.st_gid = mygid;
|
|
|
+ f->f_st.st_nlink = 1;
|
|
|
+ f->f_st.st_mtime =
|
|
|
+ gdostime(bp->Zdr.z_modtime, bp->Zdr.z_moddate);
|
|
|
+ f->f_st.st_size = ple32(bp->Zdr.z_nsize);
|
|
|
+ f->f_csize = ple32(bp->Zdr.z_csize);
|
|
|
+ f->f_cmethod = ple16(bp->Zdr.z_cmethod);
|
|
|
+ f->f_chksum = ple32(bp->Zdr.z_crc32);
|
|
|
+ f->f_gflag = ple16(bp->Zdr.z_gflag);
|
|
|
+ rd = SIZEOF_zip_header;
|
|
|
+ namlen = ple16(bp->Zdr.z_namelen)&0177777;
|
|
|
+ if (f->f_nsiz < namlen+1) {
|
|
|
+ free(f->f_name);
|
|
|
+ f->f_name = smalloc(f->f_nsiz = namlen+1);
|
|
|
+ }
|
|
|
+ if (bread(f->f_name, namlen) != namlen)
|
|
|
+ goto corrupt;
|
|
|
+ (f->f_name)[namlen] = '\0';
|
|
|
+ if (f->f_name[namlen-1] == '/')
|
|
|
+ f->f_st.st_mode = 0777&~(mode_t)umsk|S_IFDIR;
|
|
|
+ else
|
|
|
+ f->f_st.st_mode = 0666&~(mode_t)umsk|S_IFREG;
|
|
|
+ rd += namlen;
|
|
|
+ if ((l1 = ziprxtra(f, &bp->Zdr)) < 0)
|
|
|
+ goto corrupt;
|
|
|
+ rd += l1;
|
|
|
+ f->f_pad = 1;
|
|
|
+ } else
|
|
|
+ abort();
|
|
|
+ if (fmttype & TYP_CPIO) {
|
|
|
+ if (f->f_st.st_nlink <= 0 || namlen <= 0 || namlen >= SANELIMIT)
|
|
|
+ goto corrupt;
|
|
|
+ if (namlen > f->f_nsiz) {
|
|
|
+ if (f->f_name)
|
|
|
+ free(f->f_name);
|
|
|
+ f->f_name = smalloc(f->f_nsiz = namlen);
|
|
|
+ }
|
|
|
+ if (bread(f->f_name, namlen) != namlen)
|
|
|
+ unexeoa();
|
|
|
+ if (f->f_name[namlen-1] != '\0')
|
|
|
+ goto corrupt;
|
|
|
+ rd += namlen;
|
|
|
+ skippad(rd, f->f_pad);
|
|
|
+ if (fmttype & TYP_NCPIO &&
|
|
|
+ (!formatforced || fmttype & TYP_SCO)) {
|
|
|
+
|
|
|
+ * The UnixWare format is a hack, but not a bad
|
|
|
+ * one. It is backwards compatible as far as
|
|
|
+ * possible; old implementations can use the -k
|
|
|
+ * option and will then get only the beginning
|
|
|
+ * of a large file, but all other files in the
|
|
|
+ * archive.
|
|
|
+ */
|
|
|
+ if (namlen >= 24 && memcmp(&f->f_name[namlen-23],
|
|
|
+ "\0size=", 6) == 0) {
|
|
|
+ fmttype |= TYP_SCO;
|
|
|
+ f->f_st.st_size = rdhex(&f->f_name[namlen-17],
|
|
|
+ 16);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (attempts) {
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ msg(0, 0, sysv3 < 0 ?
|
|
|
+ "Re-synced after skipping %lld bytes.\n" :
|
|
|
+ "Re-synchronized on magic number/header.\n",
|
|
|
+ skipped);
|
|
|
+ }
|
|
|
+ attempts = 0;
|
|
|
+ if (f->f_st.st_atime == 0 || (pax_preserve&(PAX_P_ATIME|PAX_P_EVERY)) ==
|
|
|
+ PAX_P_ATIME)
|
|
|
+ f->f_st.st_atime = f->f_st.st_mtime;
|
|
|
+ if ((f->f_dsize = f->f_st.st_size) < 0)
|
|
|
+ goto badhdr;
|
|
|
+ if (fmttype & TYP_CPIO && strcmp(f->f_name, trailer) == 0)
|
|
|
+ return 1;
|
|
|
+ return 0;
|
|
|
+corrupt:
|
|
|
+ if (kflag) {
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ msg(3, 0, "Corrupt header, file(s) may be lost.\n");
|
|
|
+ }
|
|
|
+badhdr:
|
|
|
+ if (kflag) {
|
|
|
+ int next = fmttype & TYP_TAR ? 512 : 1;
|
|
|
+ if (attempts++ == 0) {
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ msg(1, 0, sysv3 < 0 ? "Out of phase; resyncing.\n" :
|
|
|
+ "Searching for magic number/header.\n");
|
|
|
+ errcnt++;
|
|
|
+ }
|
|
|
+ for (l1 = next; l1 < hsz; l1++)
|
|
|
+ bp->data[l1-next] = bp->data[l1];
|
|
|
+ if (bread(&bp->data[l1-next], next) != next)
|
|
|
+ unexeoa();
|
|
|
+ skipped++;
|
|
|
+ goto retry;
|
|
|
+ }
|
|
|
+ if (tflag)
|
|
|
+ fflush(stdout);
|
|
|
+ msg(3, 1, sysv3 < 0 ? "Out of phase--get help\n" :
|
|
|
+ sysv3 > 0 ? "Out of sync, bad magic number/header.\n" :
|
|
|
+ "Bad magic number/header.\n");
|
|
|
+
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Determine the kind of archive on tape.
|
|
|
+ */
|
|
|
+static void
|
|
|
+whathdr(void)
|
|
|
+{
|
|
|
+again: if (blktop >= SIZEOF_hdr_cpio &&
|
|
|
+ ple16(blkbuf) == mag_bin) {
|
|
|
+ fmttype = FMT_BINLE;
|
|
|
+ } else if (blktop >= SIZEOF_hdr_cpio &&
|
|
|
+ pbe16(blkbuf) == mag_bin) {
|
|
|
+ fmttype = FMT_BINBE;
|
|
|
+ } else if (blktop >= SIZEOF_c_hdr &&
|
|
|
+ memcmp(blkbuf, mag_odc, sizeof mag_odc) == 0) {
|
|
|
+
|
|
|
+ * The DEC format is rubbish. Instead of introducing a new
|
|
|
+ * archive magic, its engineers reused the POSIX/odc magic
|
|
|
+ * and changed the fields. But there's a workaround: For a
|
|
|
+ * real odc archive, the byte following the file name is a
|
|
|
+ * \0 byte (unless the archive is damaged, of course). If
|
|
|
+ * it is not a \0 byte, but a \0 byte appears at the
|
|
|
+ * corresponding location for the DEC format, this is
|
|
|
+ * treated as a DEC archive. It must be noted that the
|
|
|
+ * Tru64 UNIX 5.1 cpio command is too stupid even for
|
|
|
+ * doing that - it will spill out a list of complaints
|
|
|
+ * if an extended archive is read but -e is not given.
|
|
|
+ */
|
|
|
+ int ns1, ns2;
|
|
|
+ ns1 = rdoct(((struct c_hdr *)blkbuf)->c_namesz, 6);
|
|
|
+ ns2 = rdoct(((struct d_hdr *)blkbuf)->d_namesz, 6);
|
|
|
+ if (blktop >= SIZEOF_d_hdr &&
|
|
|
+ (ns1 >= blktop - SIZEOF_c_hdr ||
|
|
|
+ blkbuf[SIZEOF_c_hdr+ns1-1] != '\0') &&
|
|
|
+ ns2 <= blktop - SIZEOF_d_hdr &&
|
|
|
+ blkbuf[SIZEOF_d_hdr+ns2-1] == '\0')
|
|
|
+ fmttype = FMT_DEC;
|
|
|
+ else
|
|
|
+ fmttype = FMT_ODC;
|
|
|
+ } else if (blktop >= SIZEOF_Exp_cpio_hdr &&
|
|
|
+ memcmp(blkbuf, mag_asc, sizeof mag_asc) == 0) {
|
|
|
+ fmttype = FMT_ASC;
|
|
|
+ } else if (blktop >= SIZEOF_Exp_cpio_hdr &&
|
|
|
+ memcmp(blkbuf, mag_crc, sizeof mag_crc) == 0) {
|
|
|
+ fmttype = FMT_CRC;
|
|
|
+ } else if (blktop >= SIZEOF_cray_hdr &&
|
|
|
+ pbe64(blkbuf) == mag_bin) {
|
|
|
+
|
|
|
+ * Old and new Cray headers are identical in the first
|
|
|
+ * 64 header bytes (including the magic). cpio(5) on
|
|
|
+ * UNICOS does not describe what the new param field
|
|
|
+ * is for.
|
|
|
+ *
|
|
|
+ * An archive is treated as old format if the mtime
|
|
|
+ * and namesize fields make sense and all characters
|
|
|
+ * of the name are non-null.
|
|
|
+ */
|
|
|
+ struct cray_hdr *Cp = (struct cray_hdr *)blkbuf;
|
|
|
+ long long mtime, namesize;
|
|
|
+ fmttype = FMT_CRAY;
|
|
|
+ mtime = pbe64(Cp->C_mtime - CRAY_PARAMSZ);
|
|
|
+ namesize = pbe64(Cp->C_namesize - CRAY_PARAMSZ);
|
|
|
+ if (mtime > 0 && mtime < (1LL<<31) &&
|
|
|
+ namesize > 0 && namesize < 2048 &&
|
|
|
+ blktop > SIZEOF_cray_hdr-
|
|
|
+ CRAY_PARAMSZ+namesize+1) {
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < namesize; i++)
|
|
|
+ if (blkbuf[SIZEOF_cray_hdr-
|
|
|
+ CRAY_PARAMSZ+i] == '\0')
|
|
|
+ break;
|
|
|
+ if (i == namesize-1)
|
|
|
+ fmttype = FMT_CRAY5;
|
|
|
+ }
|
|
|
+ } else if (blktop >= 512 &&
|
|
|
+ memcmp(&blkbuf[257], mag_ustar, 6) == 0 &&
|
|
|
+ tcssum((union bincpio *)blkbuf, 1) == 0) {
|
|
|
+ fmttype = FMT_USTAR;
|
|
|
+ } else if (blktop >= 512 &&
|
|
|
+ memcmp(&blkbuf[257], mag_gnutar, 8) == 0 &&
|
|
|
+ tcssum((union bincpio *)blkbuf, 1) == 0) {
|
|
|
+ fmttype = FMT_GNUTAR;
|
|
|
+ } else if (blktop >= 512 && blkbuf[0] &&
|
|
|
+ to avoid match on
|
|
|
+ /dev/zero etc. */
|
|
|
+ memcmp(&blkbuf[257], "\0\0\0\0\0", 5) == 0 &&
|
|
|
+ tcssum((union bincpio *)blkbuf, 0) == 0) {
|
|
|
+ fmttype = FMT_OTAR;
|
|
|
+ } else if (blktop >= SIZEOF_zip_header &&
|
|
|
+ (memcmp(blkbuf, mag_zipctr, sizeof mag_zipctr) == 0 ||
|
|
|
+ memcmp(blkbuf, mag_zipsig, sizeof mag_zipsig) == 0 ||
|
|
|
+ memcmp(blkbuf, mag_zipend, sizeof mag_zipend) == 0 ||
|
|
|
+ memcmp(blkbuf, mag_zip64e, sizeof mag_zip64e) == 0 ||
|
|
|
+ memcmp(blkbuf, mag_zip64l, sizeof mag_zip64l) == 0)) {
|
|
|
+ fmttype = FMT_ZIP;
|
|
|
+ } else if (blktop >= 512 && memcmp(blkbuf,"\0\0\0\0\0\0\0\0",8) == 0 &&
|
|
|
+ memcmp(&blkbuf[65], mag_bar, sizeof mag_bar) == 0 &&
|
|
|
+ bcssum((union bincpio *)blkbuf) == 0) {
|
|
|
+ fmttype = FMT_BAR;
|
|
|
+ compressed_bar = blkbuf[71] == '1';
|
|
|
+ curpos = 512;
|
|
|
+ } else if (!Aflag && blktop > 3 && memcmp(blkbuf, "BZh", 3) == 0 &&
|
|
|
+ redirect("bzip2", "-cd") == 0) {
|
|
|
+ goto zip;
|
|
|
+ } else if (!Aflag && blktop > 2 && memcmp(blkbuf, "\37\235", 2) == 0 &&
|
|
|
+ redirect("zcat", NULL) == 0) {
|
|
|
+ goto zip;
|
|
|
+ } else if (!Aflag && blktop > 2 && memcmp(blkbuf, "\37\213", 2) == 0 &&
|
|
|
+ redirect("gzip", "-cd") == 0) {
|
|
|
+ goto zip;
|
|
|
+ } else if (!Aflag && blktop > 4 &&
|
|
|
+ memcmp(blkbuf, "\355\253\356\333", 4) == 0 &&
|
|
|
+ redirect("rpm2cpio", "-") == 0) {
|
|
|
+ goto zip;
|
|
|
+ } else {
|
|
|
+ msg(3, 0, sysv3 ? "This is not a cpio file, bad header.\n" :
|
|
|
+ "Not a cpio file, bad header.\n");
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+zip:
|
|
|
+ blktop = curpos = 0;
|
|
|
+ blocks = 0;
|
|
|
+ bytes = 0;
|
|
|
+ mfl = 0;
|
|
|
+ mstat();
|
|
|
+ if (mread() == 0)
|
|
|
+ unexeoa();
|
|
|
+ goto again;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Processing of a single file with -i.
|
|
|
+ */
|
|
|
+static int
|
|
|
+infile(struct file *f)
|
|
|
+{
|
|
|
+ int val;
|
|
|
+
|
|
|
+ if ((fmttype & TYP_CPIO || fmttype == FMT_ZIP && f->f_st.st_size) &&
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ if (f->f_lsiz < f->f_st.st_size+1)
|
|
|
+ f->f_lnam = srealloc(f->f_lnam,
|
|
|
+ f->f_lsiz = f->f_st.st_size+1);
|
|
|
+ if (bread(f->f_lnam, f->f_st.st_size) != f->f_st.st_size)
|
|
|
+ unexeoa();
|
|
|
+ f->f_lnam[f->f_st.st_size] = '\0';
|
|
|
+ skippad(f->f_st.st_size, f->f_pad);
|
|
|
+ }
|
|
|
+ if (tflag)
|
|
|
+ val = filet(f, indata);
|
|
|
+ else
|
|
|
+ val = filein(f, indata, f->f_name);
|
|
|
+ return val != 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Fetch the data of regular files from tape and write it to tfd or, if
|
|
|
+ * tfd < 0, discard it.
|
|
|
+ */
|
|
|
+static int
|
|
|
+indata(struct file *f, const char *tgt, int tfd)
|
|
|
+{
|
|
|
+ char *buf;
|
|
|
+ size_t bufsize;
|
|
|
+ struct stat ts;
|
|
|
+ long long size;
|
|
|
+ ssize_t rd;
|
|
|
+ uint32_t ssum = 0, usum = 0;
|
|
|
+ int val = 0;
|
|
|
+ int doswap = 0;
|
|
|
+
|
|
|
+ size = fmttype == FMT_ZIP ? f->f_csize :
|
|
|
+ f->f_Kbase ? f->f_Kbase : f->f_st.st_size;
|
|
|
+ doswap = ((bflag|sflag) == 0 ||
|
|
|
+ ckodd(size, 2, "bytes", f->f_name) == 0) &
|
|
|
+ ((bflag|Sflag) == 0 ||
|
|
|
+ ckodd(size, 4, "halfwords", f->f_name) == 0) &
|
|
|
+ (bflag|sflag|Sflag);
|
|
|
+ if (fmttype == FMT_ZIP && f->f_cmethod != C_STORED)
|
|
|
+ return zipread(f, tgt, tfd, doswap);
|
|
|
+ if (tfd < 0 || fstat(tfd, &ts) < 0)
|
|
|
+ ts.st_blksize = 4096;
|
|
|
+ getbuf(&buf, &bufsize, ts.st_blksize);
|
|
|
+again: while (size) {
|
|
|
+ if ((rd = bread(buf, size > bufsize ? bufsize : size)) <= 0)
|
|
|
+ unexeoa();
|
|
|
+ if (doswap)
|
|
|
+ swap(buf, rd, bflag || sflag, bflag || Sflag);
|
|
|
+ if (tfd >= 0 && write(tfd, buf, rd) != rd) {
|
|
|
+ emsg(3, "Cannot write \"%s\"", tgt);
|
|
|
+ tfd = -1;
|
|
|
+ val = -1;
|
|
|
+ }
|
|
|
+ size -= rd;
|
|
|
+ if (fmttype & TYP_CRC)
|
|
|
+ do {
|
|
|
+ rd--;
|
|
|
+ ssum += ((signed char *)buf)[rd];
|
|
|
+ usum += ((unsigned char *)buf)[rd];
|
|
|
+ } while (rd);
|
|
|
+ }
|
|
|
+ if (f->f_Kbase) {
|
|
|
+ skippad(f->f_Ksize, f->f_pad);
|
|
|
+ readK2hdr(f);
|
|
|
+ size = f->f_Krest;
|
|
|
+ goto again;
|
|
|
+ }
|
|
|
+ skippad(fmttype==FMT_ZIP ? f->f_csize :
|
|
|
+ f->f_Ksize ? f->f_Krest : f->f_st.st_size, f->f_pad);
|
|
|
+ if (fmttype & TYP_CRC) {
|
|
|
+ if (f->f_chksum != ssum && f->f_chksum != usum) {
|
|
|
+ msg(3, 0, "\"%s\" - checksum error\n", f->f_name);
|
|
|
+ if (kflag)
|
|
|
+ errcnt++;
|
|
|
+ else
|
|
|
+ val = -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Skip the data for a file on tape.
|
|
|
+ */
|
|
|
+static int
|
|
|
+skipfile(struct file *f)
|
|
|
+{
|
|
|
+ char b[4096];
|
|
|
+ long long size;
|
|
|
+ ssize_t rd;
|
|
|
+
|
|
|
+ if (fmttype & TYP_TAR && ((f->f_st.st_mode&S_IFMT) == S_IFLNK ||
|
|
|
+ f->f_st.st_nlink > 1)) {
|
|
|
+ if (fmttype & TYP_USTAR && (!formatforced ||
|
|
|
+ fmttype == FMT_PAX) &&
|
|
|
+ f->f_st.st_nlink > 1 &&
|
|
|
+ f->f_st.st_size > 0)
|
|
|
+ ;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ * SVR4 cpio derivatives always ignore the size of these,
|
|
|
+ * even if not reading tar formats. We do the same for now,
|
|
|
+ * although POSIX (for -H odc format) says the contrary.
|
|
|
+ */
|
|
|
+ if (fmttype != FMT_ZIP && ((f->f_st.st_mode&S_IFMT) == S_IFDIR ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFCHR ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFBLK ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFIFO ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFNAM ||
|
|
|
+ (f->f_st.st_mode&S_IFMT) == S_IFNWK))
|
|
|
+ return 0;
|
|
|
+ if (fmttype == FMT_ZIP && f->f_gflag & FG_DESC)
|
|
|
+ return zipread(f, f->f_name, -1, 0);
|
|
|
+ size = fmttype == FMT_ZIP ? f->f_csize :
|
|
|
+ f->f_Kbase ? f->f_Kbase : f->f_st.st_size;
|
|
|
+again: while (size) {
|
|
|
+ if ((rd = bread(b, size > sizeof b ? sizeof b : size)) <= 0)
|
|
|
+ unexeoa();
|
|
|
+ size -= rd;
|
|
|
+ }
|
|
|
+ if (f->f_Kbase) {
|
|
|
+ skippad(f->f_Ksize, f->f_pad);
|
|
|
+ readK2hdr(f);
|
|
|
+ size = f->f_Krest;
|
|
|
+ goto again;
|
|
|
+ }
|
|
|
+ skippad(fmttype==FMT_ZIP ? f->f_csize :
|
|
|
+ f->f_Ksize ? f->f_Krest : f->f_st.st_size, f->f_pad);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Skip data also, but perform checks as if copying.
|
|
|
+ */
|
|
|
+static int
|
|
|
+skipdata(struct file *f, int (*copydata)(struct file *, const char *, int))
|
|
|
+{
|
|
|
+ switch (f->f_st.st_mode&S_IFMT) {
|
|
|
+ case S_IFLNK:
|
|
|
+ break;
|
|
|
+ case S_IFDIR:
|
|
|
+ case S_IFBLK:
|
|
|
+ case S_IFCHR:
|
|
|
+ case S_IFIFO:
|
|
|
+ case S_IFNAM:
|
|
|
+ case S_IFNWK:
|
|
|
+ if (fmttype != FMT_ZIP)
|
|
|
+ break;
|
|
|
+
|
|
|
+ case S_IFREG:
|
|
|
+ default:
|
|
|
+ if (fmttype & TYP_TAR && f->f_st.st_nlink > 1 &&
|
|
|
+ ((fmttype & TYP_USTAR) == 0 ||
|
|
|
+ formatforced && fmttype != FMT_PAX))
|
|
|
+ break;
|
|
|
+ if (copydata(f, f->f_name, -1) != 0)
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Seek to a position in the archive measured from the begin of
|
|
|
+ * operation. Handle media-dependent seeks. n must be a multiple
|
|
|
+ * of the tape device's physical block size.
|
|
|
+ */
|
|
|
+static int
|
|
|
+tseek(off_t n)
|
|
|
+{
|
|
|
+ int fault;
|
|
|
+
|
|
|
+ if (tapeblock > 0) {
|
|
|
+ int i = (n - poffs) / tapeblock;
|
|
|
+#if defined (__linux__) || defined (__sun) || defined (__FreeBSD__) || \
|
|
|
+ defined (__hpux) || defined (_AIX) || defined (__NetBSD__) || \
|
|
|
+ defined (__OpenBSD__) || defined (__DragonFly__) || defined (__APPLE__)
|
|
|
+ struct mtop mo;
|
|
|
+ mo.mt_op = i > 0 ? MTFSR : MTBSR;
|
|
|
+ mo.mt_count = i > 0 ? i : -i;
|
|
|
+ fault = ioctl(mt, MTIOCTOP, &mo);
|
|
|
+#else
|
|
|
+ int t, a;
|
|
|
+ t = i > 0 ? T_SBF : T_SBB;
|
|
|
+ a = i > 0 ? i : -i;
|
|
|
+ fault = ioctl(mt, t, a);
|
|
|
+#endif
|
|
|
+ } else
|
|
|
+ fault = lseek(mt, n - poffs, SEEK_CUR) == (off_t)-1 ? -1 : 0;
|
|
|
+ if (fault == 0)
|
|
|
+ poffs = n;
|
|
|
+ return fault;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Advance to the trailer on the tape (for -A).
|
|
|
+ */
|
|
|
+static int
|
|
|
+totrailer(void)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+ struct file f;
|
|
|
+ off_t ooffs, noffs, diff;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (mread() == 0)
|
|
|
+ unexeoa();
|
|
|
+ if (fmttype == FMT_NONE)
|
|
|
+ whathdr();
|
|
|
+ memset(&f, 0, sizeof f);
|
|
|
+ for (;;) {
|
|
|
+ ooffs = aoffs;
|
|
|
+ if ((i = readhdr(&f, &bc)) < 0)
|
|
|
+ goto fail;
|
|
|
+ if (i > 0)
|
|
|
+ break;
|
|
|
+ markdev(f.f_st.st_dev);
|
|
|
+ if (skipfile(&f) != 0)
|
|
|
+ goto fail;
|
|
|
+ if (fmttype == FMT_ZIP)
|
|
|
+ zipdefer(f.f_name, &f.f_st, ooffs,
|
|
|
+ f.f_chksum, f.f_csize, &bc.Zdr);
|
|
|
+ pax_track(f.f_name, f.f_st.st_mtime);
|
|
|
+ }
|
|
|
+
|
|
|
+ * Now seek to the position of the trailer, but retain the
|
|
|
+ * block alignment.
|
|
|
+ */
|
|
|
+ diff = ooffs % blksiz;
|
|
|
+ noffs = ooffs - diff;
|
|
|
+ if (diff ? tseek(noffs) == 0 && mread() >= diff && tseek(noffs) == 0
|
|
|
+ : tseek(ooffs) == 0) {
|
|
|
+ free(f.f_name);
|
|
|
+ free(f.f_lnam);
|
|
|
+ nwritten = ooffs;
|
|
|
+ curpos = diff;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+fail: msg(4, 1, "Unable to append to this archive\n");
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static long long
|
|
|
+rdoct(const char *data, int len)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ long long val = 0;
|
|
|
+
|
|
|
+ for (i = 0; i < len && data[i] == ' '; i++);
|
|
|
+ for ( ; i < len && data[i] && data[i] != ' '; i++) {
|
|
|
+ val <<= 3;
|
|
|
+ val += data[i] - '0';
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+static long long
|
|
|
+rdhex(const char *data, int len)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ long long val = 0;
|
|
|
+
|
|
|
+ for (i = 0; i < len && data[i] == ' '; i++);
|
|
|
+ for ( ; i < len && data[i] && data[i] != ' '; i++) {
|
|
|
+ val <<= 4;
|
|
|
+ val += data[i] > '9' ? data[i] > 'F' ? data[i] - 'a' + 10 :
|
|
|
+ data[i] - 'A' + 10 : data[i] - '0';
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+unexeoa(void)
|
|
|
+{
|
|
|
+ if (sysv3) {
|
|
|
+ fprintf(stderr,
|
|
|
+ "Can't read input: end of file encountered "
|
|
|
+ "prior to expected end of archive.\n");
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ msg(3, 1, "Unexpected end-of-archive encountered.\n");
|
|
|
+}
|
|
|
+
|
|
|
+static char *peekdata;
|
|
|
+static size_t peekbot, peektop, peeksize;
|
|
|
+
|
|
|
+void
|
|
|
+bunread(const char *data, size_t sz)
|
|
|
+{
|
|
|
+ peekdata = srealloc(peekdata, peeksize += sz);
|
|
|
+ memcpy(&peekdata[peekbot], data, sz);
|
|
|
+ peektop += sz;
|
|
|
+ aoffs -= sz;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Buffered read of data from tape. sz is the amount of data required
|
|
|
+ * by the archive format; if it cannot be retrieved, processing fails.
|
|
|
+ */
|
|
|
+ssize_t
|
|
|
+bread(char *data, size_t sz)
|
|
|
+{
|
|
|
+ ssize_t rd = 0;
|
|
|
+
|
|
|
+ if (peekdata) {
|
|
|
+ rd = sz>peektop-peekbot ? peektop-peekbot : sz;
|
|
|
+ memcpy(&data[0], &peekdata[peekbot], rd);
|
|
|
+ sz -= rd;
|
|
|
+ peekbot += rd;
|
|
|
+ if (peekbot == peektop) {
|
|
|
+ free(peekdata);
|
|
|
+ peekdata = 0;
|
|
|
+ peeksize = 0;
|
|
|
+ peekbot = peektop = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ while (sz) {
|
|
|
+ if (blktop - curpos >= sz) {
|
|
|
+ memcpy(&data[rd], &blkbuf[curpos], sz);
|
|
|
+ curpos += sz;
|
|
|
+ rd += sz;
|
|
|
+ aoffs += rd;
|
|
|
+ return rd;
|
|
|
+ }
|
|
|
+ if (blktop > curpos) {
|
|
|
+ memcpy(&data[rd], &blkbuf[curpos], blktop - curpos);
|
|
|
+ rd += blktop - curpos;
|
|
|
+ sz -= blktop - curpos;
|
|
|
+ curpos = blktop;
|
|
|
+ }
|
|
|
+ if (mfl < 0) {
|
|
|
+ if (mfl == -1) {
|
|
|
+ emsg(3, "I/O error on \"%s\"",
|
|
|
+ Iflag ? Iflag : "input");
|
|
|
+ if (kflag == 0)
|
|
|
+ break;
|
|
|
+ if (tapeblock < 0 && (
|
|
|
+ (mtst.st_mode&S_IFMT)==S_IFBLK||
|
|
|
+ (mtst.st_mode&S_IFMT)==S_IFCHR||
|
|
|
+ (mtst.st_mode&S_IFMT)==S_IFREG
|
|
|
+ ) && lseek(mt, blksiz, SEEK_CUR)
|
|
|
+ == (off_t)-1) {
|
|
|
+ emsg(3, "Cannot lseek()");
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (kflag == 0 || mfl == -2) {
|
|
|
+ if ((mtst.st_mode&S_IFMT)!=S_IFCHR &&
|
|
|
+ (mtst.st_mode&S_IFMT)!=S_IFBLK)
|
|
|
+ break;
|
|
|
+ newmedia(mfl == -1 ? errno : 0);
|
|
|
+ if (mfl == -1) {
|
|
|
+ mfl = -2;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (fmttype & TYP_BAR)
|
|
|
+ curpos = 512;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mread();
|
|
|
+ }
|
|
|
+ aoffs += rd;
|
|
|
+ return rd;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read a block of data from tape.
|
|
|
+ */
|
|
|
+static ssize_t
|
|
|
+mread(void)
|
|
|
+{
|
|
|
+ ssize_t ro, rt = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ if ((ro = read(mt, blkbuf + rt, blksiz - rt)) <= 0) {
|
|
|
+ if (ro < 0) {
|
|
|
+ if (errno == EINTR)
|
|
|
+ continue;
|
|
|
+ mfl = -1;
|
|
|
+ } else
|
|
|
+ mfl = -2;
|
|
|
+ if (rt > 0) {
|
|
|
+ rt += ro;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ curpos = blktop = 0;
|
|
|
+ return ro;
|
|
|
+ }
|
|
|
+ rt += ro;
|
|
|
+ poffs += ro;
|
|
|
+ if (tapeblock == 0) {
|
|
|
+ tapeblock = ro;
|
|
|
+ if (!Bflag && !Cflag)
|
|
|
+ blksiz = ro;
|
|
|
+ }
|
|
|
+ } while (rt < blksiz);
|
|
|
+ curpos = 0;
|
|
|
+ blocks += rt >> 9;
|
|
|
+ bytes += rt & 0777;
|
|
|
+ blktop = rt;
|
|
|
+ return rt;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Look what kind of tape or other archive media we are working on and
|
|
|
+ * set the buffer size appropriately (if not specified by the user).
|
|
|
+ */
|
|
|
+static void
|
|
|
+mstat(void)
|
|
|
+{
|
|
|
+ if (fstat(mt, &mtst) < 0) {
|
|
|
+ emsg(3, "Error during stat() of archive");
|
|
|
+ done(1);
|
|
|
+ }
|
|
|
+#if defined (__linux__)
|
|
|
+ if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
|
|
|
+ struct mtget mg;
|
|
|
+ if (ioctl(mt, MTIOCGET, &mg) == 0)
|
|
|
+ tapeblock = (mg.mt_dsreg&MT_ST_BLKSIZE_MASK) >>
|
|
|
+ MT_ST_BLKSIZE_SHIFT;
|
|
|
+ } else if ((mtst.st_mode&S_IFMT) == S_IFBLK) {
|
|
|
+
|
|
|
+ * If using a block device, write blocks of the floppy
|
|
|
+ * disk sector with direct i/o. This enables signals
|
|
|
+ * after each block is written instead of being ~40
|
|
|
+ * seconds in uninterruptible sleep when calling close()
|
|
|
+ * later. For block devices other than floppies, use the
|
|
|
+ * kernel defined i/o block size. For floppies, use direct
|
|
|
+ * i/o even when reading since it is faster.
|
|
|
+ */
|
|
|
+ struct floppy_struct fs;
|
|
|
+ int floppy = -1;
|
|
|
+ int blkbsz;
|
|
|
+
|
|
|
+ if (blksiz == 0) {
|
|
|
+ if ((floppy = ioctl(mt, FDGETPRM, &fs)) == 0)
|
|
|
+ blksiz = fs.sect * FD_SECTSIZE(&fs);
|
|
|
+#ifdef BLKBSZGET
|
|
|
+ else if (ioctl(mt, BLKBSZGET, &blkbsz) == 0)
|
|
|
+ blksiz = blkbsz;
|
|
|
+#endif
|
|
|
+ }
|
|
|
+#ifdef O_DIRECT
|
|
|
+ if ((action == 'o' || floppy == 0) && blksiz != 0) {
|
|
|
+ int flags;
|
|
|
+ if ((flags = fcntl(mt, F_GETFL)) != -1)
|
|
|
+ fcntl(mt, F_SETFL, flags | O_DIRECT);
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+#elif defined (__sun)
|
|
|
+ if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
|
|
|
+ struct mtdrivetype_request mr;
|
|
|
+ static struct mtdrivetype md;
|
|
|
+ mr.size = sizeof md;
|
|
|
+ mr.mtdtp = &md;
|
|
|
+ if (ioctl(mt, MTIOCGETDRIVETYPE, &mr) == 0)
|
|
|
+ tapeblock = md.bsize;
|
|
|
+ }
|
|
|
+#elif defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) \
|
|
|
+ || defined (__DragonFly__) || defined (__APPLE__)
|
|
|
+ if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
|
|
|
+ struct mtget mg;
|
|
|
+ if (ioctl(mt, MTIOCGET, &mg) == 0)
|
|
|
+ tapeblock = mg.mt_blksiz;
|
|
|
+ }
|
|
|
+#elif defined (__hpux) || defined (_AIX)
|
|
|
+#else
|
|
|
+ if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
|
|
|
+ struct blklen bl;
|
|
|
+ if (ioctl(mt, T_RDBLKLEN, &bl) == 0)
|
|
|
+
|
|
|
+ * These are not the values we're interested in
|
|
|
+ * (always 1 and 16M-1 for DAT/DDS tape drives).
|
|
|
+ */
|
|
|
+ tapeblock = 0;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ if (blksiz == 0)
|
|
|
+ switch (mtst.st_mode&S_IFMT) {
|
|
|
+ case S_IFREG:
|
|
|
+ case S_IFBLK:
|
|
|
+ blksiz = 4096;
|
|
|
+ break;
|
|
|
+ case S_IFCHR:
|
|
|
+ if (action == 'o' && !Aflag) {
|
|
|
+ if (pax != PAX_TYPE_CPIO) {
|
|
|
+ if (fmttype & TYP_PAX)
|
|
|
+ blksiz = 5120;
|
|
|
+ else if (fmttype & TYP_TAR)
|
|
|
+ blksiz = 10240;
|
|
|
+ else if (fmttype & TYP_CPIO)
|
|
|
+ blksiz = 5120;
|
|
|
+ else
|
|
|
+ blksiz = 512;
|
|
|
+ } else
|
|
|
+ blksiz = tapeblock>0 ? tapeblock : 512;
|
|
|
+ } else
|
|
|
+ blksiz = tapeblock > 0 && tapeblock % 1024 ?
|
|
|
+ tapeblock : tapeblock > 10240 ?
|
|
|
+ tapeblock : 10240;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ blksiz = 512;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Skip tape data such that size becomes aligned to pad.
|
|
|
+ */
|
|
|
+static int
|
|
|
+skippad(unsigned long long size, int pad)
|
|
|
+{
|
|
|
+ char b[512];
|
|
|
+ int to;
|
|
|
+
|
|
|
+ if ((to = size % pad) != 0) {
|
|
|
+ if (bread(b, pad - to) != pad - to)
|
|
|
+ unexeoa();
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+allzero(const char *bp, int n)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ for (i = 0; i < n; i++)
|
|
|
+ if (bp[i] != '\0')
|
|
|
+ return 0;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+#define CACHESIZE 16
|
|
|
+
|
|
|
+static const char *
|
|
|
+getuser(uid_t uid)
|
|
|
+{
|
|
|
+ static struct {
|
|
|
+ char *name;
|
|
|
+ uid_t uid;
|
|
|
+ } cache[CACHESIZE];
|
|
|
+ static int last;
|
|
|
+ int i;
|
|
|
+ struct passwd *pwd;
|
|
|
+ const char *name;
|
|
|
+
|
|
|
+ for (i = 0; i < CACHESIZE && cache[i].name; i++)
|
|
|
+ if (cache[i].uid == uid)
|
|
|
+ goto found;
|
|
|
+ if ((pwd = getpwuid(uid)) != NULL)
|
|
|
+ name = pwd->pw_name;
|
|
|
+ else
|
|
|
+ name = "";
|
|
|
+ if (i >= CACHESIZE) {
|
|
|
+ if (last >= CACHESIZE)
|
|
|
+ last = 0;
|
|
|
+ i = last++;
|
|
|
+ }
|
|
|
+ if (cache[i].name)
|
|
|
+ free(cache[i].name);
|
|
|
+ cache[i].name = sstrdup(name);
|
|
|
+ cache[i].uid = uid;
|
|
|
+found: return cache[i].name[0] ? cache[i].name : NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static const char *
|
|
|
+getgroup(gid_t gid)
|
|
|
+{
|
|
|
+ static struct {
|
|
|
+ char *name;
|
|
|
+ gid_t gid;
|
|
|
+ } cache[CACHESIZE];
|
|
|
+ static int last;
|
|
|
+ int i;
|
|
|
+ struct group *grp;
|
|
|
+ const char *name;
|
|
|
+
|
|
|
+ for (i = 0; i < CACHESIZE && cache[i].name; i++)
|
|
|
+ if (cache[i].gid == gid)
|
|
|
+ goto found;
|
|
|
+ if ((grp = getgrgid(gid)) != NULL)
|
|
|
+ name = grp->gr_name;
|
|
|
+ else
|
|
|
+ name = "";
|
|
|
+ if (i >= CACHESIZE) {
|
|
|
+ if (last >= CACHESIZE)
|
|
|
+ last = 0;
|
|
|
+ i = last++;
|
|
|
+ }
|
|
|
+ if (cache[i].name)
|
|
|
+ free(cache[i].name);
|
|
|
+ cache[i].name = sstrdup(name);
|
|
|
+ cache[i].gid = gid;
|
|
|
+found: return cache[i].name[0] ? cache[i].name : NULL;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Return a version of the passed string that contains at most one '%d'
|
|
|
+ * and no other printf formats.
|
|
|
+ */
|
|
|
+char *
|
|
|
+oneintfmt(const char *op)
|
|
|
+{
|
|
|
+ char *new, *np;
|
|
|
+ int no = 0;
|
|
|
+
|
|
|
+ np = new = smalloc(2 * strlen(op) + 1);
|
|
|
+ do {
|
|
|
+ if (*op == '%') {
|
|
|
+ *np++ = *op++;
|
|
|
+ if (*op != '%')
|
|
|
+ if (*op != 'd' || no++)
|
|
|
+ *np++ = '%';
|
|
|
+ }
|
|
|
+ *np++ = *op;
|
|
|
+ } while (*op++);
|
|
|
+ return new;
|
|
|
+}
|
|
|
+
|
|
|
+char *
|
|
|
+sstrdup(const char *op)
|
|
|
+{
|
|
|
+ char *np;
|
|
|
+
|
|
|
+ np = smalloc(strlen(op) + 1);
|
|
|
+ strcpy(np, op);
|
|
|
+ return np;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Add this pattern to the extraction list with -i.
|
|
|
+ */
|
|
|
+void
|
|
|
+addg(const char *pattern, int art)
|
|
|
+{
|
|
|
+ struct glist *gp;
|
|
|
+
|
|
|
+ gp = scalloc(1, sizeof *gp);
|
|
|
+ if (pax == PAX_TYPE_CPIO && pattern[0] == '!') {
|
|
|
+ gp->g_not = 1;
|
|
|
+ pattern++;
|
|
|
+ }
|
|
|
+ gp->g_pat = sstrdup(pattern);
|
|
|
+ gp->g_art = art;
|
|
|
+ if (pax != PAX_TYPE_CPIO) {
|
|
|
+ struct glist *gb = NULL, *gc;
|
|
|
+ for (gc = patterns; gc; gc = gc->g_nxt)
|
|
|
+ gb = gc;
|
|
|
+ if (gb)
|
|
|
+ gb->g_nxt = gp;
|
|
|
+ else
|
|
|
+ patterns = gp;
|
|
|
+ } else {
|
|
|
+ gp->g_nxt = patterns;
|
|
|
+ patterns = gp;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Check if the file name s matches any of the given patterns.
|
|
|
+ */
|
|
|
+static struct glist *
|
|
|
+want(struct file *f, struct glist **gb)
|
|
|
+{
|
|
|
+ extern int gmatch(const char *, const char *);
|
|
|
+ struct glist *gp;
|
|
|
+
|
|
|
+ for (gp = patterns; gp; gp = gp->g_nxt) {
|
|
|
+ if ((gmatch(f->f_name, gp->g_pat) != 0) ^ gp->g_not &&
|
|
|
+ (pax_nflag == 0 || gp->g_gotcha == 0)) {
|
|
|
+ return gp;
|
|
|
+ }
|
|
|
+ *gb = gp;
|
|
|
+ }
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+patfile(void)
|
|
|
+{
|
|
|
+ struct iblok *ip;
|
|
|
+ char *name = NULL;
|
|
|
+ size_t namsiz = 0, namlen;
|
|
|
+
|
|
|
+ if ((ip = ib_open(Eflag, 0)) == NULL)
|
|
|
+ msg(3, -2, "Cannot open \"%s\" to read patterns\n", Eflag);
|
|
|
+ while ((namlen = ib_getlin(ip, &name, &namsiz, srealloc)) != 0) {
|
|
|
+ if (name[namlen-1] == '\n')
|
|
|
+ name[--namlen] = '\0';
|
|
|
+ addg(name, 0);
|
|
|
+ }
|
|
|
+ ib_close(ip);
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+swap(char *b, size_t sz, int s8, int s16)
|
|
|
+{
|
|
|
+ uint8_t u8;
|
|
|
+ uint16_t u16;
|
|
|
+ union types2 *t2;
|
|
|
+ union types4 *t4;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (s8) {
|
|
|
+ for (i = 0; i < (sz >> 1); i++) {
|
|
|
+ t2 = &((union types2 *)b)[i];
|
|
|
+ u8 = t2->byte[0];
|
|
|
+ t2->byte[0] = t2->byte[1];
|
|
|
+ t2->byte[1] = u8;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (s16) {
|
|
|
+ for (i = 0; i < (sz >> 2); i++) {
|
|
|
+ t4 = &((union types4 *)b)[i];
|
|
|
+ u16 = t4->sword[0];
|
|
|
+ t4->sword[0] = t4->sword[1];
|
|
|
+ t4->sword[1] = u16;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+ckodd(long long size, int mod, const char *str, const char *fn)
|
|
|
+{
|
|
|
+ if (size % mod) {
|
|
|
+ msg(3, 0, "Cannot swap %s of \"%s\", odd number of %s\n",
|
|
|
+ str, fn, str);
|
|
|
+ errcnt++;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Interactive rename (-r option).
|
|
|
+ */
|
|
|
+static int
|
|
|
+rname(char **oldp, size_t *olds)
|
|
|
+{
|
|
|
+ char *new = NULL;
|
|
|
+ size_t newsize = 0;
|
|
|
+ int i, r;
|
|
|
+ char c;
|
|
|
+
|
|
|
+ fprintf(stderr, "Rename \"%s\"? ", *oldp);
|
|
|
+ if (tty == 0)
|
|
|
+ if ((tty = open("/dev/tty", O_RDWR)) < 0 ||
|
|
|
+ fcntl(tty, F_SETFD, FD_CLOEXEC) < 0)
|
|
|
+ err: msg(3, 1, "Cannot read tty.\n");
|
|
|
+ i = 0;
|
|
|
+ while ((r = read(tty, &c, 1)) == 1 && c != '\n') {
|
|
|
+ if (i+1 >= newsize)
|
|
|
+ new = srealloc(new, newsize += 32);
|
|
|
+ new[i++] = c;
|
|
|
+ }
|
|
|
+ if (r <= 0)
|
|
|
+ goto err;
|
|
|
+ if (new == NULL)
|
|
|
+ return 0;
|
|
|
+ new[i] = '\0';
|
|
|
+ if (new[0] == '.' && new[1] == '\0') {
|
|
|
+ free(new);
|
|
|
+ } else {
|
|
|
+ free(*oldp);
|
|
|
+ *oldp = new;
|
|
|
+ *olds = newsize;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Filter data from tape through the commands given in arg?.
|
|
|
+ */
|
|
|
+static int
|
|
|
+redirect(const char *arg0, const char *arg1)
|
|
|
+{
|
|
|
+ int pd[2];
|
|
|
+
|
|
|
+ if (pipe(pd) < 0)
|
|
|
+ return -1;
|
|
|
+ switch (fork()) {
|
|
|
+ case 0:
|
|
|
+ if (tapeblock>=0 || lseek(mt, -blktop, SEEK_CUR) == (off_t)-1) {
|
|
|
+ int xpd[2];
|
|
|
+ if (pipe(xpd) == 0 && fork() == 0) {
|
|
|
+ ssize_t rd, wo, wt;
|
|
|
+ close(xpd[0]);
|
|
|
+ do {
|
|
|
+ wo = wt = 0;
|
|
|
+ do {
|
|
|
+ if ((wo = write(xpd[1],
|
|
|
+ blkbuf + wt,
|
|
|
+ blktop - wt))
|
|
|
+ <= 0) {
|
|
|
+ if (errno == EINTR)
|
|
|
+ continue;
|
|
|
+ _exit(0);
|
|
|
+ }
|
|
|
+ wt += wo;
|
|
|
+ } while (wt < blktop);
|
|
|
+ } while ((rd = mread()) >= 0);
|
|
|
+ if (rd < 0) {
|
|
|
+ emsg(3, "Read error on \"%s\"",
|
|
|
+ Iflag && !sysv3 ?
|
|
|
+ Iflag : "input");
|
|
|
+ }
|
|
|
+ _exit(0);
|
|
|
+ } else {
|
|
|
+ close(xpd[1]);
|
|
|
+ dup2(xpd[0], 0);
|
|
|
+ close(xpd[0]);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ dup2(mt, 0);
|
|
|
+ }
|
|
|
+ close(mt);
|
|
|
+ dup2(pd[1], 1);
|
|
|
+ close(pd[0]);
|
|
|
+ close(pd[1]);
|
|
|
+ execlp(arg0, arg0, arg1, NULL);
|
|
|
+ fprintf(stderr, "%s: could not exec %s: %s\n",
|
|
|
+ progname, arg0, strerror(errno));
|
|
|
+ _exit(0177);
|
|
|
+
|
|
|
+ default:
|
|
|
+ dup2(pd[0], mt);
|
|
|
+ close(pd[0]);
|
|
|
+ close(pd[1]);
|
|
|
+ tapeblock = -1;
|
|
|
+ break;
|
|
|
+ case -1:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Get the name stored in a tar header. buf is expected to be at least
|
|
|
+ * TPFXSIZ+TNAMSIZ+2 bytes.
|
|
|
+ */
|
|
|
+static char *
|
|
|
+tnameof(struct tar_header *hp, char *buf)
|
|
|
+{
|
|
|
+ const char *cp;
|
|
|
+ char *bp = buf;
|
|
|
+
|
|
|
+ if (fmttype & TYP_USTAR && fmttype != FMT_GNUTAR &&
|
|
|
+ hp->t_prefix[0] != '\0') {
|
|
|
+ cp = hp->t_prefix;
|
|
|
+ while (cp < &hp->t_prefix[TPFXSIZ] && *cp)
|
|
|
+ *bp++ = *cp++;
|
|
|
+ if (bp > buf)
|
|
|
+ *bp++ = '/';
|
|
|
+ }
|
|
|
+ cp = hp->t_name;
|
|
|
+ while (cp < &hp->t_name[TNAMSIZ] && *cp)
|
|
|
+ *bp++ = *cp++;
|
|
|
+ *bp = '\0';
|
|
|
+ return buf;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Store fn as file name in a tar header.
|
|
|
+ */
|
|
|
+static int
|
|
|
+tmkname(struct tar_header *hp, const char *fn)
|
|
|
+{
|
|
|
+ const char *cp, *cs = NULL;
|
|
|
+
|
|
|
+ for (cp = fn; *cp; cp++) {
|
|
|
+ if (fmttype & TYP_USTAR && *cp == '/' && cp[1] != '\0' &&
|
|
|
+ cp > fn && cp-fn <= TPFXSIZ)
|
|
|
+ cs = cp;
|
|
|
+ }
|
|
|
+ if (fmttype == FMT_GNUTAR && cp - fn > 99) {
|
|
|
+ writegnuname(fn, cp - fn + 1, 'L');
|
|
|
+ cp = &fn[99];
|
|
|
+ } else if (cp - (cs ? &cs[1] : fn) > TNAMSIZ) {
|
|
|
+ if (fmttype & TYP_PAX && utf8(fn)) {
|
|
|
+ paxrec |= PR_PATH;
|
|
|
+ strcpy(hp->t_name, sequence());
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ msg(3, 0, "%s: file name too long\n", fn);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ if (cs && cp - fn > TNAMSIZ) {
|
|
|
+ memcpy(hp->t_prefix, fn, cs - fn);
|
|
|
+ if (cs - fn < TPFXSIZ)
|
|
|
+ hp->t_prefix[cs - fn] = '\0';
|
|
|
+ memcpy(hp->t_name, &cs[1], cp - &cs[1]);
|
|
|
+ if (cp - &cs[1] < TNAMSIZ)
|
|
|
+ hp->t_name[cp - &cs[1]] = '\0';
|
|
|
+ } else {
|
|
|
+ memcpy(hp->t_name, fn, cp - fn);
|
|
|
+ if (cp - fn < TNAMSIZ)
|
|
|
+ hp->t_name[cp - fn] = '\0';
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Get the link name of a tar header.
|
|
|
+ */
|
|
|
+static void
|
|
|
+tlinkof(struct tar_header *hp, struct file *f)
|
|
|
+{
|
|
|
+ const char *cp;
|
|
|
+ char *bp;
|
|
|
+
|
|
|
+
|
|
|
+ if (f->f_lsiz < TNAMSIZ+1)
|
|
|
+ f->f_lnam = srealloc(f->f_lnam, f->f_lsiz = TNAMSIZ+1);
|
|
|
+ cp = hp->t_linkname;
|
|
|
+ bp = f->f_lnam;
|
|
|
+ while (cp < &hp->t_linkname[TNAMSIZ] && *cp)
|
|
|
+ *bp++ = *cp++;
|
|
|
+ *bp = '\0';
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Create the link name in a tar header.
|
|
|
+ */
|
|
|
+static int
|
|
|
+tmklink(struct tar_header *hp, const char *fn)
|
|
|
+{
|
|
|
+ const char *cp;
|
|
|
+
|
|
|
+ for (cp = fn; *cp; cp++);
|
|
|
+ if (fmttype == FMT_GNUTAR && cp - fn > 99) {
|
|
|
+ writegnuname(fn, cp - fn + 1, 'K');
|
|
|
+ cp = &fn[99];
|
|
|
+ } else if (cp - fn > TNAMSIZ) {
|
|
|
+ if (fmttype & TYP_PAX && utf8(fn)) {
|
|
|
+ paxrec |= PR_LINKPATH;
|
|
|
+ strcpy(hp->t_linkname, sequence());
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ msg(3, 0, "%s: linked name too long\n", fn);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ memcpy(hp->t_linkname, fn, cp - fn);
|
|
|
+ if (cp - fn < TNAMSIZ)
|
|
|
+ hp->t_linkname[cp - fn] = '\0';
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+tlflag(struct stat *st)
|
|
|
+{
|
|
|
+ if (fmttype & TYP_BAR) {
|
|
|
+ switch (st->st_mode & S_IFMT) {
|
|
|
+ case S_IFREG:
|
|
|
+ case S_IFDIR:
|
|
|
+ return '0';
|
|
|
+ case S_IFLNK:
|
|
|
+ return '2';
|
|
|
+ default:
|
|
|
+ return '3';
|
|
|
+ }
|
|
|
+ } else if (fmttype & TYP_USTAR) {
|
|
|
+ switch (st->st_mode & S_IFMT) {
|
|
|
+ case S_IFREG:
|
|
|
+ return '0';
|
|
|
+ case S_IFLNK:
|
|
|
+ return '2';
|
|
|
+ case S_IFCHR:
|
|
|
+ return '3';
|
|
|
+ case S_IFBLK:
|
|
|
+ return '4';
|
|
|
+ case S_IFDIR:
|
|
|
+ return '5';
|
|
|
+ case S_IFIFO:
|
|
|
+ return '6';
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ switch (st->st_mode & S_IFMT) {
|
|
|
+ case S_IFREG:
|
|
|
+ return '\0';
|
|
|
+ case S_IFLNK:
|
|
|
+ return '2';
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Ustar checksums are created using unsigned chars, as specified by
|
|
|
+ * POSIX. Traditional tar implementations use signed chars. Some
|
|
|
+ * implementations (notably SVR4 cpio derivatives) use signed chars
|
|
|
+ * even for ustar archives, but this is clearly an implementation bug.
|
|
|
+ */
|
|
|
+static void
|
|
|
+tchksum(union bincpio *bp)
|
|
|
+{
|
|
|
+ uint32_t sum;
|
|
|
+ char *cp;
|
|
|
+
|
|
|
+ memset(bp->Tdr.t_chksum, ' ', sizeof bp->Tdr.t_chksum);
|
|
|
+ sum = 0;
|
|
|
+ if (fmttype & TYP_USTAR)
|
|
|
+ for (cp = bp->data; cp < &bp->data[512]; cp++)
|
|
|
+ sum += *((unsigned char *)cp);
|
|
|
+ else
|
|
|
+ for (cp = bp->data; cp < &bp->data[512]; cp++)
|
|
|
+ sum += *((signed char *)cp);
|
|
|
+ sprintf(bp->Tdr.t_chksum, "%7.7o", sum);
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+tcssum(union bincpio *bp, int ustar)
|
|
|
+{
|
|
|
+ uint32_t ssum = 0, usum = 0, osum;
|
|
|
+ char ochk[sizeof bp->Tdr.t_chksum];
|
|
|
+ char *cp;
|
|
|
+
|
|
|
+ osum = rdoct(bp->Tdr.t_chksum, 8);
|
|
|
+ memcpy(ochk, bp->Tdr.t_chksum, sizeof ochk);
|
|
|
+ memset(bp->Tdr.t_chksum, ' ', sizeof bp->Tdr.t_chksum);
|
|
|
+ for (cp = bp->data; cp < &bp->data[512]; cp++) {
|
|
|
+ ssum += *((signed char *)cp);
|
|
|
+ usum += *((unsigned char *)cp);
|
|
|
+ }
|
|
|
+ memcpy(bp->Tdr.t_chksum, ochk, sizeof bp->Tdr.t_chksum);
|
|
|
+ return ssum != osum && usum != osum;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+trdsum(union bincpio *bp)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (fmttype & TYP_BAR)
|
|
|
+ i = bcssum(bp);
|
|
|
+ else
|
|
|
+ i = tcssum(bp, fmttype & TYP_USTAR);
|
|
|
+ if (i)
|
|
|
+ msg(3, 0, "Bad header - checksum error.\n");
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+static mode_t
|
|
|
+tifmt(int c)
|
|
|
+{
|
|
|
+ switch (c) {
|
|
|
+ default:
|
|
|
+ case '\0':
|
|
|
+ case '0':
|
|
|
+ return S_IFREG;
|
|
|
+ case '2':
|
|
|
+ return S_IFLNK;
|
|
|
+ case '3':
|
|
|
+ return S_IFCHR;
|
|
|
+ case '4':
|
|
|
+ return S_IFBLK;
|
|
|
+ case '5':
|
|
|
+ return S_IFDIR;
|
|
|
+ case '6':
|
|
|
+ return S_IFIFO;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * bar format support functions.
|
|
|
+ */
|
|
|
+static void
|
|
|
+bchksum(union bincpio *bp)
|
|
|
+{
|
|
|
+ uint32_t sum;
|
|
|
+ char *cp;
|
|
|
+
|
|
|
+ memset(bp->Bdr.b_chksum, ' ', sizeof bp->Bdr.b_chksum);
|
|
|
+ sum = 0;
|
|
|
+ for (cp = bp->data; cp < &bp->data[512]; cp++)
|
|
|
+ sum += *((signed char *)cp);
|
|
|
+ sprintf(bp->Bdr.b_chksum, "%7.7o", sum);
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+bcssum(union bincpio *bp)
|
|
|
+{
|
|
|
+ uint32_t sum, osum;
|
|
|
+ char ochk[sizeof bp->Bdr.b_chksum];
|
|
|
+ char *cp;
|
|
|
+
|
|
|
+ osum = rdoct(bp->Bdr.b_chksum, 8);
|
|
|
+ memcpy(ochk, bp->Bdr.b_chksum, sizeof ochk);
|
|
|
+ memset(bp->Bdr.b_chksum, ' ', sizeof bp->Bdr.b_chksum);
|
|
|
+ sum = 0;
|
|
|
+ for (cp = bp->data; cp < &bp->data[512]; cp++)
|
|
|
+ sum += *((signed char *)cp);
|
|
|
+ memcpy(bp->Bdr.b_chksum, ochk, sizeof bp->Bdr.b_chksum);
|
|
|
+ return sum != osum;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+blinkof(const char *cp, struct file *f, int namlen)
|
|
|
+{
|
|
|
+ if (f->f_lsiz < 512)
|
|
|
+ f->f_lnam = srealloc(f->f_lnam, f->f_lsiz = 512);
|
|
|
+ strcpy(f->f_lnam, &cp[SIZEOF_bar_header + namlen]);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+dump_barhdr(void)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+ static int volno;
|
|
|
+ static time_t now = -1;
|
|
|
+
|
|
|
+ memset(&bc, 0, 512);
|
|
|
+ sprintf(bc.Bdr.b_uid, "%d", myuid & 07777777);
|
|
|
+ sprintf(bc.Bdr.b_gid, "%d", mygid & 07777777);
|
|
|
+ bc.Bdr.b_size[0] = '0';
|
|
|
+ memcpy(bc.Bdr.b_bar_magic, mag_bar, sizeof bc.Bdr.b_bar_magic);
|
|
|
+ sprintf(bc.Bdr.b_volume_num, "%d", ++volno & 0777);
|
|
|
+ bc.Bdr.b_compressed = '0';
|
|
|
+ if (now == (time_t)-1)
|
|
|
+ time(&now);
|
|
|
+ sprintf(bc.Bdr.b_date, "%llo", now & 077777777777LL);
|
|
|
+ bchksum(&bc);
|
|
|
+ bwrite(bc.data, 512);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Support for compressed bar format (any regular file is piped through zcat).
|
|
|
+ */
|
|
|
+static pid_t zpid;
|
|
|
+
|
|
|
+static int
|
|
|
+zcreat(const char *name, mode_t mode)
|
|
|
+{
|
|
|
+ int pd[2];
|
|
|
+ int fd;
|
|
|
+
|
|
|
+ if (pipe(pd) < 0)
|
|
|
+ return -1;
|
|
|
+ if ((fd = creat(name, mode)) < 0) {
|
|
|
+ fd = errno;
|
|
|
+ close(pd[0]);
|
|
|
+ close(pd[1]);
|
|
|
+ errno = fd;
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ switch (zpid = fork()) {
|
|
|
+ case -1:
|
|
|
+ return -1;
|
|
|
+ case 0:
|
|
|
+ dup2(pd[0], 0);
|
|
|
+ dup2(fd, 1);
|
|
|
+ close(pd[0]);
|
|
|
+ close(pd[1]);
|
|
|
+ close(fd);
|
|
|
+ execlp("zcat", "zcat", NULL);
|
|
|
+ _exit(0177);
|
|
|
+
|
|
|
+ }
|
|
|
+ close(pd[0]);
|
|
|
+ close(fd);
|
|
|
+ sigset(SIGPIPE, SIG_IGN);
|
|
|
+ return pd[1];
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+zclose(int fd)
|
|
|
+{
|
|
|
+ int c, s;
|
|
|
+
|
|
|
+ c = close(fd);
|
|
|
+ while (waitpid(zpid, &s, 0) != zpid);
|
|
|
+ return c != 0 || s != 0 ? -1 : 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * If using the -A option, device numbers that appear in the archive
|
|
|
+ * are not reused for appended files. This avoids wrong hardlink
|
|
|
+ * connections on extraction.
|
|
|
+ *
|
|
|
+ * In fact, this should be done even if we did not fake device and
|
|
|
+ * inode numbers, since it is not guaranteed that the archive was
|
|
|
+ * created on the same machine, or even on the same machine, inode
|
|
|
+ * number could have changed after a file was unlinked.
|
|
|
+ */
|
|
|
+static void
|
|
|
+markdev(dev_t dev)
|
|
|
+{
|
|
|
+ struct dslot *dp, *dq = NULL;;
|
|
|
+
|
|
|
+ for (dp = markeddevs; dp; dp = dp->d_nxt) {
|
|
|
+ if (dp->d_dev == dev)
|
|
|
+ return;
|
|
|
+ dq = dp;
|
|
|
+ }
|
|
|
+ dp = scalloc(1, sizeof *dp);
|
|
|
+ dp->d_dev = dev;
|
|
|
+ if (markeddevs == NULL)
|
|
|
+ markeddevs = dp;
|
|
|
+ else
|
|
|
+ dq->d_nxt = dp;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+marked(dev_t dev)
|
|
|
+{
|
|
|
+ struct dslot *dp;
|
|
|
+
|
|
|
+ for (dp = markeddevs; dp; dp = dp->d_nxt)
|
|
|
+ if (dp->d_dev == dev)
|
|
|
+ return 1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+cantsup(int err, const char *file)
|
|
|
+{
|
|
|
+ if (sysv3)
|
|
|
+ msg(err ? 3 : 2, 0,
|
|
|
+ "format can't support expanded types on %s\n",
|
|
|
+ file);
|
|
|
+ else
|
|
|
+ msg(0, 0, "%s format can't support expanded types on %s\n",
|
|
|
+ err ? "Error" : "Warning", file);
|
|
|
+ errcnt++;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+onint(int signo)
|
|
|
+{
|
|
|
+ if (cur_ofile && cur_tfile && rename(cur_tfile, cur_ofile) < 0)
|
|
|
+ emsg(3, "Cannot recover original \"%s\"", cur_ofile);
|
|
|
+ if (cur_ofile && cur_tfile == NULL && unlink(cur_ofile) < 0)
|
|
|
+ emsg(3, "Cannot remove incomplete \"%s\"", cur_ofile);
|
|
|
+ exit(signo | 0200);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read the compressed zip data part for a file.
|
|
|
+ */
|
|
|
+static int
|
|
|
+zipread(struct file *f, const char *tgt, int tfd, int doswap)
|
|
|
+{
|
|
|
+ int val = 0;
|
|
|
+ uint32_t crc = 0;
|
|
|
+
|
|
|
+ if (f->f_gflag & FG_DESC) {
|
|
|
+ if (f->f_cmethod != C_DEFLATED && f->f_cmethod != C_ENHDEFLD ||
|
|
|
+ f->f_gflag & FG_CRYPT)
|
|
|
+ msg(4, 1, "Cannot handle zip data descriptor\n");
|
|
|
+ f->f_csize = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ f->f_st.st_size = 0x7FFFFFFFFFFFFFFFLL;
|
|
|
+ } else if (tfd < 0)
|
|
|
+ return skipfile(f);
|
|
|
+ if (f->f_gflag & FG_CRYPT)
|
|
|
+ return cantunzip(f, "encrypted");
|
|
|
+ switch (f->f_cmethod) {
|
|
|
+ case C_DEFLATED:
|
|
|
+ case C_ENHDEFLD:
|
|
|
+ val = zipinflate(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+ case C_SHRUNK:
|
|
|
+ val = zipunshrink(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+ case C_IMPLODED:
|
|
|
+ val = zipexplode(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+ case C_REDUCED1:
|
|
|
+ case C_REDUCED2:
|
|
|
+ case C_REDUCED3:
|
|
|
+ case C_REDUCED4:
|
|
|
+ val = zipexpand(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+ case C_TOKENIZED:
|
|
|
+ return cantunzip(f, "tokenized");
|
|
|
+ case C_DCLIMPLODED:
|
|
|
+ val = zipblast(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+ case C_BZIP2:
|
|
|
+#if USE_BZLIB
|
|
|
+ val = zipunbz2(f, tgt, tfd, doswap, &crc);
|
|
|
+ break;
|
|
|
+#else
|
|
|
+ return cantunzip(f, "bzip2 compressed");
|
|
|
+#endif
|
|
|
+ default:
|
|
|
+ return cantunzip(f, "compressed");
|
|
|
+ }
|
|
|
+ if (f->f_gflag & FG_DESC)
|
|
|
+ zipreaddesc(f);
|
|
|
+ if (val == 0 && crc != f->f_chksum) {
|
|
|
+ msg(3, 0, "\"%s\" - checksum error\n", f->f_name);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read a zip data descriptor (i. e. a field after the compressed data
|
|
|
+ * that contains the actual values for sizes and crc).
|
|
|
+ */
|
|
|
+static void
|
|
|
+zipreaddesc(struct file *f)
|
|
|
+{
|
|
|
+ if (f->f_oflag & OF_ZIP64) {
|
|
|
+ struct zipddesc64 zd64;
|
|
|
+ bread((char *)&zd64, SIZEOF_zipddesc64);
|
|
|
+ if (memcmp(zd64.zd_signature, mag_zipdds, sizeof mag_zipdds))
|
|
|
+ msg(4, 1, "Invalid zip data descriptor\n");
|
|
|
+ f->f_chksum = ple32(zd64.zd_crc32);
|
|
|
+ f->f_dsize = f->f_st.st_size = ple64(zd64.zd_nsize) &
|
|
|
+ 0xFFFFFFFFFFFFFFFFULL;
|
|
|
+ f->f_csize = ple64(zd64.zd_csize) &
|
|
|
+ 0xFFFFFFFFFFFFFFFFULL;
|
|
|
+ } else {
|
|
|
+ struct zipddesc zd;
|
|
|
+ bread((char *)&zd, SIZEOF_zipddesc);
|
|
|
+ if (memcmp(zd.zd_signature, mag_zipdds, sizeof mag_zipdds))
|
|
|
+ msg(4, 1, "Invalid zip data descriptor\n");
|
|
|
+ f->f_chksum = ple32(zd.zd_crc32);
|
|
|
+ f->f_dsize = f->f_st.st_size = ple32(zd.zd_nsize)&0xFFFFFFFFUL;
|
|
|
+ f->f_csize = ple32(zd.zd_csize)&0xFFFFFFFFUL;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+cantunzip(struct file *f, const char *method)
|
|
|
+{
|
|
|
+ msg(3, 0, "Cannot unzip %s file \"%s\"\n", method, f->f_name);
|
|
|
+ errcnt++;
|
|
|
+ return skipfile(f);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * PC-DOS time format:
|
|
|
+ *
|
|
|
+ * 31 24 20 15 10 4 0
|
|
|
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
|
|
|
+ * | | | | |
|
|
|
+ * |year |months |days |hours |minutes |biseconds|
|
|
|
+ *
|
|
|
+ * refers to local time on the machine it was created on.
|
|
|
+ */
|
|
|
+
|
|
|
+static time_t
|
|
|
+gdostime(const char *tp, const char *dp)
|
|
|
+{
|
|
|
+ uint32_t v;
|
|
|
+ struct tm tm;
|
|
|
+
|
|
|
+ v = (int)(tp[0]&0377) +
|
|
|
+ ((int)(tp[1]&0377) << 8) +
|
|
|
+ ((int)(dp[0]&0377) << 16) +
|
|
|
+ ((int)(dp[1]&0377) << 24);
|
|
|
+ memset(&tm, 0, sizeof tm);
|
|
|
+ tm.tm_sec = (v&0x1F) << 1;
|
|
|
+ tm.tm_min = (v&0x7E0) >> 5;
|
|
|
+ tm.tm_hour = (v&0xF800) >> 11;
|
|
|
+ tm.tm_mday = ((v&0x1F0000) >> 16);
|
|
|
+ tm.tm_mon = ((v&0x1E00000) >> 21) - 1;
|
|
|
+ tm.tm_year = ((v&0xFE000000) >> 25) + 80;
|
|
|
+ tm.tm_isdst = -1;
|
|
|
+ return mktime(&tm);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+mkdostime(time_t t, char *tp, char *dp)
|
|
|
+{
|
|
|
+ uint32_t v;
|
|
|
+ struct tm *tm;
|
|
|
+
|
|
|
+ tm = localtime(&t);
|
|
|
+ v = (tm->tm_sec >> 1) + (tm->tm_sec&1) + (tm->tm_min << 5) +
|
|
|
+ (tm->tm_hour << 11) + (tm->tm_mday << 16) +
|
|
|
+ ((tm->tm_mon+1) << 21) + ((tm->tm_year - 80) << 25);
|
|
|
+ le16p(v&0x0000ffff, tp);
|
|
|
+ le16p((v&0xffff0000) >> 16, dp);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read and interpret the zip extra field for a file.
|
|
|
+ */
|
|
|
+static ssize_t
|
|
|
+ziprxtra(struct file *f, struct zip_header *z)
|
|
|
+{
|
|
|
+ union zextra *x, *xp;
|
|
|
+ short tag, size;
|
|
|
+ ssize_t len;
|
|
|
+
|
|
|
+ len = ple16(z->z_extralen)&0177777;
|
|
|
+ if (len > 0) {
|
|
|
+ x = smalloc(len);
|
|
|
+ if (bread((char *)x, len) != len)
|
|
|
+ return -1;
|
|
|
+ if (len < 4)
|
|
|
+ return len;
|
|
|
+ xp = x;
|
|
|
+ while (len > 0) {
|
|
|
+ if (len < 4)
|
|
|
+ return -1;
|
|
|
+ tag = ple16(xp->Ze_gn.ze_gn_tag);
|
|
|
+ size = (ple16(xp->Ze_gn.ze_gn_tsize)&0177777) + 4;
|
|
|
+ switch (tag) {
|
|
|
+ case mag_zip64f:
|
|
|
+ if (size != SIZEOF_zextra_64 &&
|
|
|
+ size != SIZEOF_zextra_64_a &&
|
|
|
+ size != SIZEOF_zextra_64_b)
|
|
|
+ break;
|
|
|
+ if (f->f_st.st_size == 0xffffffff)
|
|
|
+ f->f_st.st_size =
|
|
|
+ ple64(xp->Ze_64.ze_64_nsize);
|
|
|
+ if (f->f_csize == 0xffffffff)
|
|
|
+ f->f_csize =
|
|
|
+ ple64(xp->Ze_64.ze_64_csize);
|
|
|
+ f->f_oflag |= OF_ZIP64;
|
|
|
+ break;
|
|
|
+ case 0x000d:
|
|
|
+ if (size != SIZEOF_zextra_pk)
|
|
|
+ break;
|
|
|
+ f->f_st.st_atime = ple32(xp->Ze_pk.ze_pk_atime);
|
|
|
+ f->f_st.st_mtime = ple32(xp->Ze_pk.ze_pk_mtime);
|
|
|
+ f->f_st.st_uid = ple16(xp->Ze_pk.ze_pk_uid) &
|
|
|
+ 0177777;
|
|
|
+ f->f_st.st_gid = ple16(xp->Ze_pk.ze_pk_gid) &
|
|
|
+ 0177777;
|
|
|
+ break;
|
|
|
+ case 0x5455:
|
|
|
+ if (xp->Ze_et.ze_et_flags[0] & 1)
|
|
|
+ f->f_st.st_atime =
|
|
|
+ ple32(xp->Ze_et.ze_et_atime);
|
|
|
+ if (xp->Ze_et.ze_et_flags[0] & 2)
|
|
|
+ f->f_st.st_mtime =
|
|
|
+ ple32(xp->Ze_et.ze_et_mtime);
|
|
|
+ if (xp->Ze_et.ze_et_flags[0] & 3)
|
|
|
+ f->f_st.st_ctime =
|
|
|
+ ple32(xp->Ze_et.ze_et_ctime);
|
|
|
+ break;
|
|
|
+ case 0x5855:
|
|
|
+ if (size != SIZEOF_zextra_i1)
|
|
|
+ break;
|
|
|
+ f->f_st.st_atime = ple32(xp->Ze_i1.ze_i1_atime);
|
|
|
+ f->f_st.st_mtime = ple32(xp->Ze_i1.ze_i1_mtime);
|
|
|
+ f->f_st.st_uid = ple16(xp->Ze_i1.ze_i1_uid) &
|
|
|
+ 0177777;
|
|
|
+ f->f_st.st_gid = ple16(xp->Ze_i1.ze_i1_gid) &
|
|
|
+ 0177777;
|
|
|
+ break;
|
|
|
+ case 0x7855:
|
|
|
+ if (size != SIZEOF_zextra_i2)
|
|
|
+ break;
|
|
|
+ f->f_st.st_uid = ple16(xp->Ze_i2.ze_i2_uid) &
|
|
|
+ 0177777;
|
|
|
+ f->f_st.st_gid = ple16(xp->Ze_i2.ze_i2_gid) &
|
|
|
+ 0177777;
|
|
|
+ break;
|
|
|
+ case 0x756e:
|
|
|
+ if (size < SIZEOF_zextra_as)
|
|
|
+ break;
|
|
|
+ f->f_st.st_mode = ple16(xp->Ze_as.ze_as_mode);
|
|
|
+ f->f_st.st_uid = ple16(xp->Ze_as.ze_as_uid) &
|
|
|
+ 0177777;
|
|
|
+ f->f_st.st_gid = ple16(xp->Ze_as.ze_as_gid) &
|
|
|
+ 0177777;
|
|
|
+ if ((f->f_st.st_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ if (f->f_lsiz < size-14+1)
|
|
|
+ f->f_lnam = srealloc(f->f_lnam,
|
|
|
+ f->f_lsiz =
|
|
|
+ size-18+1);
|
|
|
+ memcpy(f->f_lnam, &((char *)xp)[18],
|
|
|
+ size-18);
|
|
|
+ f->f_lnam[size-18] = '\0';
|
|
|
+ f->f_st.st_size = size-18;
|
|
|
+ } else {
|
|
|
+ f->f_st.st_rdev =
|
|
|
+ ple32(xp->Ze_as.ze_as_sizdev);
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case mag_zipcpio:
|
|
|
+ if (size != SIZEOF_zextra_cp)
|
|
|
+ break;
|
|
|
+ f->f_st.st_dev = ple32(xp->Ze_cp.ze_cp_dev);
|
|
|
+ f->f_st.st_ino = ple32(xp->Ze_cp.ze_cp_ino);
|
|
|
+ f->f_st.st_mode = ple32(xp->Ze_cp.ze_cp_mode);
|
|
|
+ f->f_st.st_uid = ple32(xp->Ze_cp.ze_cp_uid) &
|
|
|
+ 0xFFFFFFFFUL;
|
|
|
+ f->f_st.st_gid = ple32(xp->Ze_cp.ze_cp_gid) &
|
|
|
+ 0xFFFFFFFFUL;
|
|
|
+ f->f_st.st_nlink = ple32(xp->Ze_cp.ze_cp_nlink)&
|
|
|
+ 0xFFFFFFFFUL;
|
|
|
+ f->f_st.st_rdev = ple32(xp->Ze_cp.ze_cp_rdev);
|
|
|
+ f->f_rmajor = major(f->f_st.st_rdev);
|
|
|
+ f->f_rminor = minor(f->f_st.st_rdev);
|
|
|
+ f->f_st.st_mtime = ple32(xp->Ze_cp.ze_cp_mtime);
|
|
|
+ f->f_st.st_atime = ple32(xp->Ze_cp.ze_cp_atime);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ xp = (union zextra *)&((char *)xp)[size];
|
|
|
+ len -= size;
|
|
|
+ }
|
|
|
+ free(x);
|
|
|
+ }
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Write the central directory and the end of a zip file.
|
|
|
+ */
|
|
|
+static void
|
|
|
+ziptrailer(void)
|
|
|
+{
|
|
|
+ struct zipstuff *zs;
|
|
|
+ struct zipcentral zc;
|
|
|
+ struct zipend ze;
|
|
|
+ long long cpstart, cpend, entries = 0;
|
|
|
+ size_t sz;
|
|
|
+
|
|
|
+ cpstart = nwritten;
|
|
|
+ for (zs = zipbulk; zs; zs = zs->zs_next) {
|
|
|
+ entries++;
|
|
|
+ memset(&zc, 0, SIZEOF_zipcentral);
|
|
|
+ memcpy(zc.zc_signature, mag_zipctr, 4);
|
|
|
+ zc.zc_versionmade[0] = 20;
|
|
|
+ zc.zc_versionextr[0] = zs->zs_cmethod == 8 ? 20 : 10;
|
|
|
+ mkdostime(zs->zs_mtime, zc.zc_modtime, zc.zc_moddate);
|
|
|
+ le32p(zs->zs_crc32, zc.zc_crc32);
|
|
|
+ le16p(zs->zs_cmethod, zc.zc_cmethod);
|
|
|
+ le16p(zs->zs_gflag, zc.zc_gflag);
|
|
|
+
|
|
|
+ * We flag files as created on PC-DOS / FAT filesystem
|
|
|
+ * and thus set PC-DOS attributes here.
|
|
|
+ */
|
|
|
+ if ((zs->zs_mode&0222) == 0)
|
|
|
+ zc.zc_external[0] |= 0x01;
|
|
|
+ if ((zs->zs_mode&S_IFMT) == S_IFDIR)
|
|
|
+ zc.zc_external[0] |= 0x10;
|
|
|
+ sz = strlen(zs->zs_name);
|
|
|
+ le16p(sz, zc.zc_namelen);
|
|
|
+ if (zs->zs_size >= 0xffffffff || zs->zs_csize >= 0xffffffff ||
|
|
|
+ zs->zs_relative >= 0xffffffff) {
|
|
|
+ struct zextra_64 zf;
|
|
|
+
|
|
|
+ memset(&zf, 0, SIZEOF_zextra_64);
|
|
|
+ le16p(mag_zip64f, zf.ze_64_tag);
|
|
|
+ le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
|
|
|
+ if ((zs->zs_mode&S_IFMT) == S_IFREG ||
|
|
|
+ (zs->zs_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ le32p(0xffffffff, zc.zc_csize);
|
|
|
+ le32p(0xffffffff, zc.zc_nsize);
|
|
|
+ le64p(zs->zs_csize, zf.ze_64_csize);
|
|
|
+ le64p(zs->zs_size, zf.ze_64_nsize);
|
|
|
+ }
|
|
|
+ le64p(zs->zs_relative, zf.ze_64_reloff);
|
|
|
+ le32p(0xffffffff, zc.zc_relative);
|
|
|
+ le16p(SIZEOF_zextra_64, zc.zc_extralen);
|
|
|
+ bwrite((char *)&zc, SIZEOF_zipcentral);
|
|
|
+ bwrite(zs->zs_name, sz);
|
|
|
+ bwrite((char *)&zf, SIZEOF_zextra_64);
|
|
|
+ } else {
|
|
|
+ if ((zs->zs_mode&S_IFMT) == S_IFREG ||
|
|
|
+ (zs->zs_mode&S_IFMT) == S_IFLNK) {
|
|
|
+ le32p(zs->zs_csize, zc.zc_csize);
|
|
|
+ le32p(zs->zs_size, zc.zc_nsize);
|
|
|
+ }
|
|
|
+ le32p(zs->zs_relative, zc.zc_relative);
|
|
|
+ bwrite((char *)&zc, SIZEOF_zipcentral);
|
|
|
+ bwrite(zs->zs_name, sz);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ cpend = nwritten;
|
|
|
+ memset(&ze, 0, SIZEOF_zipend);
|
|
|
+ memcpy(ze.ze_signature, mag_zipend, 4);
|
|
|
+ if (cpend >= 0xffffffff || entries >= 0xffff) {
|
|
|
+ struct zip64end z6;
|
|
|
+ struct zip64loc z4;
|
|
|
+
|
|
|
+ memset(&z6, 0, SIZEOF_zip64end);
|
|
|
+ memcpy(z6.z6_signature, mag_zip64e, 4);
|
|
|
+ le64p(SIZEOF_zip64end - 12, z6.z6_recsize);
|
|
|
+ z6.z6_versionmade[0] = 20;
|
|
|
+ z6.z6_versionextr[0] = 20;
|
|
|
+ le64p(entries, z6.z6_thisentries);
|
|
|
+ le64p(entries, z6.z6_allentries);
|
|
|
+ le64p(cpend - cpstart, z6.z6_dirsize);
|
|
|
+ le64p(cpstart, z6.z6_startsize);
|
|
|
+ bwrite((char *)&z6, SIZEOF_zip64end);
|
|
|
+ memset(&z4, 0, SIZEOF_zip64loc);
|
|
|
+ memcpy(z4.z4_signature, mag_zip64l, 4);
|
|
|
+ le64p(cpend, z4.z4_reloff);
|
|
|
+ le32p(1, z4.z4_alldiskn);
|
|
|
+ bwrite((char *)&z4, SIZEOF_zip64loc);
|
|
|
+ le16p(0xffff, ze.ze_thisentries);
|
|
|
+ le16p(0xffff, ze.ze_allentries);
|
|
|
+ le32p(0xffffffff, ze.ze_dirsize);
|
|
|
+ le32p(0xffffffff, ze.ze_startsize);
|
|
|
+ } else {
|
|
|
+ le16p(entries, ze.ze_thisentries);
|
|
|
+ le16p(entries, ze.ze_allentries);
|
|
|
+ le32p(cpend - cpstart, ze.ze_dirsize);
|
|
|
+ le32p(cpstart, ze.ze_startsize);
|
|
|
+ }
|
|
|
+ bwrite((char *)&ze, SIZEOF_zipend);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Store the data later needed for the central directory.
|
|
|
+ */
|
|
|
+static void
|
|
|
+zipdefer(const char *fn, struct stat *st, long long relative,
|
|
|
+ uint32_t crc, long long csize, const struct zip_header *zh)
|
|
|
+{
|
|
|
+ struct zipstuff *zp;
|
|
|
+
|
|
|
+ zp = scalloc(1, sizeof *zp);
|
|
|
+ zp->zs_name = sstrdup(fn);
|
|
|
+ zp->zs_size = st->st_size;
|
|
|
+ zp->zs_mtime = st->st_mtime;
|
|
|
+ zp->zs_mode = st->st_mode;
|
|
|
+ zp->zs_relative = relative;
|
|
|
+ zp->zs_cmethod = ple16(zh->z_cmethod);
|
|
|
+ zp->zs_gflag = ple16(zh->z_gflag);
|
|
|
+ zp->zs_csize = csize;
|
|
|
+ zp->zs_crc32 = crc;
|
|
|
+ zp->zs_next = zipbulk;
|
|
|
+ zipbulk = zp;
|
|
|
+}
|
|
|
+
|
|
|
+#define ziptrlevel() ( \
|
|
|
+ zipclevel == 01 ? 9 : \
|
|
|
+ zipclevel == 02 ? 3 : \
|
|
|
+ zipclevel == 03 ? 1 : \
|
|
|
+ 6 \
|
|
|
+)
|
|
|
+
|
|
|
+
|
|
|
+ * Write (and compress) data for a regular file to a zip archive.
|
|
|
+ */
|
|
|
+static int
|
|
|
+zipwrite(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
|
|
|
+ uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
|
|
|
+{
|
|
|
+#if USE_ZLIB
|
|
|
+ struct z_stream_s z;
|
|
|
+ int i;
|
|
|
+ size_t osize = 0;
|
|
|
+#endif
|
|
|
+ char *ibuf, *obuf = 0;
|
|
|
+
|
|
|
+ if (st->st_size > 196608 || (ibuf = malloc(st->st_size)) == 0) {
|
|
|
+#if USE_ZLIB
|
|
|
+ if (zipclevel < 04)
|
|
|
+ return zipwdesc(fd, fn, st, bp, sz, dev, ino,
|
|
|
+ crc, csize);
|
|
|
+#endif
|
|
|
+ return zipwtemp(fd, fn, st, bp, sz, dev, ino, crc, csize);
|
|
|
+ }
|
|
|
+ *csize = 0;
|
|
|
+ if (read(fd, ibuf, st->st_size) != st->st_size) {
|
|
|
+ free(ibuf);
|
|
|
+ emsg(3, "Cannot read \"%s\"", fn);
|
|
|
+ close(fd);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ *crc = zipcrc(0, (unsigned char *)ibuf, st->st_size);
|
|
|
+#if USE_BZLIB
|
|
|
+ if (zipclevel == 07) {
|
|
|
+ unsigned int sb;
|
|
|
+ if ((obuf = malloc(sb = st->st_size)) == 0)
|
|
|
+ goto store;
|
|
|
+ if (BZ2_bzBuffToBuffCompress(obuf, &sb, ibuf, st->st_size,
|
|
|
+ 9, 0, 0) != BZ_OK)
|
|
|
+ goto store;
|
|
|
+ *csize = sb;
|
|
|
+ bp->Zdr.z_cmethod[0] = C_BZIP2;
|
|
|
+ bp->Zdr.z_version[0] = 0x2e;
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ if (zipclevel > 03)
|
|
|
+ goto store;
|
|
|
+#if USE_ZLIB
|
|
|
+ memset(&z, 0, sizeof z);
|
|
|
+ if (deflateInit2(&z, ziptrlevel(), Z_DEFLATED, -15,
|
|
|
+ 8, Z_DEFAULT_STRATEGY) < 0)
|
|
|
+ goto store;
|
|
|
+ z.next_in = (unsigned char *)ibuf;
|
|
|
+ z.avail_in = z.total_in = st->st_size;
|
|
|
+ do {
|
|
|
+ if (z.avail_out == 0) {
|
|
|
+ if ((obuf = realloc(obuf, osize += 4096)) == 0) {
|
|
|
+ deflateEnd(&z);
|
|
|
+ goto store;
|
|
|
+ }
|
|
|
+ z.next_out = (unsigned char *)&obuf[*csize];
|
|
|
+ z.avail_out = osize - *csize;
|
|
|
+ }
|
|
|
+ if ((i = deflate(&z, z.avail_in ? Z_NO_FLUSH : Z_FINISH)) < 0) {
|
|
|
+ deflateEnd(&z);
|
|
|
+ goto store;
|
|
|
+ }
|
|
|
+ *csize = osize - z.avail_out;
|
|
|
+ } while (z.avail_in || i != Z_STREAM_END);
|
|
|
+ deflateEnd(&z);
|
|
|
+ if (*csize < st->st_size) {
|
|
|
+ bp->Zdr.z_cmethod[0] = C_DEFLATED;
|
|
|
+ bp->Zdr.z_gflag[0] |= zipclevel << 1;
|
|
|
+ bp->Zdr.z_version[0] = 20;
|
|
|
+ } else
|
|
|
+#endif
|
|
|
+ store: *csize = st->st_size;
|
|
|
+#if USE_BZLIB
|
|
|
+out:
|
|
|
+#endif
|
|
|
+ le32p(*crc, bp->Zdr.z_crc32);
|
|
|
+ le32p(*csize, bp->Zdr.z_csize);
|
|
|
+ bwrite((char *)bp, SIZEOF_zip_header);
|
|
|
+ bwrite(fn, sz);
|
|
|
+ zipwxtra(fn, st, dev, ino);
|
|
|
+ switch (bp->Zdr.z_cmethod[0]) {
|
|
|
+ case C_DEFLATED:
|
|
|
+ case C_BZIP2:
|
|
|
+ bwrite(obuf, *csize);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ bwrite(ibuf, *csize);
|
|
|
+ }
|
|
|
+ free(ibuf);
|
|
|
+ free(obuf);
|
|
|
+ close(fd);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Write and compress data to a zip archive for a file that is to large
|
|
|
+ * too be kept in memory. If there is an error with the temporary file
|
|
|
+ * (e. g. no space left on device), the file is stored in uncompressed
|
|
|
+ * form.
|
|
|
+ */
|
|
|
+static int
|
|
|
+zipwtemp(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
|
|
|
+ uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
|
|
|
+{
|
|
|
+ static int tf = -1;
|
|
|
+ static char tlate[] = "/var/tmp/cpioXXXXXX";
|
|
|
+ char ibuf[32768];
|
|
|
+#if USE_ZLIB || USE_BZLIB
|
|
|
+ char obuf[32768];
|
|
|
+#endif
|
|
|
+ struct zextra_64 zf;
|
|
|
+ struct zextra_64 *zfp = 0;
|
|
|
+ long long size = st->st_size;
|
|
|
+ const char *sname;
|
|
|
+ int cuse, sf;
|
|
|
+ ssize_t rd;
|
|
|
+
|
|
|
+ *csize = 0;
|
|
|
+ *crc = 0;
|
|
|
+#if USE_ZLIB || USE_BZLIB
|
|
|
+ if (tf < 0) {
|
|
|
+ if ((tf = mkstemp(tlate)) >= 0)
|
|
|
+ unlink(tlate);
|
|
|
+ } else if (lseek(tf, 0, SEEK_SET) != 0) {
|
|
|
+ close(tf);
|
|
|
+ tf = -1;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+#if USE_ZLIB
|
|
|
+ if (zipclevel < 04) {
|
|
|
+ struct z_stream_s z;
|
|
|
+ memset(&z, 0, sizeof z);
|
|
|
+ if ((cuse = deflateInit2(&z, ziptrlevel(), Z_DEFLATED,
|
|
|
+ -15, 8, Z_DEFAULT_STRATEGY)) < 0)
|
|
|
+ goto store;
|
|
|
+ do {
|
|
|
+ if (z.avail_in == 0 && size > 0) {
|
|
|
+ if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
|
|
|
+ emsg(3, "Cannot read \"%s\"", fn);
|
|
|
+ close(fd);
|
|
|
+ ftruncate(tf, 0);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ z.next_in = (unsigned char *)ibuf;
|
|
|
+ z.avail_in = z.total_in = rd;
|
|
|
+ size -= rd;
|
|
|
+ *crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
|
|
|
+ }
|
|
|
+ if (z.next_out == NULL || (char *)z.next_out > obuf) {
|
|
|
+ if (z.next_out && tf >= 0) {
|
|
|
+ if (write(tf, obuf,
|
|
|
+ (char *)z.next_out-obuf) !=
|
|
|
+ (char *)z.next_out-obuf) {
|
|
|
+ close(tf);
|
|
|
+ tf = -1;
|
|
|
+ }
|
|
|
+ *csize += (char *)z.next_out - obuf;
|
|
|
+ }
|
|
|
+ z.next_out = (unsigned char *)obuf;
|
|
|
+ z.avail_out = sizeof obuf;
|
|
|
+ }
|
|
|
+ if (cuse >= 0 && cuse != Z_STREAM_END)
|
|
|
+ cuse = deflate(&z,
|
|
|
+ z.avail_in?Z_NO_FLUSH:Z_FINISH);
|
|
|
+ else
|
|
|
+ z.avail_in = 0;
|
|
|
+ } while (size>0 || (char *)z.next_out>obuf ||
|
|
|
+ cuse>=0 && cuse!=Z_STREAM_END);
|
|
|
+ deflateEnd(&z);
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+#if USE_BZLIB
|
|
|
+ if (zipclevel == 07) {
|
|
|
+ bz_stream bs;
|
|
|
+ int ok, on;
|
|
|
+ memset(&bs, sizeof bs, 0);
|
|
|
+ if ((ok = BZ2_bzCompressInit(&bs, 9, 0, 0)) != BZ_OK)
|
|
|
+ goto store;
|
|
|
+ cuse = 1;
|
|
|
+ do {
|
|
|
+ if (bs.avail_in == 0 && size > 0) {
|
|
|
+ if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
|
|
|
+ emsg(3, "Cannot read \"%s\"", fn);
|
|
|
+ close(fd);
|
|
|
+ ftruncate(tf, 0);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ bs.next_in = ibuf;
|
|
|
+ bs.avail_in = rd;
|
|
|
+ size -= rd;
|
|
|
+ *crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
|
|
|
+ }
|
|
|
+ if (bs.next_out == NULL || bs.next_out > obuf) {
|
|
|
+ if (bs.next_out && tf >= 0) {
|
|
|
+ on = bs.next_out - obuf;
|
|
|
+ if (write(tf, obuf, on) != on) {
|
|
|
+ close(tf);
|
|
|
+ tf = -1;
|
|
|
+ }
|
|
|
+ *csize += on;
|
|
|
+ }
|
|
|
+ bs.next_out = obuf;
|
|
|
+ bs.avail_out = sizeof obuf;
|
|
|
+ }
|
|
|
+ if (ok != BZ_STREAM_END) {
|
|
|
+ switch (ok = BZ2_bzCompress(&bs,
|
|
|
+ bs.avail_in?BZ_RUN:BZ_FINISH)) {
|
|
|
+ case BZ_RUN_OK:
|
|
|
+ case BZ_FINISH_OK:
|
|
|
+ case BZ_STREAM_END:
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ msg(3, 1, "Compression error %d "
|
|
|
+ "on \"%s\"\n", ok, fn);
|
|
|
+ close(fd);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (size > 0 || bs.next_out > obuf || ok != BZ_STREAM_END);
|
|
|
+ BZ2_bzCompressEnd(&bs);
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+store: cuse = -1;
|
|
|
+ while (size > 0) {
|
|
|
+ if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
|
|
|
+ emsg(3, "Cannot read \"%s\"", fn);
|
|
|
+ close(fd);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ size -= rd;
|
|
|
+ *crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
|
|
|
+ }
|
|
|
+out: if (tf >= 0 && cuse >= 0 && *csize < st->st_size) {
|
|
|
+ if (zipclevel == 07) {
|
|
|
+ bp->Zdr.z_cmethod[0] = C_BZIP2;
|
|
|
+ bp->Zdr.z_version[0] = 0x2e;
|
|
|
+ } else {
|
|
|
+ bp->Zdr.z_cmethod[0] = C_DEFLATED;
|
|
|
+ bp->Zdr.z_gflag[0] |= zipclevel << 1;
|
|
|
+ bp->Zdr.z_version[0] = 20;
|
|
|
+ }
|
|
|
+ sf = tf;
|
|
|
+ sname = tlate;
|
|
|
+ } else {
|
|
|
+ *csize = st->st_size;
|
|
|
+ sf = fd;
|
|
|
+ sname = fn;
|
|
|
+ }
|
|
|
+ if ((lseek(sf, 0, SEEK_SET)) != 0) {
|
|
|
+ emsg(3, "Cannot rewind \"%s\"", sname);
|
|
|
+ errcnt++;
|
|
|
+ close(fd);
|
|
|
+ ftruncate(tf, 0);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ le32p(*crc, bp->Zdr.z_crc32);
|
|
|
+ if (st->st_size >= 0xffffffff || *csize >= 0xffffffff) {
|
|
|
+ int n;
|
|
|
+ zfp = &zf;
|
|
|
+ memset(&zf, 0, SIZEOF_zextra_64);
|
|
|
+ le16p(mag_zip64f, zf.ze_64_tag);
|
|
|
+ le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
|
|
|
+ le64p(st->st_size, zf.ze_64_nsize);
|
|
|
+ le64p(*csize, zf.ze_64_csize);
|
|
|
+ le32p(0xffffffff, bp->Zdr.z_csize);
|
|
|
+ le32p(0xffffffff, bp->Zdr.z_nsize);
|
|
|
+ n = (ple16(bp->Zdr.z_extralen)&0177777) + SIZEOF_zextra_64;
|
|
|
+ le16p(n, bp->Zdr.z_extralen);
|
|
|
+ } else
|
|
|
+ le32p(*csize, bp->Zdr.z_csize);
|
|
|
+ bwrite((char *)bp, SIZEOF_zip_header);
|
|
|
+ bwrite(fn, sz);
|
|
|
+ if (zfp)
|
|
|
+ bwrite((char *)zfp, SIZEOF_zextra_64);
|
|
|
+ zipwxtra(fn, st, dev, ino);
|
|
|
+ size = *csize;
|
|
|
+ while (size) {
|
|
|
+ if ((rd=read(sf, ibuf, size>sizeof ibuf?sizeof ibuf:size)) <= 0)
|
|
|
+ msg(3, 1, "Cannot read \"%s\"\n", sname);
|
|
|
+ bwrite(ibuf, rd);
|
|
|
+ size -= rd;
|
|
|
+ }
|
|
|
+ ftruncate(tf, 0);
|
|
|
+ close(fd);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+#if USE_ZLIB
|
|
|
+
|
|
|
+ * Write a zip archive entry using the data descriptor structure.
|
|
|
+ */
|
|
|
+static int
|
|
|
+zipwdesc(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
|
|
|
+ uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
|
|
|
+{
|
|
|
+ struct zextra_64 zf;
|
|
|
+ struct zextra_64 *zfp = 0;
|
|
|
+ char ibuf[32768], obuf[32768];
|
|
|
+ long long size = st->st_size;
|
|
|
+ ssize_t rd;
|
|
|
+ struct z_stream_s z;
|
|
|
+ int cuse;
|
|
|
+
|
|
|
+ *csize = 0;
|
|
|
+ *crc = 0;
|
|
|
+ memset(&z, 0, sizeof z);
|
|
|
+ if ((cuse = deflateInit2(&z, ziptrlevel(), Z_DEFLATED,
|
|
|
+ -15, 8, Z_DEFAULT_STRATEGY)) < 0)
|
|
|
+ return zipwtemp(fd, fn, st, bp, sz, dev, ino, crc, csize);
|
|
|
+ bp->Zdr.z_cmethod[0] = C_DEFLATED;
|
|
|
+ bp->Zdr.z_gflag[0] |= zipclevel << 1 | FG_DESC;
|
|
|
+ bp->Zdr.z_version[0] = 20;
|
|
|
+
|
|
|
+ * RFC 1951 states that deflate compression needs 5 bytes additional
|
|
|
+ * space per 32k block in the worst case. Thus a compressed size
|
|
|
+ * greater than 4G-1 can be reached if at least 131052 blocks are
|
|
|
+ * used.
|
|
|
+ */
|
|
|
+ if (st->st_size >= 131052LL*32768) {
|
|
|
+ int n;
|
|
|
+ zfp = &zf;
|
|
|
+ memset(&zf, 0, SIZEOF_zextra_64);
|
|
|
+ le16p(mag_zip64f, zf.ze_64_tag);
|
|
|
+ le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
|
|
|
+ le32p(0xffffffff, bp->Zdr.z_csize);
|
|
|
+ le32p(0xffffffff, bp->Zdr.z_nsize);
|
|
|
+ n = (ple16(bp->Zdr.z_extralen)&0177777) + SIZEOF_zextra_64;
|
|
|
+ le16p(n, bp->Zdr.z_extralen);
|
|
|
+ }
|
|
|
+ bwrite((char *)bp, SIZEOF_zip_header);
|
|
|
+ bwrite(fn, sz);
|
|
|
+ if (zfp)
|
|
|
+ bwrite((char *)zfp, SIZEOF_zextra_64);
|
|
|
+ zipwxtra(fn, st, dev, ino);
|
|
|
+ do {
|
|
|
+ if (z.avail_in == 0 && size > 0) {
|
|
|
+ if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
|
|
|
+ emsg(3, "Cannot read \"%s\"", fn);
|
|
|
+ st->st_size -= size;
|
|
|
+ size = 0;
|
|
|
+ rd = 0;
|
|
|
+ }
|
|
|
+ z.next_in = (unsigned char *)ibuf;
|
|
|
+ z.avail_in = z.total_in = rd;
|
|
|
+ size -= rd;
|
|
|
+ *crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
|
|
|
+ }
|
|
|
+ if (z.next_out == NULL || (char *)z.next_out > obuf) {
|
|
|
+ if (z.next_out) {
|
|
|
+ bwrite(obuf, (char *)z.next_out - obuf);
|
|
|
+ *csize += (char *)z.next_out - obuf;
|
|
|
+ }
|
|
|
+ z.next_out = (unsigned char *)obuf;
|
|
|
+ z.avail_out = sizeof obuf;
|
|
|
+ }
|
|
|
+ if (cuse >= 0 && cuse != Z_STREAM_END)
|
|
|
+ cuse = deflate(&z, z.avail_in?Z_NO_FLUSH:Z_FINISH);
|
|
|
+ else
|
|
|
+ z.avail_in = 0;
|
|
|
+ } while (size > 0 || (char *)z.next_out > obuf ||
|
|
|
+ cuse >= 0 && cuse != Z_STREAM_END);
|
|
|
+ deflateEnd(&z);
|
|
|
+ if (zfp) {
|
|
|
+ struct zipddesc64 zd64;
|
|
|
+ memcpy(zd64.zd_signature, mag_zipdds, sizeof mag_zipdds);
|
|
|
+ le32p(*crc, zd64.zd_crc32);
|
|
|
+ le64p(st->st_size, zd64.zd_nsize);
|
|
|
+ le64p(*csize, zd64.zd_csize);
|
|
|
+ bwrite((char *)&zd64, SIZEOF_zipddesc64);
|
|
|
+ } else {
|
|
|
+ struct zipddesc zd;
|
|
|
+ memcpy(zd.zd_signature, mag_zipdds, sizeof mag_zipdds);
|
|
|
+ le32p(*crc, zd.zd_crc32);
|
|
|
+ le32p(st->st_size, zd.zd_nsize);
|
|
|
+ le32p(*csize, zd.zd_csize);
|
|
|
+ bwrite((char *)&zd, SIZEOF_zipddesc);
|
|
|
+ }
|
|
|
+ close(fd);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ * Write the extra fields for a file to a zip archive (currently
|
|
|
+ * our own field type). Note that the z_extralen field in the file
|
|
|
+ * header must correspond to the size of the data written here.
|
|
|
+ */
|
|
|
+static int
|
|
|
+zipwxtra(const char *fn, struct stat *st, uint32_t dev, uint32_t ino)
|
|
|
+{
|
|
|
+ struct zextra_cp z;
|
|
|
+
|
|
|
+ memset(&z, 0, SIZEOF_zextra_cp);
|
|
|
+ le16p(mag_zipcpio, z.ze_cp_tag);
|
|
|
+ le16p(SIZEOF_zextra_cp - 4, z.ze_cp_tsize);
|
|
|
+ le32p(dev, z.ze_cp_mode);
|
|
|
+ le32p(ino, z.ze_cp_ino);
|
|
|
+ le32p(st->st_mode&(S_IFMT|07777), z.ze_cp_mode);
|
|
|
+ le32p(st->st_uid, z.ze_cp_uid);
|
|
|
+ le32p(st->st_gid, z.ze_cp_gid);
|
|
|
+ le32p(st->st_nlink, z.ze_cp_nlink);
|
|
|
+ le32p(st->st_rdev, z.ze_cp_rdev);
|
|
|
+ le32p(st->st_mtime, z.ze_cp_mtime);
|
|
|
+ le32p(st->st_atime, z.ze_cp_atime);
|
|
|
+ bwrite((char *)&z, SIZEOF_zextra_cp);
|
|
|
+ return SIZEOF_zextra_cp;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+zipinfo(struct file *f)
|
|
|
+{
|
|
|
+ const char *cp;
|
|
|
+ char b[5];
|
|
|
+ int i;
|
|
|
+
|
|
|
+ printf(" %7llu", f->f_csize);
|
|
|
+ if (f->f_dsize) {
|
|
|
+ i = f->f_csize*100 / f->f_dsize;
|
|
|
+ i += f->f_csize*200 / f->f_dsize & 1;
|
|
|
+ i = 100 - i;
|
|
|
+ } else
|
|
|
+ i = 0;
|
|
|
+ printf(" %3d%%", i);
|
|
|
+ switch (f->f_cmethod) {
|
|
|
+ case C_STORED:
|
|
|
+ cp = "stor";
|
|
|
+ break;
|
|
|
+ case C_SHRUNK:
|
|
|
+ cp = "shrk";
|
|
|
+ break;
|
|
|
+ case C_REDUCED1:
|
|
|
+ cp = "re:1";
|
|
|
+ break;
|
|
|
+ case C_REDUCED2:
|
|
|
+ cp = "re:2";
|
|
|
+ break;
|
|
|
+ case C_REDUCED3:
|
|
|
+ cp = "re:3";
|
|
|
+ break;
|
|
|
+ case C_REDUCED4:
|
|
|
+ cp = "re:4";
|
|
|
+ break;
|
|
|
+ case C_IMPLODED:
|
|
|
+ b[0] = 'i';
|
|
|
+ b[1] = f->f_gflag & FG_BIT1 ? '8' : '4';
|
|
|
+ b[2] = ':';
|
|
|
+ b[3] = f->f_gflag & FG_BIT2 ? '3' : '2';
|
|
|
+ b[4] = '\0';
|
|
|
+ cp = b;
|
|
|
+ break;
|
|
|
+ case C_TOKENIZED:
|
|
|
+ cp = "tokn";
|
|
|
+ break;
|
|
|
+ case C_DEFLATED:
|
|
|
+ b[0] = 'd', b[1] = 'e', b[2] = 'f', b[4] = '\0';
|
|
|
+ if (f->f_gflag & FG_BIT2)
|
|
|
+ b[3] = f->f_gflag & FG_BIT1 ? 'S' : 'F';
|
|
|
+ else
|
|
|
+ b[3] = f->f_gflag & FG_BIT1 ? 'X' : 'N';
|
|
|
+ cp = b;
|
|
|
+ break;
|
|
|
+ case C_ENHDEFLD:
|
|
|
+ cp = "edef";
|
|
|
+ break;
|
|
|
+ case C_DCLIMPLODED:
|
|
|
+ cp = "dcli";
|
|
|
+ break;
|
|
|
+ case C_BZIP2:
|
|
|
+ cp = "bz2 ";
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ snprintf(b, sizeof b, "%4.4X", f->f_cmethod);
|
|
|
+ cp = b;
|
|
|
+ }
|
|
|
+ printf(" %s", cp);
|
|
|
+}
|
|
|
+
|
|
|
+#if USE_BZLIB
|
|
|
+int
|
|
|
+zipunbz2(struct file *f, const char *tgt, int tfd, int doswap, uint32_t *crc)
|
|
|
+{
|
|
|
+ bz_stream bs;
|
|
|
+ long long isize = f->f_csize;
|
|
|
+ char ibuf[4096], obuf[8192];
|
|
|
+ int in, on, val = 0, ok;
|
|
|
+
|
|
|
+ memset(&bs, 0, sizeof bs);
|
|
|
+
|
|
|
+ if ((ok = BZ2_bzDecompressInit(&bs, 0, 0)) != BZ_OK) {
|
|
|
+ msg(3, 0, "bzip2 initialization error %d on \"%s\"\n",
|
|
|
+ ok, f->f_name);
|
|
|
+ errcnt++;
|
|
|
+ return skipfile(f);
|
|
|
+ }
|
|
|
+ while (isize > 0 || ok == BZ_OK) {
|
|
|
+ if (bs.avail_in == 0 && isize > 0) {
|
|
|
+ in = sizeof ibuf < isize ? sizeof ibuf : isize;
|
|
|
+ isize -= in;
|
|
|
+ if (bread(ibuf, in) != in)
|
|
|
+ unexeoa();
|
|
|
+ if (doswap)
|
|
|
+ swap(ibuf, in, bflag || sflag, bflag || Sflag);
|
|
|
+ bs.next_in = ibuf;
|
|
|
+ bs.avail_in = in;
|
|
|
+ }
|
|
|
+ if (ok == BZ_OK) {
|
|
|
+ bs.next_out = obuf;
|
|
|
+ bs.avail_out = sizeof obuf;
|
|
|
+ switch (ok = BZ2_bzDecompress(&bs)) {
|
|
|
+ case BZ_OK:
|
|
|
+ case BZ_STREAM_END:
|
|
|
+ on = sizeof obuf - bs.avail_out;
|
|
|
+ if (tfd >= 0 && write(tfd, obuf, on) != on) {
|
|
|
+ emsg(3, "Cannot write \"%s\"", tgt);
|
|
|
+ tfd = -1;
|
|
|
+ val = 1;
|
|
|
+ }
|
|
|
+ *crc = zipcrc(*crc, (unsigned char *)obuf, on);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ msg(3, 0, "compression error %d on \"%s\"\n",
|
|
|
+ ok, f->f_name);
|
|
|
+ errcnt++;
|
|
|
+ val = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BZ2_bzDecompressEnd(&bs);
|
|
|
+ return val;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+struct blasthow {
|
|
|
+ struct file *bh_f;
|
|
|
+ const char *bh_tgt;
|
|
|
+ long long bh_isize;
|
|
|
+ uint32_t *bh_crc;
|
|
|
+ int bh_tfd;
|
|
|
+ int bh_doswap;
|
|
|
+ int bh_val;
|
|
|
+};
|
|
|
+
|
|
|
+static unsigned
|
|
|
+blastin(void *how, unsigned char **buf)
|
|
|
+{
|
|
|
+ const int chunk = 16384;
|
|
|
+ static unsigned char *hold;
|
|
|
+ struct blasthow *bp = how;
|
|
|
+ unsigned sz;
|
|
|
+
|
|
|
+ if (bp->bh_isize <= 0)
|
|
|
+ return 0;
|
|
|
+ if (hold == NULL)
|
|
|
+ hold = smalloc(chunk);
|
|
|
+ sz = bp->bh_isize > chunk ? chunk : bp->bh_isize;
|
|
|
+ bp->bh_isize -= sz;
|
|
|
+ if (bread((char *)hold, sz) != sz)
|
|
|
+ unexeoa();
|
|
|
+ if (bp->bh_doswap)
|
|
|
+ swap((char *)hold, sz, bflag || sflag, bflag || Sflag);
|
|
|
+ *buf = hold;
|
|
|
+ return sz;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+blastout(void *how, unsigned char *buf, unsigned len)
|
|
|
+{
|
|
|
+ struct blasthow *bp = how;
|
|
|
+
|
|
|
+ if (bp->bh_tfd >= 0 && write(bp->bh_tfd, buf, len) != len) {
|
|
|
+ emsg(3, "Cannot write \"%s\"", bp->bh_tgt);
|
|
|
+ bp->bh_tfd = -1;
|
|
|
+ bp->bh_val = 1;
|
|
|
+ }
|
|
|
+ *bp->bh_crc = zipcrc(*bp->bh_crc, buf, len);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+zipblast(struct file *f, const char *tgt, int tfd, int doswap, uint32_t *crc)
|
|
|
+{
|
|
|
+ struct blasthow bh;
|
|
|
+ int n;
|
|
|
+
|
|
|
+ bh.bh_f = f;
|
|
|
+ bh.bh_tgt = tgt;
|
|
|
+ bh.bh_isize = f->f_csize;
|
|
|
+ bh.bh_crc = crc;
|
|
|
+ bh.bh_tfd = tfd;
|
|
|
+ bh.bh_doswap = doswap;
|
|
|
+ bh.bh_val = 0;
|
|
|
+ switch (n = blast(blastin, &bh, blastout, &bh)) {
|
|
|
+ case 0:
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ msg(3, 0, "compression error %d on \"%s\"\n", n, f->f_name);
|
|
|
+ errcnt++;
|
|
|
+ bh.bh_val = 1;
|
|
|
+ }
|
|
|
+ while (bh.bh_isize) {
|
|
|
+ char buf[4096];
|
|
|
+ unsigned n;
|
|
|
+ n = bh.bh_isize > sizeof buf ? sizeof buf : bh.bh_isize;
|
|
|
+ if (bread(buf, n) != n)
|
|
|
+ unexeoa();
|
|
|
+ bh.bh_isize -= n;
|
|
|
+ }
|
|
|
+ return bh.bh_val;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * The SGI -K format was introduced with SGI's IRIX 5.X. It is essentially
|
|
|
+ * a slightly extended binary format. The known additions are:
|
|
|
+ *
|
|
|
+ * - If the major or minor st_rdev device number exceeds the limit of
|
|
|
+ * 255 imposed by the 16-bit c_rdev field, this field is set to 0xFFFF
|
|
|
+ * and st_rdev is stored in the c_filesize 32-bit field. The first 14
|
|
|
+ * bits of this field compose the major device number, the minor is
|
|
|
+ * stored in the remaining 18 bits. This enables implementations to
|
|
|
+ * read the modified format without special support if they ignore
|
|
|
+ * the size of device files; otherwise they will try to read a lot
|
|
|
+ * of archive data and fail.
|
|
|
+ *
|
|
|
+ * - If the file is larger than 2 GB - 1 byte, two nearly identical
|
|
|
+ * archive headers are stored for it. The only difference is in
|
|
|
+ * the c_filesize field:
|
|
|
+ *
|
|
|
+ * [first header: file size X times 2 GB]
|
|
|
+ * [first data part: X times 2 GB]
|
|
|
+ * [second header: file size modulo 2 GB]
|
|
|
+ * [second data part: rest of data]
|
|
|
+ *
|
|
|
+ * The first header can be recognized by a negative c_filesize. A
|
|
|
+ * value of 0xFFFFFFFF means that 2 GB follow, 0xFFFFFFFE -> 4 GB
|
|
|
+ * 0xFFFFFFFD -> 6 GB, 0xFFFFFFFC -> 8 GB, and so forth. The second
|
|
|
+ * is a standard binary cpio header, although the following data is
|
|
|
+ * meant to be appended to the preceding file.
|
|
|
+ *
|
|
|
+ * It is important to note that padding follows the number in
|
|
|
+ * c_filesize, not the amount of data written; thus all data parts
|
|
|
+ * with odd c_filesize fields (0xFFFFFFFF = 2+ GB, 0xFFFFFFFD = 6+ GB
|
|
|
+ * etc.) cause the following archive entries to be aligned on an odd
|
|
|
+ * offset. This seems to be an implementation artifact but has to be
|
|
|
+ * followed for compatibility.
|
|
|
+ *
|
|
|
+ * This extension seems a bit weird since no known cpio implementation
|
|
|
+ * is able to read these archive entries without special support. Thus
|
|
|
+ * a more straightforward extension (such as storing the size just past
|
|
|
+ * the file name) would well have had the same effect. Nevertheless,
|
|
|
+ * the cpio -K format is useful, so it is implemented here.
|
|
|
+ *
|
|
|
+ * --Note that IRIX 6.X tar also has a -K option. This option extends
|
|
|
+ * the tar format in essentially the same way as the second extension
|
|
|
+ * to cpio described above. Unfortunately, the result is definitively
|
|
|
+ * broken. Contrasting to the binary cpio format, the standard POSIX
|
|
|
+ * tar format is well able to hold files of size 0xFFFFFFFF and below
|
|
|
+ * in a regular manner. Thus, a tar -K archive entry is _exactly_ the
|
|
|
+ * same as two regular POSIX tar entries for the same file. And this
|
|
|
+ * situation even occurs on a regular basis with tar -r! For this
|
|
|
+ * reason, we do not implement the IRIX tar -K format and will probably
|
|
|
+ * never do so unless it is changed (the tar format really has a lot
|
|
|
+ * of options to indicate extensions that might be used for this).
|
|
|
+ *
|
|
|
+ * Many thanks to Sven Mascheck who made archiving tests on the IRIX
|
|
|
+ * machine.
|
|
|
+ */
|
|
|
+
|
|
|
+ * This function reads the second header of a SGI -K format archive.
|
|
|
+ */
|
|
|
+static void
|
|
|
+readK2hdr(struct file *f)
|
|
|
+{
|
|
|
+ struct file n;
|
|
|
+ union bincpio bc;
|
|
|
+
|
|
|
+ n.f_name = n.f_lnam = NULL;
|
|
|
+ n.f_nsiz = n.f_lsiz = 0;
|
|
|
+ readhdr(&n, &bc);
|
|
|
+ f->f_Krest = n.f_st.st_size;
|
|
|
+ f->f_dsize = f->f_st.st_size = n.f_st.st_size + f->f_Kbase;
|
|
|
+ f->f_Kbase = 0;
|
|
|
+ free(n.f_name);
|
|
|
+ free(n.f_lnam);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Read the data of a GNU filename extra header.
|
|
|
+ */
|
|
|
+static int
|
|
|
+readgnuname(char **np, size_t *sp, long length)
|
|
|
+{
|
|
|
+ if (length > SANELIMIT)
|
|
|
+ return -1;
|
|
|
+ if (*sp == 0 || *sp <= length)
|
|
|
+ *np = srealloc(*np, *sp = length+1);
|
|
|
+ bread(*np, length);
|
|
|
+ (*np)[length] = '\0';
|
|
|
+ skippad(length, 512);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Write a GNU filename extra header and its data.
|
|
|
+ */
|
|
|
+static void
|
|
|
+writegnuname(const char *fn, long length, int flag)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+
|
|
|
+ memset(bc.data, 0, 512);
|
|
|
+ strcpy(bc.Tdr.t_name, "././@LongLink");
|
|
|
+ sprintf(bc.Tdr.t_mode, "%7.7o", 0);
|
|
|
+ sprintf(bc.Tdr.t_uid, "%7.7o", 0);
|
|
|
+ sprintf(bc.Tdr.t_gid, "%7.7o", 0);
|
|
|
+ sprintf(bc.Tdr.t_size, "%11.11lo", length);
|
|
|
+ sprintf(bc.Tdr.t_mtime, "%11.11lo", 0L);
|
|
|
+ bc.Tdr.t_linkflag = flag;
|
|
|
+ memcpy(bc.Tdr.t_magic, mag_gnutar, 8);
|
|
|
+ strcpy(bc.Tdr.t_uname, "root");
|
|
|
+ strcpy(bc.Tdr.t_gname, "root");
|
|
|
+ tchksum(&bc);
|
|
|
+ bwrite(bc.data, 512);
|
|
|
+ bwrite(fn, length);
|
|
|
+ length %= 512;
|
|
|
+ memset(bc.data, 0, 512 - length);
|
|
|
+ bwrite(bc.data, 512 - length);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * POSIX.1-2001 pax format support.
|
|
|
+ */
|
|
|
+static void
|
|
|
+tgetpax(struct tar_header *tp, struct file *f)
|
|
|
+{
|
|
|
+ char *keyword, *value;
|
|
|
+ char *block, *bp;
|
|
|
+ long long n;
|
|
|
+ enum paxrec pr;
|
|
|
+
|
|
|
+ n = rdoct(tp->t_size, 12);
|
|
|
+ bp = block = smalloc(n+1);
|
|
|
+ bread(block, n);
|
|
|
+ skippad(n, 512);
|
|
|
+ block[n] = '\0';
|
|
|
+ while (bp < &block[n]) {
|
|
|
+ int c;
|
|
|
+ pr = tgetrec(&bp, &keyword, &value);
|
|
|
+ switch (pr) {
|
|
|
+ case PR_ATIME:
|
|
|
+ f->f_st.st_atime = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_GID:
|
|
|
+ f->f_st.st_gid = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_LINKPATH:
|
|
|
+ c = strlen(value);
|
|
|
+ if (f->f_lnam == NULL || f->f_lsiz < c+1) {
|
|
|
+ f->f_lsiz = c+1;
|
|
|
+ f->f_lnam = srealloc(f->f_lnam, c+1);
|
|
|
+ }
|
|
|
+ strcpy(f->f_lnam, value);
|
|
|
+ break;
|
|
|
+ case PR_MTIME:
|
|
|
+ f->f_st.st_mtime = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_PATH:
|
|
|
+ c = strlen(value);
|
|
|
+ if (f->f_name == NULL || f->f_nsiz < c+1) {
|
|
|
+ f->f_nsiz = c+1;
|
|
|
+ f->f_name = srealloc(f->f_name, c+1);
|
|
|
+ }
|
|
|
+ strcpy(f->f_name, value);
|
|
|
+ break;
|
|
|
+ case PR_SIZE:
|
|
|
+ f->f_st.st_size = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_UID:
|
|
|
+ f->f_st.st_uid = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_SUN_DEVMAJOR:
|
|
|
+ f->f_rmajor = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ case PR_SUN_DEVMINOR:
|
|
|
+ f->f_rminor = strtoll(value, NULL, 10);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ paxrec |= pr;
|
|
|
+ }
|
|
|
+ if (tp->t_linkflag == 'g') {
|
|
|
+ globrec = paxrec & ~(PR_LINKPATH|PR_PATH|PR_SIZE);
|
|
|
+ globst = f->f_st;
|
|
|
+ }
|
|
|
+ free(block);
|
|
|
+}
|
|
|
+
|
|
|
+static enum paxrec
|
|
|
+tgetrec(char **bp, char **keyword, char **value)
|
|
|
+{
|
|
|
+ char *x;
|
|
|
+ long n = 0;
|
|
|
+ enum paxrec pr;
|
|
|
+
|
|
|
+ *keyword = "";
|
|
|
+ *value = "";
|
|
|
+ while (**bp && (n = strtol(*bp, &x, 10)) <= 0 && (*x!=' ' || *x!='\t'))
|
|
|
+ do
|
|
|
+ (*bp)++;
|
|
|
+ while (**bp && **bp != '\n');
|
|
|
+ if (*x == '\0' || **bp == '\0') {
|
|
|
+ (*bp)++;
|
|
|
+ return PR_NONE;
|
|
|
+ }
|
|
|
+ while (x < &(*bp)[n] && (*x == ' ' || *x == '\t'))
|
|
|
+ x++;
|
|
|
+ if (x == &(*bp)[n] || *x == '=')
|
|
|
+ goto out;
|
|
|
+ *keyword = x;
|
|
|
+ while (x < &(*bp)[n] && *x != '=')
|
|
|
+ x++;
|
|
|
+ if (x == &(*bp)[n])
|
|
|
+ goto out;
|
|
|
+ *x = '\0';
|
|
|
+ if (&x[1] < &(*bp)[n])
|
|
|
+ *value = &x[1];
|
|
|
+ (*bp)[n-1] = '\0';
|
|
|
+out: *bp = &(*bp)[n];
|
|
|
+ if (strcmp(*keyword, "atime") == 0)
|
|
|
+ pr = PR_ATIME;
|
|
|
+ else if (strcmp(*keyword, "gid") == 0)
|
|
|
+ pr = PR_GID;
|
|
|
+ else if (strcmp(*keyword, "linkpath") == 0)
|
|
|
+ pr = PR_LINKPATH;
|
|
|
+ else if (strcmp(*keyword, "mtime") == 0)
|
|
|
+ pr = PR_MTIME;
|
|
|
+ else if (strcmp(*keyword, "path") == 0)
|
|
|
+ pr = PR_PATH;
|
|
|
+ else if (strcmp(*keyword, "size") == 0)
|
|
|
+ pr = PR_SIZE;
|
|
|
+ else if (strcmp(*keyword, "uid") == 0)
|
|
|
+ pr = PR_UID;
|
|
|
+ else if (strcmp(*keyword, "SUN.devmajor") == 0)
|
|
|
+ pr = PR_SUN_DEVMAJOR;
|
|
|
+ else if (strcmp(*keyword, "SUN.devminor") == 0)
|
|
|
+ pr = PR_SUN_DEVMINOR;
|
|
|
+ else
|
|
|
+ pr = PR_NONE;
|
|
|
+ return pr;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+wrpax(const char *longname, const char *linkname, struct stat *sp)
|
|
|
+{
|
|
|
+ union bincpio bc;
|
|
|
+ char *pdata = NULL;
|
|
|
+ long psize = 0, pcur = 0;
|
|
|
+ long long blocks;
|
|
|
+
|
|
|
+ memset(bc.data, 0, 512);
|
|
|
+ if (paxrec & PR_ATIME)
|
|
|
+ addrec(&pdata, &psize, &pcur, "atime", NULL, sp->st_atime);
|
|
|
+ if (paxrec & PR_GID)
|
|
|
+ addrec(&pdata, &psize, &pcur, "gid", NULL, sp->st_gid);
|
|
|
+ if (paxrec & PR_LINKPATH)
|
|
|
+ addrec(&pdata, &psize, &pcur, "linkpath", linkname, 0);
|
|
|
+ if (paxrec & PR_MTIME)
|
|
|
+ addrec(&pdata, &psize, &pcur, "mtime", NULL, sp->st_mtime);
|
|
|
+ if (paxrec & PR_PATH)
|
|
|
+ addrec(&pdata, &psize, &pcur, "path", longname, 0);
|
|
|
+ if (paxrec & PR_SIZE)
|
|
|
+ addrec(&pdata, &psize, &pcur, "size", NULL, sp->st_size);
|
|
|
+ if (paxrec & PR_UID)
|
|
|
+ addrec(&pdata, &psize, &pcur, "uid", NULL, sp->st_uid);
|
|
|
+ if (paxrec & PR_SUN_DEVMAJOR)
|
|
|
+ addrec(&pdata, &psize, &pcur, "SUN.devmajor", NULL,
|
|
|
+ major(sp->st_rdev));
|
|
|
+ if (paxrec & PR_SUN_DEVMINOR)
|
|
|
+ addrec(&pdata, &psize, &pcur, "SUN.devminor", NULL,
|
|
|
+ minor(sp->st_rdev));
|
|
|
+ paxnam(&bc.Tdr, longname);
|
|
|
+ sprintf(bc.Tdr.t_mode, "%7.7o", fmttype==FMT_SUN ? 0444|S_IFREG : 0444);
|
|
|
+ sprintf(bc.Tdr.t_uid, "%7.7o", 0);
|
|
|
+ sprintf(bc.Tdr.t_gid, "%7.7o", 0);
|
|
|
+ sprintf(bc.Tdr.t_size, "%11.11lo", pcur);
|
|
|
+ sprintf(bc.Tdr.t_mtime, "%11.11o", 0);
|
|
|
+ strcpy(bc.Tdr.t_magic, "ustar");
|
|
|
+ bc.Tdr.t_version[0] = bc.Tdr.t_version[1] = '0';
|
|
|
+ strcpy(bc.Tdr.t_uname, "root");
|
|
|
+ strcpy(bc.Tdr.t_gname, "root");
|
|
|
+ bc.Tdr.t_linkflag = fmttype==FMT_SUN ? 'X' : 'x';
|
|
|
+ tchksum(&bc);
|
|
|
+ bwrite(bc.data, 512);
|
|
|
+ memset(&pdata[pcur], 0, psize - pcur);
|
|
|
+ blocks = (pcur + (512-1)) / 512;
|
|
|
+ bwrite(pdata, blocks * 512);
|
|
|
+ free(pdata);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+addrec(char **pdata, long *psize, long *pcur,
|
|
|
+ const char *keyword, const char *sval, long long lval)
|
|
|
+{
|
|
|
+ char dval[25], xval[25];
|
|
|
+ long od, d, r;
|
|
|
+
|
|
|
+ if (sval == 0) {
|
|
|
+ sprintf(xval, "%lld", lval);
|
|
|
+ sval = xval;
|
|
|
+ }
|
|
|
+ r = strlen(keyword) + strlen(sval) + 3;
|
|
|
+ d = 0;
|
|
|
+ do {
|
|
|
+ od = d;
|
|
|
+ d = sprintf(dval, "%ld", od + r);
|
|
|
+ } while (d != od);
|
|
|
+ *psize += d + r + 1 + 512;
|
|
|
+ *pdata = srealloc(*pdata, *psize);
|
|
|
+ sprintf(&(*pdata)[*pcur], "%s %s=%s\n", dval, keyword, sval);
|
|
|
+ *pcur += d + r;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+paxnam(struct tar_header *hp, const char *name)
|
|
|
+{
|
|
|
+ char buf[257], *bp;
|
|
|
+ const char *cp, *np;
|
|
|
+ int bl = 0;
|
|
|
+ static int pid;
|
|
|
+
|
|
|
+ if (pid == 0)
|
|
|
+ pid = getpid();
|
|
|
+ for (np = name; *np; np++);
|
|
|
+ while (np > name && *np != '/') {
|
|
|
+ np--;
|
|
|
+ bl++;
|
|
|
+ }
|
|
|
+ if ((np > name || *name == '/') && np-name <= 120)
|
|
|
+ for (bp = buf, cp = name; cp < np; bp++, cp++)
|
|
|
+ *bp = *cp;
|
|
|
+ else {
|
|
|
+ *buf = '.';
|
|
|
+ bp = &buf[1];
|
|
|
+ }
|
|
|
+ snprintf(bp, sizeof buf - (bp - buf), "/PaxHeaders.%d/%s",
|
|
|
+ pid, bl < 100 ? np>name?&np[1]:name : sequence());
|
|
|
+ tmkname(hp, buf);
|
|
|
+}
|
|
|
+
|
|
|
+static char *
|
|
|
+sequence(void)
|
|
|
+{
|
|
|
+ static char buf[25];
|
|
|
+ static long long d;
|
|
|
+
|
|
|
+ sprintf(buf, "%10.10lld", ++d);
|
|
|
+ return buf;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+pax_oneopt(const char *s, int warn)
|
|
|
+{
|
|
|
+ if (strcmp(s, "linkdata") == 0)
|
|
|
+ pax_oflag |= PO_LINKDATA;
|
|
|
+ else if (strcmp(s, "times") == 0)
|
|
|
+ pax_oflag |= PO_TIMES;
|
|
|
+ else {
|
|
|
+ if (warn)
|
|
|
+ msg(2, 0, "Unknown flag \"-o %s\"\n", s);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+pax_options(char *s, int warn)
|
|
|
+{
|
|
|
+ char *o = s, c;
|
|
|
+ int val = 0, word = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ if (word == 0) {
|
|
|
+ if (isspace(*s&0377))
|
|
|
+ o = &s[1];
|
|
|
+ else
|
|
|
+ word = 1;
|
|
|
+ }
|
|
|
+ if (*s == ',' || *s == '\0') {
|
|
|
+ c = *s;
|
|
|
+ *s = '\0';
|
|
|
+ val |= pax_oneopt(o, warn);
|
|
|
+ *s = c;
|
|
|
+ o = &s[1];
|
|
|
+ word = 0;
|
|
|
+ }
|
|
|
+ } while (*s++);
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+ * Given a symbolic link "base" and the result of readlink "name", form
|
|
|
+ * a valid path name for the link target.
|
|
|
+ */
|
|
|
+static char *
|
|
|
+joinpath(const char *base, char *name)
|
|
|
+{
|
|
|
+ const char *bp = NULL, *cp;
|
|
|
+ char *new, *np;
|
|
|
+
|
|
|
+ if (*name == '/')
|
|
|
+ return name;
|
|
|
+ for (cp = base; *cp; cp++)
|
|
|
+ if (*cp == '/')
|
|
|
+ bp = cp;
|
|
|
+ if (bp == NULL)
|
|
|
+ return name;
|
|
|
+ np = new = smalloc(bp - base + strlen(name) + 2);
|
|
|
+ for (cp = base; cp < bp; cp++)
|
|
|
+ *np++ = *cp;
|
|
|
+ *np++ = '/';
|
|
|
+ for (cp = name; *cp; cp++)
|
|
|
+ *np++ = *cp;
|
|
|
+ *np = '\0';
|
|
|
+ free(name);
|
|
|
+ return new;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+utf8(const char *cp)
|
|
|
+{
|
|
|
+ int c, n;
|
|
|
+
|
|
|
+ while (*cp) if ((c = *cp++ & 0377) & 0200) {
|
|
|
+ if (c == (c & 037 | 0300))
|
|
|
+ n = 1;
|
|
|
+ else if (c == (c & 017 | 0340))
|
|
|
+ n = 2;
|
|
|
+ else if (c == (c & 07 | 0360))
|
|
|
+ n = 3;
|
|
|
+ else if (c == (c & 03 | 0370))
|
|
|
+ n = 4;
|
|
|
+ else if (c == (c & 01 | 0374))
|
|
|
+ n = 5;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ while (n--) {
|
|
|
+ c = *cp++ & 0377;
|
|
|
+ if (c != (c & 077 | 0200))
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static time_t
|
|
|
+fetchtime(const char *cp)
|
|
|
+{
|
|
|
+ struct tm tm;
|
|
|
+ time_t t;
|
|
|
+ char *xp;
|
|
|
+ int n;
|
|
|
+
|
|
|
+ t = strtoll(cp, &xp, 10);
|
|
|
+ if (*xp == '\0')
|
|
|
+ return t;
|
|
|
+ memset(&tm, 0, sizeof tm);
|
|
|
+ n = sscanf(cp, "%4d%2d%2dT%2d%2d%2d",
|
|
|
+ &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
|
|
|
+ &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
|
|
|
+ tm.tm_year -= 1900;
|
|
|
+ tm.tm_mon--;
|
|
|
+ tm.tm_isdst = -1;
|
|
|
+ t = mktime(&tm);
|
|
|
+ if (n < 3 || t == (time_t)-1)
|
|
|
+ msg(4, 1, "line %lld: illegal time \"%s\"\n",
|
|
|
+ lineno, cp);
|
|
|
+ return t;
|
|
|
+}
|
|
|
+
|
|
|
+static char *
|
|
|
+nextfield(char *cp, const char *fieldname)
|
|
|
+{
|
|
|
+ while (*cp && *cp != ':')
|
|
|
+ cp++;
|
|
|
+ if (*cp == 0)
|
|
|
+ msg(4, 1, "line %lld: unterminated \"%s\" field\n",
|
|
|
+ lineno, fieldname);
|
|
|
+ *cp++ = 0;
|
|
|
+ return cp;
|
|
|
+}
|
|
|
+
|
|
|
+static char *
|
|
|
+getproto(char *np, struct prototype *pp)
|
|
|
+{
|
|
|
+ char *tp, *xp;
|
|
|
+ long long t, u;
|
|
|
+
|
|
|
+ memset(pp, 0, sizeof *pp);
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ tp = nextfield(np, "type");
|
|
|
+ if (np[1])
|
|
|
+ goto notype;
|
|
|
+ switch (np[0]) {
|
|
|
+ case 'b':
|
|
|
+ pp->pt_mode |= S_IFBLK;
|
|
|
+ break;
|
|
|
+ case 'c':
|
|
|
+ pp->pt_mode |= S_IFCHR;
|
|
|
+ break;
|
|
|
+ case 'd':
|
|
|
+ pp->pt_mode |= S_IFDIR;
|
|
|
+ break;
|
|
|
+ case 'f':
|
|
|
+ pp->pt_mode |= S_IFREG;
|
|
|
+ break;
|
|
|
+ case 'p':
|
|
|
+ pp->pt_mode |= S_IFIFO;
|
|
|
+ break;
|
|
|
+ case 's':
|
|
|
+ pp->pt_mode |= S_IFLNK;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ notype:
|
|
|
+ msg(4, 1, "line %lld: unknown type \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ }
|
|
|
+ pp->pt_spec |= PT_TYPE;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ struct passwd *pwd;
|
|
|
+ tp = nextfield(np, "owner");
|
|
|
+ t = strtoll(np, &xp, 10);
|
|
|
+ if (*xp == '\0')
|
|
|
+ pp->pt_uid = t;
|
|
|
+ else {
|
|
|
+ if ((pwd = getpwnam(np)) == NULL)
|
|
|
+ msg(4, 1, "line %lld: unknown user \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ pp->pt_uid = pwd->pw_uid;
|
|
|
+ }
|
|
|
+ pp->pt_spec |= PT_OWNER;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ struct group *grp;
|
|
|
+ tp = nextfield(np, "group");
|
|
|
+ t = strtoll(np, &xp, 10);
|
|
|
+ if (*xp == '\0')
|
|
|
+ pp->pt_gid = t;
|
|
|
+ else {
|
|
|
+ if ((grp = getgrnam(np)) == NULL)
|
|
|
+ msg(4, 1, "line %lld: unknown group \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ pp->pt_gid = grp->gr_gid;
|
|
|
+ }
|
|
|
+ pp->pt_spec |= PT_GROUP;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ tp = nextfield(np, "mode");
|
|
|
+ t = strtol(np, &xp, 8);
|
|
|
+ if (t & ~07777 || *xp)
|
|
|
+ msg(4, 1, "line %lld: illegal mode \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ pp->pt_mode |= t;
|
|
|
+ pp->pt_spec |= PT_MODE;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ tp = nextfield(np, "access time");
|
|
|
+ pp->pt_atime = fetchtime(np);
|
|
|
+ pp->pt_spec |= PT_ATIME;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':')
|
|
|
+ np++;
|
|
|
+ else {
|
|
|
+ tp = nextfield(np, "modification time");
|
|
|
+ pp->pt_mtime = fetchtime(np);
|
|
|
+ pp->pt_spec |= PT_MTIME;
|
|
|
+ np = tp;
|
|
|
+ }
|
|
|
+ if (*np == ':') {
|
|
|
+ np++;
|
|
|
+ if (*np++ != ':')
|
|
|
+ majmin: msg(4, 1, "line %lld: need either both major and "
|
|
|
+ "minor or none\n",
|
|
|
+ lineno);
|
|
|
+ } else {
|
|
|
+ tp = nextfield(np, "major");
|
|
|
+ t = strtoll(np, &xp, 10);
|
|
|
+ if (*xp)
|
|
|
+ msg(4, 1, "line %lld: illegal major \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ np = tp;
|
|
|
+ if (*np == ':')
|
|
|
+ goto majmin;
|
|
|
+ tp = nextfield(np, "minor");
|
|
|
+ u = strtoll(np, &xp, 10);
|
|
|
+ if (*xp)
|
|
|
+ msg(4, 1, "line %lld: illegal minor \"%s\"\n",
|
|
|
+ lineno, np);
|
|
|
+ np = tp;
|
|
|
+ pp->pt_rdev = makedev(t, u);
|
|
|
+ pp->pt_spec |= PT_RDEV;
|
|
|
+ }
|
|
|
+ return np;
|
|
|
+}
|
Waldemar Brodkorb