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;
}
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("calloc", "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)->pass = false;
(*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_close((*pack)->aread);
archive_read_free((*pack)->aread);
archive_write_close((*pack)->awrite);
archive_write_free((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL; /* error set by _set_format() */
}
snprintf(archive_path, sizeof(archive_path), "%s.%s", path,
ext);
pkg_debug(1, "Packing to file '%s'", archive_path);
if (archive_write_open_filename(
(*pack)->awrite, archive_path) != ARCHIVE_OK) {
pkg_emit_errno("archive_write_open_filename",
archive_path);
archive_read_close((*pack)->aread);
archive_read_free((*pack)->aread);
archive_write_close((*pack)->awrite);
archive_write_free((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL;
}
} else { /* pass mode directly write to the disk */
pkg_debug(1, "Packing to directory '%s' (pass mode)", path);
(*pack)->pass = true;
(*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);
}
static int ar_write_destroy(lua_State *L) {
struct archive** self_ref = ar_write_check(L, 1);
if ( NULL == *self_ref ) return 0;
// If called in destructor, we were already removed from the weak
// table, so we need to re-register so that the write callback
// will work.
ar_registry_set(L, *self_ref);
if ( ARCHIVE_OK != archive_write_close(*self_ref) ) {
lua_pushfstring(L, "archive_write_close: %s", archive_error_string(*self_ref));
archive_write_free(*self_ref);
__ref_count--;
*self_ref = NULL;
lua_error(L);
}
ar_write_get_writer(L, 1); // {self}, writer
if ( ! lua_isnil(L, -1) ) {
lua_pushvalue(L, 1); // {self}, writer, {self}
lua_pushnil(L); // {self}, writer, {self}, nil
lua_call(L, 2, 1); // {self}, result
}
if ( ARCHIVE_OK != archive_write_free(*self_ref) ) {
luaL_error(L, "archive_write_free: %s", archive_error_string(*self_ref));
}
__ref_count--;
*self_ref = NULL;
return 0;
}
void write_archive(const char *outname, const char **filename)
{
struct archive *a;
struct archive_entry *entry;
struct stat st;
char buff[8192];
int len;
int fd;
a = archive_write_new();
archive_write_set_compression_gzip(a);
archive_write_set_format_pax_restricted(a); // Note 1
archive_write_open_filename(a, outname, 10240);
while (*filename) {
stat(*filename, &st);
entry = archive_entry_new(); // Note 2
archive_entry_set_pathname(entry, *filename);
archive_entry_set_size(entry, st.st_size); // Note 3
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++;
}
archive_write_close(a); // Note 4
archive_write_free(a); // Note 5
}
void emd_ruby_uncompress_cleanup(struct archive *input_archive, struct archive *output_archive)
{
archive_read_close(input_archive);
archive_read_free(input_archive);
archive_write_close(output_archive);
archive_write_free(output_archive);
}
int Tarball::install () {
archive_entry *entry;
int r;
archive* a = archive_read_new();
archive_read_support_format_all(a);
archive_read_support_filter_all(a);
archive* ext = archive_write_disk_new();
const 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);
const std::string subdir = "deps";
const std::string filename = subdir + "/" + basename(this->location);
printf("Unpacking archive %s\n", filename.c_str());
if ((r = archive_read_open_filename(a,filename.c_str(), 10240))) {
fprintf(stderr, "Error opening archive:\n%s\n", archive_error_string(a));
return -1;
}
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) {
return -1;
}
rewrite_subdir(entry, subdir);
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) {
return -1;
}
}
r = archive_write_finish_entry(ext);
if (r < ARCHIVE_OK) {
fprintf(stderr, "%s\n", archive_error_string(ext));
}
if (r < ARCHIVE_WARN) {
return -1;
}
}
archive_read_close(a);
archive_read_free(a);
archive_write_close(ext);
archive_write_free(ext);
return 0;
};
/*
* Destroy the archive structure.
*
* Be careful: user might just call write_new and then write_free.
* Don't assume we actually wrote anything or performed any non-trivial
* initialization.
*/
static int
_archive_write_free(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r = ARCHIVE_OK, r1;
if (_a == NULL)
return (ARCHIVE_OK);
/* It is okay to call free() in state FATAL. */
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_free");
if (a->archive.state != ARCHIVE_STATE_FATAL)
r = archive_write_close(&a->archive);
/* Release format resources. */
if (a->format_free != NULL) {
r1 = (a->format_free)(a);
if (r1 < r)
r = r1;
}
__archive_write_filters_free(_a);
/* Release various dynamic buffers. */
free((void *)(uintptr_t)(const void *)a->nulls);
archive_string_free(&a->archive.error_string);
a->archive.magic = 0;
__archive_clean(&a->archive);
free(a);
return (r);
}
// Based on libarchive's public example code.
// https://github.com/libarchive/libarchive/wiki/Examples#wiki-A_Basic_Write_Example
void GuiZipper::packageFiles(const char *outputFile, const char *baseDir,
char **filenames, int numFiles, bool binary, const char *absMetaFilename,
const char *metaFilename) throw (ZipperException*) {
int r;
struct archive *a = archive_write_new();
r = archive_write_add_filter_gzip(a);
checkForErrors("Error adding filter gzip", a, r);
r = archive_write_set_format_pax_restricted(a);
checkForErrors("Error setting format pax restricted", a, r);
r = archive_write_open_filename(a, outputFile);
checkForErrors("Error opening file", a, r);
packageSingleFile(absMetaFilename, metaFilename, a, false);
for (int x = 0; x < numFiles; x++) {
char *filename = filenames[x];
char *filePath = fileManager_->getFilePath(baseDir, filename);
try {
packageSingleFile(filePath, filename, a, binary);
} catch (ZipperException *ze) {
delete filePath;
throw ze;
}
delete filePath;
}
r = archive_write_close(a);
checkForErrors("Error writing close", a, r);
r = archive_write_free(a);
checkForErrors("Error writing free", a, r);
}
int write_archive_from_mem(char *outname, MagickWand *wand)
{
int archiveSize = 0;
int pageNumber = 1;
struct archive *a;
struct archive_entry *entry;
a = archive_write_new();
archive_write_set_format_ustar(a);
archive_write_open_filename(a, outname);
char filename[13];
MagickResetIterator(wand);
MagickNextImage(wand); // Has to be called after MagickResetIterator to set the first picture as the current
do {
unsigned char *data;
size_t size;
data = MagickWriteImageBlob(wand, &size);
entry = archive_entry_new();
snprintf(filename, 13, "page_%d", pageNumber++);
archive_entry_set_pathname(entry, filename);
archive_entry_set_size(entry, size);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
archive_write_header(a, entry);
archiveSize += archive_write_data(a, data, size);
archive_entry_free(entry);
} while (MagickNextImage(wand));
archive_write_close(a);
archive_write_free(a);
return archiveSize;
}
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
}
int
packing_init(struct packing **pack, const char *path, pkg_formats format)
{
char archive_path[MAXPATHLEN];
const char *ext;
assert(pack != NULL);
*pack = xcalloc(1, sizeof(struct packing));
(*pack)->aread = archive_read_disk_new();
archive_read_disk_set_standard_lookup((*pack)->aread);
archive_read_disk_set_symlink_physical((*pack)->aread);
(*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_close((*pack)->aread);
archive_read_free((*pack)->aread);
archive_write_close((*pack)->awrite);
archive_write_free((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL; /* error set by _set_format() */
}
snprintf(archive_path, sizeof(archive_path), "%s.%s", path,
ext);
pkg_debug(1, "Packing to file '%s'", archive_path);
if (archive_write_open_filename(
(*pack)->awrite, archive_path) != ARCHIVE_OK) {
pkg_emit_errno("archive_write_open_filename",
archive_path);
archive_read_close((*pack)->aread);
archive_read_free((*pack)->aread);
archive_write_close((*pack)->awrite);
archive_write_free((*pack)->awrite);
*pack = NULL;
return EPKG_FATAL;
}
(*pack)->resolver = archive_entry_linkresolver_new();
archive_entry_linkresolver_set_strategy((*pack)->resolver,
archive_format((*pack)->awrite));
return (EPKG_OK);
}
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 db_writer_close(db_writer_t *writer)
{
archive_write_close(writer->archive);
buffer_free(&writer->buf);
archive_entry_free(writer->entry);
archive_write_free(writer->archive);
close(writer->fd);
free(writer);
}
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
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 (cpio->dot)
fprintf(stderr, "\n");
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(cpio->archive));
if (!cpio->quiet) {
int64_t blocks =
(archive_filter_bytes(cpio->archive, 0) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_write_free(cpio->archive);
}
void MemoryWriteArchive::writeArchive()
{
std::vector<StreamSPtr>::iterator it;
for (it = m_sinks.begin(); it != m_sinks.end(); ++it)
{
it->get()->flush();
it->get()->component()->archive();
}
archive_write_close(m_archive);
archive_write_free(m_archive);
}
// Based on libarchive's public example code.
// https://github.com/libarchive/libarchive/wiki/Examples#wiki-Constructing_Objects_On_Disk
void GuiZipper::unpackFile(const char *zipFile, const char *outputDir)
throw (ZipperException*) {
// TODO: use archive_write_disk_open instead (if/when it exists)
char cwd[4096];
getcwd(cwd, 4096);
char *absZipFile = fileManager_->getAbsFilePath(zipFile);
platformstl::filesystem_traits<char> traits;
traits.set_current_directory(outputDir);
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_tar(a);
archive_read_support_filter_gzip(a);
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
r = archive_read_open_filename(a, absZipFile, 10240);
checkForErrors("Error opening archive for reading", a, r);
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF) {
break;
}
checkForErrors("Error reading next archive header", a, r);
r = archive_write_header(ext, entry);
checkForErrors("Error writing next archive header", a, r);
copyData(a, ext, outputDir);
r = archive_write_finish_entry(ext);
checkForErrors("Error writing archive finish entry", a, r);
}
r = archive_read_close(a);
checkForErrors("Error closing read archive", a, r);
r = archive_read_free(a);
checkForErrors("Error freeing read archive", a, r);
r = archive_write_close(ext);
checkForErrors("Error closing write archive", a, r);
r = archive_write_free(ext);
checkForErrors("Error freeing write archive", a, r);
traits.set_current_directory(cwd);
delete absZipFile;
}
static gboolean
asb_utils_write_archive (const gchar *filename,
const gchar *path_orig,
GPtrArray *files,
GError **error)
{
const gchar *tmp;
gboolean ret = TRUE;
gsize len;
guint i;
struct archive *a;
struct archive_entry *entry;
struct stat st;
a = archive_write_new ();
if (g_str_has_suffix (filename, ".gz")) {
archive_write_add_filter_gzip (a);
archive_write_set_filter_option (a, "gzip", "timestamp", NULL);
}
if (g_str_has_suffix (filename, ".bz2"))
archive_write_add_filter_bzip2 (a);
if (g_str_has_suffix (filename, ".xz"))
archive_write_add_filter_xz (a);
archive_write_set_format_pax_restricted (a);
archive_write_open_filename (a, filename);
for (i = 0; i < files->len; i++) {
g_autofree gchar *data = NULL;
g_autofree gchar *filename_full = NULL;
tmp = g_ptr_array_index (files, i);
filename_full = g_build_filename (path_orig, tmp, NULL);
if (stat (filename_full, &st) != 0)
continue;
entry = archive_entry_new ();
archive_entry_set_pathname (entry, tmp);
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);
ret = g_file_get_contents (filename_full, &data, &len, error);
if (!ret) {
archive_entry_free (entry);
break;
}
archive_write_data (a, data, len);
archive_entry_free (entry);
}
archive_write_close (a);
archive_write_free (a);
return ret;
}
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);
}
void
packing_finish(struct packing *pack)
{
if (pack == NULL)
return;
archive_read_close(pack->aread);
archive_read_free(pack->aread);
archive_write_close(pack->awrite);
archive_write_free(pack->awrite);
free(pack);
}
static void
extract(const char *filename)
{
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int flags;
int r;
flags = ARCHIVE_EXTRACT_OWNER | ARCHIVE_EXTRACT_PERM;
a = archive_read_new();
archive_read_support_format_all(a);
#if ARCHIVE_VERSION_NUMBER < 3000000
archive_read_support_compression_all(a);
#else
archive_read_support_filter_all(a);
#endif
ext = archive_write_disk_new();
archive_write_disk_set_options(ext, flags);
archive_write_disk_set_standard_lookup(ext);
#if ARCHIVE_VERSION_NUMBER < 3000000
if ((r = archive_read_open_file(a, filename, 10240)))
die("archive_read_open_file");
#else
if ((r = archive_read_open_filename(a, filename, 10240)))
die("archive_read_open_filename");
#endif
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r < ARCHIVE_WARN)
die(archive_error_string(a));
r = archive_write_header(ext, entry);
if (r == ARCHIVE_OK && archive_entry_size(entry) > 0) {
r = copy_data(a, ext);
if (r < ARCHIVE_WARN)
die(archive_error_string(a));
}
r = archive_write_finish_entry(ext);
if (r < ARCHIVE_WARN)
die(archive_error_string(ext));
}
archive_read_close(a);
archive_read_free(a);
archive_write_close(ext);
archive_write_free(ext);
}
void write_archive(const char *outname, const char **filename) {
struct archive *a;
a = archive_write_new();
archive_write_set_format_zip(a);
archive_write_open_filename(a, outname);
while(*filename) {
file_to_archive(a, *filename);
filename++;
}
archive_write_close(a);
archive_write_free(a);
}
static void
extract (int fd)
{
struct archive *a;
struct archive *ext;
struct archive_entry *entry;
int r;
a = archive_read_new ();
ext = archive_write_disk_new ();
archive_read_support_format_tar (a);
archive_read_support_filter_xz (a);
archive_read_support_filter_gzip (a);
if ((r = archive_read_open_fd (a, fd, 16*1024)))
die_with_libarchive (a, "archive_read_open_fd: %s");
while (1)
{
r = archive_read_next_header (a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK)
die_with_libarchive (a, "archive_read_next_header: %s");
if (!should_extract (entry))
continue;
r = archive_write_header (ext, entry);
if (r != ARCHIVE_OK)
die_with_libarchive (ext, "archive_write_header: %s");
else
{
copy_archive (a, ext);
r = archive_write_finish_entry (ext);
if (r != ARCHIVE_OK)
die_with_libarchive (ext, "archive_write_finish_entry: %s");
}
}
archive_read_close (a);
archive_read_free (a);
archive_write_close (ext);
archive_write_free (ext);
}
void errorReporterClose(ErrorReporter self) {
#if HAVE_LIBARCHIVE
struct archive* outArchive;
CharString outputFilename = newCharString();
LinkedList reportContents = newLinkedList();
#endif
// Always do this, just in case
flushErrorLog();
#if HAVE_LIBARCHIVE
// In case any part of the error report causes a segfault, this function will
// be called recursively. A mutex would really be a better solution here, but
// this will also work just fine.
if(!self->completed) {
self->completed = true;
buildAbsolutePath(self->desktopPath, self->reportName, "tar.gz", outputFilename);
listDirectory(self->reportDirPath->data, reportContents);
if(self != NULL) {
outArchive = archive_write_new();
archive_write_set_compression_gzip(outArchive);
archive_write_set_format_pax_restricted(outArchive);
archive_write_open_filename(outArchive, outputFilename->data);
linkedListForeach(reportContents, _remapFileToErrorReportRelativePath, self);
chdir(self->desktopPath->data);
linkedListForeach(reportContents, _addFileToArchive, outArchive);
archive_write_close(outArchive);
archive_write_free(outArchive);
}
// Remove original error report
removeDirectory(self->reportDirPath);
}
#endif
printf("\n=== Error report complete ===\n");
printf("Created error report at %s\n", self->reportDirPath->data);
#if HAVE_LIBARCHIVE
printf("Please email the report to: %s\n", SUPPORT_EMAIL);
#else
printf("Please compress and email the report to: %s\n", SUPPORT_EMAIL);
#endif
printf("Thanks!\n");
}
/*
* Destroy the archive structure.
*/
static int
_archive_write_finish(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r = ARCHIVE_OK;
__archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_ANY, "archive_write_finish");
if (a->archive.state != ARCHIVE_STATE_CLOSED)
r = archive_write_close(&a->archive);
/* Release various dynamic buffers. */
free((void *)(uintptr_t)(const void *)a->nulls);
archive_string_free(&a->archive.error_string);
a->archive.magic = 0;
free(a);
return (r);
}
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
}
void Package::pack()
{
struct archive *a;
char buf[8192];
std::string package_base_filename(mManifest.packageName() + "-"
+ std::to_string(mManifest.packageVersion()) + "-"
+ mManifest.targetArch());
std::string tbz2_path = mWorkDir.string() + "/"
+ package_base_filename + ".rps";
a = archive_write_new();
archive_write_add_filter_bzip2(a);
archive_write_set_format_pax_restricted(a);
archive_write_open_filename(a, tbz2_path.c_str());
struct stat st;
struct archive_entry *entry;
for (auto &f: mManifest.files()) {
std::string source = mUnpackedDir.string() + std::string("/data/") + f.name();
std::string dest = std::string("data/") + f.name();
stat(source.c_str(), &st);
entry = archive_entry_new();
archive_entry_set_pathname(entry, dest.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);
int fd = open(source.c_str(), O_RDONLY);
int len = read(fd, buf, sizeof(buf));
while (len > 0) {
archive_write_data(a, buf, len);
len = read(fd, buf, sizeof(buf));
}
close(fd);
archive_entry_free(entry);
}
archive_write_close(a);
archive_write_free(a);
}
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;
}
