int
vcpio_wr(ARCHD *arcn)
{
HD_VCPIO *hd;
unsigned int nsz;
HD_VCPIO hdblk;
/*
* check and repair truncated device and inode fields in the cpio
* header
*/
if (map_dev(arcn, (u_long)VCPIO_MASK, (u_long)VCPIO_MASK) < 0)
return(-1);
nsz = arcn->nlen + 1;
hd = &hdblk;
if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR))
arcn->sb.st_rdev = 0;
/*
* add the proper magic value depending whether we were asked for
* file data crc's, and the crc if needed.
*/
if (docrc) {
if (ul_asc((u_long)VCMAGIC, hd->c_magic, sizeof(hd->c_magic),
OCT) ||
ul_asc((u_long)arcn->crc,hd->c_chksum,sizeof(hd->c_chksum),
HEX))
goto out;
} else {
if (ul_asc((u_long)VMAGIC, hd->c_magic, sizeof(hd->c_magic),
OCT) ||
ul_asc((u_long)0L, hd->c_chksum, sizeof(hd->c_chksum),HEX))
goto out;
}
switch(arcn->type) {
case PAX_CTG:
case PAX_REG:
case PAX_HRG:
/*
* caller will copy file data to the archive. tell him how
* much to pad.
*/
arcn->pad = VCPIO_PAD(arcn->sb.st_size);
# ifdef NET2_STAT
if (ul_asc((u_long)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), HEX)) {
# else
if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), HEX)) {
# endif
paxwarn(1,"File is too large for sv4cpio format %s",
arcn->org_name);
return(1);
}
break;
case PAX_SLK:
/*
* no file data for the caller to process, the file data has
* the size of the link
*/
arcn->pad = 0L;
if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize,
sizeof(hd->c_filesize), HEX))
goto out;
break;
default:
/*
* no file data for the caller to process
*/
arcn->pad = 0L;
if (ul_asc((u_long)0L, hd->c_filesize, sizeof(hd->c_filesize),
HEX))
goto out;
break;
}
/*
* set the other fields in the header
*/
if (ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino),
HEX) ||
ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),
HEX) ||
ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),
HEX) ||
ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),
HEX) ||
ul_asc((u_long)arcn->sb.st_mtime, hd->c_mtime, sizeof(hd->c_mtime),
HEX) ||
ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),
HEX) ||
ul_asc((u_long)MAJOR(arcn->sb.st_dev),hd->c_maj, sizeof(hd->c_maj),
HEX) ||
ul_asc((u_long)MINOR(arcn->sb.st_dev),hd->c_min, sizeof(hd->c_min),
HEX) ||
ul_asc((u_long)MAJOR(arcn->sb.st_rdev),hd->c_rmaj,sizeof(hd->c_maj),
HEX) ||
ul_asc((u_long)MINOR(arcn->sb.st_rdev),hd->c_rmin,sizeof(hd->c_min),
HEX) ||
ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), HEX))
goto out;
/*
* write the header, the file name and padding as required.
*/
if ((wr_rdbuf((char *)&hdblk, (int)sizeof(HD_VCPIO)) < 0) ||
(wr_rdbuf(arcn->name, (int)nsz) < 0) ||
(wr_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + nsz))) < 0)) {
paxwarn(1,"Could not write sv4cpio header for %s",arcn->org_name);
return(-1);
}
/*
* if we have file data, tell the caller we are done, copy the file
*/
if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) ||
(arcn->type == PAX_HRG))
return(0);
/*
* if we are not a link, tell the caller we are done, go to next file
*/
if (arcn->type != PAX_SLK)
return(1);
/*
* write the link name, tell the caller we are done.
*/
if ((wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) ||
(wr_skip((off_t)(VCPIO_PAD(arcn->ln_nlen))) < 0)) {
paxwarn(1,"Could not write sv4cpio link name for %s",
arcn->org_name);
return(-1);
}
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1,"Sv4cpio header field is too small for file %s",arcn->org_name);
return(1);
}
/*
* Routines common to the old binary header cpio
*/
/*
* bcpio_id()
* determine if a block given to us is an old binary cpio header
* (with/without header byte swapping)
* Return:
* 0 if a valid header, -1 otherwise
*/
int
bcpio_id(char *blk, int size)
{
if (size < (int)sizeof(HD_BCPIO))
return(-1);
/*
* check both normal and byte swapped magic cookies
*/
if (((u_short)SHRT_EXT(blk)) == MAGIC)
return(0);
if (((u_short)RSHRT_EXT(blk)) == MAGIC) {
if (!swp_head)
++swp_head;
return(0);
}
return(-1);
}
/*
* bcpio_rd()
* determine if a buffer is an old binary archive entry. (It may have byte
* swapped header) convert and store the values in the ARCHD parameter.
* This is a very old header format and should not really be used.
* Return:
* 0 if a valid header, -1 otherwise.
*/
int
bcpio_rd(ARCHD *arcn, char *buf)
{
HD_BCPIO *hd;
int nsz;
/*
* check the header
*/
if (bcpio_id(buf, sizeof(HD_BCPIO)) < 0)
return(-1);
arcn->pad = 0L;
hd = (HD_BCPIO *)buf;
if (swp_head) {
/*
* header has swapped bytes on 16 bit boundaries
*/
arcn->sb.st_dev = (dev_t)(RSHRT_EXT(hd->h_dev));
arcn->sb.st_ino = (ino_t)(RSHRT_EXT(hd->h_ino));
arcn->sb.st_mode = (mode_t)(RSHRT_EXT(hd->h_mode));
arcn->sb.st_uid = (uid_t)(RSHRT_EXT(hd->h_uid));
arcn->sb.st_gid = (gid_t)(RSHRT_EXT(hd->h_gid));
arcn->sb.st_nlink = (nlink_t)(RSHRT_EXT(hd->h_nlink));
arcn->sb.st_rdev = (dev_t)(RSHRT_EXT(hd->h_rdev));
arcn->sb.st_mtime = (time_t)(RSHRT_EXT(hd->h_mtime_1));
arcn->sb.st_mtime = (arcn->sb.st_mtime << 16) |
((time_t)(RSHRT_EXT(hd->h_mtime_2)));
arcn->sb.st_size = (off_t)(RSHRT_EXT(hd->h_filesize_1));
arcn->sb.st_size = (arcn->sb.st_size << 16) |
((off_t)(RSHRT_EXT(hd->h_filesize_2)));
nsz = (int)(RSHRT_EXT(hd->h_namesize));
} else {
arcn->sb.st_dev = (dev_t)(SHRT_EXT(hd->h_dev));
arcn->sb.st_ino = (ino_t)(SHRT_EXT(hd->h_ino));
arcn->sb.st_mode = (mode_t)(SHRT_EXT(hd->h_mode));
arcn->sb.st_uid = (uid_t)(SHRT_EXT(hd->h_uid));
arcn->sb.st_gid = (gid_t)(SHRT_EXT(hd->h_gid));
arcn->sb.st_nlink = (nlink_t)(SHRT_EXT(hd->h_nlink));
arcn->sb.st_rdev = (dev_t)(SHRT_EXT(hd->h_rdev));
arcn->sb.st_mtime = (time_t)(SHRT_EXT(hd->h_mtime_1));
arcn->sb.st_mtime = (arcn->sb.st_mtime << 16) |
((time_t)(SHRT_EXT(hd->h_mtime_2)));
arcn->sb.st_size = (off_t)(SHRT_EXT(hd->h_filesize_1));
arcn->sb.st_size = (arcn->sb.st_size << 16) |
((off_t)(SHRT_EXT(hd->h_filesize_2)));
nsz = (int)(SHRT_EXT(hd->h_namesize));
}
arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
/*
* check the file name size, if bogus give up. otherwise read the file
* name
*/
if (nsz < 2)
return(-1);
arcn->nlen = nsz - 1;
if (rd_nm(arcn, nsz) < 0)
return(-1);
/*
* header + file name are aligned to 2 byte boundaries, skip if needed
*/
if (rd_skip((off_t)(BCPIO_PAD(sizeof(HD_BCPIO) + nsz))) < 0)
return(-1);
/*
* if not a link (or a file with no data), calculate pad size (for
* padding which follows the file data), clear the link name and return
*/
if (((arcn->sb.st_mode & C_IFMT) != C_ISLNK)||(arcn->sb.st_size == 0)){
/*
* we have a valid header (not a link)
*/
arcn->ln_nlen = 0;
arcn->ln_name[0] = '\0';
arcn->pad = BCPIO_PAD(arcn->sb.st_size);
return(com_rd(arcn));
}
if ((rd_ln_nm(arcn) < 0) ||
(rd_skip((off_t)(BCPIO_PAD(arcn->sb.st_size))) < 0))
return(-1);
/*
* we have a valid header (with a link)
*/
return(com_rd(arcn));
}
int
bcpio_wr(ARCHD *arcn)
{
HD_BCPIO *hd;
int nsz;
HD_BCPIO hdblk;
off_t t_offt;
int t_int;
time_t t_timet;
/*
* check and repair truncated device and inode fields in the cpio
* header
*/
if (map_dev(arcn, (u_long)BCPIO_MASK, (u_long)BCPIO_MASK) < 0)
return(-1);
if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR))
arcn->sb.st_rdev = 0;
hd = &hdblk;
switch(arcn->type) {
case PAX_CTG:
case PAX_REG:
case PAX_HRG:
/*
* caller will copy file data to the archive. tell him how
* much to pad.
*/
arcn->pad = BCPIO_PAD(arcn->sb.st_size);
hd->h_filesize_1[0] = CHR_WR_0(arcn->sb.st_size);
hd->h_filesize_1[1] = CHR_WR_1(arcn->sb.st_size);
hd->h_filesize_2[0] = CHR_WR_2(arcn->sb.st_size);
hd->h_filesize_2[1] = CHR_WR_3(arcn->sb.st_size);
t_offt = (off_t)(SHRT_EXT(hd->h_filesize_1));
t_offt = (t_offt<<16) | ((off_t)(SHRT_EXT(hd->h_filesize_2)));
if (arcn->sb.st_size != t_offt) {
paxwarn(1,"File is too large for bcpio format %s",
arcn->org_name);
return(1);
}
break;
case PAX_SLK:
/*
* no file data for the caller to process, the file data has
* the size of the link
*/
arcn->pad = 0L;
hd->h_filesize_1[0] = CHR_WR_0(arcn->ln_nlen);
hd->h_filesize_1[1] = CHR_WR_1(arcn->ln_nlen);
hd->h_filesize_2[0] = CHR_WR_2(arcn->ln_nlen);
hd->h_filesize_2[1] = CHR_WR_3(arcn->ln_nlen);
t_int = (int)(SHRT_EXT(hd->h_filesize_1));
t_int = (t_int << 16) | ((int)(SHRT_EXT(hd->h_filesize_2)));
if (arcn->ln_nlen != t_int)
goto out;
break;
default:
/*
* no file data for the caller to process
*/
arcn->pad = 0L;
hd->h_filesize_1[0] = (char)0;
hd->h_filesize_1[1] = (char)0;
hd->h_filesize_2[0] = (char)0;
hd->h_filesize_2[1] = (char)0;
break;
}
/*
* build up the rest of the fields
*/
hd->h_magic[0] = CHR_WR_2(MAGIC);
hd->h_magic[1] = CHR_WR_3(MAGIC);
hd->h_dev[0] = CHR_WR_2(arcn->sb.st_dev);
hd->h_dev[1] = CHR_WR_3(arcn->sb.st_dev);
if (arcn->sb.st_dev != (dev_t)(SHRT_EXT(hd->h_dev)))
goto out;
hd->h_ino[0] = CHR_WR_2(arcn->sb.st_ino);
hd->h_ino[1] = CHR_WR_3(arcn->sb.st_ino);
if (arcn->sb.st_ino != (ino_t)(SHRT_EXT(hd->h_ino)))
goto out;
hd->h_mode[0] = CHR_WR_2(arcn->sb.st_mode);
hd->h_mode[1] = CHR_WR_3(arcn->sb.st_mode);
if (arcn->sb.st_mode != (mode_t)(SHRT_EXT(hd->h_mode)))
goto out;
hd->h_uid[0] = CHR_WR_2(arcn->sb.st_uid);
hd->h_uid[1] = CHR_WR_3(arcn->sb.st_uid);
if (arcn->sb.st_uid != (uid_t)(SHRT_EXT(hd->h_uid)))
goto out;
hd->h_gid[0] = CHR_WR_2(arcn->sb.st_gid);
hd->h_gid[1] = CHR_WR_3(arcn->sb.st_gid);
if (arcn->sb.st_gid != (gid_t)(SHRT_EXT(hd->h_gid)))
goto out;
hd->h_nlink[0] = CHR_WR_2(arcn->sb.st_nlink);
hd->h_nlink[1] = CHR_WR_3(arcn->sb.st_nlink);
if (arcn->sb.st_nlink != (nlink_t)(SHRT_EXT(hd->h_nlink)))
goto out;
hd->h_rdev[0] = CHR_WR_2(arcn->sb.st_rdev);
hd->h_rdev[1] = CHR_WR_3(arcn->sb.st_rdev);
if (arcn->sb.st_rdev != (dev_t)(SHRT_EXT(hd->h_rdev)))
goto out;
hd->h_mtime_1[0] = CHR_WR_0(arcn->sb.st_mtime);
hd->h_mtime_1[1] = CHR_WR_1(arcn->sb.st_mtime);
hd->h_mtime_2[0] = CHR_WR_2(arcn->sb.st_mtime);
hd->h_mtime_2[1] = CHR_WR_3(arcn->sb.st_mtime);
t_timet = (time_t)(SHRT_EXT(hd->h_mtime_1));
t_timet = (t_timet << 16) | ((time_t)(SHRT_EXT(hd->h_mtime_2)));
if (arcn->sb.st_mtime != t_timet)
goto out;
nsz = arcn->nlen + 1;
hd->h_namesize[0] = CHR_WR_2(nsz);
hd->h_namesize[1] = CHR_WR_3(nsz);
if (nsz != (int)(SHRT_EXT(hd->h_namesize)))
goto out;
/*
* write the header, the file name and padding as required.
*/
if ((wr_rdbuf((char *)&hdblk, (int)sizeof(HD_BCPIO)) < 0) ||
(wr_rdbuf(arcn->name, nsz) < 0) ||
(wr_skip((off_t)(BCPIO_PAD(sizeof(HD_BCPIO) + nsz))) < 0)) {
paxwarn(1, "Could not write bcpio header for %s", arcn->org_name);
return(-1);
}
/*
* if we have file data, tell the caller we are done
*/
if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) ||
(arcn->type == PAX_HRG))
return(0);
/*
* if we are not a link, tell the caller we are done, go to next file
*/
if (arcn->type != PAX_SLK)
return(1);
/*
* write the link name, tell the caller we are done.
*/
if ((wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) ||
(wr_skip((off_t)(BCPIO_PAD(arcn->ln_nlen))) < 0)) {
paxwarn(1,"Could not write bcpio link name for %s",arcn->org_name);
return(-1);
}
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1,"Bcpio header field is too small for file %s", arcn->org_name);
return(1);
}
int
cpio_wr(ARCHD *arcn)
{
HD_CPIO *hd;
int nsz;
HD_CPIO hdblk;
/*
* check and repair truncated device and inode fields in the header
*/
if (map_dev(arcn, (u_long)CPIO_MASK, (u_long)CPIO_MASK) < 0)
return(-1);
arcn->pad = 0L;
nsz = arcn->nlen + 1;
hd = &hdblk;
if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR))
arcn->sb.st_rdev = 0;
switch(arcn->type) {
case PAX_CTG:
case PAX_REG:
case PAX_HRG:
/*
* set data size for file data
*/
# ifdef NET2_STAT
if (ul_asc((u_long)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), OCT)) {
# else
if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), OCT)) {
# endif
paxwarn(1,"File is too large for cpio format %s",
arcn->org_name);
return(1);
}
break;
case PAX_SLK:
/*
* set data size to hold link name
*/
if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize,
sizeof(hd->c_filesize), OCT))
goto out;
break;
default:
/*
* all other file types have no file data
*/
if (ul_asc((u_long)0, hd->c_filesize, sizeof(hd->c_filesize),
OCT))
goto out;
break;
}
/*
* copy the values to the header using octal ascii
*/
if (ul_asc((u_long)MAGIC, hd->c_magic, sizeof(hd->c_magic), OCT) ||
ul_asc((u_long)arcn->sb.st_dev, hd->c_dev, sizeof(hd->c_dev),
OCT) ||
ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino),
OCT) ||
ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),
OCT) ||
ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),
OCT) ||
ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),
OCT) ||
ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),
OCT) ||
ul_asc((u_long)arcn->sb.st_rdev, hd->c_rdev, sizeof(hd->c_rdev),
OCT) ||
ul_asc((u_long)arcn->sb.st_mtime,hd->c_mtime,sizeof(hd->c_mtime),
OCT) ||
ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), OCT))
goto out;
/*
* write the file name to the archive
*/
if ((wr_rdbuf((char *)&hdblk, (int)sizeof(HD_CPIO)) < 0) ||
(wr_rdbuf(arcn->name, nsz) < 0)) {
paxwarn(1, "Unable to write cpio header for %s", arcn->org_name);
return(-1);
}
/*
* if this file has data, we are done. The caller will write the file
* data, if we are link tell caller we are done, go to next file
*/
if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) ||
(arcn->type == PAX_HRG))
return(0);
if (arcn->type != PAX_SLK)
return(1);
/*
* write the link name to the archive, tell the caller to go to the
* next file as we are done.
*/
if (wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) {
paxwarn(1,"Unable to write cpio link name for %s",arcn->org_name);
return(-1);
}
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1, "Cpio header field is too small to store file %s",
arcn->org_name);
return(1);
}
/*
* Routines common to the system VR4 version of cpio (with/without file CRC)
*/
/*
* vcpio_id()
* determine if a block given to us is a valid system VR4 cpio header
* WITHOUT crc. WATCH it the magic cookies are in OCTAL, the header
* uses HEX
* Return:
* 0 if a valid header, -1 otherwise
*/
int
vcpio_id(char *blk, int size)
{
if ((size < (int)sizeof(HD_VCPIO)) ||
(strncmp(blk, AVMAGIC, sizeof(AVMAGIC) - 1) != 0))
return(-1);
return(0);
}
/*
* crc_id()
* determine if a block given to us is a valid system VR4 cpio header
* WITH crc. WATCH it the magic cookies are in OCTAL the header uses HEX
* Return:
* 0 if a valid header, -1 otherwise
*/
int
crc_id(char *blk, int size)
{
if ((size < (int)sizeof(HD_VCPIO)) ||
(strncmp(blk, AVCMAGIC, (int)sizeof(AVCMAGIC) - 1) != 0))
return(-1);
return(0);
}
/*
* crc_strd()
w set file data CRC calculations. Fire up the hard link detection code
* Return:
* 0 if ok -1 otherwise (the return values of lnk_start())
*/
int
crc_strd(void)
{
docrc = 1;
return(lnk_start());
}
int
ustar_wr(ARCHD *arcn)
{
HD_USTAR *hd;
char *pt;
char hdblk[sizeof(HD_USTAR)];
/*
* check for those file system types ustar cannot store
*/
if (arcn->type == PAX_SCK) {
paxwarn(1, "Ustar cannot archive a socket %s", arcn->org_name);
return(1);
}
/*
* user asked that dirs not be written to the archive
*/
if (arcn->type == PAX_DIR && tar_nodir)
return (1);
/*
* check the length of the linkname
*/
if (PAX_IS_LINK(arcn->type) && (arcn->ln_nlen > sizeof(hd->linkname))) {
paxwarn(1, "Link name too long for ustar %s", arcn->ln_name);
return(1);
}
/*
* split the path name into prefix and name fields (if needed). if
* pt != arcn->name, the name has to be split
*/
if ((pt = name_split(arcn->name, arcn->nlen)) == NULL) {
paxwarn(1, "File name too long for ustar %s", arcn->name);
return(1);
}
/*
* zero out the header so we don't have to worry about zero fill below
*/
memset(hdblk, 0, sizeof(hdblk));
hd = (HD_USTAR *)hdblk;
arcn->pad = 0;
/*
* split the name, or zero out the prefix
*/
if (pt != arcn->name) {
/*
* name was split, pt points at the / where the split is to
* occur, we remove the / and copy the first part to the prefix
*/
*pt = '\0';
fieldcpy(hd->prefix, sizeof(hd->prefix), arcn->name,
sizeof(arcn->name));
*pt++ = '/';
}
/*
* copy the name part. this may be the whole path or the part after
* the prefix
*/
fieldcpy(hd->name, sizeof(hd->name), pt,
sizeof(arcn->name) - (pt - arcn->name));
/*
* set the fields in the header that are type dependent
*/
switch (arcn->type) {
case PAX_DIR:
hd->typeflag = DIRTYPE;
if (ul_oct(0, hd->size, sizeof(hd->size), 3))
goto out;
break;
case PAX_CHR:
case PAX_BLK:
if (arcn->type == PAX_CHR)
hd->typeflag = CHRTYPE;
else
hd->typeflag = BLKTYPE;
if (ul_oct(MAJOR(arcn->sb.st_rdev), hd->devmajor,
sizeof(hd->devmajor), 3) ||
ul_oct(MINOR(arcn->sb.st_rdev), hd->devminor,
sizeof(hd->devminor), 3) ||
ul_oct(0, hd->size, sizeof(hd->size), 3))
goto out;
break;
case PAX_FIF:
hd->typeflag = FIFOTYPE;
if (ul_oct(0, hd->size, sizeof(hd->size), 3))
goto out;
break;
case PAX_SLK:
case PAX_HLK:
case PAX_HRG:
if (arcn->type == PAX_SLK)
hd->typeflag = SYMTYPE;
else
hd->typeflag = LNKTYPE;
fieldcpy(hd->linkname, sizeof(hd->linkname), arcn->ln_name,
sizeof(arcn->ln_name));
if (ul_oct(0, hd->size, sizeof(hd->size), 3))
goto out;
break;
case PAX_REG:
case PAX_CTG:
default:
/*
* file data with this type, set the padding
*/
if (arcn->type == PAX_CTG)
hd->typeflag = CONTTYPE;
else
hd->typeflag = REGTYPE;
arcn->pad = TAR_PAD(arcn->sb.st_size);
if (ull_oct(arcn->sb.st_size, hd->size, sizeof(hd->size), 3)) {
paxwarn(1, "File is too long for ustar %s",
arcn->org_name);
return(1);
}
break;
}
strncpy(hd->magic, TMAGIC, TMAGLEN);
strncpy(hd->version, TVERSION, TVERSLEN);
/*
* set the remaining fields. Some versions want all 16 bits of mode
* we better humor them (they really do not meet spec though)....
*/
if (ul_oct(arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 3)) {
if (uid_nobody == 0) {
if (uid_name("nobody", &uid_nobody) == -1)
goto out;
}
if (uid_warn != arcn->sb.st_uid) {
uid_warn = arcn->sb.st_uid;
paxwarn(1,
"Ustar header field is too small for uid %lu, "
"using nobody", (u_long)arcn->sb.st_uid);
}
if (ul_oct(uid_nobody, hd->uid, sizeof(hd->uid), 3))
goto out;
}
if (ul_oct(arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 3)) {
if (gid_nobody == 0) {
if (gid_name("nobody", &gid_nobody) == -1)
goto out;
}
if (gid_warn != arcn->sb.st_gid) {
gid_warn = arcn->sb.st_gid;
paxwarn(1,
"Ustar header field is too small for gid %lu, "
"using nobody", (u_long)arcn->sb.st_gid);
}
if (ul_oct(gid_nobody, hd->gid, sizeof(hd->gid), 3))
goto out;
}
if (ull_oct(arcn->sb.st_mtime < 0 ? 0 : arcn->sb.st_mtime, hd->mtime,
sizeof(hd->mtime), 3) ||
ul_oct(arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 3))
goto out;
if (!Nflag) {
strncpy(hd->uname, name_uid(arcn->sb.st_uid, 0), sizeof(hd->uname));
strncpy(hd->gname, name_gid(arcn->sb.st_gid, 0), sizeof(hd->gname));
} else {
strncpy(hd->uname, "", sizeof(hd->uname));
strncpy(hd->gname, "", sizeof(hd->gname));
}
/*
* calculate and store the checksum write the header to the archive
* return 0 tells the caller to now write the file data, 1 says no data
* needs to be written
*/
if (ul_oct(tar_chksm(hdblk, sizeof(HD_USTAR)), hd->chksum,
sizeof(hd->chksum), 3))
goto out;
if (wr_rdbuf(hdblk, sizeof(HD_USTAR)) < 0)
return(-1);
if (wr_skip(BLKMULT - sizeof(HD_USTAR)) < 0)
return(-1);
if (PAX_IS_REG(arcn->type))
return(0);
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1, "Ustar header field is too small for %s", arcn->org_name);
return(1);
}
int
tar_wr(ARCHD *arcn)
{
HD_TAR *hd;
int len;
char hdblk[sizeof(HD_TAR)];
/*
* check for those file system types which tar cannot store
*/
switch (arcn->type) {
case PAX_DIR:
/*
* user asked that dirs not be written to the archive
*/
if (tar_nodir)
return(1);
break;
case PAX_CHR:
paxwarn(1, "Tar cannot archive a character device %s",
arcn->org_name);
return(1);
case PAX_BLK:
paxwarn(1, "Tar cannot archive a block device %s", arcn->org_name);
return(1);
case PAX_SCK:
paxwarn(1, "Tar cannot archive a socket %s", arcn->org_name);
return(1);
case PAX_FIF:
paxwarn(1, "Tar cannot archive a fifo %s", arcn->org_name);
return(1);
case PAX_SLK:
case PAX_HLK:
case PAX_HRG:
if (arcn->ln_nlen > sizeof(hd->linkname)) {
paxwarn(1, "Link name too long for tar %s",
arcn->ln_name);
return(1);
}
break;
case PAX_REG:
case PAX_CTG:
default:
break;
}
/*
* check file name len, remember extra char for dirs (the / at the end)
*/
len = arcn->nlen;
if (arcn->type == PAX_DIR)
++len;
if (len > sizeof(hd->name)) {
paxwarn(1, "File name too long for tar %s", arcn->name);
return(1);
}
/*
* Copy the data out of the ARCHD into the tar header based on the type
* of the file. Remember, many tar readers want all fields to be
* padded with zero so we zero the header first. We then set the
* linkflag field (type), the linkname, the size, and set the padding
* (if any) to be added after the file data (0 for all other types,
* as they only have a header).
*/
memset(hdblk, 0, sizeof(hdblk));
hd = (HD_TAR *)hdblk;
fieldcpy(hd->name, sizeof(hd->name), arcn->name, sizeof(arcn->name));
arcn->pad = 0;
if (arcn->type == PAX_DIR) {
/*
* directories are the same as files, except have a filename
* that ends with a /, we add the slash here. No data follows
* dirs, so no pad.
*/
hd->linkflag = AREGTYPE;
hd->name[len-1] = '/';
if (ul_oct(0, hd->size, sizeof(hd->size), 1))
goto out;
} else if (arcn->type == PAX_SLK) {
/*
* no data follows this file, so no pad
*/
hd->linkflag = SYMTYPE;
fieldcpy(hd->linkname, sizeof(hd->linkname), arcn->ln_name,
sizeof(arcn->ln_name));
if (ul_oct(0, hd->size, sizeof(hd->size), 1))
goto out;
} else if (PAX_IS_HARDLINK(arcn->type)) {
/*
* no data follows this file, so no pad
*/
hd->linkflag = LNKTYPE;
fieldcpy(hd->linkname, sizeof(hd->linkname), arcn->ln_name,
sizeof(arcn->ln_name));
if (ul_oct(0, hd->size, sizeof(hd->size), 1))
goto out;
} else {
/*
* data follows this file, so set the pad
*/
hd->linkflag = AREGTYPE;
if (ull_oct(arcn->sb.st_size, hd->size, sizeof(hd->size), 1)) {
paxwarn(1, "File is too large for tar %s",
arcn->org_name);
return(1);
}
arcn->pad = TAR_PAD(arcn->sb.st_size);
}
/*
* copy those fields that are independent of the type
*/
if (ul_oct(arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 0) ||
ull_oct(arcn->sb.st_mtime < 0 ? 0 : arcn->sb.st_mtime, hd->mtime,
sizeof(hd->mtime), 1) ||
ul_oct(arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 0) ||
ul_oct(arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 0))
goto out;
/*
* calculate and add the checksum, then write the header. A return of
* 0 tells the caller to now write the file data, 1 says no data needs
* to be written
*/
if (ul_oct(tar_chksm(hdblk, sizeof(HD_TAR)), hd->chksum,
sizeof(hd->chksum), 3))
goto out;
if (wr_rdbuf(hdblk, sizeof(HD_TAR)) < 0)
return(-1);
if (wr_skip(BLKMULT - sizeof(HD_TAR)) < 0)
return(-1);
if (PAX_IS_REG(arcn->type))
return(0);
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1, "Tar header field is too small for %s", arcn->org_name);
return(1);
}
int
vcpio_wr(ARCHD *arcn)
{
HD_VCPIO *hd;
unsigned int nsz;
char hdblk[sizeof(HD_VCPIO)];
/*
* check and repair truncated device and inode fields in the cpio
* header
*/
if (map_dev(arcn, (u_long)VCPIO_MASK, (u_long)VCPIO_MASK) < 0)
return(-1);
nsz = arcn->nlen + 1;
hd = (HD_VCPIO *)hdblk;
if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR))
arcn->sb.st_rdev = 0;
/*
* add the proper magic value depending whether we were asked for
* file data crc's, and the crc if needed.
*/
if (docrc) {
if (ul_asc((u_long)VCMAGIC, hd->c_magic, sizeof(hd->c_magic),
OCT) ||
ul_asc((u_long)arcn->crc,hd->c_chksum,sizeof(hd->c_chksum),
HEX))
goto out;
} else {
if (ul_asc((u_long)VMAGIC, hd->c_magic, sizeof(hd->c_magic),
OCT) ||
ul_asc((u_long)0L, hd->c_chksum, sizeof(hd->c_chksum),HEX))
goto out;
}
switch(arcn->type) {
case PAX_CTG:
case PAX_REG:
case PAX_HRG:
/*
* caller will copy file data to the archive. tell him how
* much to pad.
*/
arcn->pad = VCPIO_PAD(arcn->sb.st_size);
if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), HEX)) {
paxwarn(1,"File is too large for sv4cpio format %s",
arcn->org_name);
return(1);
}
break;
case PAX_SLK:
/*
* no file data for the caller to process, the file data has
* the size of the link
*/
arcn->pad = 0L;
if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize,
sizeof(hd->c_filesize), HEX))
goto out;
break;
default:
/*
* no file data for the caller to process
*/
arcn->pad = 0L;
if (ul_asc((u_long)0L, hd->c_filesize, sizeof(hd->c_filesize),
HEX))
goto out;
break;
}
/*
* set the other fields in the header
*/
if (ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino),
HEX) ||
ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),
HEX) ||
ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),
HEX) ||
ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),
HEX) ||
ul_asc((u_long)arcn->sb.st_mtime, hd->c_mtime, sizeof(hd->c_mtime),
HEX) ||
ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),
HEX) ||
ul_asc((u_long)MAJOR(arcn->sb.st_dev),hd->c_maj, sizeof(hd->c_maj),
HEX) ||
ul_asc((u_long)MINOR(arcn->sb.st_dev),hd->c_min, sizeof(hd->c_min),
HEX) ||
ul_asc((u_long)MAJOR(arcn->sb.st_rdev),hd->c_rmaj,sizeof(hd->c_maj),
HEX) ||
ul_asc((u_long)MINOR(arcn->sb.st_rdev),hd->c_rmin,sizeof(hd->c_min),
HEX) ||
ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), HEX))
goto out;
/*
* write the header, the file name and padding as required.
*/
if ((wr_rdbuf(hdblk, (int)sizeof(HD_VCPIO)) < 0) ||
(wr_rdbuf(arcn->name, (int)nsz) < 0) ||
(wr_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + nsz))) < 0)) {
paxwarn(1,"Could not write sv4cpio header for %s",arcn->org_name);
return(-1);
}
/*
* if we have file data, tell the caller we are done, copy the file
*/
if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) ||
(arcn->type == PAX_HRG))
return(0);
/*
* if we are not a link, tell the caller we are done, go to next file
*/
if (arcn->type != PAX_SLK)
return(1);
/*
* write the link name, tell the caller we are done.
*/
if ((wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) ||
(wr_skip((off_t)(VCPIO_PAD(arcn->ln_nlen))) < 0)) {
paxwarn(1,"Could not write sv4cpio link name for %s",
arcn->org_name);
return(-1);
}
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1,"Sv4cpio header field is too small for file %s",arcn->org_name);
return(1);
}
int
cpio_wr(ARCHD *arcn)
{
HD_CPIO *hd;
int nsz;
char hdblk[sizeof(HD_CPIO)];
/*
* check and repair truncated device and inode fields in the header
*/
if (map_dev(arcn, (u_long)CPIO_MASK, (u_long)CPIO_MASK) < 0)
return(-1);
arcn->pad = 0L;
nsz = arcn->nlen + 1;
hd = (HD_CPIO *)hdblk;
if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR))
arcn->sb.st_rdev = 0;
switch(arcn->type) {
case PAX_CTG:
case PAX_REG:
case PAX_HRG:
/*
* set data size for file data
*/
if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize,
sizeof(hd->c_filesize), OCT)) {
paxwarn(1,"File is too large for cpio format %s",
arcn->org_name);
return(1);
}
break;
case PAX_SLK:
/*
* set data size to hold link name
*/
if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize,
sizeof(hd->c_filesize), OCT))
goto out;
break;
default:
/*
* all other file types have no file data
*/
if (ul_asc((u_long)0, hd->c_filesize, sizeof(hd->c_filesize),
OCT))
goto out;
break;
}
/*
* copy the values to the header using octal ascii
*/
if (ul_asc((u_long)MAGIC, hd->c_magic, sizeof(hd->c_magic), OCT) ||
ul_asc((u_long)arcn->sb.st_dev, hd->c_dev, sizeof(hd->c_dev),
OCT) ||
ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino),
OCT) ||
ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),
OCT) ||
ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),
OCT) ||
ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),
OCT) ||
ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),
OCT) ||
ul_asc((u_long)arcn->sb.st_rdev, hd->c_rdev, sizeof(hd->c_rdev),
OCT) ||
ul_asc((u_long)arcn->sb.st_mtime,hd->c_mtime,sizeof(hd->c_mtime),
OCT) ||
ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), OCT))
goto out;
/*
* write the file name to the archive
*/
if ((wr_rdbuf(hdblk, (int)sizeof(HD_CPIO)) < 0) ||
(wr_rdbuf(arcn->name, nsz) < 0)) {
paxwarn(1, "Unable to write cpio header for %s", arcn->org_name);
return(-1);
}
/*
* if this file has data, we are done. The caller will write the file
* data, if we are link tell caller we are done, go to next file
*/
if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) ||
(arcn->type == PAX_HRG))
return(0);
if (arcn->type != PAX_SLK)
return(1);
/*
* write the link name to the archive, tell the caller to go to the
* next file as we are done.
*/
if (wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) {
paxwarn(1,"Unable to write cpio link name for %s",arcn->org_name);
return(-1);
}
return(1);
out:
/*
* header field is out of range
*/
paxwarn(1, "Cpio header field is too small to store file %s",
arcn->org_name);
return(1);
}
