void DTAR_writer_init()
{
char compress=DTAR_user_opts->compress;
char filename=DTAR_user_opts->dest_path;
DTAR_writer->flags= O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_CLOEXEC;
DTAR_writer->a=archive_write_new();
switch (compress) {
case 'j': case 'y':
archive_write_add_filter_bzip2(a);
break;
case 'Z':
archive_write_add_filter_compress(a);
break;
case 'z':
archive_write_add_filter_gzip(a);
break;
default:
archive_write_add_filter_none(a);
break;
}
archive_write_set_format_ustar(a);
archive_write_set_bytes_per_block(a,0);
if (strcmp(filename, "-") == 0)
filename = NULL;
DTAR_writer->fd_tar=open(filename,DTAR_writer->flags,0666);
archive_write_open_fd(a, DTAR_writer->fd_tar);
}
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;
}
static void
create(const char *filename, int compress, const char **argv)
{
struct archive *a;
struct archive *disk;
struct archive_entry *entry;
ssize_t len;
int fd;
a = archive_write_new();
switch (compress) {
#ifndef NO_BZIP2_CREATE
case 'j': case 'y':
archive_write_add_filter_bzip2(a);
break;
#endif
#ifndef NO_COMPRESS_CREATE
case 'Z':
archive_write_add_filter_compress(a);
break;
#endif
#ifndef NO_GZIP_CREATE
case 'z':
archive_write_add_filter_gzip(a);
break;
#endif
default:
archive_write_add_filter_none(a);
break;
}
archive_write_set_format_ustar(a);
if (filename != NULL && strcmp(filename, "-") == 0)
filename = NULL;
archive_write_open_filename(a, filename);
disk = archive_read_disk_new();
#ifndef NO_LOOKUP
archive_read_disk_set_standard_lookup(disk);
#endif
while (*argv != NULL) {
struct archive *disk = archive_read_disk_new();
int r;
r = archive_read_disk_open(disk, *argv);
if (r != ARCHIVE_OK) {
errmsg(archive_error_string(disk));
errmsg("\n");
exit(1);
}
for (;;) {
int needcr = 0;
entry = archive_entry_new();
r = archive_read_next_header2(disk, entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
errmsg(archive_error_string(disk));
errmsg("\n");
exit(1);
}
archive_read_disk_descend(disk);
if (verbose) {
msg("a ");
msg(archive_entry_pathname(entry));
needcr = 1;
}
r = archive_write_header(a, entry);
if (r < ARCHIVE_OK) {
errmsg(": ");
errmsg(archive_error_string(a));
needcr = 1;
}
if (r == ARCHIVE_FATAL)
exit(1);
if (r > ARCHIVE_FAILED) {
#if 0
/* Ideally, we would be able to use
* the same code to copy a body from
* an archive_read_disk to an
* archive_write that we use for
* copying data from an archive_read
* to an archive_write_disk.
* Unfortunately, this doesn't quite
* work yet. */
copy_data(disk, a);
#else
/* For now, we use a simpler loop to copy data
* into the target archive. */
fd = open(archive_entry_sourcepath(entry), 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);
#endif
}
archive_entry_free(entry);
if (needcr)
msg("\n");
}
archive_read_close(disk);
archive_read_free(disk);
argv++;
}
archive_write_close(a);
archive_write_free(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);
}
int
archive_write_set_compression_compress(struct archive *a)
{
__archive_write_filters_free(a);
return (archive_write_add_filter_compress(a));
}
