int
tar_extract_all(TAR *t, char *prefix)
{
char *filename;
char buf[MAXPATHLEN];
int i;
#ifdef TAR_DEBUG
printf("==> tar_extract_all(TAR *t, \"%s\")\n",
(prefix ? prefix : "(null)"));
#endif
while ((i = th_read(t)) == 0)
{
#ifdef TAR_DEBUG
puts(" tar_extract_all(): calling th_get_pathname()");
#endif
filename = th_get_pathname(t);
if (t->options & TAR_VERBOSE)
th_print_long_ls(t);
if (prefix != NULL)
snprintf(buf, sizeof(buf), "%s/%s", prefix, filename);
else
strlcpy(buf, filename, sizeof(buf));
#ifdef TAR_DEBUG
printf(" tar_extract_all(): calling tar_extract_file(t, "
"\"%s\")\n", buf);
#endif
if (tar_extract_file(t, buf) != 0)
return -1;
}
return (i == 1 ? 0 : -1);
}
int
tar_find(TAR *t, char *searchstr)
{
if (!searchstr)
return 0;
char *filename;
int i, entryfound = 0;
#ifdef DEBUG
printf("==> tar_find(0x%lx, %s)\n", (long unsigned int)t, searchstr);
#endif
while ((i = th_read(t)) == 0) {
filename = th_get_pathname(t);
if (fnmatch(searchstr, filename, FNM_FILE_NAME | FNM_PERIOD) == 0) {
entryfound++;
#ifdef DEBUG
printf("Found matching entry: %s\n", filename);
#endif
break;
}
}
#ifdef DEBUG
if (!entryfound)
printf("No matching entry found.\n");
#endif
return entryfound;
}
/* FIFO */
int
tar_extract_fifo(TAR *t, char *realname)
{
mode_t mode;
char *filename;
if (!TH_ISFIFO(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
if (mkdirhier(dirname(filename)) == -1)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (fifo)\n", filename);
#endif
if (mkfifo(filename, mode) == -1)
{
#ifdef DEBUG
perror("mkfifo()");
#endif
return -1;
}
return 0;
}
/* symlink */
int
tar_extract_symlink(TAR *t, char *realname)
{
char *filename;
if (!TH_ISSYM(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
if (mkdirhier(dirname(filename)) == -1)
return -1;
if (unlink(filename) == -1 && errno != ENOENT)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (symlink to %s)\n",
filename, th_get_linkname(t));
#endif
if (symlink(th_get_linkname(t), filename) == -1)
{
#ifdef DEBUG
perror("symlink()");
#endif
return -1;
}
return 0;
}
int
tar_extract_glob(TAR *t, char *globname, char *prefix)
{
char *filename;
char buf[MAXPATHLEN];
int i;
while ((i = th_read(t)) == 0)
{
filename = th_get_pathname(t);
if (fnmatch(globname, filename, FNM_PATHNAME | FNM_PERIOD))
{
if (TH_ISREG(t) && tar_skip_regfile(t))
return -1;
continue;
}
if (t->options & TAR_VERBOSE)
th_print_long_ls(t);
if (prefix != NULL)
snprintf(buf, sizeof(buf), "%s/%s", prefix, filename);
else
strlcpy(buf, filename, sizeof(buf));
if (tar_extract_file(t, filename) != 0)
return -1;
}
return (i == 1 ? 0 : -1);
}
/* \internal
Checks whether a tar file is valid.
A valid tar file does not contains files
that start with ./ or contain ..
This is intended to prevent malicious packages
placing binaries outside of the sandbox directory
*/
bool check_tar_valid( const QString &tarfile )
{
TAR *tarHandle = get_tar_ptr( tarfile );
bool ret=true;
QString filename;
int i;
while ( (i = th_read(tarHandle)) == 0)
{
filename = th_get_pathname( tarHandle );
if ( !filename.startsWith("./") || filename.contains( "..") )
{
ret = false;
qWarning() << "check_tar_valid:- tar contains invalid file path: "
<< filename << "\nAll paths must begin with ./ and not contain .." ;
break;
}
else if ( TH_ISBLK(tarHandle) || TH_ISCHR(tarHandle) )
{
ret = false;
qWarning() << "check_tar_valid:-tar invalid, contains device special file:"
<< filename;
break;
}
else if ( TH_ISLNK(tarHandle) )
{
ret = false;
qWarning() << "check_tar_valid:-tar invalid, contains hard link:"
<< filename;
break;
} else if (TH_ISSYM(tarHandle) )
{
QString target;
if ((tarHandle->options & TAR_GNU) && tarHandle->th_buf.gnu_longlink != NULL)
target = tarHandle->th_buf.gnu_longlink;
else
target = tarHandle->th_buf.linkname;
if ( target.startsWith("/") || target.contains( "..") )
{
ret = false;
qWarning() << "check_tar_valid:tar invalid, contains symlink whose target"
<< (target.startsWith("/")?"is an absolute path.":"references "
"a parent directory.")
<< "Link:" << filename << "Target:" << target;
break;
}
}
if( TH_ISREG(tarHandle) )
tar_skip_regfile(tarHandle);
}
tar_close( tarHandle );
return ret;
}
/* directory */
int
tar_extract_dir(TAR *t, char *realname)
{
mode_t mode;
char *filename;
if (!TH_ISDIR(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
if (mkdirhier(dirname(filename)) == -1)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (mode %04o, directory)\n", filename,
mode);
#endif
if (mkdir(filename, mode) == -1)
{
if (errno == EEXIST)
{
if (chmod(filename, mode) == -1)
{
#ifdef DEBUG
perror("chmod()");
#endif
return -1;
}
else
{
#ifdef DEBUG
puts(" *** using existing directory");
#endif
return 1;
}
}
else
{
#ifdef DEBUG
perror("mkdir()");
#endif
return -1;
}
}
return 0;
}
int
util_tar_extract(const char *tar_filename, const char* index_file, const char* out_dir)
{
TAR *tar = NULL;
int ret = tar_open(&tar, tar_filename, &gztype, O_RDONLY, 0, TAR_GNU);
if (ret != 0) {
ERROR_ERRNO("Fail to open tarfile: %s\n", tar_filename);
return ret;
}
//ret = tar_extract_all(tar, tar_prefix);
while (th_read(tar) == 0) {
char *archive_filename = th_get_pathname(tar);
char *out_filename = mem_printf("%s/%s", out_dir, archive_filename);
char *mode = mem_alloc0(4*sizeof(char));
int_to_oct(th_get_mode(tar), mode, 4*sizeof(char));
uid_t uid = th_get_uid(tar);
gid_t gid = th_get_gid(tar);
INFO("Writing file %s to %s", archive_filename, out_filename);
if (TH_ISCHR(tar)) {
// writing file attributes to index file (TODO use hashmap to handle duplicates)
file_printf_append(index_file, "%s c %s %d %d %d %d\n",
archive_filename, mode, uid, gid,
th_get_devmajor(tar),
th_get_devminor(tar));
} else if (TH_ISBLK(tar)) {
// writing file attributes to index file (TODO use hashmap to handle duplicates)
file_printf_append(index_file, "%s b %s %d %d %d %d\n",
archive_filename, mode, uid, gid,
th_get_devmajor(tar),
th_get_devminor(tar));
} else {
if (tar_extract_file(tar, out_filename) != 0) {
INFO_ERRNO("Skipping file: %s", archive_filename);
} else {
// writing file attributes to index file (TODO use hashmap to handle duplicates)
file_printf_append(index_file, "%s m %s %d %d\n",
archive_filename, mode, uid, gid);
}
}
mem_free(mode);
mem_free(archive_filename);
mem_free(out_filename);
}
ret |= tar_close(tar);
return ret;
}
/* hardlink */
int
tar_extract_hardlink(TAR * t, char *realname, char *prefix)
{
char *filename;
char *linktgt = NULL;
char *lnp;
libtar_hashptr_t hp;
if (!TH_ISLNK(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
if (mkdirhier(dirname(filename)) == -1)
return -1;
libtar_hashptr_reset(&hp);
if (libtar_hash_getkey(t->h, &hp, th_get_linkname(t),
(libtar_matchfunc_t)libtar_str_match) != 0)
{
lnp = (char *)libtar_hashptr_data(&hp);
linktgt = &lnp[strlen(lnp) + 1];
}
else
linktgt = th_get_linkname(t);
char *newtgt = strdup(linktgt);
sprintf(linktgt, "%s/%s", prefix, newtgt);
#ifdef DEBUG
printf(" ==> extracting: %s (link to %s)\n", filename, linktgt);
#endif
if (link(linktgt, filename) == -1)
{
#ifdef DEBUG
perror("link()");
#endif
printf("Failed restore of hardlink '%s' but returning as if nothing bad happened anyway\n", filename);
return 0; // Used to be -1
}
return 0;
}
/* hardlink */
int
tar_extract_hardlink(TAR * t, char *realname)
{
char *filename;
char *linktgt = NULL;
char *lnp;
libtar_hashptr_t hp;
if (!TH_ISLNK(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
if (mkdirhier(dirname(filename)) == -1)
return -1;
libtar_hashptr_reset(&hp);
if (libtar_hash_getkey(t->h, &hp, th_get_linkname(t),
(libtar_matchfunc_t)libtar_str_match) != 0)
{
lnp = (char *)libtar_hashptr_data(&hp);
linktgt = &lnp[strlen(lnp) + 1];
}
else
linktgt = th_get_linkname(t);
#ifdef DEBUG
printf(" ==> extracting: %s (link to %s)\n", filename, linktgt);
#endif
if (link(linktgt, filename) == -1)
{
#ifdef DEBUG
perror("link()");
#endif
return -1;
}
return 0;
}
/* block device */
int
tar_extract_blockdev(TAR *t, char *realname)
{
mode_t mode;
unsigned long devmaj, devmin;
char *filename;
if (!TH_ISBLK(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
devmaj = th_get_devmajor(t);
devmin = th_get_devminor(t);
if (mkdirhier(dirname(filename)) == -1)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (block device %ld,%ld)\n",
filename, devmaj, devmin);
#endif
if (mknod(filename, mode | S_IFBLK,
makedev(devmaj, devmin)) == -1)
{
#ifdef DEBUG
perror("mknod()");
#endif
return -1;
}
return 0;
}
/* character device */
int
tar_extract_chardev(TAR *t, char *realname)
{
mode_t mode;
unsigned long devmaj, devmin;
char *filename;
if (!TH_ISCHR(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
devmaj = th_get_devmajor(t);
devmin = th_get_devminor(t);
if (mkdirhier(dirname(filename)) == -1)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (character device %ld,%ld)\n",
filename, devmaj, devmin);
#endif
if (mknod(filename, mode | S_IFCHR,
compat_makedev(devmaj, devmin)) == -1)
{
#ifdef DEBUG
printf("mknod() failed, returning good anyway");
#endif
return 0;
}
return 0;
}
void
th_print_long_ls(TAR *t)
{
char modestring[12];
struct passwd *pw;
struct group *gr;
uid_t uid;
gid_t gid;
char username[_POSIX_LOGIN_NAME_MAX];
char groupname[_POSIX_LOGIN_NAME_MAX];
time_t mtime;
struct tm *mtm;
#ifdef HAVE_STRFTIME
char timebuf[18];
#else
const char *months[] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
#endif
uid = th_get_uid(t);
pw = getpwuid(uid);
if (pw == NULL)
snprintf(username, sizeof(username), "%d", uid);
else
strlcpy(username, pw->pw_name, sizeof(username));
gid = th_get_gid(t);
gr = getgrgid(gid);
if (gr == NULL)
snprintf(groupname, sizeof(groupname), "%d", gid);
else
strlcpy(groupname, gr->gr_name, sizeof(groupname));
strmode(th_get_mode(t), modestring);
printf("%.10s %-8.8s %-8.8s ", modestring, username, groupname);
if (TH_ISCHR(t) || TH_ISBLK(t))
printf(" %3d, %3d ", th_get_devmajor(t), th_get_devminor(t));
else
printf("%9ld ", (long)th_get_size(t));
mtime = th_get_mtime(t);
mtm = localtime(&mtime);
#ifdef HAVE_STRFTIME
strftime(timebuf, sizeof(timebuf), "%h %e %H:%M %Y", mtm);
printf("%s", timebuf);
#else
printf("%.3s %2d %2d:%02d %4d",
months[mtm->tm_mon],
mtm->tm_mday, mtm->tm_hour, mtm->tm_min, mtm->tm_year + 1900);
#endif
printf(" %s", th_get_pathname(t));
if (TH_ISSYM(t) || TH_ISLNK(t))
{
if (TH_ISSYM(t))
printf(" -> ");
else
printf(" link to ");
if ((t->options & TAR_GNU) && t->th_buf.gnu_longlink != NULL)
printf("%s", t->th_buf.gnu_longlink);
else
printf("%.100s", t->th_buf.linkname);
}
putchar('\n');
}
static int
tar_set_file_perms(TAR *t, char *realname)
{
mode_t mode;
uid_t uid;
gid_t gid;
struct utimbuf ut;
char *filename;
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
uid = th_get_uid(t);
gid = th_get_gid(t);
ut.modtime = ut.actime = th_get_mtime(t);
/* change owner/group */
if (geteuid() == 0)
#ifdef HAVE_LCHOWN
if (lchown(filename, uid, gid) == -1)
{
# ifdef DEBUG
fprintf(stderr, "lchown(\"%s\", %d, %d): %s\n",
filename, uid, gid, strerror(errno));
# endif
#else /* ! HAVE_LCHOWN */
if (!TH_ISSYM(t) && chown(filename, uid, gid) == -1)
{
# ifdef DEBUG
fprintf(stderr, "chown(\"%s\", %d, %d): %s\n",
filename, uid, gid, strerror(errno));
# endif
#endif /* HAVE_LCHOWN */
return -1;
}
/* change access/modification time */
if (!TH_ISSYM(t) && utime(filename, &ut) == -1)
{
#ifdef DEBUG
perror("utime()");
#endif
return -1;
}
/* change permissions */
if (!TH_ISSYM(t) && chmod(filename, mode) == -1)
{
#ifdef DEBUG
perror("chmod()");
#endif
return -1;
}
return 0;
}
/* switchboard */
int
tar_extract_file(TAR *t, char *realname)
{
int i;
char *lnp;
int pathname_len;
int realname_len;
if (t->options & TAR_NOOVERWRITE)
{
struct stat s;
if (lstat(realname, &s) == 0 || errno != ENOENT)
{
errno = EEXIST;
return -1;
}
}
if (TH_ISDIR(t))
{
i = tar_extract_dir(t, realname);
if (i == 1)
i = 0;
}
else if (TH_ISLNK(t))
i = tar_extract_hardlink(t, realname);
else if (TH_ISSYM(t))
i = tar_extract_symlink(t, realname);
else if (TH_ISCHR(t))
i = tar_extract_chardev(t, realname);
else if (TH_ISBLK(t))
i = tar_extract_blockdev(t, realname);
else if (TH_ISFIFO(t))
i = tar_extract_fifo(t, realname);
else /* if (TH_ISREG(t)) */
i = tar_extract_regfile(t, realname);
if (i != 0)
return i;
i = tar_set_file_perms(t, realname);
if (i != 0)
return i;
pathname_len = strlen(th_get_pathname(t)) + 1;
realname_len = strlen(realname) + 1;
lnp = (char *)calloc(1, pathname_len + realname_len);
if (lnp == NULL)
return -1;
strcpy(&lnp[0], th_get_pathname(t));
strcpy(&lnp[pathname_len], realname);
#ifdef DEBUG
printf("tar_extract_file(): calling libtar_hash_add(): key=\"%s\", "
"value=\"%s\"\n", th_get_pathname(t), realname);
#endif
if (libtar_hash_add(t->h, lnp) != 0)
return -1;
return 0;
}
/* extract regular file */
int
tar_extract_regfile(TAR *t, char *realname)
{
mode_t mode;
size_t size;
uid_t uid;
gid_t gid;
int fdout;
int i, k;
char buf[T_BLOCKSIZE];
char *filename;
#ifdef DEBUG
printf("==> tar_extract_regfile(t=0x%lx, realname=\"%s\")\n", t,
realname);
#endif
if (!TH_ISREG(t))
{
errno = EINVAL;
return -1;
}
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
size = th_get_size(t);
uid = th_get_uid(t);
gid = th_get_gid(t);
if (mkdirhier(dirname(filename)) == -1)
return -1;
#ifdef DEBUG
printf(" ==> extracting: %s (mode %04o, uid %d, gid %d, %d bytes)\n",
filename, mode, uid, gid, size);
#endif
fdout = open(filename, O_WRONLY | O_CREAT | O_TRUNC
#ifdef O_BINARY
| O_BINARY
#endif
, 0666);
if (fdout == -1)
{
#ifdef DEBUG
perror("open()");
#endif
return -1;
}
#if 0
/* change the owner. (will only work if run as root) */
if (fchown(fdout, uid, gid) == -1 && errno != EPERM)
{
#ifdef DEBUG
perror("fchown()");
#endif
return -1;
}
/* make sure the mode isn't inheritted from a file we're overwriting */
if (fchmod(fdout, mode & 07777) == -1)
{
#ifdef DEBUG
perror("fchmod()");
#endif
return -1;
}
#endif
/* extract the file */
for (i = size; i > 0; i -= T_BLOCKSIZE)
{
k = tar_block_read(t, buf);
if (k != T_BLOCKSIZE)
{
if (k != -1)
errno = EINVAL;
return -1;
}
/* write block to output file */
if (write(fdout, buf,
((i > T_BLOCKSIZE) ? T_BLOCKSIZE : i)) == -1)
return -1;
}
/* close output file */
if (close(fdout) == -1)
return -1;
#ifdef DEBUG
printf("### done extracting %s\n", filename);
#endif
return 0;
}
static int sandbox_attr(void *fpctx,void *handle,const char *attr,glite_jp_attrval_t **attrval)
{
glite_jp_error_t err;
glite_jp_context_t ctx = fpctx;
glite_jp_attrval_t *out = NULL;
int i,nout = 0, count = 0;
sb_handle *h = handle;
printf("sandbox_attr() called\n");
memset(&err,0,sizeof err);
err.source = __FUNCTION__;
glite_jp_clear_error(ctx);
*attrval = NULL;
if (!strcmp(attr, GLITE_JP_ATTR_ISB_FILENAME)) {
while ((i = th_read(h->t)) == 0)
{
printf("-- %s\n", th_get_pathname(h->t));
if ( !(count % ALLOC_CHUNK) ) {
*attrval = realloc(*attrval, (count + ALLOC_CHUNK + 1) * sizeof(**attrval) );
memset( (*attrval) + count, 0, (ALLOC_CHUNK + 1) * sizeof(**attrval));
}
(*attrval)[count].name = strdup(GLITE_JP_ATTR_ISB_FILENAME);
(*attrval)[count].value = strdup(th_get_pathname(h->t));
(*attrval)[count].origin = GLITE_JP_ATTR_ORIG_FILE;
(*attrval)[count].timestamp = th_get_mtime(h->t);
count++;
if (TH_ISREG(h->t) && tar_skip_regfile(h->t) != 0)
{
err.code = EIO;
err.desc = "tar_skip_regfile";
return glite_jp_stack_error(ctx,&err);
}
}
}
else if (!strcmp(attr, GLITE_JP_ATTR_OSB_FILENAME)) {
printf("Namespace %s not implemented yet\n", GLITE_JP_ATTR_OSB_FILENAME);
}
else if (strstr(attr,GLITE_JP_OSB_CONTENT_NS)) {
printf("Namespace %s not implemented yet\n", GLITE_JP_OSB_CONTENT_NS);
}
else if (strstr(attr,GLITE_JP_ISB_CONTENT_NS)) {
char *fileName = (char *) attr + sizeof(GLITE_JP_ISB_CONTENT_NS);
printf("untaring file: %s\n", fileName);
while (th_read(h->t) == 0)
{
if ( !strcmp(fileName, th_get_pathname(h->t)) ) {
/* extract the file */
int k;
size_t size;
char buf[T_BLOCKSIZE];
char *value;
if (!TH_ISREG(h->t)) assert(0); // not a regular file
size = th_get_size(h->t);
value = (char *) malloc(size * sizeof(char) + 1);
memset( value, 0, size * sizeof(char) + 1);
for (i = 0; i < size; i += T_BLOCKSIZE)
{
k = tar_block_read(h->t, buf);
if (k == -1)
{
err.code = errno;
err.desc = "tar_block_read";
return glite_jp_stack_error(ctx,&err);
}
// tar_block_read calls glite_jppsbe_pread, which usually
// returns whole block (read from the middle of uploaded
// tar file
// so cut k in order to the last chunk had correct size
if (i + T_BLOCKSIZE > size) {
k = size - i;
}
strncpy(value + i, buf, k);
}
*attrval = malloc(2 * sizeof(**attrval) );
memset( (*attrval), 0, 2 * sizeof(**attrval));
(*attrval)[0].name = strdup(attr);
(*attrval)[0].value = value;
(*attrval)[0].origin = GLITE_JP_ATTR_ORIG_FILE;
(*attrval)[0].timestamp = th_get_mtime(h->t);
}
else if (TH_ISREG(h->t) && tar_skip_regfile(h->t) != 0)
{
err.code = EIO;
err.desc = "tar_skip_regfile";
return glite_jp_stack_error(ctx,&err);
}
}
}
return glite_jp_stack_error(ctx,&err);
}
static int
tar_set_file_perms(TAR *t, char *realname)
{
mode_t mode;
uid_t uid;
gid_t gid;
struct utimbuf ut;
char *filename;
filename = (realname ? realname : th_get_pathname(t));
mode = th_get_mode(t);
uid = th_get_uid(t);
gid = th_get_gid(t);
ut.modtime = ut.actime = th_get_mtime(t);
#ifdef DEBUG
printf(" ==> setting perms: %s (mode %04o, uid %d, gid %d)\n",
filename, mode, uid, gid);
#endif
/* change owner/group */
if (geteuid() == 0)
#ifdef HAVE_LCHOWN
if (lchown(filename, uid, gid) == -1)
{
# ifdef DEBUG
fprintf(stderr, "lchown(\"%s\", %d, %d): %s\n",
filename, uid, gid, strerror(errno));
# endif
#else /* ! HAVE_LCHOWN */
if (!TH_ISSYM(t) && chown(filename, uid, gid) == -1)
{
# ifdef DEBUG
fprintf(stderr, "chown(\"%s\", %d, %d): %s\n",
filename, uid, gid, strerror(errno));
# endif
#endif /* HAVE_LCHOWN */
return -1;
}
/* change access/modification time */
if (!TH_ISSYM(t) && utime(filename, &ut) == -1)
{
#ifdef DEBUG
perror("utime()");
#endif
return -1;
}
/* change permissions */
if (!TH_ISSYM(t) && chmod(filename, mode) == -1)
{
#ifdef DEBUG
perror("chmod()");
#endif
return -1;
}
return 0;
}
/* switchboard */
int
tar_extract_file(TAR *t, char *realname, char *prefix, const int *progress_fd)
{
int i;
char *lnp;
int pathname_len;
int realname_len;
if (t->options & TAR_NOOVERWRITE)
{
struct stat s;
if (lstat(realname, &s) == 0 || errno != ENOENT)
{
errno = EEXIST;
return -1;
}
}
if (TH_ISDIR(t))
{
printf("dir\n");
i = tar_extract_dir(t, realname);
if (i == 1)
i = 0;
}
else if (TH_ISLNK(t)) {
printf("link\n");
i = tar_extract_hardlink(t, realname, prefix);
}
else if (TH_ISSYM(t)) {
printf("sym\n");
i = tar_extract_symlink(t, realname);
}
else if (TH_ISCHR(t)) {
printf("chr\n");
i = tar_extract_chardev(t, realname);
}
else if (TH_ISBLK(t)) {
printf("blk\n");
i = tar_extract_blockdev(t, realname);
}
else if (TH_ISFIFO(t)) {
printf("fifo\n");
i = tar_extract_fifo(t, realname);
}
else /* if (TH_ISREG(t)) */ {
printf("reg\n");
i = tar_extract_regfile(t, realname, progress_fd);
}
if (i != 0) {
printf("FAILED RESTORE OF FILE i: %s\n", realname);
return i;
}
i = tar_set_file_perms(t, realname);
if (i != 0) {
printf("FAILED SETTING PERMS: %d\n", i);
return i;
}
#ifdef HAVE_SELINUX
if((t->options & TAR_STORE_SELINUX) && t->th_buf.selinux_context != NULL)
{
#ifdef DEBUG
printf(" Restoring SELinux context %s to file %s\n", t->th_buf.selinux_context, realname);
#endif
if (lsetfilecon(realname, t->th_buf.selinux_context) < 0) {
fprintf(stderr, "Failed to restore SELinux context %s!\n", strerror(errno));
}
}
#endif
/*
pathname_len = strlen(th_get_pathname(t)) + 1;
realname_len = strlen(realname) + 1;
lnp = (char *)calloc(1, pathname_len + realname_len);
if (lnp == NULL)
return -1;
strcpy(&lnp[0], th_get_pathname(t));
strcpy(&lnp[pathname_len], realname);
#ifdef DEBUG
printf("tar_extract_file(): calling libtar_hash_add(): key=\"%s\", "
"value=\"%s\"\n", th_get_pathname(t), realname);
#endif
if (libtar_hash_add(t->h, lnp) != 0)
return -1;
free(lnp);
*/
return 0;
}
