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);
}
