int fwfile_add_meta_conf_str(const char *configtxt, int configtxt_len, struct archive *a, const unsigned char *signing_key) { struct archive_entry *entry; // If the user passed in a signing key, sign the meta.conf. if (signing_key) { unsigned char signature[crypto_sign_BYTES]; crypto_sign_detached(signature, NULL, (unsigned char *) configtxt, configtxt_len, signing_key); entry = archive_entry_new(); archive_entry_set_pathname(entry, "meta.conf.ed25519"); archive_entry_set_size(entry, sizeof(signature)); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(a, entry); archive_write_data(a, signature, sizeof(signature)); archive_entry_free(entry); } // Add meta.conf entry = archive_entry_new(); archive_entry_set_pathname(entry, "meta.conf"); archive_entry_set_size(entry, configtxt_len); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(a, entry); archive_write_data(a, configtxt, configtxt_len); archive_entry_free(entry); return 0; }
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); }
/* Helper function to copy file to archive. */ static int write_file_data(struct bsdtar *bsdtar, struct archive *a, struct archive_entry *entry, int fd) { ssize_t bytes_read; ssize_t bytes_written; off_t progress = 0; bytes_read = read(fd, bsdtar->buff, FILEDATABUFLEN); while (bytes_read > 0) { siginfo_printinfo(bsdtar, progress); bytes_written = archive_write_data(a, bsdtar->buff, bytes_read); if (bytes_written < 0) { /* Write failed; this is bad */ bsdtar_warnc(bsdtar, 0, "%s", archive_error_string(a)); return (-1); } if (bytes_written < bytes_read) { /* Write was truncated; warn but continue. */ bsdtar_warnc(bsdtar, 0, "%s: Truncated write; file may have grown while being archived.", archive_entry_pathname(entry)); return (0); } progress += bytes_written; bytes_read = read(fd, bsdtar->buff, FILEDATABUFLEN); } 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 }
static void _addFileToArchive(void* item, void* userData) { char* itemPath = (char*)item; struct archive* outArchive = (struct archive*)userData; struct archive_entry* entry = archive_entry_new(); struct stat fileStat; FILE* filePointer; size_t bytesRead; byte* fileBuffer = (byte*)malloc(8192); stat(itemPath, &fileStat); archive_entry_set_pathname(entry, itemPath); archive_entry_set_size(entry, fileStat.st_size); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(outArchive, entry); filePointer = fopen(itemPath, "rb"); do { bytesRead = fread(fileBuffer, 1, 8192, filePointer); if(bytesRead > 0) { archive_write_data(outArchive, fileBuffer, bytesRead); } } while(bytesRead > 0); fclose(filePointer); archive_entry_free(entry); }
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); }
void GuiZipper::packageSingleFile(const char *absFilename, const char *filename, struct archive *a, bool binary) throw (ZipperException*) { struct stat st; char buff[8192]; int fd; stat(absFilename, &st); struct archive_entry *entry = archive_entry_new(); archive_entry_copy_stat(entry, &st); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_pathname(entry, filename); archive_entry_set_perm(entry, 0644); int r = archive_write_header(a, entry); checkForErrors("Error writing header", a, r); int flags = O_RDONLY; #ifdef __WIN32__ if (binary) { flags |= O_BINARY; } #endif fd = open(absFilename, flags); ssize_t 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); }
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; }
/* Helper function to copy data between archives. */ static int copy_file_data(struct bsdtar *bsdtar, struct archive *a, struct archive *ina, struct archive_entry *entry) { ssize_t bytes_read; ssize_t bytes_written; int64_t progress = 0; bytes_read = archive_read_data(ina, bsdtar->buff, bsdtar->buff_size); while (bytes_read > 0) { if (need_report()) report_write(bsdtar, a, entry, progress); bytes_written = archive_write_data(a, bsdtar->buff, bytes_read); if (bytes_written < bytes_read) { lafe_warnc(0, "%s", archive_error_string(a)); return (-1); } progress += bytes_written; bytes_read = archive_read_data(ina, bsdtar->buff, bsdtar->buff_size); } return (0); }
int xbps_archive_append_buf(struct archive *ar, const void *buf, const size_t buflen, const char *fname, const mode_t mode, const char *uname, const char *gname) { struct archive_entry *entry; assert(ar); assert(buf); assert(fname); assert(uname); assert(gname); entry = archive_entry_new(); assert(entry); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, mode); archive_entry_set_uname(entry, uname); archive_entry_set_gname(entry, gname); archive_entry_set_pathname(entry, fname); archive_entry_set_size(entry, buflen); if (archive_write_header(ar, entry) != ARCHIVE_OK) { archive_entry_free(entry); return archive_errno(ar); } if (archive_write_data(ar, buf, buflen) != ARCHIVE_OK) { archive_entry_free(entry); return archive_errno(ar); } archive_write_finish_entry(ar); archive_entry_free(entry); return 0; }
int packing_append_buffer(struct packing *pack, const char *buffer, const char *path, int size) { struct archive_entry *entry; int ret = EPKG_OK; entry = archive_entry_new(); archive_entry_clear(entry); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_entry_set_gname(entry, "wheel"); archive_entry_set_uname(entry, "root"); archive_entry_set_pathname(entry, path); archive_entry_set_size(entry, size); if (archive_write_header(pack->awrite, entry) == -1) { pkg_emit_errno("archive_write_header", path); ret = EPKG_FATAL; goto cleanup; } if (archive_write_data(pack->awrite, buffer, size) == -1) { pkg_emit_errno("archive_write_data", path); ret = EPKG_FATAL; } cleanup: archive_entry_free(entry); return (ret); }
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 StudioFrame::WriteDefsToZip(struct archive *zip) { tinyxml2::XMLDocument xmlDoc; tinyxml2::XMLPrinter printer; CreateDefs(xmlDoc, true); xmlDoc.Accept(&printer); const char *buffer = printer.CStr(); struct archive_entry *entry = archive_entry_new(); if (entry == NULL) { wxMessageBox(_("archive_entry_new error")); return -1; } archive_entry_set_pathname(entry, "oaml.defs"); archive_entry_set_size(entry, strlen(buffer)); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(zip, entry); if (archive_write_data(zip, buffer, strlen(buffer)) != strlen(buffer)) { wxMessageBox(_("archive_write_data error")); return -1; } archive_entry_free(entry); return 0; }
/* Helper function to copy data between archives. */ static int copy_file_data(struct bsdtar *bsdtar, struct archive *a, struct archive *ina) { ssize_t bytes_read; ssize_t bytes_written; off_t progress = 0; bytes_read = archive_read_data(ina, bsdtar->buff, FILEDATABUFLEN); while (bytes_read > 0) { disk_pause(bsdtar); if (network_select(0)) return (-1); siginfo_printinfo(bsdtar, progress); bytes_written = archive_write_data(a, bsdtar->buff, bytes_read); if (bytes_written < bytes_read) { bsdtar_warnc(bsdtar, 0, "%s", archive_error_string(a)); return (-1); } if (truncate_archive(bsdtar)) break; if (checkpoint_archive(bsdtar, 1)) return (-1); progress += bytes_written; bytes_read = archive_read_data(ina, bsdtar->buff, FILEDATABUFLEN); } return (0); }
void Writer::write_data_helper(const char *string, size_t length) { if(archive_write_data(_ar, (const void *) string, length) == -1) { std::string error_msg = archive_error_string(_ar); throw Error(error_msg); } }
static gboolean dump_data (GFile *file, struct archive *archive, GCancellable *cancellable, GError **error) { char buffer[32*1024]; g_autoptr(GFileInputStream) in = NULL; gssize in_buffer; in = g_file_read (file, cancellable, error); if (in == NULL) return FALSE; while (TRUE) { in_buffer = g_input_stream_read (G_INPUT_STREAM (in), buffer, sizeof (buffer), cancellable, error); if (in_buffer == -1) return FALSE; if (in_buffer == 0) break; if (archive_write_data (archive, buffer, in_buffer) < ARCHIVE_OK) return xdg_app_fail (error, "Can't write tar data"); } return TRUE; }
int packing_append_file(struct packing *pack, const char *filepath, const char *newpath) { int fd; int len; char linkdest[MAXPATHLEN]; char buf[BUFSIZ]; int retcode = EPKG_OK; struct stat st; archive_entry_clear(pack->entry); archive_entry_copy_sourcepath(pack->entry, filepath); retcode = archive_read_disk_entry_from_file(pack->aread, pack->entry, -1, NULL); if (retcode != ARCHIVE_OK) { pkg_emit_event(PKG_EVENT_ARCHIVE_ERROR, /*argc*/2, filepath, pack->aread); retcode = EPKG_FATAL; goto cleanup; } retcode = EPKG_OK; lstat(filepath, &st); archive_entry_copy_stat(pack->entry, &st); if (S_ISLNK(st.st_mode)) { bzero(linkdest, MAXPATHLEN); readlink(filepath, linkdest, MAXPATHLEN); archive_entry_set_symlink(pack->entry, linkdest); } if (newpath != NULL) archive_entry_set_pathname(pack->entry, newpath); if (archive_entry_filetype(pack->entry) != AE_IFREG) { archive_entry_set_size(pack->entry, 0); } archive_write_header(pack->awrite, pack->entry); if (archive_entry_size(pack->entry) > 0) { if ((fd = open(filepath, O_RDONLY)) < 0) { pkg_emit_event(PKG_EVENT_IO_ERROR, /*argc*/3, "open", filepath, strerror(errno)); 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_clear(pack->entry); return (retcode); }
int test1() { struct archive *a = archive_write_new(); int ret = archive_write_set_format_zip(a); unsigned char buffer[100]; int size; ret = archive_write_open_memory(a, buffer, 100, &size); // add a file struct archive_entry *entry = archive_entry_new(); archive_entry_set_pathname(entry, "hello.txt"); archive_entry_set_size(entry, 5); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); ret = archive_write_header(a, entry); printf("archive_write_header: ret=%d\n", ret); la_ssize_t n = archive_write_data(a, "world", 5); printf("archive_write_data: n=%d, error=%s\n", n, archive_error_string(a)); // ad another file // archive_entry_clear(entry); archive_entry_set_pathname(entry, "somedir/yo.txt"); archive_entry_set_size(entry, 5); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(a, entry); n = archive_write_data(a, "12345", 5); printf("archive_write_data: n=%d, error=%s\n", n, archive_error_string(a)); archive_entry_free(entry); ret = archive_write_free(a); printf("archive_write_free: ret=%d, error=%s\n", ret, archive_error_string(a)); printf("size=%d\n", size); write(1, buffer, size); }
static int write_cpio_entry(struct archive_conv *conv, const char *entryname) { off_t entry_size = archive_entry_size(conv->ae); off_t bytes_w = 0; size_t alloc_size = entry_size * 1.1; struct archive_line_reader reader = {}; _cleanup_free_ char *entry_data = NULL, *s = NULL, *line = NULL; /* be generous */ MALLOC(entry_data, alloc_size, return -1); MALLOC(line, MAX_LINE_SIZE, return -1); reader.line.base = line; /* discard the first line */ reader_getline(&reader, conv->in); while (reader_getline(&reader, conv->in) == ARCHIVE_OK) { /* ensure enough memory */ if (bytes_w + reader.line.size + 1 > alloc_size) { alloc_size *= 1.1; entry_data = realloc(entry_data, alloc_size); } /* do the copy, with a slash prepended */ entry_data[bytes_w++] = '/'; memcpy(&entry_data[bytes_w], reader.line.base, reader.line.size); bytes_w += reader.line.size; entry_data[bytes_w++] = '\n'; } /* adjust the entry size for removing the first line and adding slashes */ archive_entry_set_size(conv->ae, bytes_w); /* store the metadata as simply $pkgname-$pkgver-$pkgrel */ s = strdup(entryname); *(strrchr(s, '/')) = '\0'; archive_entry_update_pathname_utf8(conv->ae, s); if (archive_write_header(conv->out, conv->ae) != ARCHIVE_OK) { fprintf(stderr, "error: failed to write entry header: %s/%s: %s\n", conv->reponame, archive_entry_pathname(conv->ae), strerror(errno)); return -errno; } if (archive_write_data(conv->out, entry_data, bytes_w) != bytes_w) { fprintf(stderr, "error: failed to write entry: %s/%s: %s\n", conv->reponame, archive_entry_pathname(conv->ae), strerror(errno)); return -errno; } return 0; }
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 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); }
static void write_entry(struct archive *archive, struct archive_entry *entry) { char buf[16384]; const char *name; int fd; off_t len; ssize_t buf_len; if (archive_entry_pathname(entry) == NULL) { warnx("entry with NULL path"); return; } if (archive_write_header(archive, entry)) { errx(2, "cannot write %s to archive: %s", archive_entry_pathname(entry), archive_error_string(archive)); } /* Only regular files can have data. */ if (archive_entry_filetype(entry) != AE_IFREG || archive_entry_size(entry) == 0) { archive_entry_free(entry); return; } name = archive_entry_pathname(entry); if ((fd = open(name, O_RDONLY)) == -1) err(2, "cannot open data file %s", name); len = archive_entry_size(entry); while (len > 0) { buf_len = (len > (off_t)sizeof(buf)) ? (ssize_t)sizeof(buf) : (ssize_t)len; if ((buf_len = read(fd, buf, buf_len)) == 0) break; else if (buf_len < 0) err(2, "cannot read from %s", name); archive_write_data(archive, buf, (size_t)buf_len); len -= buf_len; } close(fd); archive_entry_free(entry); }
int packing_append_buffer(struct packing *pack, const char *buffer, const char *path, int size) { archive_entry_clear(pack->entry); archive_entry_set_filetype(pack->entry, AE_IFREG); archive_entry_set_perm(pack->entry, 0644); archive_entry_set_gname(pack->entry, "wheel"); archive_entry_set_uname(pack->entry, "root"); archive_entry_set_pathname(pack->entry, path); archive_entry_set_size(pack->entry, size); archive_write_header(pack->awrite, pack->entry); archive_write_data(pack->awrite, buffer, size); archive_entry_clear(pack->entry); return (EPKG_OK); }
int StudioFrame::WriteFileToZip(struct archive *zip, std::string file) { const char *filename = file.c_str(); void *fd = studioCbs.open(filename); if (fd == NULL) { wxString str; str.Printf(wxT("Error creating file %s"), filename); wxMessageBox(str); return -1; } studioCbs.seek(fd, 0, SEEK_END); size_t size = studioCbs.tell(fd); studioCbs.seek(fd, 0, SEEK_SET); wxFileName fname(filename); struct archive_entry *entry = archive_entry_new(); if (entry == NULL) { wxMessageBox(_("archive_entry_new error")); return -1; } archive_entry_set_pathname(entry, fname.GetFullName().ToStdString().c_str()); archive_entry_set_size(entry, size); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(zip, entry); char buffer[4096]; while (size > 0) { int bytes = studioCbs.read(buffer, 1, 4096, fd); if (bytes == 0) break; if (archive_write_data(zip, buffer, bytes) != bytes) { studioCbs.close(fd); wxMessageBox(_("archive_write_data error")); return -1; } } studioCbs.close(fd); archive_entry_free(entry); return 0; }
static void write_file_content(struct archive * a, char * buf, rpmfi fi) { rpm_loff_t left = rpmfiFSize(fi); size_t len, read; while (left) { len = (left > BUFSIZE ? BUFSIZE : left); read = rpmfiArchiveRead(fi, buf, len); if (read==len) { archive_write_data(a, buf, len); } else { fprintf(stderr, "Error reading file from rpm payload\n"); break; } left -= len; } }
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"); };
static int ar_write_data(lua_State *L) { struct archive* self; const char* data; size_t len; size_t wrote; self = *ar_write_check(L, 1); if ( NULL == self ) err("NULL archive{write}!"); data = lua_tolstring(L, 2, &len); wrote = archive_write_data(self, data, len); if ( -1 == wrote ) { err("archive_write_data: %s", archive_error_string(self)); } return 0; }
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 }
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)); }
static void write_meta_file(struct memory_file *file, struct archive *archive) { struct archive_entry *entry; entry = archive_entry_new(); archive_entry_set_pathname(entry, file->name); archive_entry_copy_stat(entry, &file->st); archive_entry_set_uname(entry, file->owner); archive_entry_set_gname(entry, file->group); if (archive_write_header(archive, entry)) errx(2, "cannot write to archive: %s", archive_error_string(archive)); archive_write_data(archive, file->data, file->len); archive_entry_free(entry); }