int StudioFrame::CreateZip(std::string zfile, std::vector<std::string> files) {
struct archive *zip;
zip = archive_write_new();
if (zip == NULL) {
wxMessageBox(_("archive_write_new error"));
return -1;
}
archive_write_set_format_zip(zip);
// archive_write_zip_set_compression_store(zip);
archive_write_open_filename(zip, zfile.c_str());
if (WriteDefsToZip(zip)) {
archive_write_close(zip);
archive_write_finish(zip);
return -1;
}
for (size_t i=0; i<files.size(); i++) {
if (WriteFileToZip(zip, files[i])) {
archive_write_close(zip);
archive_write_finish(zip);
return -1;
}
}
archive_write_close(zip);
archive_write_finish(zip);
return 0;
}
static void create_reg_file4(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
/* Leave the size unset. The data should not be truncated. */
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(ARCHIVE_OK,
archive_write_data_block(ad, data, sizeof(data), 0));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(ad);
#else
assertEqualInt(0, archive_write_finish(ad));
#endif
/* Test the entry on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
#if !defined(_WIN32) || defined(__CYGWIN__)
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
#endif
failure(msg);
assertEqualInt(st.st_size, sizeof(data));
}
static void create_reg_file3(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
/* Set the size smaller than the data and verify the truncation. */
archive_entry_set_size(ae, 5);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(5, archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(ad);
#else
assertEqualInt(0, archive_write_finish(ad));
#endif
/* Test the entry on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
#if !defined(_WIN32) || defined(__CYGWIN__)
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
#endif
assertEqualInt(st.st_size, 5);
}
static void create(struct archive_entry *ae, const char *msg)
{
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
/* When verifying a dir, ignore the S_ISGID bit, as some systems set
* that automatically. */
if (archive_entry_filetype(ae) == AE_IFDIR)
st.st_mode &= ~S_ISGID;
assertEqualInt(st.st_mode, archive_entry_mode(ae) & ~UMASK);
}
/*
* memory to file
*/
int archive_extract_file3( void *arch_buff, size_t arch_size, const char *src, char *dest )
{
int flags;
const char *filename;
struct archive *arch_r = NULL, *arch_w = NULL;
struct archive_entry *entry;
if( !src || !dest )
return -1;
arch_r = archive_read_new();
archive_read_support_format_all( arch_r );
archive_read_support_compression_all( arch_r );
if( archive_read_open_memory( arch_r, arch_buff, arch_size ) != ARCHIVE_OK )
goto errout;
while( archive_read_next_header( arch_r, &entry ) == ARCHIVE_OK )
{
filename = archive_entry_pathname( entry );
if( fnmatch( src, filename, FNM_PATHNAME | FNM_PERIOD ) )
{
if( archive_read_data_skip( arch_r ) != ARCHIVE_OK )
{
goto errout;
}
}
else
{
#ifdef DEBUG
printf("extract:%s\n", filename );
#endif
flags = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS;
arch_w = archive_write_disk_new();
archive_write_disk_set_options( arch_w, flags );
archive_write_disk_set_standard_lookup( arch_w );
archive_entry_set_pathname( entry, dest );
if( archive_read_extract2( arch_r, entry, arch_w ) != ARCHIVE_OK )
goto errout;
archive_write_finish( arch_w );
}
}
archive_read_finish( arch_r );
return 0;
errout:
#ifdef DEBUG
fprintf( stderr, "%s\n", archive_error_string( arch_r ) );
#endif
if( arch_r )
archive_read_finish( arch_r );
if( arch_w )
archive_write_finish( arch_w );
return -1;
}
int
packing_init(struct packing **pack, const char *path, pkg_formats format)
{
char archive_path[MAXPATHLEN];
const char *ext;
assert(pack != NULL);
if ((*pack = calloc(1, sizeof(struct packing))) == NULL) {
pkg_emit_errno("malloc", "packing");
return (EPKG_FATAL);
}
(*pack)->aread = archive_read_disk_new();
archive_read_disk_set_standard_lookup((*pack)->aread);
archive_read_disk_set_symlink_physical((*pack)->aread);
if (!is_dir(path)) {
(*pack)->awrite = archive_write_new();
archive_write_set_format_pax_restricted((*pack)->awrite);
ext = packing_set_format((*pack)->awrite, format);
if (ext == NULL) {
archive_read_finish((*pack)->aread);
archive_write_finish((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL; /* error set by _set_format() */
}
snprintf(archive_path, sizeof(archive_path), "%s.%s", path,
ext);
if (archive_write_open_filename(
(*pack)->awrite, archive_path) != ARCHIVE_OK) {
pkg_emit_errno("archive_write_open_filename",
archive_path);
archive_read_finish((*pack)->aread);
archive_write_finish((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL;
}
} else { /* pass mode directly write to the disk */
(*pack)->awrite = archive_write_disk_new();
archive_write_disk_set_options((*pack)->awrite,
EXTRACT_ARCHIVE_FLAGS);
}
(*pack)->resolver = archive_entry_linkresolver_new();
archive_entry_linkresolver_set_strategy((*pack)->resolver,
ARCHIVE_FORMAT_TAR_PAX_RESTRICTED);
return (EPKG_OK);
}
void
write_archive(const char *outname, const char **filename)
{
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[8192];
int len;
FILE* fd;
a = archive_write_new();
//archive_write_add_filter_gzip(a);
//archive_write_set_format_pax_restricted(a); // Note 1
archive_write_set_format_zip(a);
//archive_write_add_filter_none(a);
archive_write_open_filename(a, outname);
while (*filename) {
stat(*filename, &st);
entry = archive_entry_new(); // Note 2
myarch_set_entry( *filename, st.st_size, entry);
archive_write_header(a, entry);
fd = fopen(*filename, "rb");
printf("Read File %s return fd %p\n", *filename, fd);
while ((len = fread(buff, 1, sizeof(buff), fd)) > 0) {
printf(" len %d\n", len);
archive_write_data(a, buff, len);
}
fclose(fd);
archive_entry_free(entry);
filename++;
}
archive_write_close(a); // Note 4
archive_write_finish(a); // Note 5
}
void write_archive(const char *outname, const char **filename)
{
struct mydata *mydata = malloc(sizeof(struct mydata));
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[8192];
int len;
int fd;
a = archive_write_new();
mydata->name = outname;
archive_write_set_compression_gzip(a);
archive_write_set_format_ustar(a);
archive_write_open(a, mydata, myopen, mywrite, myclose);
while (*filename) {
stat(*filename, &st);
entry = archive_entry_new();
archive_entry_copy_stat(entry, &st);
archive_entry_set_pathname(entry, *filename);
archive_entry_set_size(entry, st.st_size);
archive_clear_error(a);
archive_write_header(a, entry);
fd = open(*filename, O_RDONLY);
len = read(fd, buff, sizeof(buff));
while ( len > 0 ) {
archive_write_data(a, buff, len);
len = read(fd, buff, sizeof(buff));
}
archive_entry_free(entry);
filename++;
}
archive_write_finish(a);
}
static void create_reg_file2(struct archive_entry *ae, const char *msg)
{
const int datasize = 100000;
char *data;
struct archive *ad;
int i;
data = malloc(datasize);
for (i = 0; i < datasize; i++)
data[i] = (char)(i % 256);
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
/*
* See above for an explanation why this next call
* is necessary.
*/
archive_entry_set_size(ae, datasize);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
for (i = 0; i < datasize - 999; i += 1000) {
assertEqualIntA(ad, ARCHIVE_OK,
archive_write_data_block(ad, data + i, 1000, i));
}
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
assertEqualInt(0, archive_write_finish(ad));
/* Test the entries on disk. */
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
assertFileSize(archive_entry_pathname(ae), i);
assertFileContents(data, datasize, archive_entry_pathname(ae));
free(data);
}
static void create_reg_file2(struct archive_entry *ae, const char *msg)
{
const int datasize = 100000;
char *data;
char *compare;
struct archive *ad;
struct stat st;
int i, fd;
data = malloc(datasize);
for (i = 0; i < datasize; i++)
data[i] = (char)(i % 256);
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
/*
* See above for an explanation why this next call
* is necessary.
*/
archive_entry_set_size(ae, datasize);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
for (i = 0; i < datasize - 999; i += 1000) {
assertEqualIntA(ad, ARCHIVE_OK,
archive_write_data_block(ad, data + i, 1000, i));
}
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
assertEqualInt(st.st_size, i);
compare = malloc(datasize);
fd = open(archive_entry_pathname(ae), O_RDONLY);
assertEqualInt(datasize, read(fd, compare, datasize));
close(fd);
assert(memcmp(compare, data, datasize) == 0);
free(compare);
free(data);
}
int extract_archive(const char* filename, const char* to_path) {
struct archive* a;
struct archive* ext;
struct archive_entry* entry;
int r;
int flags = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS;
a = archive_read_new();
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
archive_read_support_format_all(a);
archive_read_support_compression_all(a);
if(filename != NULL && strcmp(filename, "-") == 0) {
filename = NULL;
}
if((r = archive_read_open_file(a, filename, 10240))) {
printf("archive_read_open_file(): %s\n", archive_error_string(a));
return r;
}
for(;;) {
r = archive_read_next_header(a, &entry);
if(r == ARCHIVE_EOF) {
break;
}
if(r != ARCHIVE_OK) {
printf("archive_read_next_header(): %s\n", archive_error_string(a));
return 0;
}
// rewrite pathname
const char* path = archive_entry_pathname(entry);
char new_path[PATH_MAX + 1];
sprintf(new_path, "%s/%s", to_path, path + (strncmp(path, "rootfs/", 7) == 0 ? 7 : 0));
archive_entry_set_pathname(entry, new_path);
r = archive_write_header(ext, entry);
if(r != ARCHIVE_OK) {
printf("archive_write_header(): %s\n", archive_error_string(ext));
} else {
copy_data(a, ext);
if(r != ARCHIVE_OK) {
printf("archive_write_finish_entry(): %s\n", archive_error_string(ext));
return 0;
}
}
r = archive_write_finish_entry(ext);
}
archive_read_close(a);
archive_read_finish(a);
archive_write_close(ext);
archive_write_finish(ext);
return 1;
}
static void create_reg_file(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
archive_write_disk_set_options(ad, ARCHIVE_EXTRACT_TIME);
failure("%s", msg);
/*
* A touchy API design issue: archive_write_data() does (as of
* 2.4.12) enforce the entry size as a limit on the data
* written to the file. This was not enforced prior to
* 2.4.12. The change was prompted by the refined
* hardlink-restore semantics introduced at that time. In
* short, libarchive needs to know whether a "hardlink entry"
* is going to overwrite the contents so that it can know
* whether or not to open the file for writing. This implies
* that there is a fundamental semantic difference between an
* entry with a zero size and one with a non-zero size in the
* case of hardlinks and treating the hardlink case
* differently from the regular file case is just asking for
* trouble. So, a zero size must always mean that no data
* will be accepted, which is consistent with the file size in
* the entry being a maximum size.
*/
archive_entry_set_size(ae, sizeof(data));
archive_entry_set_mtime(ae, 123456789, 0);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(ad);
#else
assertEqualInt(0, archive_write_finish(ad));
#endif
/* Test the entries on disk. */
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
assertFileSize(archive_entry_pathname(ae), sizeof(data));
/* test_write_disk_times has more detailed tests of this area. */
assertFileMtime(archive_entry_pathname(ae), 123456789, 0);
failure("No atime given, so atime should get set to current time");
assertFileAtimeRecent(archive_entry_pathname(ae));
}
int
repodata_flush(struct xbps_handle *xhp, const char *repodir,
xbps_dictionary_t idx, xbps_dictionary_t idxfiles)
{
struct archive *ar;
mode_t myumask;
char *repofile, *tname, *xml;
int repofd;
/* Create a tempfile for our repository archive */
repofile = xbps_repo_path(xhp, repodir);
tname = xbps_xasprintf("%s.XXXXXXXXXX", repofile);
if ((repofd = mkstemp(tname)) == -1)
return errno;
/* Create and write our repository archive */
ar = archive_write_new();
assert(ar);
archive_write_set_compression_gzip(ar);
archive_write_set_format_pax_restricted(ar);
archive_write_set_options(ar, "compression-level=9");
archive_write_open_fd(ar, repofd);
xml = xbps_dictionary_externalize(idx);
assert(xml);
if (xbps_archive_append_buf(ar, xml, strlen(xml),
XBPS_PKGINDEX, 0644, "root", "root") != 0) {
free(xml);
return -1;
}
free(xml);
xml = xbps_dictionary_externalize(idxfiles);
assert(xml);
if (xbps_archive_append_buf(ar, xml, strlen(xml),
XBPS_PKGINDEX_FILES, 0644, "root", "root") != 0) {
free(xml);
return -1;
}
free(xml);
archive_write_finish(ar);
/* Write data to tempfile and rename */
fdatasync(repofd);
myumask = umask(0);
(void)umask(myumask);
assert(fchmod(repofd, 0666 & ~myumask) != -1);
close(repofd);
rename(tname, repofile);
free(repofile);
free(tname);
return 0;
}
static void create_reg_file(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
/*
* A touchy API design issue: archive_write_data() does (as of
* 2.4.12) enforce the entry size as a limit on the data
* written to the file. This was not enforced prior to
* 2.4.12. The change was prompted by the refined
* hardlink-restore semantics introduced at that time. In
* short, libarchive needs to know whether a "hardlink entry"
* is going to overwrite the contents so that it can know
* whether or not to open the file for writing. This implies
* that there is a fundamental semantic difference between an
* entry with a zero size and one with a non-zero size in the
* case of hardlinks and treating the hardlink case
* differently from the regular file case is just asking for
* trouble. So, a zero size must always mean that no data
* will be accepted, which is consistent with the file size in
* the entry being a maximum size.
*/
archive_entry_set_size(ae, sizeof(data));
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
assertEqualInt(st.st_size, sizeof(data));
}
int
packing_finish(struct packing *pack)
{
archive_entry_free(pack->entry);
archive_read_finish(pack->aread);
archive_write_close(pack->awrite);
archive_write_finish(pack->awrite);
return (EPKG_OK);
}
static void create(struct archive_entry *ae, const char *msg)
{
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
assert(st.st_mode == (archive_entry_mode(ae) & ~UMASK));
}
/*
* Cleanup function for archive_extract.
*/
static int
archive_read_extract_cleanup(struct archive_read *a)
{
int ret = ARCHIVE_OK;
#if ARCHIVE_API_VERSION > 1
ret =
#endif
archive_write_finish(a->extract->ad);
free(a->extract);
a->extract = NULL;
return (ret);
}
static void
mode_pass(struct cpio *cpio, const char *destdir)
{
struct lafe_line_reader *lr;
const char *p;
int r;
/* Ensure target dir has a trailing '/' to simplify path surgery. */
cpio->destdir = malloc(strlen(destdir) + 8);
strcpy(cpio->destdir, destdir);
if (destdir[strlen(destdir) - 1] != '/')
strcat(cpio->destdir, "/");
cpio->archive = archive_write_disk_new();
if (cpio->archive == NULL)
lafe_errc(1, 0, "Failed to allocate archive object");
r = archive_write_disk_set_options(cpio->archive, cpio->extract_flags);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(cpio->archive));
cpio->linkresolver = archive_entry_linkresolver_new();
archive_write_disk_set_standard_lookup(cpio->archive);
cpio->archive_read_disk = archive_read_disk_new();
if (cpio->archive_read_disk == NULL)
lafe_errc(1, 0, "Failed to allocate archive object");
if (cpio->option_follow_links)
archive_read_disk_set_symlink_logical(cpio->archive_read_disk);
else
archive_read_disk_set_symlink_physical(cpio->archive_read_disk);
archive_read_disk_set_standard_lookup(cpio->archive_read_disk);
lr = lafe_line_reader("-", cpio->option_null);
while ((p = lafe_line_reader_next(lr)) != NULL)
file_to_archive(cpio, p);
lafe_line_reader_free(lr);
archive_entry_linkresolver_free(cpio->linkresolver);
r = archive_write_close(cpio->archive);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(cpio->archive));
if (!cpio->quiet) {
int64_t blocks =
(archive_position_uncompressed(cpio->archive) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_write_finish(cpio->archive);
}
int createArchiveofFilesPC(char** files, unsigned long * size,
unsigned int fileCount, const char* filename, const char* tarHostDir) {
unsigned int ctr = 0;
struct timespec ts;
struct archive_entry* entry;
struct archive* archive = archive_write_new();
int dirlen = strlen(tarHostDir);
if ((archive_write_set_compression_gzip(archive) != ARCHIVE_OK)
|| (archive_write_set_format_ustar(archive) != ARCHIVE_OK)
|| (archive_write_open_filename(archive, filename) != ARCHIVE_OK)) {
printf("%s\n", archive_error_string(archive));
return -1;
}
int tarHostDirLen = strlen(tarHostDir);
for (ctr = 0; ctr < fileCount; ctr++) {
entry = archive_entry_new();
clock_gettime(CLOCK_REALTIME, &ts);
//Set entry to be stored under the tarHostDir directory
const char* path = files[ctr];
int pathlength = dirlen + strlen(path) + 2; //One for / and the other for '\0'
char newPath[pathlength];
if(tarHostDirLen>0)
snprintf(newPath, pathlength, "%s/%s", tarHostDir, boost::filesystem::path(path).filename().c_str());
else
snprintf(newPath, pathlength, "%s", boost::filesystem::path(path).filename().c_str());
archive_entry_set_pathname(entry, newPath);
archive_entry_set_size(entry, size[ctr]);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0444);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec);
int rc = archive_write_header(archive, entry);
char *contents = new char[size[ctr]+1];
FILE* fp = fopen(files[ctr],"rb");
fread((void *)contents, size[ctr], 1, fp);
fclose(fp);
archive_write_data(archive, contents, size[ctr]);
archive_entry_free(entry);
entry = NULL;
delete[] contents;
if (ARCHIVE_OK != rc) {
printf("%s\n", archive_error_string(archive));
return -1;
}
}
archive_write_finish(archive);
}
int
packing_finish(struct packing *pack)
{
assert(pack != NULL);
archive_read_finish(pack->aread);
archive_write_close(pack->awrite);
archive_write_finish(pack->awrite);
free(pack);
return (EPKG_OK);
}
static void create_reg_file_win(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
struct stat st;
char *p, *fname;
size_t l;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
archive_write_disk_set_options(ad, ARCHIVE_EXTRACT_TIME);
failure("%s", msg);
archive_entry_set_size(ae, sizeof(data));
archive_entry_set_mtime(ae, 123456789, 0);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(ad);
#else
assertEqualInt(0, archive_write_finish(ad));
#endif
/* Test the entries on disk. */
l = strlen(archive_entry_pathname(ae));
fname = malloc(l + 1);
assert(NULL != fname);
strcpy(fname, archive_entry_pathname(ae));
/* Replace unusable characters in Windows to '_' */
for (p = fname; *p != '\0'; p++)
if (*p == ':' || *p == '*' || *p == '?' ||
*p == '"' || *p == '<' || *p == '>' || *p == '|')
*p = '_';
assert(0 == stat(fname, &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
assertEqualInt(st.st_size, sizeof(data));
}
static void create_reg_file(struct archive_entry *ae, const char *msg)
{
static const char data[]="abcdefghijklmnopqrstuvwxyz";
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
assertEqualInt(st.st_size, sizeof(data));
}
static void
test(int pristine)
{
struct archive* a = archive_write_new();
if (!pristine)
archive_write_set_compression_gzip(a);
should(a, ARCHIVE_OK, NULL, NULL, NULL);
should(a, ARCHIVE_OK, "", "", "");
should(a, ARCHIVE_FAILED, NULL, "fubar", NULL);
should(a, ARCHIVE_FAILED, NULL, "fubar", "snafu");
should(a, ARCHIVE_FAILED, "fubar", "snafu", NULL);
should(a, ARCHIVE_FAILED, "fubar", "snafu", "betcha");
archive_write_finish(a);
}
int archive_create_tar_bzip2(const char **pathnames) {
int error = 0;
struct archive *a = archive_write_new();
archive_write_set_compression_bzip2(a);
archive_write_set_format_ustar(a);
archive_write_open_file(a, NULL);
while (*pathnames) {
append_path_recursively(*pathnames, a);
pathnames++;
}
archive_write_close(a);
archive_write_finish(a);
return error;
}
static void create_archive(const char *filepath, const char *tarfile)
{
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[8192];
int len;
int fd;
char **filenames, **filename;
filenames = list_filenames(filepath);
filename = filenames;
a = archive_write_new();
archive_write_set_compression_bzip2(a);
archive_write_set_format_ustar(a);
archive_write_open_filename(a, tarfile);
while (*filename) {
stat(*filename, &st);
entry = archive_entry_new();
archive_entry_set_pathname(entry, *filename);
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(*filename, 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);
filename++;
}
free_str_array(filenames);
archive_write_close(a);
#if ARCHIVE_VERSION_NUMBER < 4000000
archive_write_finish(a);
#else
archive_write_free(a);
#endif
}
int createArchiveofFiles(char** files, unsigned long * size,
unsigned int fileCount, const char* filename) {
unsigned int ctr = 0;
struct timespec ts;
struct archive_entry* entry;
struct archive* archive = archive_write_new();
if ((archive_write_set_compression_gzip(archive) != ARCHIVE_OK)
|| (archive_write_set_format_ustar(archive) != ARCHIVE_OK)
|| (archive_write_open_filename(archive, filename) != ARCHIVE_OK)) {
printf("%s\n", archive_error_string(archive));
return -1;
}
for (ctr = 0; ctr < fileCount; ctr++) {
entry = archive_entry_new();
clock_gettime(CLOCK_REALTIME, &ts);
archive_entry_set_pathname(entry, files[ctr]);
archive_entry_set_size(entry, size[ctr]);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0444);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec);
int rc = archive_write_header(archive, entry);
char *contents = new char[size[ctr]+1];
FILE* fp = fopen(files[ctr],"rb");
fread((void *)contents, size[ctr], 1, fp);
fclose(fp);
archive_write_data(archive, contents, size[ctr]);
archive_entry_free(entry);
entry = NULL;
delete[] contents;
if (ARCHIVE_OK != rc) {
printf("%s\n", archive_error_string(archive));
return -1;
}
}
archive_write_finish(archive);
}
static void
mode_pass(struct cpio *cpio, const char *destdir)
{
unsigned long blocks;
struct line_reader *lr;
const char *p;
int r;
/* Ensure target dir has a trailing '/' to simplify path surgery. */
cpio->destdir = malloc(strlen(destdir) + 8);
strcpy(cpio->destdir, destdir);
if (destdir[strlen(destdir) - 1] != '/')
strcat(cpio->destdir, "/");
cpio->archive = archive_write_disk_new();
if (cpio->archive == NULL)
cpio_errc(1, 0, "Failed to allocate archive object");
r = archive_write_disk_set_options(cpio->archive, cpio->extract_flags);
if (r != ARCHIVE_OK)
cpio_errc(1, 0, archive_error_string(cpio->archive));
cpio->linkresolver = archive_entry_linkresolver_new();
archive_write_disk_set_standard_lookup(cpio->archive);
lr = process_lines_init("-", cpio->line_separator);
while ((p = process_lines_next(lr)) != NULL)
file_to_archive(cpio, p);
process_lines_free(lr);
archive_entry_linkresolver_free(cpio->linkresolver);
r = archive_write_close(cpio->archive);
if (r != ARCHIVE_OK)
cpio_errc(1, 0, archive_error_string(cpio->archive));
if (!cpio->quiet) {
blocks = (archive_position_uncompressed(cpio->archive) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", blocks,
blocks == 1 ? "block" : "blocks");
}
archive_write_finish(cpio->archive);
}
// This function will create a gzipped tar file (outname)
// which contains the files matched by the function pattern_match.
// Pattern_match should return 0 on no match and 1 on match.
int create_archive(char *outname, char *path,
const std::vector<std::string> &filenames)
{
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[BUFFER_SIZE];
int len;
int fd;
a = archive_write_new();
archive_write_set_compression_gzip(a);
archive_write_set_format_pax_restricted(a);
archive_write_open_filename(a, outname);
for (unsigned int i=0;i<filenames.size();i++) {
stat(filenames[i].c_str(), &st);
entry = archive_entry_new();
archive_entry_set_pathname(entry, filenames[i].c_str());
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(filenames[i].c_str(), 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_write_close(a);
archive_write_finish(a);
return 0;
}
int
packing_init(struct packing **pack, const char *path, pkg_formats format)
{
char archive_path[MAXPATHLEN];
const char *ext;
if ((*pack = calloc(1, sizeof(struct packing))) == NULL) {
pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
strerror(errno));
}
(*pack)->aread = archive_read_disk_new();
archive_read_disk_set_standard_lookup((*pack)->aread);
archive_read_disk_set_symlink_physical((*pack)->aread);
(*pack)->entry = archive_entry_new();
if (!is_dir(path)) {
(*pack)->awrite = archive_write_new();
archive_write_set_format_pax_restricted((*pack)->awrite);
if ((ext = packing_set_format((*pack)->awrite, format)) == NULL) {
archive_read_finish((*pack)->aread);
archive_write_finish((*pack)->awrite);
archive_entry_free((*pack)->entry);
return EPKG_FATAL; /* error set by _set_format() */
}
snprintf(archive_path, sizeof(archive_path), "%s.%s", path, ext);
archive_write_open_filename((*pack)->awrite, archive_path);
} else { /* pass mode directly write to the disk */
(*pack)->awrite = archive_write_disk_new();
archive_write_disk_set_options((*pack)->awrite, EXTRACT_ARCHIVE_FLAGS);
}
return (EPKG_OK);
}
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_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("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. */
assertA(0 == archive_write_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(a);
#else
assertA(0 == archive_write_finish(a));
#endif
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_compression_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));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Leading '/' preserved on long filenames");
#else
assertEqualString(filename, archive_entry_pathname(ae));
#endif
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));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Trailing '/' preserved on dirnames");
#else
assertEqualString(dirname, archive_entry_pathname(ae));
#endif
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
assertA(0 == archive_read_next_header(a, &ae));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Trailing '/' added to dir names");
#else
assertEqualString(dirname, archive_entry_pathname(ae));
#endif
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
/* Verify the end of the archive. */
assert(1 == archive_read_next_header(a, &ae));
assert(0 == archive_read_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
}
