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; }
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); }
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 Writer::close() { if(_ar) { archive_write_free(_ar); _ar = 0; } }
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; }
static void test(int pristine) { struct archive* a = archive_write_new(); int known_option_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_OK; if (!pristine) { archive_write_add_filter_gzip(a); archive_write_set_format_iso9660(a); } /* NULL and "" denote `no option', so they're ok no matter * what, if any, formats are registered */ should(a, ARCHIVE_OK, NULL, NULL, NULL); should(a, ARCHIVE_OK, "", "", ""); /* unknown modules and options */ should(a, ARCHIVE_FAILED, "fubar", "snafu", NULL); should(a, ARCHIVE_FAILED, "fubar", "snafu", "betcha"); /* unknown modules and options */ should(a, ARCHIVE_FAILED, NULL, "snafu", NULL); should(a, ARCHIVE_FAILED, NULL, "snafu", "betcha"); /* ARCHIVE_OK with iso9660 loaded, ARCHIVE_WARN otherwise */ should(a, known_option_rv, "iso9660", "joliet", NULL); should(a, known_option_rv, "iso9660", "joliet", NULL); should(a, known_option_rv, NULL, "joliet", NULL); should(a, known_option_rv, NULL, "joliet", NULL); archive_write_free(a); }
/* * Create a shar archive and write files/trees into it. */ static int shar_write(char **fn, size_t nfn) { struct archive *a; size_t i; int error = 0; assert(fn != NULL); assert(nfn > 0); a = shar_create(); for (i = 0; i < nfn; i++) { if (r_opt) { if (shar_write_tree(a, fn[i]) != ARCHIVE_OK) error = 1; } else { if (shar_write_path(a, fn[i]) != ARCHIVE_OK) error = 1; } } if (archive_write_free(a) != ARCHIVE_OK) errx(EXIT_FAILURE, "%s", archive_error_string(a)); if (error != 0) warnx("Error exit delayed from previous errors."); return (error); }
static void verify_zip_filesize(uint64_t size, int expected) { struct archive *a; struct archive_entry *ae; char buff[256]; size_t used; /* Zip format: Create a new archive in memory. */ assert((a = archive_write_new()) != NULL); assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); /* Disable Zip64 extensions. */ assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_option(a, "zip", "zip64", NULL)); assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used)); assert((ae = archive_entry_new()) != NULL); archive_entry_set_pathname(ae, "test"); archive_entry_set_mode(ae, AE_IFREG | 0644); archive_entry_set_size(ae, size); assertEqualInt(expected, archive_write_header(a, ae)); archive_entry_free(ae); /* Don't actually write 4GB! ;-) */ assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a)); }
/* * Verify that KOI8-R filenames are not translated to Unicode and UTF-8 * when using hdrcharset=BINARY option. */ static void test_pax_filename_encoding_KOI8R_BINARY(void) { struct archive *a; struct archive_entry *entry; char buff[4096]; size_t used; if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) { skipping("KOI8-R locale not available on this system."); return; } a = archive_write_new(); assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a)); /* BINARY mode should be accepted. */ assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=BINARY")); assertEqualInt(ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used)); entry = archive_entry_new2(a); archive_entry_set_pathname(entry, "\xD0\xD2\xC9"); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_size(entry, 0); assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry)); archive_entry_free(entry); assertEqualInt(ARCHIVE_OK, archive_write_free(a)); /* "hdrcharset=BINARY" pax attribute should be written. */ assertEqualMem(buff + 512, "21 hdrcharset=BINARY\x0A", 21); /* Above three characters in KOI8-R should not translate to any * character-set. */ assertEqualMem(buff + 512+21, "12 path=\xD0\xD2\xC9\x0A", 12); }
static gboolean archive_finish_callback (gpointer user_data) { FetchData *fetch_data = (FetchData *) user_data; gint free_result; if (fetch_data->ext != NULL) { free_result = archive_write_free(fetch_data->ext); if (free_result != ARCHIVE_OK) g_warning("Failed to free archive_write_disk"); } if (fetch_data->a != NULL) { free_result = archive_read_free(fetch_data->a); if (free_result != ARCHIVE_OK) g_warning("Failed to free archive_read"); } if (fetch_data->finish_callback) { fetch_data->finish_callback (fetch_data->error, fetch_data->user_data); } g_clear_error (&fetch_data->error); if (fetch_data != NULL) g_slice_free(FetchData, fetch_data); return FALSE; }
static void test_big_entries(int (*set_format)(struct archive *), int64_t size, int expected) { struct archive_entry *ae; struct archive *a; size_t buffsize = 1000000; size_t used; char *buff; 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)); assert((ae = archive_entry_new()) != NULL); archive_entry_copy_pathname(ae, "file"); archive_entry_set_size(ae, size); archive_entry_set_filetype(ae, AE_IFREG); assertEqualInt(expected, archive_write_header(a, ae)); if (expected != ARCHIVE_OK) assert(archive_error_string(a) != NULL); archive_entry_free(ae); archive_write_free(a); free(buff); }
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; };
static void DTAR_write_header(struct archive* ar, uint64_t idx, uint64_t offset) { /* allocate and entry for this item */ struct archive_entry* entry = archive_entry_new(); /* get file name for this item */ /* fill up entry, FIXME: the uglyness of removing leading slash */ const char* fname = mfu_flist_file_get_name(DTAR_flist, idx); archive_entry_copy_pathname(entry, &fname[1]); if (DTAR_user_opts.preserve) { struct archive* source = archive_read_disk_new(); archive_read_disk_set_standard_lookup(source); int fd = open(fname, O_RDONLY); if (archive_read_disk_entry_from_file(source, entry, fd, NULL) != ARCHIVE_OK) { MFU_LOG(MFU_LOG_ERR, "archive_read_disk_entry_from_file(): %s", archive_error_string(ar)); } archive_read_free(source); close(fd); } else { /* TODO: read stat info from mfu_flist */ struct stat stbuf; mfu_lstat(fname, &stbuf); archive_entry_copy_stat(entry, &stbuf); /* set user name of owner */ const char* uname = mfu_flist_file_get_username(DTAR_flist, idx); archive_entry_set_uname(entry, uname); /* set group name */ const char* gname = mfu_flist_file_get_groupname(DTAR_flist, idx); archive_entry_set_gname(entry, gname); } /* TODO: Seems to be a bug here potentially leading to corrupted * archive files. archive_write_free also writes two blocks of * NULL bytes at the end of an archive file, however, each rank * will have a different view of the length of the file, so one * rank may write its NULL blocks over top of the actual data * written by another rank */ /* write entry info to archive */ struct archive* dest = archive_write_new(); archive_write_set_format_pax(dest); if (archive_write_open_fd(dest, DTAR_writer.fd_tar) != ARCHIVE_OK) { MFU_LOG(MFU_LOG_ERR, "archive_write_open_fd(): %s", archive_error_string(ar)); } /* seek to offset in tar archive for this file */ lseek(DTAR_writer.fd_tar, offset, SEEK_SET); /* write header for this item */ if (archive_write_header(dest, entry) != ARCHIVE_OK) { MFU_LOG(MFU_LOG_ERR, "archive_write_header(): %s", archive_error_string(ar)); } archive_entry_free(entry); archive_write_free(dest); }
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); }
static gboolean archive_finish_callback (gpointer user_data) { FetchData *fetch_data = (FetchData *) user_data; gint free_result; if (fetch_data == NULL) { g_warning("%s: fetch_data is NULL", __func__); return FALSE; } if (fetch_data->ext != NULL) { free_result = archive_write_free(fetch_data->ext); if (free_result != ARCHIVE_OK) g_warning("Failed to free archive_write_disk"); } if (fetch_data->a != NULL) { free_result = archive_read_free(fetch_data->a); if (free_result != ARCHIVE_OK) g_warning("Failed to free archive_read"); } if (fetch_data->finish_callback) { fetch_data->finish_callback (fetch_data->error, fetch_data->user_data); } else { g_clear_error(&fetch_data->error); } soup_session_abort (session); g_object_unref (session); g_slice_free(FetchData, fetch_data); return FALSE; }
// 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 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); }
Status Carver::compress(const std::set<boost::filesystem::path>& paths) { auto arch = archive_write_new(); if (arch == nullptr) { return Status(1, "Failed to create tar archive"); } // Zipping doesn't seem to be working currently // archive_write_set_format_zip(arch); archive_write_set_format_pax_restricted(arch); auto ret = archive_write_open_filename(arch, archivePath_.string().c_str()); if (ret == ARCHIVE_FATAL) { archive_write_free(arch); return Status(1, "Failed to open tar archive for writing"); } for (const auto& f : paths) { PlatformFile pFile(f.string(), PF_OPEN_EXISTING | PF_READ); auto entry = archive_entry_new(); archive_entry_set_pathname(entry, f.leaf().string().c_str()); archive_entry_set_size(entry, pFile.size()); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); // archive_entry_set_atime(); // archive_entry_set_ctime(); // archive_entry_set_mtime(); archive_write_header(arch, entry); // TODO: Chunking or a max file size. std::ifstream in(f.string(), std::ios::binary); std::stringstream buffer; buffer << in.rdbuf(); archive_write_data(arch, buffer.str().c_str(), buffer.str().size()); in.close(); archive_entry_free(entry); } archive_write_free(arch); PlatformFile archFile(archivePath_.string(), PF_OPEN_EXISTING | PF_READ); updateCarveValue(carveGuid_, "size", std::to_string(archFile.size())); updateCarveValue( carveGuid_, "sha256", hashFromFile(HashType::HASH_TYPE_SHA256, archivePath_.string())); return Status(0, "Ok"); };
/* * Verify that CP932/SJIS filenames are correctly translated to Unicode and UTF-8. */ static void test_pax_filename_encoding_CP932(void) { struct archive *a; struct archive_entry *entry; char buff[4096]; size_t used; if (NULL == setlocale(LC_ALL, "Japanese_Japan") && NULL == setlocale(LC_ALL, "ja_JP.SJIS")) { skipping("eucJP locale not available on this system."); return; } /* Check if the paltform completely supports the string conversion. */ a = archive_write_new(); assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a)); if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) { skipping("This system cannot convert character-set" " from CP932/SJIS to UTF-8."); archive_write_free(a); return; } archive_write_free(a); /* Re-create a write archive object since filenames should be written * in UTF-8 by default. */ a = archive_write_new(); assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a)); assertEqualInt(ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used)); entry = archive_entry_new2(a); archive_entry_set_pathname(entry, "\x95\x5C.txt"); /* Check the Unicode version. */ archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_size(entry, 0); assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry)); archive_entry_free(entry); assertEqualInt(ARCHIVE_OK, archive_write_free(a)); /* Check UTF-8 version. */ assertEqualMem(buff + 512, "16 path=\xE8\xA1\xA8.txt\x0A", 16); }
/* * Verify that CP1251 filenames are correctly translated to Unicode and UTF-8. */ static void test_pax_filename_encoding_CP1251(void) { struct archive *a; struct archive_entry *entry; char buff[4096]; size_t used; if (NULL == setlocale(LC_ALL, "Russian_Russia") && NULL == setlocale(LC_ALL, "ru_RU.CP1251")) { skipping("KOI8-R locale not available on this system."); return; } /* Check if the paltform completely supports the string conversion. */ a = archive_write_new(); assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a)); if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) { skipping("This system cannot convert character-set" " from KOI8-R to UTF-8."); archive_write_free(a); return; } archive_write_free(a); /* Re-create a write archive object since filenames should be written * in UTF-8 by default. */ a = archive_write_new(); assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a)); assertEqualInt(ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used)); entry = archive_entry_new2(a); archive_entry_set_pathname(entry, "\xef\xf0\xe8"); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_size(entry, 0); assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry)); archive_entry_free(entry); assertEqualInt(ARCHIVE_OK, archive_write_free(a)); /* Above three characters in KOI8-R should translate to the following * three characters (two bytes each) in UTF-8. */ assertEqualMem(buff + 512, "15 path=\xD0\xBF\xD1\x80\xD0\xB8\x0A", 15); }
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); }
/* * Cleanup function for archive_extract. */ static int archive_read_extract_cleanup(struct archive_read *a) { int ret = ARCHIVE_OK; ret = archive_write_free(a->extract->ad); free(a->extract); a->extract = NULL; return (ret); }
static void extract_recovery(char *ramdisk_path) { // Delete everything in the current root DIR *root = opendir("/"); struct dirent *dp; while ((dp = readdir(root)) != NULL) { unlink(dp->d_name); } closedir(root); // Open the ramdisk struct archive *a = archive_read_new(); archive_read_support_filter_lzma(a); archive_read_support_format_cpio(a); if (archive_read_open_filename(a, ramdisk_path, 4096) == ARCHIVE_OK) { // Set up the writer struct archive *ext = archive_write_disk_new(); archive_write_disk_set_options(ext, ARCHIVE_EXTRACT_UNLINK | ARCHIVE_EXTRACT_PERM); chdir("/"); while (1) { struct archive_entry *entry; // Read the next file if (archive_read_next_header(a, &entry) == ARCHIVE_EOF) break; // Create the file archive_write_header(ext, entry); // If the file has data to write... if (!archive_entry_size_is_set(entry) || archive_entry_size(entry) > 0) { const void *block; size_t size; int64_t offset; // Write the blocks until EOF while (1) { if (archive_read_data_block(a, &block, &size, &offset) == ARCHIVE_EOF) break; archive_write_data_block(ext, block, size, offset); } } } archive_write_free(ext); } archive_read_free(a); }
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); }
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); }
// 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; }
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); }