int archive_create( char *arch_file, int compress, int format, char *src_dir, char **exclude )
{
int fd, len, ret, skip;
char *pwd, **files;
DIR *dir;
struct dirent *dir_entry;
struct archive *arch_w = NULL, *arch_r = NULL;
struct archive_entry *arch_entry = NULL;
char buf[8192];
if( !arch_file || !src_dir )
return -1;
dir = opendir( src_dir );
if( !dir )
return -1;
arch_w = archive_write_new();
switch( compress )
{
case 'j': //bz2
//archive_write_add_filter_bzip2( arch_w ); //libarchive 3
archive_write_set_compression_bzip2( arch_w );
break;
case 'J': //xz
//archive_write_add_filter_xz( arch_w );
archive_write_set_compression_xz( arch_w );
break;
case 'z': //gzip
//archive_write_add_filter_gzip( arch_w );
archive_write_set_compression_gzip( arch_w );
break;
}
switch( format )
{
case 'c': //cpio
archive_write_set_format_cpio( arch_w );
break;
case 't': //tar
archive_write_set_format_ustar( arch_w );
break;
default: //tar
archive_write_set_format_ustar( arch_w );
break;
}
ret = archive_write_open_filename( arch_w, arch_file );
if( ret != ARCHIVE_OK )
{
archive_write_finish( arch_w );
return -1;
}
pwd = getcwd( NULL, 0 );
chdir( src_dir );
while( (dir_entry = readdir( dir )) )
{
if( !strcmp( dir_entry->d_name, "." ) || !strcmp( dir_entry->d_name, ".." ) )
{
continue;
}
if( exclude )
{
files = exclude;
skip = 0;
while( *files )
{
if( !strcmp( *files, dir_entry->d_name ) )
{
skip = 1;
break;
}
files++;
}
if( skip )
continue;
}
arch_r = archive_read_disk_new();
ret = archive_read_disk_open( arch_r, dir_entry->d_name );
if( ret != ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_r ) );
#endif
archive_write_finish( arch_w );
return -1;
}
for( ; ; )
{
arch_entry = archive_entry_new();
ret = archive_read_next_header2( arch_r, arch_entry );
if( ret == ARCHIVE_EOF )
break;
if( ret != ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_r ) );
#endif
archive_entry_free( arch_entry );
archive_write_finish( arch_r );
archive_write_finish( arch_w );
return -1;
}
#ifdef DEBUG
printf( "%s\n", archive_entry_pathname( arch_entry ) );
#endif
archive_read_disk_descend( arch_r );
ret = archive_write_header( arch_w, arch_entry );
if( ret < ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_w ) );
#endif
archive_entry_free( arch_entry );
archive_write_finish( arch_r );
archive_write_finish( arch_w );
return -1;
}
if( ( fd = open( archive_entry_sourcepath( arch_entry ), O_RDONLY ) ) != -1 )
{
len = read( fd, buf, 8192 );
while( len > 0 )
{
archive_write_data( arch_w, buf, len );
len = read( fd, buf, 8192 );
}
close( fd );
}
archive_entry_free( arch_entry );
}
/* libarchive 3
archive_read_close( arch_r );
archive_read_free( arch_r );
*/
archive_read_finish( arch_r );
}
if( arch_w )
{
/* libarchive 3
archive_write_close( arch_r );
archive_write_free( arch_r );
*/
archive_write_finish( arch_w );
}
if( pwd )
{
chdir( pwd );
free( pwd );
}
return 0;
}
RESULTCODE ArchiveProcessorImpl::Decompress()
{
const char* tpath = GetArchivePath();
if(tpath==NULL)
{
return AG_FAILURE;
}
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int flags;
int r;
/* Select which attributes we want to restore. */
flags = ARCHIVE_EXTRACT_TIME;
flags |= ARCHIVE_EXTRACT_PERM;
flags |= ARCHIVE_EXTRACT_ACL;
flags |= ARCHIVE_EXTRACT_FFLAGS;
a = archive_read_new();
archive_read_support_format_all(a);
archive_read_support_compression_all(a);
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
if((r = archive_read_open_filename(a, tpath, 10240)))
{
return AG_FAILURE;
}
while(true)
{
r = archive_read_next_header(a, &entry);
if( r== ARCHIVE_EOF)
{
break;
}
if( r < ARCHIVE_OK)
{
fprintf(stderr, "%s\n", archive_error_string(a));
}
if( r< ARCHIVE_WARN)
{
break;
}
r = archive_write_header(ext, entry);
if (r < ARCHIVE_OK)
{
fprintf(stderr, "%s\n", archive_error_string(ext));
}
else if (archive_entry_size(entry) > 0)
{
r = copy_data(a, ext);
}
if (r < ARCHIVE_OK)
{
fprintf(stderr, "%s\n", archive_error_string(ext));
}
if (r < ARCHIVE_WARN)
{
break;
}
r = archive_write_finish_entry(ext);
if (r < ARCHIVE_OK)
{
fprintf(stderr, "%s\n", archive_error_string(ext));
}
if(r < ARCHIVE_WARN)
{
break;
}
}
archive_read_close(a);
archive_read_free(a);
archive_write_close(ext);
archive_write_free(ext);
//return r==ARCHIVE_OK ? AG_SUCCESS : AG_FAILURE;
return AG_SUCCESS;
}
static int
entry_to_archive(struct cpio *cpio, struct archive_entry *entry)
{
const char *destpath = archive_entry_pathname(entry);
const char *srcpath = archive_entry_sourcepath(entry);
int fd = -1;
ssize_t bytes_read;
int r;
/* Print out the destination name to the user. */
if (cpio->verbose)
fprintf(stderr,"%s", destpath);
/*
* Option_link only makes sense in pass mode and for
* regular files. Also note: if a link operation fails
* because of cross-device restrictions, we'll fall back
* to copy mode for that entry.
*
* TODO: Test other cpio implementations to see if they
* hard-link anything other than regular files here.
*/
if (cpio->option_link
&& archive_entry_filetype(entry) == AE_IFREG)
{
struct archive_entry *t;
/* Save the original entry in case we need it later. */
t = archive_entry_clone(entry);
if (t == NULL)
lafe_errc(1, ENOMEM, "Can't create link");
/* Note: link(2) doesn't create parent directories,
* so we use archive_write_header() instead as a
* convenience. */
archive_entry_set_hardlink(t, srcpath);
/* This is a straight link that carries no data. */
archive_entry_set_size(t, 0);
r = archive_write_header(cpio->archive, t);
archive_entry_free(t);
if (r != ARCHIVE_OK)
lafe_warnc(archive_errno(cpio->archive),
"%s", archive_error_string(cpio->archive));
if (r == ARCHIVE_FATAL)
exit(1);
#ifdef EXDEV
if (r != ARCHIVE_OK && archive_errno(cpio->archive) == EXDEV) {
/* Cross-device link: Just fall through and use
* the original entry to copy the file over. */
lafe_warnc(0, "Copying file instead");
} else
#endif
return (0);
}
/*
* Make sure we can open the file (if necessary) before
* trying to write the header.
*/
if (archive_entry_filetype(entry) == AE_IFREG) {
if (archive_entry_size(entry) > 0) {
fd = open(srcpath, O_RDONLY | O_BINARY);
if (fd < 0) {
lafe_warnc(errno,
"%s: could not open file", srcpath);
goto cleanup;
}
}
} else {
archive_entry_set_size(entry, 0);
}
r = archive_write_header(cpio->archive, entry);
if (r != ARCHIVE_OK)
lafe_warnc(archive_errno(cpio->archive),
"%s: %s",
srcpath,
archive_error_string(cpio->archive));
if (r == ARCHIVE_FATAL)
exit(1);
if (r >= ARCHIVE_WARN && fd >= 0) {
bytes_read = read(fd, cpio->buff, cpio->buff_size);
while (bytes_read > 0) {
r = archive_write_data(cpio->archive,
cpio->buff, bytes_read);
if (r < 0)
lafe_errc(1, archive_errno(cpio->archive),
"%s", archive_error_string(cpio->archive));
if (r < bytes_read) {
lafe_warnc(0,
"Truncated write; file may have grown while being archived.");
}
bytes_read = read(fd, cpio->buff, cpio->buff_size);
}
}
fd = restore_time(cpio, entry, srcpath, fd);
cleanup:
if (cpio->verbose)
fprintf(stderr,"\n");
if (fd >= 0)
close(fd);
return (0);
}
int main(int argc, char **argv) {
int i;
unsigned int version = 0, help = 0;
char cpiotmpfile[] = CPIOTMPFILE;
struct archive *archive;
struct archive_entry *entry;
struct stat st;
char buff[64];
int len, fdfile, fdarchive;
DIR * dir;
struct dirent * ent;
char * filename, * path;
off_t pathlength = 0;
int8_t rc = EXIT_FAILURE;
/* get command line options */
while ((i = getopt_long(argc, argv, optstring, options_long, NULL)) != -1)
switch (i) {
case 'h':
help++;
break;
case 'V':
version++;
break;
}
if (version > 0)
printf("%s: %s v%s (compiled: " __DATE__ ", " __TIME__ ")\n", argv[0], PROGNAME, VERSION);
if (help > 0)
fprintf(stderr, "usage: %s [-h|--help] [-V|--version]\n", argv[0]);
if (version > 0 || help > 0)
return EXIT_SUCCESS;
if ((fdarchive = mkstemp(cpiotmpfile)) < 0) {
perror("mkstemp() failed");
goto out10;
}
if ((archive = archive_write_new()) == NULL) {
fprintf(stderr, "archive_write_new() failed.\n");
goto out10;
}
if (archive_write_set_format_cpio_newc(archive) != ARCHIVE_OK) {
fprintf(stderr, "archive_write_set_format_cpio_newc() failed.\n");
goto out10;
}
if (archive_write_open_fd(archive, fdarchive) != ARCHIVE_OK) {
fprintf(stderr, "archive_write_open_fd() failed.\n");
goto out10;
}
while (1) {
path = strdup(CHALLENGEDIR + 1);
if (strstr(path + pathlength, "/") == NULL)
break;
*strstr(path + pathlength, "/") = 0;
pathlength = strlen(path) + 1;
if (add_dir(archive, path) < 0) {
fprintf(stderr, "add_dir() failed");
goto out10;
}
free(path);
}
if ((dir = opendir(CHALLENGEDIR)) == NULL) {
perror("opendir() failed");
goto out10;
}
while ((ent = readdir(dir)) != NULL) {
filename = malloc(sizeof(CHALLENGEDIR) + strlen(ent->d_name) + 1);
sprintf(filename, CHALLENGEDIR "%s", ent->d_name);
if (stat(filename, &st) < 0) {
perror("stat() failed");
goto out10;
}
if (S_ISREG(st.st_mode)) {
if ((entry = archive_entry_new()) == NULL) {
fprintf(stderr, "archive_entry_new() failed.\n");
goto out10;
}
/* these do not return exit code */
archive_entry_set_pathname(entry, filename + 1);
archive_entry_set_size(entry, st.st_size);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
if (archive_write_header(archive, entry) != ARCHIVE_OK) {
fprintf(stderr, "archive_write_header() failed");
goto out10;
}
if ((fdfile = open(filename, O_RDONLY)) < 0) {
perror("open() failed");
goto out10;
}
if ((len = read(fdfile, buff, sizeof(buff))) < 0) {
perror("read() failed");
goto out10;
}
while (len > 0) {
if (archive_write_data(archive, buff, len) < 0) {
fprintf(stderr, "archive_write_data() failed");
goto out10;
}
if ((len = read(fdfile, buff, sizeof(buff))) < 0) {
perror("read() failed");
goto out10;
}
}
if (close(fdfile) < 0) {
perror("close() failed");
goto out10;
}
archive_entry_free(entry);
}
free(filename);
}
if (closedir(dir) < 0) {
perror("closedir() failed");
goto out10;
}
if (archive_write_close(archive) != ARCHIVE_OK) {
fprintf(stderr, "archive_write_close() failed");
goto out10;
}
if (archive_write_free(archive) != ARCHIVE_OK) {
fprintf(stderr, "archive_write_free() failed");
goto out10;
}
if (access(CPIOFILE, F_OK) == 0 && unlink(CPIOFILE) < 0) {
perror("unkink() failed");
goto out10;
}
if (rename(cpiotmpfile, CPIOFILE) < 0) {
perror("rename() failed");
goto out10;
}
rc = EXIT_SUCCESS;
out10:
if (access(cpiotmpfile, F_OK) == 0)
unlink(cpiotmpfile);
return rc;
}
void
pkg_sign_gpg(const char *name, const char *output)
{
struct archive *pkg;
struct archive_entry *entry, *hash_entry, *sign_entry;
int fd;
struct stat sb;
char *hash_file, *signature_file, *tmp, *pkgname, hash[SHA512_DIGEST_STRING_LENGTH];
unsigned char block[65536];
off_t i, size;
size_t block_len, signature_len;
if ((fd = open(name, O_RDONLY)) == -1)
err(EXIT_FAILURE, "Cannot open binary package %s", name);
if (fstat(fd, &sb) == -1)
err(EXIT_FAILURE, "Cannot stat %s", name);
entry = archive_entry_new();
archive_entry_copy_stat(entry, &sb);
pkgname = extract_pkgname(fd);
hash_file = xasprintf(hash_template, pkgname,
(long long)archive_entry_size(entry));
free(pkgname);
for (i = 0; i < archive_entry_size(entry); i += block_len) {
if (i + (off_t)sizeof(block) < archive_entry_size(entry))
block_len = sizeof(block);
else
block_len = archive_entry_size(entry) % sizeof(block);
if (read(fd, block, block_len) != (ssize_t)block_len)
err(2, "short read");
hash_block(block, block_len, hash);
tmp = xasprintf("%s%s\n", hash_file, hash);
free(hash_file);
hash_file = tmp;
}
tmp = xasprintf("%s%s", hash_file, hash_trailer);
free(hash_file);
hash_file = tmp;
if (detached_gpg_sign(hash_file, strlen(hash_file), &signature_file,
&signature_len, gpg_keyring_sign, gpg_sign_as))
err(EXIT_FAILURE, "Cannot sign hash file");
lseek(fd, 0, SEEK_SET);
sign_entry = archive_entry_clone(entry);
hash_entry = archive_entry_clone(entry);
pkgname = strrchr(name, '/');
archive_entry_set_pathname(entry, pkgname != NULL ? pkgname + 1 : name);
archive_entry_set_pathname(hash_entry, HASH_FNAME);
archive_entry_set_pathname(sign_entry, GPG_SIGNATURE_FNAME);
archive_entry_set_size(hash_entry, strlen(hash_file));
archive_entry_set_size(sign_entry, signature_len);
pkg = archive_write_new();
archive_write_set_compression_none(pkg);
archive_write_set_format_ar_bsd(pkg);
archive_write_open_filename(pkg, output);
archive_write_header(pkg, hash_entry);
archive_write_data(pkg, hash_file, strlen(hash_file));
archive_write_finish_entry(pkg);
archive_entry_free(hash_entry);
archive_write_header(pkg, sign_entry);
archive_write_data(pkg, signature_file, signature_len);
archive_write_finish_entry(pkg);
archive_entry_free(sign_entry);
size = archive_entry_size(entry);
archive_write_header(pkg, entry);
for (i = 0; i < size; i += block_len) {
if (i + (off_t)sizeof(block) < size)
block_len = sizeof(block);
else
block_len = size % sizeof(block);
if (read(fd, block, block_len) != (ssize_t)block_len)
err(2, "short read");
archive_write_data(pkg, block, block_len);
}
archive_write_finish_entry(pkg);
archive_entry_free(entry);
archive_write_finish(pkg);
close(fd);
exit(0);
}
compare_acls(acl_t acl, struct archive_test_acl_t *myacls, int n)
#endif
{
int *marker;
int matched;
int i;
#if HAVE_SUN_ACL
int e;
aclent_t *acl_entry;
#else
int entry_id = ACL_FIRST_ENTRY;
acl_entry_t acl_entry;
#endif
/* Count ACL entries in myacls array and allocate an indirect array. */
marker = malloc(sizeof(marker[0]) * n);
if (marker == NULL)
return;
for (i = 0; i < n; i++)
marker[i] = i;
/*
* Iterate over acls in system acl object, try to match each
* one with an item in the myacls array.
*/
#if HAVE_SUN_ACL
for(e = 0; e < acl->acl_cnt; e++) {
acl_entry = &((aclent_t *)acl->acl_aclp)[e];
#else
while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {
/* After the first time... */
entry_id = ACL_NEXT_ENTRY;
#endif
/* Search for a matching entry (tag and qualifier) */
for (i = 0, matched = 0; i < n && !matched; i++) {
if (acl_match(acl_entry, &myacls[marker[i]])) {
/* We found a match; remove it. */
marker[i] = marker[n - 1];
n--;
matched = 1;
}
}
/* TODO: Print out more details in this case. */
failure("ACL entry on file that shouldn't be there");
assert(matched == 1);
}
/* Dump entries in the myacls array that weren't in the system acl. */
for (i = 0; i < n; ++i) {
failure(" ACL entry missing from file: "
"type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s''\n",
myacls[marker[i]].type, myacls[marker[i]].permset,
myacls[marker[i]].tag, myacls[marker[i]].qual,
myacls[marker[i]].name);
assert(0); /* Record this as a failure. */
}
free(marker);
}
#endif
/*
* Verify ACL restore-to-disk. This test is Platform-specific.
*/
DEFINE_TEST(test_acl_platform_posix1e_restore)
{
#if !HAVE_SUN_ACL && !HAVE_POSIX_ACL
skipping("POSIX.1e ACLs are not supported on this platform");
#else /* HAVE_SUN_ACL || HAVE_POSIX_ACL */
struct stat st;
struct archive *a;
struct archive_entry *ae;
int n, fd;
char *func;
#if HAVE_SUN_ACL
acl_t *acl, *acl2;
#else
acl_t acl;
#endif
/*
* First, do a quick manual set/read of ACL data to
* verify that the local filesystem does support ACLs.
* If it doesn't, we'll simply skip the remaining tests.
*/
#if HAVE_SUN_ACL
n = acl_fromtext("user::rwx,user:1:rw-,group::rwx,group:15:r-x,other:rwx,mask:rwx", &acl);
failure("acl_fromtext(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
#else
acl = acl_from_text("u::rwx,u:1:rw,g::rwx,g:15:rx,o::rwx,m::rwx");
failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
assert((void *)acl != NULL);
#endif
/* Create a test file and try ACL on it. */
fd = open("pretest", O_WRONLY | O_CREAT | O_EXCL, 0777);
failure("Could not create test file?!");
if (!assert(fd >= 0)) {
acl_free(acl);
return;
}
#if HAVE_SUN_ACL
n = facl_get(fd, 0, &acl2);
if (n != 0) {
close(fd);
acl_free(acl);
}
if (errno == ENOSYS) {
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
failure("facl_get(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
if (acl2->acl_type != ACLENT_T) {
acl_free(acl2);
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
acl_free(acl2);
func = "facl_set()";
n = facl_set(fd, acl);
#else
func = "acl_set_fd()";
n = acl_set_fd(fd, acl);
#endif
acl_free(acl);
if (n != 0) {
#if HAVE_SUN_ACL
if (errno == ENOSYS)
#else
if (errno == EOPNOTSUPP || errno == EINVAL)
#endif
{
close(fd);
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
}
failure("%s: errno = %d (%s)", func, errno, strerror(errno));
assertEqualInt(0, n);
#if HAVE_SUN_ACL
#endif
close(fd);
/* Create a write-to-disk object. */
assert(NULL != (a = archive_write_disk_new()));
archive_write_disk_set_options(a,
ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL);
/* Populate an archive entry with some metadata, including ACL info */
ae = archive_entry_new();
assert(ae != NULL);
archive_entry_set_pathname(ae, "test0");
archive_entry_set_mtime(ae, 123456, 7890);
archive_entry_set_size(ae, 0);
assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the data on disk. */
assertEqualInt(0, stat("test0", &st));
assertEqualInt(st.st_mtime, 123456);
#if HAVE_SUN_ACL
n = acl_get("test0", 0, &acl);
failure("acl_get(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
#else
acl = acl_get_file("test0", ACL_TYPE_ACCESS);
failure("acl_get_file(): errno = %d (%s)", errno, strerror(errno));
assert(acl != (acl_t)NULL);
#endif
compare_acls(acl, acls2, sizeof(acls2)/sizeof(acls2[0]));
acl_free(acl);
#endif /* HAVE_SUN_ACL || HAVE_POSIX_ACL */
}
/*
* Verify ACL read-from-disk. This test is Platform-specific.
*/
DEFINE_TEST(test_acl_platform_posix1e_read)
{
#if !HAVE_SUN_ACL && !HAVE_POSIX_ACL
skipping("POSIX.1e ACLs are not supported on this platform");
#else
struct archive *a;
struct archive_entry *ae;
int n, fd, flags, dflags;
char *func, *acl_text;
const char *acl1_text, *acl2_text, *acl3_text;
#if HAVE_SUN_ACL
acl_t *acl, *acl1, *acl2, *acl3;
#else
acl_t acl1, acl2, acl3;
#endif
/*
* Manually construct a directory and two files with
* different ACLs. This also serves to verify that ACLs
* are supported on the local filesystem.
*/
/* Create a test file f1 with acl1 */
#if HAVE_SUN_ACL
acl1_text = "user::rwx,"
"group::rwx,"
"other:rwx,"
"user:1:rw-,"
"group:15:r-x,"
"mask:rwx";
n = acl_fromtext(acl1_text, &acl1);
failure("acl_fromtext(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
#else
acl1_text = "user::rwx\n"
"group::rwx\n"
"other::rwx\n"
"user:1:rw-\n"
"group:15:r-x\n"
"mask::rwx";
acl1 = acl_from_text(acl1_text);
failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
assert((void *)acl1 != NULL);
#endif
fd = open("f1", O_WRONLY | O_CREAT | O_EXCL, 0777);
failure("Could not create test file?!");
if (!assert(fd >= 0)) {
acl_free(acl1);
return;
}
#if HAVE_SUN_ACL
/* Check if Solaris filesystem supports POSIX.1e ACLs */
n = facl_get(fd, 0, &acl);
if (n != 0)
close(fd);
if (n != 0 && errno == ENOSYS) {
acl_free(acl1);
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
failure("facl_get(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
if (acl->acl_type != ACLENT_T) {
acl_free(acl);
acl_free(acl1);
close(fd);
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
func = "facl_set()";
n = facl_set(fd, acl1);
#else
func = "acl_set_fd()";
n = acl_set_fd(fd, acl1);
#endif
acl_free(acl1);
if (n != 0) {
#if HAVE_SUN_ACL
if (errno == ENOSYS)
#else
if (errno == EOPNOTSUPP || errno == EINVAL)
#endif
{
close(fd);
skipping("POSIX.1e ACLs are not supported on this filesystem");
return;
}
}
failure("%s: errno = %d (%s)", func, errno, strerror(errno));
assertEqualInt(0, n);
close(fd);
assertMakeDir("d", 0700);
/*
* Create file d/f1 with acl2
*
* This differs from acl1 in the u:1: and g:15: permissions.
*
* This file deliberately has the same name but a different ACL.
* Github Issue #777 explains how libarchive's directory traversal
* did not always correctly enter directories before attempting
* to read ACLs, resulting in reading the ACL from a like-named
* file in the wrong directory.
*/
#if HAVE_SUN_ACL
acl2_text = "user::rwx,"
"group::rwx,"
"other:---,"
"user:1:r--,"
"group:15:r--,"
"mask:rwx";
n = acl_fromtext(acl2_text, &acl2);
failure("acl_fromtext(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
#else
acl2_text = "user::rwx\n"
"group::rwx\n"
"other::---\n"
"user:1:r--\n"
"group:15:r--\n"
"mask::rwx";
acl2 = acl_from_text(acl2_text);
failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
assert((void *)acl2 != NULL);
#endif
fd = open("d/f1", O_WRONLY | O_CREAT | O_EXCL, 0777);
failure("Could not create test file?!");
if (!assert(fd >= 0)) {
acl_free(acl2);
return;
}
#if HAVE_SUN_ACL
func = "facl_set()";
n = facl_set(fd, acl2);
#else
func = "acl_set_fd()";
n = acl_set_fd(fd, acl2);
#endif
acl_free(acl2);
if (n != 0)
close(fd);
failure("%s: errno = %d (%s)", func, errno, strerror(errno));
assertEqualInt(0, n);
close(fd);
/* Create nested directory d2 with default ACLs */
assertMakeDir("d/d2", 0755);
#if HAVE_SUN_ACL
acl3_text = "user::rwx,"
"group::r-x,"
"other:r-x,"
"user:2:r--,"
"group:16:-w-,"
"mask:rwx,"
"default:user::rwx,"
"default:user:1:r--,"
"default:group::r-x,"
"default:group:15:r--,"
"default:mask:rwx,"
"default:other:r-x";
n = acl_fromtext(acl3_text, &acl3);
failure("acl_fromtext(): errno = %d (%s)", errno, strerror(errno));
assertEqualInt(0, n);
#else
acl3_text = "user::rwx\n"
"user:1:r--\n"
"group::r-x\n"
"group:15:r--\n"
"mask::rwx\n"
"other::r-x";
acl3 = acl_from_text(acl3_text);
failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
assert((void *)acl3 != NULL);
#endif
#if HAVE_SUN_ACL
func = "acl_set()";
n = acl_set("d/d2", acl3);
#else
func = "acl_set_file()";
n = acl_set_file("d/d2", ACL_TYPE_DEFAULT, acl3);
#endif
acl_free(acl3);
failure("%s: errno = %d (%s)", func, errno, strerror(errno));
assertEqualInt(0, n);
/* Create a read-from-disk object. */
assert(NULL != (a = archive_read_disk_new()));
assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "."));
assert(NULL != (ae = archive_entry_new()));
#if HAVE_SUN_ACL
flags = ARCHIVE_ENTRY_ACL_TYPE_POSIX1E
| ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA
| ARCHIVE_ENTRY_ACL_STYLE_SOLARIS;
dflags = flags;
#else
flags = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
dflags = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
#endif
/* Walk the dir until we see both of the files */
while (ARCHIVE_OK == archive_read_next_header2(a, ae)) {
archive_read_disk_descend(a);
if (strcmp(archive_entry_pathname(ae), "./f1") == 0) {
acl_text = archive_entry_acl_to_text(ae, NULL, flags);
assertEqualString(acl_text, acl1_text);
free(acl_text);
} else if (strcmp(archive_entry_pathname(ae), "./d/f1") == 0) {
acl_text = archive_entry_acl_to_text(ae, NULL, flags);
assertEqualString(acl_text, acl2_text);
free(acl_text);
} else if (strcmp(archive_entry_pathname(ae), "./d/d2") == 0) {
acl_text = archive_entry_acl_to_text(ae, NULL, dflags);
assertEqualString(acl_text, acl3_text);
free(acl_text);
}
}
archive_entry_free(ae);
assertEqualInt(ARCHIVE_OK, archive_free(a));
#endif
}
void Package::readPackageFile(const std::string &package_path)
{
if (!package_path.empty())
mPackagePath = package_path;
boost::filesystem::path unpacked_dir = mWorkDir;
unpacked_dir /= mPackagePath.stem();
mUnpackedDir = unpacked_dir;
const void *buf;
int r;
struct archive *a = archive_read_new();
struct archive_entry *entry;
archive_read_support_compression_bzip2(a);
archive_read_support_format_tar(a);
struct archive *ext = archive_write_disk_new();
int flags = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS;
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
r = archive_read_open_filename(a, package_path.c_str(), 16384);
if (r != ARCHIVE_OK) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string("archive_read_open_filename() failed for file: ") + package_path);
}
while (true) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF) {
break;
}
if (r < ARCHIVE_OK) {
std::cerr << archive_error_string(ext) << std::endl;
}
if (r < ARCHIVE_WARN) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string("archive_read_next_header() failed:") + archive_error_string(a));
}
std::cout << std::string("extract: ") << archive_entry_pathname(entry) << std::endl;
archive_entry_set_pathname(entry, (mUnpackedDir.string() + std::string("/") + archive_entry_pathname(entry)).c_str());
r = archive_write_header(ext, entry);
if (r < ARCHIVE_OK) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string("archive_write_header() failed:") + archive_error_string(ext));
} else if (archive_entry_size(entry) > 0) {
size_t size;
int64_t offset;
while (true) {
r = archive_read_data_block(a, &buf, &size, &offset);
if (r == ARCHIVE_EOF)
break;
if (r < ARCHIVE_WARN) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string(archive_error_string(ext)));
}
if (r < ARCHIVE_OK) {
std::cerr << archive_error_string(ext) << std::endl;
break;
}
r = archive_write_data_block(ext, buf, size, offset);
if (r < ARCHIVE_WARN) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string(archive_error_string(ext)));
}
if (r < ARCHIVE_OK) {
std::cerr << archive_error_string(ext) << std::endl;
break;
}
}
r = archive_write_finish_entry(ext);
if (r < ARCHIVE_OK)
std::cerr << archive_error_string(ext) << std::endl;
if (r < ARCHIVE_WARN) {
archive_read_free(a);
archive_write_free(ext);
throw Exception(std::string(archive_error_string(ext)));
}
}
}
archive_read_close(a);
archive_read_free(a);
archive_write_close(ext);
archive_write_free(ext);
}
static gboolean
dump_files (GFile *dir,
struct archive *archive,
GCancellable *cancellable,
char *parent,
GError **error)
{
g_autoptr(GFileEnumerator) fe = NULL;
gboolean ret = TRUE;
GFileType type;
fe = g_file_enumerate_children (dir,
"standard::name,standard::type,standard::is-symlink,standard::symlink-target,unix::mode,time::*",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, cancellable, error);
if (fe == NULL)
return FALSE;
while (TRUE)
{
g_autoptr(GFileInfo) info = g_file_enumerator_next_file (fe, cancellable, error);
g_autofree char *path = NULL;
g_autoptr(GFile) child = NULL;
guint32 mode;
g_autoptr(archive_entry_t) entry = archive_entry_new2 (archive);
if (!info)
{
if (error && *error != NULL)
ret = FALSE;
break;
}
type = g_file_info_get_file_type (info);
mode = g_file_info_get_attribute_uint32 (info, "unix::mode");
path = g_build_filename (parent, g_file_info_get_name (info), NULL);
child = g_file_enumerator_get_child (fe, info);
archive_entry_set_pathname (entry, path);
archive_entry_set_uid(entry, 0);
archive_entry_set_gid(entry, 0);
archive_entry_set_perm(entry, mode & 0777);
archive_entry_set_mtime(entry, 0, 0);
switch (type)
{
case G_FILE_TYPE_SYMBOLIC_LINK:
archive_entry_set_filetype (entry, AE_IFLNK);
archive_entry_set_symlink (entry, g_file_info_get_symlink_target (info));
break;
case G_FILE_TYPE_REGULAR:
archive_entry_set_filetype (entry, AE_IFREG);
archive_entry_set_size(entry, g_file_info_get_size (info));
break;
case G_FILE_TYPE_DIRECTORY:
archive_entry_set_filetype (entry, AE_IFDIR);
break;
default:
g_error ("Unhandled type %d\n", type);
break;
}
if (archive_write_header (archive, entry) < ARCHIVE_OK)
return xdg_app_fail (error, "Can't write tar header");
if (type == G_FILE_TYPE_REGULAR)
{
if (!dump_data (child, archive, cancellable, error))
return FALSE;
}
if (archive_write_finish_entry (archive) < ARCHIVE_OK)
return xdg_app_fail (error, "Can't finish tar entry");
if (type == G_FILE_TYPE_DIRECTORY)
{
if (!dump_files (child, archive, cancellable, path, error))
return FALSE;
}
}
return ret;
}
static void *
extract(void *p)
{
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int r;
int flags;
struct extract_data *data = (struct extract_data *)p;
flags = data->flags;
a = archive_read_new();
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
/*
* Note: archive_write_disk_set_standard_lookup() is useful
* here, but it requires library routines that can add 500k or
* more to a static executable.
*/
archive_read_support_format_all(a);
archive_read_support_filter_all(a);
/*
* On my system, enabling other archive formats adds 20k-30k
* each. Enabling gzip decompression adds about 20k.
* Enabling bzip2 is more expensive because the libbz2 library
* isn't very well factored.
*/
if ((r = archive_read_open_filename(a, FIFO, 4096))) {
ERROR("archive_read_open_filename(): %s %d\n",
archive_error_string(a), r);
pthread_exit((void *)-1);
}
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
ERROR("archive_read_next_header(): %s %d\n",
archive_error_string(a), 1);
pthread_exit((void *)-1);
}
if (debug)
TRACE("Extracting %s\n", archive_entry_pathname(entry));
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK)
TRACE("archive_write_header(): %s\n",
archive_error_string(ext));
else {
copy_data(a, ext);
r = archive_write_finish_entry(ext);
if (r != ARCHIVE_OK) {
ERROR("archive_write_finish_entry(): %s\n",
archive_error_string(ext));
pthread_exit((void *)-1);
}
}
}
archive_read_close(a);
archive_read_free(a);
pthread_exit((void *)0);
}
int
packing_append_file_attr(struct packing *pack, const char *filepath,
const char *newpath, const char *uname, const char *gname, mode_t perm)
{
int fd;
int len;
char buf[BUFSIZ];
int retcode = EPKG_OK;
int ret;
struct stat st;
struct archive_entry *entry, *sparse_entry;
/* ugly hack for python and emacs */
/*char *p;*/
/*bool unset_timestamp = true;*/
entry = archive_entry_new();
archive_entry_copy_sourcepath(entry, filepath);
if (lstat(filepath, &st) != 0) {
pkg_emit_errno("lstat", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
ret = archive_read_disk_entry_from_file(pack->aread, entry, -1,
&st);
if (ret != ARCHIVE_OK) {
pkg_emit_error("%s: %s", filepath,
archive_error_string(pack->aread));
retcode = EPKG_FATAL;
goto cleanup;
}
if (newpath != NULL)
archive_entry_set_pathname(entry, newpath);
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_entry_set_size(entry, 0);
}
if (uname != NULL && uname[0] != '\0')
archive_entry_set_uname(entry, uname);
if (gname != NULL && gname[0] != '\0')
archive_entry_set_gname(entry, gname);
if (perm != 0)
archive_entry_set_perm(entry, perm);
/* XXX ugly hack for python and emacs */
/* p = strrchr(filepath, '.');
if (p != NULL && (strcmp(p, ".pyc") == 0 ||
strcmp(p, ".py") == 0 ||
strcmp(p, ".pyo") == 0 ||
strcmp(p, ".elc") == 0 ||
strcmp(p, ".el") == 0
))
unset_timestamp = false;
if (unset_timestamp) {
archive_entry_unset_atime(entry);
archive_entry_unset_ctime(entry);
archive_entry_unset_mtime(entry);
archive_entry_unset_birthtime(entry);
}*/
archive_entry_linkify(pack->resolver, &entry, &sparse_entry);
if (sparse_entry != NULL && entry == NULL)
entry = sparse_entry;
archive_write_header(pack->awrite, entry);
if (archive_entry_size(entry) > 0) {
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
while ((len = read(fd, buf, sizeof(buf))) > 0)
archive_write_data(pack->awrite, buf, len);
close(fd);
}
cleanup:
archive_entry_free(entry);
return (retcode);
}
static gboolean
dump_runtime (GFile *root, GCancellable *cancellable, GError **error)
{
int i;
g_autoptr(write_archive_t) archive = NULL;
g_autoptr(GFile) files = g_file_get_child (root, "files");
archive = archive_write_new ();
if (archive == NULL)
return xdg_app_fail (error, "Can't allocate archive");
if (archive_write_set_format_gnutar (archive) < ARCHIVE_OK)
return xdg_app_fail (error, "Can't set tar format");
if (archive_write_open_FILE (archive, stdout) < ARCHIVE_OK)
return xdg_app_fail (error, "can't open stdout");
for (i = 0; i < G_N_ELEMENTS(extra_dirs); i++)
{
g_autoptr(archive_entry_t) entry = archive_entry_new2 (archive);
archive_entry_set_pathname (entry, extra_dirs[i]);
archive_entry_set_uid(entry, 0);
archive_entry_set_gid(entry, 0);
archive_entry_set_perm(entry, 0755);
archive_entry_set_mtime(entry, 0, 0);
archive_entry_set_filetype (entry, AE_IFDIR);
if (archive_write_header (archive, entry) < ARCHIVE_OK)
return xdg_app_fail (error, "Can't write tar header");
}
for (i = 0; i < G_N_ELEMENTS(extra_symlinks); i++)
{
g_autoptr(archive_entry_t) entry = NULL;
if (g_str_has_prefix (extra_symlinks[i].target, "usr/"))
{
g_autoptr(GFile) dest = g_file_resolve_relative_path (files, extra_symlinks[i].target + 4);
if (!g_file_query_exists (dest, cancellable))
continue;
}
entry = archive_entry_new2 (archive);
archive_entry_set_pathname (entry, extra_symlinks[i].path);
archive_entry_set_uid(entry, 0);
archive_entry_set_gid(entry, 0);
archive_entry_set_perm(entry, 0755);
archive_entry_set_mtime(entry, 0, 0);
archive_entry_set_filetype (entry, AE_IFLNK);
archive_entry_set_symlink (entry, extra_symlinks[i].target);
if (archive_write_header (archive, entry) < ARCHIVE_OK)
return xdg_app_fail (error, "Can't write tar header");
}
if (!dump_files (files, archive, cancellable, "usr", error))
return FALSE;
if (archive_write_close (archive) < ARCHIVE_OK)
return xdg_app_fail (error, "can't close archive");
return TRUE;
}
bool LibArchiveInterface::copyFiles(const QVariantList& files, const QString& destinationDirectory, ExtractionOptions options)
{
kDebug() << "Changing current directory to " << destinationDirectory;
QDir::setCurrent(destinationDirectory);
const bool extractAll = files.isEmpty();
const bool preservePaths = options.value(QLatin1String( "PreservePaths" )).toBool();
QString rootNode = options.value(QLatin1String("RootNode"), QVariant()).toString();
if ((!rootNode.isEmpty()) && (!rootNode.endsWith(QLatin1Char('/')))) {
rootNode.append(QLatin1Char('/'));
}
ArchiveRead arch(archive_read_new());
if (!(arch.data())) {
return false;
}
if (archive_read_support_compression_all(arch.data()) != ARCHIVE_OK) {
return false;
}
if (archive_read_support_format_all(arch.data()) != ARCHIVE_OK) {
return false;
}
if (archive_read_open_filename(arch.data(), QFile::encodeName(filename()), 10240) != ARCHIVE_OK) {
emit error(i18nc("@info", "Could not open the archive <filename>%1</filename>, libarchive cannot handle it.",
filename()));
return false;
}
ArchiveWrite writer(archive_write_disk_new());
if (!(writer.data())) {
return false;
}
archive_write_disk_set_options(writer.data(), extractionFlags());
int entryNr = 0;
int totalCount = 0;
if (extractAll) {
if (!m_cachedArchiveEntryCount) {
emit progress(0);
//TODO: once information progress has been implemented, send
//feedback here that the archive is being read
kDebug() << "For getting progress information, the archive will be listed once";
m_emitNoEntries = true;
list();
m_emitNoEntries = false;
}
totalCount = m_cachedArchiveEntryCount;
} else {
totalCount = files.size();
}
m_currentExtractedFilesSize = 0;
bool overwriteAll = false; // Whether to overwrite all files
bool skipAll = false; // Whether to skip all files
struct archive_entry *entry;
QString fileBeingRenamed;
while (archive_read_next_header(arch.data(), &entry) == ARCHIVE_OK) {
fileBeingRenamed.clear();
// retry with renamed entry, fire an overwrite query again
// if the new entry also exists
retry:
const bool entryIsDir = S_ISDIR(archive_entry_mode(entry));
//we skip directories if not preserving paths
if (!preservePaths && entryIsDir) {
archive_read_data_skip(arch.data());
continue;
}
//entryName is the name inside the archive, full path
QString entryName = QDir::fromNativeSeparators(QFile::decodeName(archive_entry_pathname(entry)));
if (entryName.startsWith(QLatin1Char( '/' ))) {
//for now we just can't handle absolute filenames in a tar archive.
//TODO: find out what to do here!!
emit error(i18n("This archive contains archive entries with absolute paths, which are not yet supported by ark."));
return false;
}
if (files.contains(entryName) || entryName == fileBeingRenamed || extractAll) {
// entryFI is the fileinfo pointing to where the file will be
// written from the archive
QFileInfo entryFI(entryName);
//kDebug() << "setting path to " << archive_entry_pathname( entry );
const QString fileWithoutPath(entryFI.fileName());
//if we DON'T preserve paths, we cut the path and set the entryFI
//fileinfo to the one without the path
if (!preservePaths) {
//empty filenames (ie dirs) should have been skipped already,
//so asserting
Q_ASSERT(!fileWithoutPath.isEmpty());
archive_entry_copy_pathname(entry, QFile::encodeName(fileWithoutPath).constData());
entryFI = QFileInfo(fileWithoutPath);
//OR, if the commonBase has been set, then we remove this
//common base from the filename
} else if (!rootNode.isEmpty()) {
kDebug() << "Removing" << rootNode << "from" << entryName;
const QString truncatedFilename(entryName.remove(0, rootNode.size()));
archive_entry_copy_pathname(entry, QFile::encodeName(truncatedFilename).constData());
entryFI = QFileInfo(truncatedFilename);
}
//now check if the file about to be written already exists
if (!entryIsDir && entryFI.exists()) {
if (skipAll) {
archive_read_data_skip(arch.data());
archive_entry_clear(entry);
continue;
} else if (!overwriteAll && !skipAll) {
Kerfuffle::OverwriteQuery query(entryName);
emit userQuery(&query);
query.waitForResponse();
if (query.responseCancelled()) {
archive_read_data_skip(arch.data());
archive_entry_clear(entry);
break;
} else if (query.responseSkip()) {
archive_read_data_skip(arch.data());
archive_entry_clear(entry);
continue;
} else if (query.responseAutoSkip()) {
archive_read_data_skip(arch.data());
archive_entry_clear(entry);
skipAll = true;
continue;
} else if (query.responseRename()) {
const QString newName(query.newFilename());
fileBeingRenamed = newName;
archive_entry_copy_pathname(entry, QFile::encodeName(newName).constData());
goto retry;
} else if (query.responseOverwriteAll()) {
overwriteAll = true;
}
}
}
//if there is an already existing directory:
if (entryIsDir && entryFI.exists()) {
if (entryFI.isWritable()) {
kDebug(1601) << "Warning, existing, but writable dir";
} else {
kDebug(1601) << "Warning, existing, but non-writable dir. skipping";
archive_entry_clear(entry);
archive_read_data_skip(arch.data());
continue;
}
}
int header_response;
kDebug() << "Writing " << fileWithoutPath << " to " << archive_entry_pathname(entry);
if ((header_response = archive_write_header(writer.data(), entry)) == ARCHIVE_OK) {
//if the whole archive is extracted and the total filesize is
//available, we use partial progress
copyData(arch.data(), writer.data(), (extractAll && m_extractedFilesSize));
} else if (header_response == ARCHIVE_WARN) {
kDebug() << "Warning while writing " << entryName;
} else {
kDebug() << "Writing header failed with error code " << header_response
<< "While attempting to write " << entryName;
}
//if we only partially extract the archive and the number of
//archive entries is available we use a simple progress based on
//number of items extracted
if (!extractAll && m_cachedArchiveEntryCount) {
++entryNr;
emit progress(float(entryNr) / totalCount);
}
archive_entry_clear(entry);
} else {
archive_read_data_skip(arch.data());
}
}
return archive_read_close(arch.data()) == ARCHIVE_OK;
}
bool vesKiwiArchiveUtils::extractArchive(const std::string& filename, const std::string& destDir)
{
this->mEntries.clear();
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int flags;
int r;
flags = ARCHIVE_EXTRACT_TIME;
flags |= ARCHIVE_EXTRACT_PERM;
flags |= ARCHIVE_EXTRACT_ACL;
flags |= ARCHIVE_EXTRACT_FFLAGS;
a = archive_read_new();
archive_read_support_format_all(a);
archive_read_support_compression_all(a);
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
if ((r = archive_read_open_file(a, filename.c_str(), 10240))) {
this->setError("Error Opening File", "Failed to open file: " + filename);
return false;
}
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK)
fprintf(stderr, "%s\n", archive_error_string(a));
if (r < ARCHIVE_WARN) {
this->setError("Error Reading Archive", archive_error_string(a));
return false;
}
std::string destPath = archive_entry_pathname(entry);
//printf("entry: %s\n", destPath.c_str());
if (destDir.size()) {
destPath = destDir + "/" + destPath;
}
archive_entry_set_pathname(entry, destPath.c_str());
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK)
fprintf(stderr, "%s\n", archive_error_string(ext));
else if (archive_entry_size(entry) > 0) {
copy_data(a, ext);
if (r != ARCHIVE_OK)
fprintf(stderr, "%s\n", archive_error_string(ext));
if (r < ARCHIVE_WARN) {
this->setError("Error Reading Archive", archive_error_string(ext));
return false;
}
}
r = archive_write_finish_entry(ext);
if (r != ARCHIVE_OK)
fprintf(stderr, "%s\n", archive_error_string(ext));
if (r < ARCHIVE_WARN) {
this->setError("Error Reading Archive", archive_error_string(ext));
return false;
}
this->mEntries.push_back(destPath);
}
archive_read_close(a);
archive_read_free(a);
archive_write_close(ext);
archive_write_free(ext);
return true;
}
int archive_create2( char *arch_file, int compress, int format, char **files )
{
int fd, len, ret;
struct archive *arch_w = NULL, *arch_r;
struct archive_entry *arch_entry = NULL;
char buf[8192];
if( !arch_file || !files )
return -1;
arch_w = archive_write_new();
switch( compress )
{
case 'j': //bz2
//archive_write_add_filter_bzip2( arch_w );
archive_write_set_compression_bzip2( arch_w );
break;
case 'J': //xz
//archive_write_add_filter_xz( arch_w );
archive_write_set_compression_xz( arch_w );
break;
case 'z': //gzip
//archive_write_add_filter_gzip( arch_w );
archive_write_set_compression_gzip( arch_w );
break;
}
switch( format )
{
case 'c': //cpio
archive_write_set_format_cpio( arch_w );
break;
case 't': //tar
archive_write_set_format_ustar( arch_w );
break;
default: //tar
archive_write_set_format_ustar( arch_w );
break;
}
ret = archive_write_open_filename( arch_w, arch_file );
if( ret != ARCHIVE_OK )
{
archive_write_finish( arch_w );
return -1;
}
while( *files )
{
arch_r = archive_read_disk_new();
ret = archive_read_disk_open( arch_r, *files );
if( ret != ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_r ) );
#endif
archive_write_finish( arch_w );
return -1;
}
for( ; ; )
{
arch_entry = archive_entry_new();
ret = archive_read_next_header2( arch_r, arch_entry );
if( ret == ARCHIVE_EOF )
break;
if( ret != ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_r ) );
#endif
archive_entry_free( arch_entry );
archive_write_finish( arch_r );
archive_write_finish( arch_w );
return -1;
}
archive_read_disk_descend( arch_r );
ret = archive_write_header( arch_w, arch_entry );
if( ret < ARCHIVE_OK )
{
#ifdef DEBUG
printf( "%s\n", archive_error_string( arch_w ) );
#endif
archive_entry_free( arch_entry );
archive_write_finish( arch_r );
archive_write_finish( arch_w );
return -1;
}
if( ( fd = open( archive_entry_sourcepath( arch_entry ), O_RDONLY ) ) != -1 )
{
len = read( fd, buf, 8192 );
while( len > 0 )
{
archive_write_data( arch_w, buf, len );
len = read( fd, buf, 8192 );
}
close( fd );
}
archive_entry_free( arch_entry );
}
/* libarchive 3
archive_read_close( arch_r );
archive_read_free( arch_r );
*/
archive_read_finish( arch_r );
}
if( arch_w )
archive_write_finish( arch_w );
return 0;
}
static void
extract(const char *filename, int do_extract, int flags)
{
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int r;
a = archive_read_new();
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
#ifndef NO_BZIP2_EXTRACT
archive_read_support_filter_bzip2(a);
#endif
#ifndef NO_GZIP_EXTRACT
archive_read_support_filter_gzip(a);
#endif
#ifndef NO_COMPRESS_EXTRACT
archive_read_support_filter_compress(a);
#endif
#ifndef NO_TAR_EXTRACT
archive_read_support_format_tar(a);
#endif
#ifndef NO_CPIO_EXTRACT
archive_read_support_format_cpio(a);
#endif
#ifndef NO_LOOKUP
archive_write_disk_set_standard_lookup(ext);
#endif
if (filename != NULL && strcmp(filename, "-") == 0)
filename = NULL;
if ((r = archive_read_open_filename(a, filename, 10240))) {
errmsg(archive_error_string(a));
errmsg("\n");
exit(r);
}
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
errmsg(archive_error_string(a));
errmsg("\n");
exit(1);
}
if (verbose && do_extract)
msg("x ");
if (verbose || !do_extract)
msg(archive_entry_pathname(entry));
if (do_extract) {
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK)
errmsg(archive_error_string(a));
else
copy_data(a, ext);
}
if (verbose || !do_extract)
msg("\n");
}
archive_read_close(a);
archive_read_free(a);
exit(0);
}
static void *
extract(void *p)
{
locale_t archive_locale;
locale_t old_locale;
struct archive *a;
struct archive *ext = NULL;
struct archive_entry *entry = NULL;
int r;
int flags;
struct extract_data *data = (struct extract_data *)p;
flags = data->flags;
int exitval = -EFAULT;
/*
* Enable system locale - change from the standard (C) to system locale.
* This allows libarchive (in case it is activated) to handle filenames.
* We only change LC_CTYPE since libarchive only needs the charset set.
* We don't use LC_ALL because it causes problems on some systems.
* We restore the original LC_CTYPE after extraction to avoid side effects.
* We use uselocale instead of setlocale to avoid setting LC_CTYPE globally.
* See on libarchive Website for a more complete description of the issue:
* https://github.com/libarchive/libarchive/issues/587
* https://github.com/libarchive/libarchive/wiki/Filenames
*/
archive_locale = newlocale(LC_CTYPE_MASK, "", (locale_t)0);
old_locale = uselocale(archive_locale);
a = archive_read_new();
if (!a) {
goto out;
}
ext = archive_write_disk_new();
if (!ext) {
goto out;
}
archive_write_disk_set_options(ext, flags);
/*
* Note: archive_write_disk_set_standard_lookup() is useful
* here, but it requires library routines that can add 500k or
* more to a static executable.
*/
archive_read_support_format_all(a);
archive_read_support_filter_all(a);
/*
* On my system, enabling other archive formats adds 20k-30k
* each. Enabling gzip decompression adds about 20k.
* Enabling bzip2 is more expensive because the libbz2 library
* isn't very well factored.
*/
char* FIFO = alloca(strlen(get_tmpdir())+strlen(FIFO_FILE_NAME)+1);
sprintf(FIFO, "%s%s", get_tmpdir(), FIFO_FILE_NAME);
if ((r = archive_read_open_filename(a, FIFO, 4096))) {
ERROR("archive_read_open_filename(): %s %d",
archive_error_string(a), r);
goto out;
}
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
ERROR("archive_read_next_header(): %s %d",
archive_error_string(a), 1);
goto out;
}
if (debug)
TRACE("Extracting %s", archive_entry_pathname(entry));
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK)
TRACE("archive_write_header(): %s",
archive_error_string(ext));
else {
copy_data(a, ext);
r = archive_write_finish_entry(ext);
if (r != ARCHIVE_OK) {
ERROR("archive_write_finish_entry(): %s",
archive_error_string(ext));
goto out;
}
}
}
exitval = 0;
out:
if (ext) {
r = archive_write_free(ext);
if (r) {
ERROR("archive_write_free(): %s %d",
archive_error_string(a), r);
exitval = -EFAULT;
}
}
if (a) {
archive_read_close(a);
archive_read_free(a);
}
uselocale(old_locale);
data->exitval = exitval;
pthread_exit(NULL);
}
static void
test_filename(const char *prefix, int dlen, int flen)
{
char buff[8192];
char filename[400];
char dirname[400];
struct archive_entry *ae;
struct archive *a;
size_t used;
int separator = 0;
int i = 0;
if (prefix != NULL) {
strcpy(filename, prefix);
i = (int)strlen(prefix);
}
if (dlen > 0) {
for (; i < dlen; i++)
filename[i] = 'a';
filename[i++] = '/';
separator = 1;
}
for (; i < dlen + flen + separator; i++)
filename[i] = 'b';
filename[i] = '\0';
strcpy(dirname, filename);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_ustar(a));
assertA(0 == archive_write_set_compression_none(a));
assertA(0 == archive_write_set_bytes_per_block(a,0));
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, filename);
archive_entry_set_mode(ae, S_IFREG | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen > 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/*
* Write a dir to it (without trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen >= 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/* Tar adds a '/' to directory names. */
strcat(dirname, "/");
/*
* Write a dir to it (with trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen >= 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
if (flen <= 100) {
/* Read the file and check the filename. */
assertA(0 == archive_read_next_header(a, &ae));
failure("dlen=%d, flen=%d", dlen, flen);
assertEqualString(filename, archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
}
/*
* Read the two dirs and check the names.
*
* Both dirs should read back with the same name, since
* tar should add a trailing '/' to any dir that doesn't
* already have one.
*/
if (flen <= 99) {
assertA(0 == archive_read_next_header(a, &ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
failure("dlen=%d, flen=%d", dlen, flen);
assertEqualString(dirname, archive_entry_pathname(ae));
}
if (flen <= 99) {
assertA(0 == archive_read_next_header(a, &ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
assertEqualString(dirname, archive_entry_pathname(ae));
}
/* Verify the end of the archive. */
failure("This fails if entries were written that should not have been written. dlen=%d, flen=%d", dlen, flen);
assertEqualInt(1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
int main(int argc, char* argv[]){
struct archive* ar;
struct archive_entry* aren;
int arnum;
if(argc < 3){
fprintf(stderr, "Usage: %s infile outfile\n", argv[0]);
return 255;
}
#ifdef ENABLE_STAGE_1
puts("==> Stage 1: Listing");
ar = archive_read_new();
archive_read_support_filter_all(ar);
archive_read_support_format_all(ar);
arnum = archive_read_open_filename(ar, argv[1], 16384);
if(arnum != ARCHIVE_OK){
fprintf(stderr, "%s: %s: %s\n",
argv[0], argv[1], archive_error_string(ar));
return 1;
}
while(archive_read_next_header(ar, &aren) == ARCHIVE_OK){
const char *hardlink, *symlink;
printf("%s format: %s, pathname: %s, size: %"PRId64", links: %d,"
"username: %s, uid: %d",
argv[1], archive_format_name(ar), archive_entry_pathname(aren),
archive_entry_size(aren), archive_entry_nlink(aren),
archive_entry_uname(aren), archive_entry_uid(aren));
hardlink = archive_entry_hardlink(aren);
symlink = archive_entry_symlink(aren);
if(hardlink != NULL){
printf(", hardlink: %s", hardlink);
}
if(symlink != NULL){
printf(", symlink: %s", symlink);
}
putchar('\n');
}
archive_read_close(ar);
archive_read_free(ar);
#endif
#ifdef ENABLE_STAGE_2
puts("==> Stage 2: Displaying");
ar = archive_read_new();
archive_read_support_filter_all(ar);
archive_read_support_format_all(ar);
arnum = archive_read_open_filename(ar, argv[1], 16384);
if(arnum != ARCHIVE_OK){
fprintf(stderr, "%s: %s: %s\n",
argv[0], argv[1], archive_error_string(ar));
return 2;
}
while(archive_read_next_header(ar, &aren) == ARCHIVE_OK){
printf("<<< %s >>>\n", archive_entry_pathname(aren));
for(;;){
size_t size;
off_t offset;
const void* buffer;
switch(archive_read_data_block(ar, &buffer, &size, &offset)){
case ARCHIVE_OK:
puts(":: Block reading succeeded");
fwrite(buffer, size, 1, stdout);
break;
case ARCHIVE_WARN:
puts(":: Block reading succeeded, warning exists");
fwrite(buffer, size, 1, stdout);
break;
case ARCHIVE_EOF:
goto loop_outside;
case ARCHIVE_RETRY:
puts(":: Block reading failed, retrying");
break;
case ARCHIVE_FATAL:
puts(":: Fatal error! STOP!");
return 2;
}
}
loop_outside:
puts("@@ Extract OK @@");
}
archive_read_close(ar);
archive_read_free(ar);
#endif
#ifdef ENABLE_STAGE_3
puts("==> Stage 3: Extracting");
struct archive* arext;
ar = archive_read_new();
archive_read_support_format_all(ar);
archive_read_support_filter_all(ar);
arext = archive_write_disk_new();
archive_write_disk_set_options(arext,
ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_ACL |
ARCHIVE_EXTRACT_FFLAGS | ARCHIVE_EXTRACT_XATTR );
archive_write_disk_set_standard_lookup(arext);
if(archive_read_open_filename(ar, argv[1], 16384)){
fprintf(stderr, "%s: %s: %s\n",
argv[0], argv[1], archive_error_string(ar));
return 3;
}
while((arnum = archive_read_next_header(ar, &aren)) == ARCHIVE_OK){
int filesize, accsize;
printf("<<< %s >>>\n", archive_entry_pathname(aren));
if(archive_write_header(arext, aren) != ARCHIVE_OK){
puts(":: Write header not OK ...");
}else if((filesize = archive_entry_size(aren)) > 0){
accsize = 0;
for(;;){
size_t size;
off_t offset;
const void* buffer;
arnum = archive_read_data_block(ar, &buffer, &size, &offset);
if(arnum != ARCHIVE_OK){
break;
}
arnum = archive_write_data(arext, buffer, size);
if(arnum >= 0){
accsize += arnum;
printf(":: %d of %d bytes written\n", accsize, filesize);
}
}
}
if(archive_write_finish_entry(arext) != ARCHIVE_OK){
return 3;
}
}
archive_read_close(ar);
archive_read_free(ar);
archive_write_close(arext);
archive_write_free(arext);
#endif
return 0;
}
static void
test_1(void)
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t blocksize;
int64_t offset, length;
char *buff2;
size_t buff2_size = 0x13000;
char buff3[1024];
long i;
assert((buff2 = malloc(buff2_size)) != NULL);
/* Repeat the following for a variety of odd blocksizes. */
for (blocksize = 1; blocksize < 100000; blocksize += blocksize + 3) {
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_format_pax(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_compression_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_per_block(a, (int)blocksize));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_in_last_block(a, (int)blocksize));
assertEqualInt(blocksize,
archive_write_get_bytes_in_last_block(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assertEqualInt(blocksize,
archive_write_get_bytes_in_last_block(a));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assertEqualInt(S_IFREG | 0755, archive_entry_mode(ae));
archive_entry_set_size(ae, 0x81000);
archive_entry_sparse_add_entry(ae, 0x10000, 0x1000);
archive_entry_sparse_add_entry(ae, 0x80000, 0x1000);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
memset(buff2, 'a', buff2_size);
for (i = 0; i < 0x81000;) {
size_t ws = buff2_size;
if (i + ws > 0x81000)
ws = 0x81000 - i;
assertEqualInt(ws,
archive_write_data(a, buff2, ws));
i += ws;
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* This calculation gives "the smallest multiple of
* the block size that is at least 11264 bytes". */
failure("blocksize=%d", blocksize);
assertEqualInt(((11264 - 1)/blocksize+1)*blocksize, used);
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(0x81000, archive_entry_size(ae));
/* Verify sparse information. */
assertEqualInt(2, archive_entry_sparse_reset(ae));
assertEqualInt(0,
archive_entry_sparse_next(ae, &offset, &length));
assertEqualInt(0x10000, offset);
assertEqualInt(0x1000, length);
assertEqualInt(0,
archive_entry_sparse_next(ae, &offset, &length));
assertEqualInt(0x80000, offset);
assertEqualInt(0x1000, length);
/* Verify file contents. */
memset(buff3, 0, sizeof(buff3));
for (i = 0; i < 0x10000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all zero",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 'a', sizeof(buff3));
for (i = 0x10000; i < 0x11000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all 'a'",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 0, sizeof(buff3));
for (i = 0x11000; i < 0x80000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all zero",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 'a', sizeof(buff3));
for (i = 0x80000; i < 0x81000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all 'a'",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF,
archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
free(buff2);
}
static void
test_format(int (*set_format)(struct archive *))
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
char *p;
size_t used;
size_t buffsize = 1000000;
char *buff;
int damaged = 0;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == (*set_format)(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(8 == archive_write_data(a, "12345678", 9));
/*
* Write another file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file2");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file2", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 4);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(4 == archive_write_data(a, "1234", 5));
/*
* Write a file with a name, filetype, and size.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_set_size(ae, 0);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
assert(archive_error_string(a) == NULL);
archive_entry_free(ae);
/*
* Write a file with a name and filetype but no size.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_unset_size(ae);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a file with a name and size but no filetype.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_set_size(ae, 0);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a file with a size and filetype but no name.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_size(ae, 0);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 110);
archive_entry_copy_pathname(ae, "dir");
archive_entry_set_mode(ae, S_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertA(0 == archive_write_header(a, ae));
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Damage the second entry to test the search-ahead recovery.
* TODO: Move the damage-recovery checking to a separate test;
* it doesn't really belong in this write test.
*/
{
int i;
for (i = 80; i < 150; i++) {
if (memcmp(buff + i, "07070", 5) == 0) {
damaged = 1;
buff[i] = 'X';
break;
}
}
}
failure("Unable to locate the second header for damage-recovery test.");
assert(damaged == 1);
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
if (!assertEqualIntA(a, 0, archive_read_next_header(a, &ae))) {
archive_read_free(a);
return;
}
assertEqualInt(1, archive_entry_mtime(ae));
/* Not the same as above: cpio doesn't store hi-res times. */
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertA(8 == archive_read_data(a, filedata, 10));
assertEqualMem(filedata, "12345678", 8);
/*
* The second file can't be read because we damaged its header.
*/
/*
* Read the third file back.
* ARCHIVE_WARN here because the damaged entry was skipped.
*/
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualString("name", archive_entry_pathname(ae));
/*
* Read the dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("dir", archive_entry_pathname(ae));
assertEqualInt((S_IFDIR | 0755), archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/* Verify the end of the archive. */
assertEqualIntA(a, 1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
int
packing_append_file_attr(struct packing *pack, const char *filepath,
const char *newpath, const char *uname, const char *gname, mode_t perm,
u_long fflags)
{
int fd;
char *map;
int retcode = EPKG_OK;
int ret;
time_t source_time;
struct stat st;
struct archive_entry *entry, *sparse_entry;
bool unset_timestamp;
const char *source_date_epoch;
entry = archive_entry_new();
archive_entry_copy_sourcepath(entry, filepath);
pkg_debug(2, "Packing file '%s'", filepath);
if (lstat(filepath, &st) != 0) {
pkg_emit_errno("lstat", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
ret = archive_read_disk_entry_from_file(pack->aread, entry, -1,
&st);
if (ret != ARCHIVE_OK) {
pkg_emit_error("%s: %s", filepath,
archive_error_string(pack->aread));
retcode = EPKG_FATAL;
goto cleanup;
}
if (newpath != NULL)
archive_entry_set_pathname(entry, newpath);
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_entry_set_size(entry, 0);
}
if (uname != NULL && uname[0] != '\0') {
if (pack->pass) {
struct passwd* pw = getpwnam(uname);
if (pw == NULL) {
pkg_emit_error("Unknown user: '******'", uname);
retcode = EPKG_FATAL;
goto cleanup;
}
archive_entry_set_uid(entry, pw->pw_uid);
}
archive_entry_set_uname(entry, uname);
}
if (gname != NULL && gname[0] != '\0') {
if (pack->pass) {
struct group *gr = (getgrnam(gname));
if (gr == NULL) {
pkg_emit_error("Unknown group: '%s'", gname);
retcode = EPKG_FATAL;
goto cleanup;
}
archive_entry_set_gid(entry, gr->gr_gid);
}
archive_entry_set_gname(entry, gname);
}
if (fflags > 0)
archive_entry_set_fflags(entry, fflags, 0);
if (perm != 0)
archive_entry_set_perm(entry, perm);
unset_timestamp = pkg_object_bool(pkg_config_get("UNSET_TIMESTAMP"));
if (unset_timestamp) {
archive_entry_unset_atime(entry);
archive_entry_unset_ctime(entry);
archive_entry_unset_mtime(entry);
archive_entry_unset_birthtime(entry);
}
if ((source_date_epoch = getenv("SOURCE_DATE_EPOCH")) != NULL) {
if (source_date_epoch[strspn(source_date_epoch, "0123456789")] != '\0') {
pkg_emit_error("Bad environment variable "
"SOURCE_DATE_EPOCH: %s", source_date_epoch);
retcode = EPKG_FATAL;
goto cleanup;
}
source_time = strtoll(source_date_epoch, NULL, 10);
archive_entry_set_atime(entry, source_time, 0);
archive_entry_set_ctime(entry, source_time, 0);
archive_entry_set_mtime(entry, source_time, 0);
archive_entry_set_birthtime(entry, source_time, 0);
}
archive_entry_linkify(pack->resolver, &entry, &sparse_entry);
if (sparse_entry != NULL && entry == NULL)
entry = sparse_entry;
archive_write_header(pack->awrite, entry);
if (archive_entry_size(entry) > 0) {
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
if (st.st_size > SSIZE_MAX) {
char buf[BUFSIZ];
int len;
while ((len = read(fd, buf, sizeof(buf))) > 0)
if (archive_write_data(pack->awrite, buf, len) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
break;
}
if (len == -1) {
pkg_emit_errno("read", "file read error");
retcode = EPKG_FATAL;
}
close(fd);
}
else {
if ((map = mmap(NULL, st.st_size, PROT_READ,
MAP_SHARED, fd, 0)) != MAP_FAILED) {
close(fd);
if (archive_write_data(pack->awrite, map, st.st_size) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
}
munmap(map, st.st_size);
}
else {
close(fd);
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
}
}
cleanup:
archive_entry_free(entry);
return (retcode);
}
static void
test_open_filename_mbs(void)
{
char buff[64];
struct archive_entry *ae;
struct archive *a;
/* Write an archive through this FILE *. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_filename(a, "test.tar"));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 8, archive_write_data(a, "12345678", 9));
/*
* Write a second file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 819200);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_filename(a, "test.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(0, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8, archive_read_data(a, buff, 10));
assertEqualMem(buff, "12345678", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(819200, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_data_skip(a));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Verify some of the error handling.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_filename(a, "nonexistent.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
void TarUtils::write(std::ostream &output, const io::ObservedFile &root, const std::set<ObservedFile> &files_to_send)
{
bool processed = false;
//create new archive, set format to tar, use callbacks (above this method)
struct archive *a;
a = archive_write_new();
archive_write_set_format_ustar(a);
archive_write_open(a, &output, &__tar_utils_open_callback, &__tar_utils_write_callback, &__tar_utils_close_callback);
for(std::set<ObservedFile>::const_iterator of_iter = files_to_send.begin(); of_iter != files_to_send.end(); ++of_iter)
{
const ObservedFile &of = (*of_iter);
const ibrcommon::File &file = of.getFile();
struct archive_entry *entry;
entry = archive_entry_new();
archive_entry_set_size(entry, file.size());
if(file.isDirectory())
{
archive_entry_set_filetype(entry, AE_IFDIR);
archive_entry_set_perm(entry, 0755);
}
else
{
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
}
archive_entry_set_pathname(entry, rel_filename(root, of).c_str());
//set timestamps
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec); //accesstime
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec); //creationtime
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec); //time, inode changed
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec); //modification time
archive_write_header(a, entry);
try {
#ifdef HAVE_LIBTFFS
//read file on vfat-image
try {
const FATFile &ffile = dynamic_cast<const FATFile&>(file);
processed = true;
// get image reader
const FatImageReader &reader = ffile.getReader();
// open fat file
io::FatImageReader::FileHandle fh = reader.open(ffile);
char buff[BUFF_SIZE];
ssize_t ret = 0;
size_t len = 0;
// read file
len = fh.read((unsigned char*)&buff, BUFF_SIZE);
//write buffer to archive
while (len > 0)
{
if( (ret = archive_write_data(a, buff, len)) < 0)
{
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive_write_data failed" << IBRCOMMON_LOGGER_ENDL;
break;
}
// read next chunk
len = fh.read((unsigned char*)&buff, BUFF_SIZE);
}
} catch (const std::bad_cast&) { };
#endif
if (!processed)
{
char buff[BUFF_SIZE];
ssize_t ret = 0;
// open file for reading
std::ifstream fs(file.getPath().c_str());
// write buffer to archive
while (fs.good())
{
// read bytes
fs.read(buff, BUFF_SIZE);
// write bytes to archive
if( (ret = archive_write_data(a, buff, fs.gcount())) < 0)
{
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive write failed" << IBRCOMMON_LOGGER_ENDL;
break;
}
}
}
} catch (const ibrcommon::IOException &e) {
// write failed
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive write failed: " << e.what() << IBRCOMMON_LOGGER_ENDL;
archive_entry_free(entry);
archive_write_close(a);
archive_write_free(a);
throw;
}
archive_entry_free(entry);
}
archive_write_close(a);
archive_write_free(a);
}
int archive_extract_tar_bzip2(void) {
struct archive *a;
struct archive *ext;
int r = 0;
int flags = 0;
int error = 0;
a = archive_read_new();
archive_read_support_format_tar(a);
archive_read_support_compression_bzip2(a);
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
if ((r = archive_read_open_file(a, NULL, 10240))) {
fprintf(stderr, "archiving: %s", archive_error_string(a));
error = r;
}
else {
for (;;) {
struct archive_entry *entry;
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF) { break; }
if (r != ARCHIVE_OK) {
fprintf(stderr, "archiving: %s", archive_error_string(a));
error = 1;
break;
}
if (archive_write_header(ext, entry) != ARCHIVE_OK) {
fprintf(stderr, "archiving: %s", archive_error_string(ext));
}
else {
const void *buff;
size_t size;
off_t offset;
for (;;) {
r = archive_read_data_block(a, &buff, &size, &offset);
if (r == ARCHIVE_EOF) { r = ARCHIVE_OK; break; }
if (r != ARCHIVE_OK) {
fprintf(stderr, "archiving: %s", archive_error_string(ext));
break;
}
r = archive_write_data_block(ext, buff, size, offset);
if (r != ARCHIVE_OK) {
fprintf(stderr, "archiving: %s", archive_error_string(ext));
break;
}
}
if (r != ARCHIVE_OK) {
error = 1;
break;
}
r = archive_write_finish_entry(ext);
if (r != ARCHIVE_OK) {
fprintf(stderr, "archiving: %s", archive_error_string(ext));
error = 1;
break;
}
}
}
}
archive_read_close(a);
archive_read_finish(a);
return error;
}
static void
test_filter_by_name(const char *filter_name, int filter_code,
int (*can_filter_prog)(void))
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = 1024 * 128;
char *buff;
int r;
assert((buff = malloc(buffsize)) != NULL);
if (buff == NULL)
return;
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
r = archive_write_add_filter_by_name(a, filter_name);
if (r == ARCHIVE_WARN) {
if (!can_filter_prog()) {
skipping("%s filter not suported on this platform",
filter_name);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
} else if (r == ARCHIVE_FATAL &&
(strcmp(archive_error_string(a),
"lzma compression not supported on this platform") == 0 ||
strcmp(archive_error_string(a),
"xz compression not supported on this platform") == 0)) {
skipping("%s filter not suported on this platform", filter_name);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
} else {
if (!assertEqualIntA(a, ARCHIVE_OK, r)) {
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_bytes_per_block(a, 10));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
assertEqualInt(1, archive_entry_mtime(ae));
archive_entry_set_ctime(ae, 1, 0);
assertEqualInt(1, archive_entry_ctime(ae));
archive_entry_set_atime(ae, 1, 0);
assertEqualInt(1, archive_entry_atime(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertEqualInt(0, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualInt(8, archive_write_data(a, "12345678", 8));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
/*
* Read and verify the file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(8, archive_entry_size(ae));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, filter_code, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
static void
test_filename(const char *prefix, int dlen, int flen)
{
char buff[8192];
char filename[400];
char dirname[400];
struct archive_entry *ae;
struct archive *a;
size_t used;
char *p;
int i;
p = filename;
if (prefix) {
strcpy(filename, prefix);
p += strlen(p);
}
if (dlen > 0) {
for (i = 0; i < dlen; i++)
*p++ = 'a';
*p++ = '/';
}
for (i = 0; i < flen; i++)
*p++ = 'b';
*p = '\0';
strcpy(dirname, filename);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_pax_restricted(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_set_bytes_per_block(a,0));
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, filename);
archive_entry_set_mode(ae, S_IFREG | 0755);
failure("Pathname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/*
* Write a dir to it (without trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("Dirname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/* Tar adds a '/' to directory names. */
strcat(dirname, "/");
/*
* Write a dir to it (with trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("Dirname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
/* Read the file and check the filename. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString(filename, archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
/*
* Read the two dirs and check the names.
*
* Both dirs should read back with the same name, since
* tar should add a trailing '/' to any dir that doesn't
* already have one. We only report the first such failure
* here.
*/
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString(dirname, archive_entry_pathname(ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString(dirname, archive_entry_pathname(ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
/* Verify the end of the archive. */
assert(1 == archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
RESULTCODE ArchiveProcessorImpl::Compress()
{
const char* tpath = GetArchivePath();
if(tpath==NULL)
{
return AG_FAILURE;
}
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[AUGE_BUFFER_MAX];
int len;
int fd;
a = archive_write_new();
if(a==NULL)
{
return AG_FAILURE;
}
//archive_write_add_filter_gzip(a);
archive_write_set_format_zip(a);
archive_write_set_format_pax_restricted(a);
archive_write_open_filename(a,tpath);
const char* fpath = NULL;
char name[AUGE_NAME_MAX];
char ext[AUGE_EXT_MAX];
char fname[AUGE_NAME_MAX];
std::vector<std::string>::iterator iter;
for(iter=m_paths.begin(); iter!=m_paths.end();iter++)
{
fpath = (*iter).c_str();
memset(fname,0,AUGE_NAME_MAX);
memset(name,0,AUGE_NAME_MAX);
memset(name,0,AUGE_EXT_MAX);
auge_split_path(fpath, NULL, NULL, name, ext);
auge_make_path(fname, NULL, NULL, name, ext);
if(strlen(fname)==0)
{
continue;
}
stat(fpath,&st);
entry = archive_entry_new();
archive_entry_set_pathname(entry,fname);
archive_entry_set_size(entry,st.st_size);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry,0644);
archive_write_header(a,entry);
fd = open(fpath,O_RDONLY);
len = read(fd,buff,sizeof(buff));
while(len>0)
{
archive_write_data(a,buff, len);
len = read(fd,buff,sizeof(buff));
}
close(fd);
archive_entry_free(entry);
}
archive_write_close(a);
archive_write_free(a);
return AG_SUCCESS;
}
static void
create(const char *filename, int compress, const char **argv)
{
struct archive *a;
struct archive *disk;
struct archive_entry *entry;
ssize_t len;
int fd;
a = archive_write_new();
switch (compress) {
#ifndef NO_BZIP2_CREATE
case 'j': case 'y':
archive_write_add_filter_bzip2(a);
break;
#endif
#ifndef NO_COMPRESS_CREATE
case 'Z':
archive_write_add_filter_compress(a);
break;
#endif
#ifndef NO_GZIP_CREATE
case 'z':
archive_write_add_filter_gzip(a);
break;
#endif
default:
archive_write_add_filter_none(a);
break;
}
archive_write_set_format_ustar(a);
if (filename != NULL && strcmp(filename, "-") == 0)
filename = NULL;
archive_write_open_filename(a, filename);
disk = archive_read_disk_new();
#ifndef NO_LOOKUP
archive_read_disk_set_standard_lookup(disk);
#endif
while (*argv != NULL) {
struct archive *disk = archive_read_disk_new();
int r;
r = archive_read_disk_open(disk, *argv);
if (r != ARCHIVE_OK) {
errmsg(archive_error_string(disk));
errmsg("\n");
exit(1);
}
for (;;) {
int needcr = 0;
entry = archive_entry_new();
r = archive_read_next_header2(disk, entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
errmsg(archive_error_string(disk));
errmsg("\n");
exit(1);
}
archive_read_disk_descend(disk);
if (verbose) {
msg("a ");
msg(archive_entry_pathname(entry));
needcr = 1;
}
r = archive_write_header(a, entry);
if (r < ARCHIVE_OK) {
errmsg(": ");
errmsg(archive_error_string(a));
needcr = 1;
}
if (r == ARCHIVE_FATAL)
exit(1);
if (r > ARCHIVE_FAILED) {
#if 0
/* Ideally, we would be able to use
* the same code to copy a body from
* an archive_read_disk to an
* archive_write that we use for
* copying data from an archive_read
* to an archive_write_disk.
* Unfortunately, this doesn't quite
* work yet. */
copy_data(disk, a);
#else
/* For now, we use a simpler loop to copy data
* into the target archive. */
fd = open(archive_entry_sourcepath(entry), O_RDONLY);
len = read(fd, buff, sizeof(buff));
while (len > 0) {
archive_write_data(a, buff, len);
len = read(fd, buff, sizeof(buff));
}
close(fd);
#endif
}
archive_entry_free(entry);
if (needcr)
msg("\n");
}
archive_read_close(disk);
archive_read_free(disk);
argv++;
}
archive_write_close(a);
archive_write_free(a);
}
static void
mode_in(struct cpio *cpio)
{
struct archive *a;
struct archive_entry *entry;
struct archive *ext;
const char *destpath;
int r;
ext = archive_write_disk_new();
if (ext == NULL)
lafe_errc(1, 0, "Couldn't allocate restore object");
r = archive_write_disk_set_options(ext, cpio->extract_flags);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
a = archive_read_new();
if (a == NULL)
lafe_errc(1, 0, "Couldn't allocate archive object");
archive_read_support_compression_all(a);
archive_read_support_format_all(a);
if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block))
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
if (lafe_excluded(cpio->matching, archive_entry_pathname(entry)))
continue;
if (cpio->option_rename) {
destpath = cpio_rename(archive_entry_pathname(entry));
archive_entry_set_pathname(entry, destpath);
} else
destpath = archive_entry_pathname(entry);
if (destpath == NULL)
continue;
if (cpio->verbose)
fprintf(stdout, "%s\n", destpath);
if (cpio->uid_override >= 0)
archive_entry_set_uid(entry, cpio->uid_override);
if (cpio->gid_override >= 0)
archive_entry_set_gid(entry, cpio->gid_override);
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK) {
fprintf(stderr, "%s: %s\n",
archive_entry_pathname(entry),
archive_error_string(ext));
} else if (archive_entry_size(entry) > 0) {
r = extract_data(a, ext);
if (r != ARCHIVE_OK)
cpio->return_value = 1;
}
}
r = archive_read_close(a);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(a));
r = archive_write_close(ext);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
if (!cpio->quiet) {
int64_t blocks = (archive_position_uncompressed(a) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_read_finish(a);
archive_write_finish(ext);
exit(cpio->return_value);
}
int powaur_backup(alpm_list_t *targets)
{
int ret = 0;
char localdb[PATH_MAX];
struct archive *a;
struct archive_entry *entry;
struct stat st;
char cwd[PATH_MAX];
char backup_dest[PATH_MAX];
char backup[MINI_BUFSZ];
time_t time_now;
struct tm tm_st;
if (targets != NULL && alpm_list_count(targets) != 1) {
pw_fprintf(PW_LOG_ERROR, stderr, "-B only takes 1 argument.\n");
return -1;
}
a = archive_write_new();
if (!a) {
return error(PW_ERR_ARCHIVE_CREATE);
}
archive_write_set_compression_bzip2(a);
archive_write_set_format_pax_restricted(a);
/* Filename = pacman-YYYY-MM-DD_HHhMM.tar.bz2 */
time(&time_now);
localtime_r(&time_now, &tm_st);
strftime(backup, MINI_BUFSZ, "pacman-%Y-%m-%d_%Hh%M.tar.bz2", &tm_st);
if (!getcwd(cwd, PATH_MAX)) {
error(PW_ERR_GETCWD);
ret = -1;
goto cleanup;
}
/* Get full path */
if (targets) {
snprintf(backup_dest, PATH_MAX, "%s/%s", targets->data, backup);
} else {
snprintf(backup_dest, PATH_MAX, "%s/%s", cwd, backup);
}
if (archive_write_open_filename(a, backup_dest) != ARCHIVE_OK) {
PW_SETERRNO(PW_ERR_ARCHIVE_OPEN);
ret = -1;
goto cleanup;
}
if (ret = chdir(pacman_dbpath)) {
error(PW_ERR_CHDIR, pacman_dbpath);
goto restore_cwd;
}
/* Create entry for the current directory. */
entry = archive_entry_new();
if (!entry) {
error(PW_ERR_ARCHIVE_ENTRY);
goto restore_cwd;
}
snprintf(localdb, PATH_MAX, "%s", "local");
if (ret = stat(localdb, &st)) {
error(PW_ERR_STAT, localdb);
goto free_entry;
}
archive_entry_set_pathname(entry, localdb);
archive_entry_copy_stat(entry, &st);
archive_write_header(a, entry);
pw_printf(PW_LOG_INFO, "Saving pacman database in %s\n", backup_dest);
ret = write_dir_archive(localdb, a);
if (!ret) {
pw_printf(PW_LOG_INFO, "Pacman database successfully saved in %s\n",
backup_dest);
} else {
pw_fprintf(PW_LOG_ERROR, stderr, "Pacman database not saved.\n");
}
free_entry:
archive_entry_free(entry);
restore_cwd:
if (chdir(cwd)) {
PW_SETERRNO(PW_ERR_RESTORECWD);
ret = -1;
}
cleanup:
archive_write_finish(a);
return ret;
}
