| /*- |
| * This file is in the public domain. |
| * Do with it as you will. |
| */ |
| |
| /*- |
| * This is a compact "tar" program whose primary goal is small size. |
| * Statically linked, it can be very small indeed. This serves a number |
| * of goals: |
| * o a testbed for libarchive (to check for link pollution), |
| * o a useful tool for space-constrained systems (boot floppies, etc), |
| * o a place to experiment with new implementation ideas for bsdtar, |
| * o a small program to demonstrate libarchive usage. |
| * |
| * Use the following macros to suppress features: |
| * NO_BZIP2 - Implies NO_BZIP2_CREATE and NO_BZIP2_EXTRACT |
| * NO_BZIP2_CREATE - Suppress bzip2 compression support. |
| * NO_BZIP2_EXTRACT - Suppress bzip2 auto-detection and decompression. |
| * NO_COMPRESS - Implies NO_COMPRESS_CREATE and NO_COMPRESS_EXTRACT |
| * NO_COMPRESS_CREATE - Suppress compress(1) compression support |
| * NO_COMPRESS_EXTRACT - Suppress compress(1) auto-detect and decompression. |
| * NO_CREATE - Suppress all archive creation support. |
| * NO_CPIO_EXTRACT - Suppress auto-detect and dearchiving of cpio archives. |
| * NO_GZIP - Implies NO_GZIP_CREATE and NO_GZIP_EXTRACT |
| * NO_GZIP_CREATE - Suppress gzip compression support. |
| * NO_GZIP_EXTRACT - Suppress gzip auto-detection and decompression. |
| * NO_LOOKUP - Try to avoid getpw/getgr routines, which can be very large |
| * NO_TAR_EXTRACT - Suppress tar extraction |
| * |
| * With all of the above macros defined (except NO_TAR_EXTRACT), you |
| * get a very small program that can recognize and extract essentially |
| * any uncompressed tar archive. On FreeBSD 5.1, this minimal program |
| * is under 64k, statically linked, which compares rather favorably to |
| * main(){printf("hello, world");} |
| * which is over 60k statically linked on the same operating system. |
| * Without any of the above macros, you get a static executable of |
| * about 180k with a lot of very sophisticated modern features. |
| * Obviously, it's trivial to add support for ISO, Zip, mtree, |
| * lzma/xz, etc. Just fill in the appropriate setup calls. |
| */ |
| |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| |
| #include <archive.h> |
| #include <archive_entry.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| /* |
| * NO_CREATE implies NO_BZIP2_CREATE and NO_GZIP_CREATE and NO_COMPRESS_CREATE. |
| */ |
| #ifdef NO_CREATE |
| #undef NO_BZIP2_CREATE |
| #define NO_BZIP2_CREATE |
| #undef NO_COMPRESS_CREATE |
| #define NO_COMPRESS_CREATE |
| #undef NO_GZIP_CREATE |
| #define NO_GZIP_CREATE |
| #endif |
| |
| /* |
| * The combination of NO_BZIP2_CREATE and NO_BZIP2_EXTRACT is |
| * equivalent to NO_BZIP2. |
| */ |
| #ifdef NO_BZIP2_CREATE |
| #ifdef NO_BZIP2_EXTRACT |
| #undef NO_BZIP2 |
| #define NO_BZIP2 |
| #endif |
| #endif |
| |
| #ifdef NO_BZIP2 |
| #undef NO_BZIP2_EXTRACT |
| #define NO_BZIP2_EXTRACT |
| #undef NO_BZIP2_CREATE |
| #define NO_BZIP2_CREATE |
| #endif |
| |
| /* |
| * The combination of NO_COMPRESS_CREATE and NO_COMPRESS_EXTRACT is |
| * equivalent to NO_COMPRESS. |
| */ |
| #ifdef NO_COMPRESS_CREATE |
| #ifdef NO_COMPRESS_EXTRACT |
| #undef NO_COMPRESS |
| #define NO_COMPRESS |
| #endif |
| #endif |
| |
| #ifdef NO_COMPRESS |
| #undef NO_COMPRESS_EXTRACT |
| #define NO_COMPRESS_EXTRACT |
| #undef NO_COMPRESS_CREATE |
| #define NO_COMPRESS_CREATE |
| #endif |
| |
| /* |
| * The combination of NO_GZIP_CREATE and NO_GZIP_EXTRACT is |
| * equivalent to NO_GZIP. |
| */ |
| #ifdef NO_GZIP_CREATE |
| #ifdef NO_GZIP_EXTRACT |
| #undef NO_GZIP |
| #define NO_GZIP |
| #endif |
| #endif |
| |
| #ifdef NO_GZIP |
| #undef NO_GZIP_EXTRACT |
| #define NO_GZIP_EXTRACT |
| #undef NO_GZIP_CREATE |
| #define NO_GZIP_CREATE |
| #endif |
| |
| #ifndef NO_CREATE |
| static void create(const char *filename, int compress, const char **argv); |
| #endif |
| static void errmsg(const char *); |
| static void extract(const char *filename, int do_extract, int flags); |
| static int copy_data(struct archive *, struct archive *); |
| static void msg(const char *); |
| static void usage(void); |
| |
| static int verbose = 0; |
| |
| int |
| main(int argc, const char **argv) |
| { |
| const char *filename = NULL; |
| int compress, flags, mode, opt; |
| |
| (void)argc; |
| mode = 'x'; |
| verbose = 0; |
| compress = '\0'; |
| flags = ARCHIVE_EXTRACT_TIME; |
| |
| /* Among other sins, getopt(3) pulls in printf(3). */ |
| while (*++argv != NULL && **argv == '-') { |
| const char *p = *argv + 1; |
| |
| while ((opt = *p++) != '\0') { |
| switch (opt) { |
| #ifndef NO_CREATE |
| case 'c': |
| mode = opt; |
| break; |
| #endif |
| case 'f': |
| if (*p != '\0') |
| filename = p; |
| else |
| filename = *++argv; |
| p += strlen(p); |
| break; |
| #ifndef NO_BZIP2_CREATE |
| case 'j': |
| compress = opt; |
| break; |
| #endif |
| case 'p': |
| flags |= ARCHIVE_EXTRACT_PERM; |
| flags |= ARCHIVE_EXTRACT_ACL; |
| flags |= ARCHIVE_EXTRACT_FFLAGS; |
| break; |
| case 't': |
| mode = opt; |
| break; |
| case 'v': |
| verbose++; |
| break; |
| case 'x': |
| mode = opt; |
| break; |
| #ifndef NO_BZIP2_CREATE |
| case 'y': |
| compress = opt; |
| break; |
| #endif |
| #ifndef NO_COMPRESS_CREATE |
| case 'Z': |
| compress = opt; |
| break; |
| #endif |
| #ifndef NO_GZIP_CREATE |
| case 'z': |
| compress = opt; |
| break; |
| #endif |
| default: |
| usage(); |
| } |
| } |
| } |
| |
| switch (mode) { |
| #ifndef NO_CREATE |
| case 'c': |
| create(filename, compress, argv); |
| break; |
| #endif |
| case 't': |
| extract(filename, 0, flags); |
| break; |
| case 'x': |
| extract(filename, 1, flags); |
| break; |
| } |
| |
| return (0); |
| } |
| |
| |
| #ifndef NO_CREATE |
| static char buff[16384]; |
| |
| static void |
| create(const char *filename, int compress, const char **argv) |
| { |
| struct archive *a; |
| 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); |
| |
| while (*argv != NULL) { |
| struct archive *disk = archive_read_disk_new(); |
| #ifndef NO_LOOKUP |
| archive_read_disk_set_standard_lookup(disk); |
| #endif |
| 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); |
| } |
| #endif |
| |
| static void |
| extract(const char *filename, int do_extract, int flags) |
| { |
| struct archive *a; |
| struct archive *ext; |
| struct archive_entry *entry; |
| int r; |
| |
| a = archive_read_new(); |
| ext = archive_write_disk_new(); |
| archive_write_disk_set_options(ext, flags); |
| #ifndef NO_BZIP2_EXTRACT |
| archive_read_support_filter_bzip2(a); |
| #endif |
| #ifndef NO_GZIP_EXTRACT |
| archive_read_support_filter_gzip(a); |
| #endif |
| #ifndef NO_COMPRESS_EXTRACT |
| archive_read_support_filter_compress(a); |
| #endif |
| #ifndef NO_TAR_EXTRACT |
| archive_read_support_format_tar(a); |
| #endif |
| #ifndef NO_CPIO_EXTRACT |
| archive_read_support_format_cpio(a); |
| #endif |
| #ifndef NO_LOOKUP |
| archive_write_disk_set_standard_lookup(ext); |
| #endif |
| if (filename != NULL && strcmp(filename, "-") == 0) |
| filename = NULL; |
| if ((r = archive_read_open_filename(a, filename, 10240))) { |
| errmsg(archive_error_string(a)); |
| errmsg("\n"); |
| exit(r); |
| } |
| for (;;) { |
| int needcr = 0; |
| r = archive_read_next_header(a, &entry); |
| if (r == ARCHIVE_EOF) |
| break; |
| if (r != ARCHIVE_OK) { |
| errmsg(archive_error_string(a)); |
| errmsg("\n"); |
| exit(1); |
| } |
| if (verbose && do_extract) |
| msg("x "); |
| if (verbose || !do_extract) { |
| msg(archive_entry_pathname(entry)); |
| msg(" "); |
| needcr = 1; |
| } |
| if (do_extract) { |
| r = archive_write_header(ext, entry); |
| if (r != ARCHIVE_OK) { |
| errmsg(archive_error_string(a)); |
| needcr = 1; |
| } |
| else { |
| r = copy_data(a, ext); |
| if (r != ARCHIVE_OK) |
| needcr = 1; |
| } |
| } |
| if (needcr) |
| msg("\n"); |
| } |
| archive_read_close(a); |
| archive_read_free(a); |
| exit(0); |
| } |
| |
| static int |
| copy_data(struct archive *ar, struct archive *aw) |
| { |
| int r; |
| const void *buff; |
| size_t size; |
| int64_t offset; |
| |
| for (;;) { |
| r = archive_read_data_block(ar, &buff, &size, &offset); |
| if (r == ARCHIVE_EOF) |
| return (ARCHIVE_OK); |
| if (r != ARCHIVE_OK) { |
| errmsg(archive_error_string(ar)); |
| return (r); |
| } |
| r = archive_write_data_block(aw, buff, size, offset); |
| if (r != ARCHIVE_OK) { |
| errmsg(archive_error_string(ar)); |
| return (r); |
| } |
| } |
| } |
| |
| static void |
| msg(const char *m) |
| { |
| write(1, m, strlen(m)); |
| } |
| |
| static void |
| errmsg(const char *m) |
| { |
| if (m == NULL) { |
| m = "Error: No error description provided.\n"; |
| } |
| write(2, m, strlen(m)); |
| } |
| |
| static void |
| usage(void) |
| { |
| /* Many program options depend on compile options. */ |
| const char *m = "Usage: minitar [-" |
| #ifndef NO_CREATE |
| "c" |
| #endif |
| #ifndef NO_BZIP2 |
| "j" |
| #endif |
| "tvx" |
| #ifndef NO_BZIP2 |
| "y" |
| #endif |
| #ifndef NO_COMPRESS |
| "Z" |
| #endif |
| #ifndef NO_GZIP |
| "z" |
| #endif |
| "] [-f file] [file]\n"; |
| |
| errmsg(m); |
| exit(1); |
| } |