int
vcpio_rd(ARCHD *arcn, char *buf)
{
HD_VCPIO *hd;
dev_t devminor;
dev_t devmajor;
int nsz;
/*
* during the id phase it was determined if we were using CRC, use the
* proper id routine.
*/
if (docrc) {
if (crc_id(buf, sizeof(HD_VCPIO)) < 0)
return(-1);
} else {
if (vcpio_id(buf, sizeof(HD_VCPIO)) < 0)
return(-1);
}
hd = (HD_VCPIO *)buf;
arcn->pad = 0L;
/*
* extract the hex ascii fields from the header
*/
arcn->sb.st_ino = (ino_t)asc_ul(hd->c_ino, sizeof(hd->c_ino), HEX);
arcn->sb.st_mode = (mode_t)asc_ul(hd->c_mode, sizeof(hd->c_mode), HEX);
arcn->sb.st_uid = (uid_t)asc_ul(hd->c_uid, sizeof(hd->c_uid), HEX);
arcn->sb.st_gid = (gid_t)asc_ul(hd->c_gid, sizeof(hd->c_gid), HEX);
#ifdef NET2_STAT
arcn->sb.st_mtime = (time_t)asc_ul(hd->c_mtime,sizeof(hd->c_mtime),HEX);
#else
arcn->sb.st_mtime = (time_t)asc_uqd(hd->c_mtime,sizeof(hd->c_mtime),HEX);
#endif
arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
#ifdef NET2_STAT
arcn->sb.st_size = (off_t)asc_ul(hd->c_filesize,
sizeof(hd->c_filesize), HEX);
#else
arcn->sb.st_size = (off_t)asc_uqd(hd->c_filesize,
sizeof(hd->c_filesize), HEX);
#endif
arcn->sb.st_nlink = (nlink_t)asc_ul(hd->c_nlink, sizeof(hd->c_nlink),
HEX);
devmajor = (dev_t)asc_ul(hd->c_maj, sizeof(hd->c_maj), HEX);
devminor = (dev_t)asc_ul(hd->c_min, sizeof(hd->c_min), HEX);
arcn->sb.st_dev = TODEV(devmajor, devminor);
devmajor = (dev_t)asc_ul(hd->c_rmaj, sizeof(hd->c_maj), HEX);
devminor = (dev_t)asc_ul(hd->c_rmin, sizeof(hd->c_min), HEX);
arcn->sb.st_rdev = TODEV(devmajor, devminor);
arcn->crc = asc_ul(hd->c_chksum, sizeof(hd->c_chksum), HEX);
/*
* check the length of the file name, if ok read it in, return -1 if
* bogus
*/
if ((nsz = (int)asc_ul(hd->c_namesize,sizeof(hd->c_namesize),HEX)) < 2)
return(-1);
arcn->nlen = nsz - 1;
if (rd_nm(arcn, nsz) < 0)
return(-1);
/*
* skip padding. header + filename is aligned to 4 byte boundries
*/
if (rd_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + 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 = VCPIO_PAD(arcn->sb.st_size);
return(com_rd(arcn));
}
/*
* read in the link name and skip over the padding
*/
if ((rd_ln_nm(arcn) < 0) ||
(rd_skip((off_t)(VCPIO_PAD(arcn->sb.st_size))) < 0))
return(-1);
/*
* we have a valid header (with a link)
*/
return(com_rd(arcn));
}
int
ustar_rd(ARCHD *arcn, char *buf)
{
HD_USTAR *hd = (HD_USTAR *)buf;
char *dest;
int cnt = 0;
dev_t devmajor;
dev_t devminor;
unsigned long long val;
/*
* we only get proper sized buffers
*/
if (ustar_id(buf, BLKMULT) < 0)
return(-1);
#ifndef SMALL
reset:
#endif
memset(arcn, 0, sizeof(*arcn));
arcn->org_name = arcn->name;
arcn->sb.st_nlink = 1;
#ifndef SMALL
/* Process Extended headers. */
if (hd->typeflag == XHDRTYPE || hd->typeflag == GHDRTYPE) {
if (rd_xheader(arcn, hd->typeflag == GHDRTYPE,
(off_t)asc_ul(hd->size, sizeof(hd->size), OCT)) < 0)
return (-1);
/* Update and check the ustar header. */
if (rd_wrbuf(buf, BLKMULT) != BLKMULT)
return (-1);
if (ustar_id(buf, BLKMULT) < 0)
return(-1);
/* if the next block is another extension, reset the values */
if (hd->typeflag == XHDRTYPE || hd->typeflag == GHDRTYPE)
goto reset;
}
#endif
if (!arcn->nlen) {
/*
* See if the filename is split into two parts. if, so join
* the parts. We copy the prefix first and add a / between
* the prefix and name.
*/
dest = arcn->name;
if (*(hd->prefix) != '\0') {
cnt = fieldcpy(dest, sizeof(arcn->name) - 1,
hd->prefix, sizeof(hd->prefix));
dest += cnt;
*dest++ = '/';
cnt++;
} else
cnt = 0;
if (hd->typeflag != LONGLINKTYPE &&
hd->typeflag != LONGNAMETYPE) {
arcn->nlen = cnt + expandname(dest,
sizeof(arcn->name) - cnt, &gnu_name_string,
hd->name, sizeof(hd->name));
}
}
if (!arcn->ln_nlen &&
hd->typeflag != LONGLINKTYPE && hd->typeflag != LONGNAMETYPE) {
arcn->ln_nlen = expandname(arcn->ln_name, sizeof(arcn->ln_name),
&gnu_link_string, hd->linkname, sizeof(hd->linkname));
}
/*
* follow the spec to the letter. we should only have mode bits, strip
* off all other crud we may be passed.
*/
arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode, sizeof(hd->mode), OCT) &
0xfff);
arcn->sb.st_size = (off_t)asc_ull(hd->size, sizeof(hd->size), OCT);
val = asc_ull(hd->mtime, sizeof(hd->mtime), OCT);
if (val > MAX_TIME_T)
arcn->sb.st_mtime = INT_MAX; /* XXX 2038 */
else
arcn->sb.st_mtime = val;
arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
/*
* If we can find the ascii names for gname and uname in the password
* and group files we will use the uid's and gid they bind. Otherwise
* we use the uid and gid values stored in the header. (This is what
* the posix spec wants).
*/
hd->gname[sizeof(hd->gname) - 1] = '\0';
if (Nflag || gid_name(hd->gname, &(arcn->sb.st_gid)) < 0)
arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
hd->uname[sizeof(hd->uname) - 1] = '\0';
if (Nflag || uid_name(hd->uname, &(arcn->sb.st_uid)) < 0)
arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
/*
* set the defaults, these may be changed depending on the file type
*/
arcn->pad = 0;
arcn->skip = 0;
arcn->sb.st_rdev = (dev_t)0;
/*
* set the mode and PAX type according to the typeflag in the header
*/
switch (hd->typeflag) {
case FIFOTYPE:
arcn->type = PAX_FIF;
arcn->sb.st_mode |= S_IFIFO;
break;
case DIRTYPE:
arcn->type = PAX_DIR;
arcn->sb.st_mode |= S_IFDIR;
arcn->sb.st_nlink = 2;
/*
* Some programs that create ustar archives append a '/'
* to the pathname for directories. This clearly violates
* ustar specs, but we will silently strip it off anyway.
*/
if (arcn->name[arcn->nlen - 1] == '/')
arcn->name[--arcn->nlen] = '\0';
break;
case BLKTYPE:
case CHRTYPE:
/*
* this type requires the rdev field to be set.
*/
if (hd->typeflag == BLKTYPE) {
arcn->type = PAX_BLK;
arcn->sb.st_mode |= S_IFBLK;
} else {
arcn->type = PAX_CHR;
arcn->sb.st_mode |= S_IFCHR;
}
devmajor = (dev_t)asc_ul(hd->devmajor,sizeof(hd->devmajor),OCT);
devminor = (dev_t)asc_ul(hd->devminor,sizeof(hd->devminor),OCT);
arcn->sb.st_rdev = TODEV(devmajor, devminor);
break;
case SYMTYPE:
case LNKTYPE:
if (hd->typeflag == SYMTYPE) {
arcn->type = PAX_SLK;
arcn->sb.st_mode |= S_IFLNK;
} else {
arcn->type = PAX_HLK;
/*
* so printing looks better
*/
arcn->sb.st_mode |= S_IFREG;
arcn->sb.st_nlink = 2;
}
break;
case LONGLINKTYPE:
case LONGNAMETYPE:
/*
* GNU long link/file; we tag these here and let the
* pax internals deal with it -- too ugly otherwise.
*/
arcn->type =
hd->typeflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;
arcn->pad = TAR_PAD(arcn->sb.st_size);
arcn->skip = arcn->sb.st_size;
break;
case CONTTYPE:
case AREGTYPE:
case REGTYPE:
default:
/*
* these types have file data that follows. Set the skip and
* pad fields.
*/
arcn->type = PAX_REG;
arcn->pad = TAR_PAD(arcn->sb.st_size);
arcn->skip = arcn->sb.st_size;
arcn->sb.st_mode |= S_IFREG;
break;
}
return(0);
}
int
cpio_rd(ARCHD *arcn, char *buf)
{
int nsz;
HD_CPIO *hd;
/*
* check that this is a valid header, if not return -1
*/
if (cpio_id(buf, sizeof(HD_CPIO)) < 0)
return(-1);
hd = (HD_CPIO *)buf;
/*
* byte oriented cpio (posix) does not have padding! extract the octal
* ascii fields from the header
*/
arcn->pad = 0L;
arcn->sb.st_dev = (dev_t)asc_ul(hd->c_dev, sizeof(hd->c_dev), OCT);
arcn->sb.st_ino = (ino_t)asc_ul(hd->c_ino, sizeof(hd->c_ino), OCT);
arcn->sb.st_mode = (mode_t)asc_ul(hd->c_mode, sizeof(hd->c_mode), OCT);
arcn->sb.st_uid = (uid_t)asc_ul(hd->c_uid, sizeof(hd->c_uid), OCT);
arcn->sb.st_gid = (gid_t)asc_ul(hd->c_gid, sizeof(hd->c_gid), OCT);
arcn->sb.st_nlink = (nlink_t)asc_ul(hd->c_nlink, sizeof(hd->c_nlink),
OCT);
arcn->sb.st_rdev = (dev_t)asc_ul(hd->c_rdev, sizeof(hd->c_rdev), OCT);
#ifdef NET2_STAT
arcn->sb.st_mtime = (time_t)asc_ul(hd->c_mtime, sizeof(hd->c_mtime),
OCT);
#else
arcn->sb.st_mtime = (time_t)asc_uqd(hd->c_mtime, sizeof(hd->c_mtime),
OCT);
#endif
arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
#ifdef NET2_STAT
arcn->sb.st_size = (off_t)asc_ul(hd->c_filesize,sizeof(hd->c_filesize),
OCT);
#else
arcn->sb.st_size = (off_t)asc_uqd(hd->c_filesize,sizeof(hd->c_filesize),
OCT);
#endif
/*
* check name size and if valid, read in the name of this entry (name
* follows header in the archive)
*/
if ((nsz = (int)asc_ul(hd->c_namesize,sizeof(hd->c_namesize),OCT)) < 2)
return(-1);
arcn->nlen = nsz - 1;
if (rd_nm(arcn, nsz) < 0)
return(-1);
if (((arcn->sb.st_mode&C_IFMT) != C_ISLNK)||(arcn->sb.st_size == 0)) {
/*
* no link name to read for this file
*/
arcn->ln_nlen = 0;
arcn->ln_name[0] = '\0';
return(com_rd(arcn));
}
/*
* check link name size and read in the link name. Link names are
* stored like file data.
*/
if (rd_ln_nm(arcn) < 0)
return(-1);
/*
* we have a valid header (with a link)
*/
return(com_rd(arcn));
}
int
tar_rd(ARCHD *arcn, char *buf)
{
HD_TAR *hd;
unsigned long long val;
char *pt;
/*
* we only get proper sized buffers passed to us
*/
if (tar_id(buf, BLKMULT) < 0)
return(-1);
memset(arcn, 0, sizeof(*arcn));
arcn->org_name = arcn->name;
arcn->sb.st_nlink = 1;
/*
* copy out the name and values in the stat buffer
*/
hd = (HD_TAR *)buf;
if (hd->linkflag != LONGLINKTYPE && hd->linkflag != LONGNAMETYPE) {
arcn->nlen = expandname(arcn->name, sizeof(arcn->name),
&gnu_name_string, hd->name, sizeof(hd->name));
arcn->ln_nlen = expandname(arcn->ln_name, sizeof(arcn->ln_name),
&gnu_link_string, hd->linkname, sizeof(hd->linkname));
}
arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode,sizeof(hd->mode),OCT) &
0xfff);
arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
arcn->sb.st_size = (off_t)asc_ull(hd->size, sizeof(hd->size), OCT);
val = asc_ull(hd->mtime, sizeof(hd->mtime), OCT);
if (val > MAX_TIME_T)
arcn->sb.st_mtime = INT_MAX; /* XXX 2038 */
else
arcn->sb.st_mtime = val;
arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
/*
* have to look at the last character, it may be a '/' and that is used
* to encode this as a directory
*/
pt = &(arcn->name[arcn->nlen - 1]);
arcn->pad = 0;
arcn->skip = 0;
switch (hd->linkflag) {
case SYMTYPE:
/*
* symbolic link, need to get the link name and set the type in
* the st_mode so -v printing will look correct.
*/
arcn->type = PAX_SLK;
arcn->sb.st_mode |= S_IFLNK;
break;
case LNKTYPE:
/*
* hard link, need to get the link name, set the type in the
* st_mode and st_nlink so -v printing will look better.
*/
arcn->type = PAX_HLK;
arcn->sb.st_nlink = 2;
/*
* no idea of what type this thing really points at, but
* we set something for printing only.
*/
arcn->sb.st_mode |= S_IFREG;
break;
case LONGLINKTYPE:
case LONGNAMETYPE:
/*
* GNU long link/file; we tag these here and let the
* pax internals deal with it -- too ugly otherwise.
*/
arcn->type =
hd->linkflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;
arcn->pad = TAR_PAD(arcn->sb.st_size);
arcn->skip = arcn->sb.st_size;
break;
case DIRTYPE:
/*
* It is a directory, set the mode for -v printing
*/
arcn->type = PAX_DIR;
arcn->sb.st_mode |= S_IFDIR;
arcn->sb.st_nlink = 2;
break;
case AREGTYPE:
case REGTYPE:
default:
/*
* If we have a trailing / this is a directory and NOT a file.
*/
arcn->ln_name[0] = '\0';
arcn->ln_nlen = 0;
if (*pt == '/') {
/*
* it is a directory, set the mode for -v printing
*/
arcn->type = PAX_DIR;
arcn->sb.st_mode |= S_IFDIR;
arcn->sb.st_nlink = 2;
} else {
/*
* have a file that will be followed by data. Set the
* skip value to the size field and calculate the size
* of the padding.
*/
arcn->type = PAX_REG;
arcn->sb.st_mode |= S_IFREG;
arcn->pad = TAR_PAD(arcn->sb.st_size);
arcn->skip = arcn->sb.st_size;
}
break;
}
/*
* strip off any trailing slash.
*/
if (*pt == '/') {
*pt = '\0';
--arcn->nlen;
}
return(0);
}
