static const char *
packing_set_format(struct archive *a, pkg_formats format)
{
const char *notsupp_fmt = "%s is not supported, trying %s";
switch (format) {
case TXZ:
if (archive_write_add_filter_xz(a) == ARCHIVE_OK)
return ("txz");
else
pkg_emit_error(notsupp_fmt, "xz", "bzip2");
case TBZ:
if (archive_write_add_filter_bzip2(a) == ARCHIVE_OK)
return ("tbz");
else
pkg_emit_error(notsupp_fmt, "bzip2", "gzip");
case TGZ:
if (archive_write_add_filter_gzip(a) == ARCHIVE_OK)
return ("tgz");
else
pkg_emit_error(notsupp_fmt, "gzip", "plain tar");
case TAR:
archive_write_add_filter_none(a);
return ("tar");
}
return (NULL);
}
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;
}
Writer *Writer::write_open_filename(const char *filename,
int compression, int format)
{
std::string error_msg;
struct archive *ar = archive_write_new();
try {
switch(compression) {
case Archive::COMPRESSION_BZIP2:
archive_write_add_filter_bzip2(ar);
break;
case Archive::COMPRESSION_COMPRESS:
archive_write_add_filter_compress(ar);
break;
case Archive::COMPRESSION_GZIP:
archive_write_add_filter_gzip(ar);
break;
case Archive::COMPRESSION_LZMA:
archive_write_add_filter_lzma(ar);
break;
case Archive::COMPRESSION_NONE:
archive_write_add_filter_none(ar);
break;
case Archive::COMPRESSION_XZ:
archive_write_add_filter_xz(ar);
break;
default:
error_msg = "unknown or unsupported compression scheme";
throw Error(error_msg);
}
set_format_helper(ar, format);
if(archive_write_open_filename(ar, filename) != ARCHIVE_OK) {
error_msg = archive_error_string(ar);
throw Error(error_msg);
}
} catch(...) {
archive_write_free(ar);
throw;
}
return new Writer(ar);
}
static db_writer_t *db_writer_new(repo_t *repo, file_t *db)
{
db_writer_t *writer = malloc(sizeof(db_writer_t));
writer->archive = archive_write_new();
writer->entry = archive_entry_new();
switch (repo->compression) {
case COMPRESS_NONE:
archive_write_add_filter_none(writer->archive);
break;
case COMPRESS_GZIP:
archive_write_add_filter_gzip(writer->archive);
break;
case COMPRESS_BZIP2:
archive_write_add_filter_bzip2(writer->archive);
break;
case COMPRESS_XZ:
archive_write_add_filter_xz(writer->archive);
break;
case COMPRESS_COMPRESS:
archive_write_add_filter_compress(writer->archive);
break;
}
archive_write_set_format_pax_restricted(writer->archive);
writer->fd = openat(repo->dirfd, db->file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
if (writer->fd < 0)
err(EXIT_FAILURE, "failed to open %s for writing", db->file);
if (flock(writer->fd, LOCK_EX) < 0)
err(EXIT_FAILURE, "failed to lock %s", db->file);
archive_write_open_fd(writer->archive, writer->fd);
buffer_init(&writer->buf, 1024);
return writer;
}
int
archive_write_set_compression_xz(struct archive *a)
{
__archive_write_filters_free(a);
return (archive_write_add_filter_xz(a));
}
static void
mode_out(struct cpio *cpio)
{
struct archive_entry *entry, *spare;
struct lafe_line_reader *lr;
const char *p;
int r;
if (cpio->option_append)
lafe_errc(1, 0, "Append mode not yet supported.");
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);
cpio->archive = archive_write_new();
if (cpio->archive == NULL)
lafe_errc(1, 0, "Failed to allocate archive object");
switch (cpio->compress) {
case OPTION_GRZIP:
r = archive_write_add_filter_grzip(cpio->archive);
break;
case 'J':
r = archive_write_add_filter_xz(cpio->archive);
break;
case OPTION_LRZIP:
r = archive_write_add_filter_lrzip(cpio->archive);
break;
case OPTION_LZMA:
r = archive_write_add_filter_lzma(cpio->archive);
break;
case OPTION_LZOP:
r = archive_write_add_filter_lzop(cpio->archive);
break;
case 'j': case 'y':
r = archive_write_add_filter_bzip2(cpio->archive);
break;
case 'z':
r = archive_write_add_filter_gzip(cpio->archive);
break;
case 'Z':
r = archive_write_add_filter_compress(cpio->archive);
break;
default:
r = archive_write_add_filter_none(cpio->archive);
break;
}
if (r < ARCHIVE_WARN)
lafe_errc(1, 0, "Requested compression not available");
switch (cpio->add_filter) {
case 0:
r = ARCHIVE_OK;
break;
case OPTION_B64ENCODE:
r = archive_write_add_filter_b64encode(cpio->archive);
break;
case OPTION_UUENCODE:
r = archive_write_add_filter_uuencode(cpio->archive);
break;
}
if (r < ARCHIVE_WARN)
lafe_errc(1, 0, "Requested filter not available");
r = archive_write_set_format_by_name(cpio->archive, cpio->format);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(cpio->archive));
archive_write_set_bytes_per_block(cpio->archive, cpio->bytes_per_block);
cpio->linkresolver = archive_entry_linkresolver_new();
archive_entry_linkresolver_set_strategy(cpio->linkresolver,
archive_format(cpio->archive));
/*
* The main loop: Copy each file into the output archive.
*/
r = archive_write_open_filename(cpio->archive, cpio->filename);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(cpio->archive));
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);
/*
* The hardlink detection may have queued up a couple of entries
* that can now be flushed.
*/
entry = NULL;
archive_entry_linkify(cpio->linkresolver, &entry, &spare);
while (entry != NULL) {
entry_to_archive(cpio, entry);
archive_entry_free(entry);
entry = NULL;
archive_entry_linkify(cpio->linkresolver, &entry, &spare);
}
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);
}
