ziptool.c File Reference

#include "config.h"
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "getopt.h"
#include "zip.h"
#include "compat.h"

Go to the source code of this file.

Classes
struct	dispatch_table_s
struct	progress_userdata_s

Macros
#define	OPTIONS_REGRESS   ""
#define	USAGE_REGRESS   ""
#define	ziptool_open   read_from_file

Typedefs
typedef struct dispatch_table_s	dispatch_table_t

Functions
static zip_flags_t	get_flags (const char *arg)
static zip_int32_t	get_compression_method (const char *arg)
static zip_uint16_t	get_encryption_method (const char *arg)
static void	hexdump (const zip_uint8_t *data, zip_uint16_t len)
int	ziptool_post_close (const char *archive)
static int	add (char *argv[])
static int	add_dir (char *argv[])
static int	add_file (char *argv[])
static int	add_from_zip (char *argv[])
static int	cat (char *argv[])
static int	count_extra (char *argv[])
static int	count_extra_by_id (char *argv[])
static int	delete (char *argv[])
static int	delete_extra (char *argv[])
static int	delete_extra_by_id (char *argv[])
static int	get_archive_comment (char *argv[])
static int	get_extra (char *argv[])
static int	get_extra_by_id (char *argv[])
static int	get_file_comment (char *argv[])
static int	get_num_entries (char *argv[])
static int	name_locate (char *argv[])
static void	progress_callback (zip_t *archive, double percentage, void *ud)
static int	print_progress (char *argv[])
static int	zrename (char *argv[])
static int	replace_file_contents (char *argv[])
static int	set_extra (char *argv[])
static int	set_archive_comment (char *argv[])
static int	set_file_comment (char *argv[])
static int	set_file_compression (char *argv[])
static int	set_file_encryption (char *argv[])
static int	set_file_dostime (char *argv[])
static int	set_file_mtime (char *argv[])
static int	set_file_mtime_all (char *argv[])
static int	set_password (char *argv[])
static int	zstat (char *argv[])
static zip_t *	read_from_file (const char *archive, int flags, zip_error_t *error, zip_uint64_t offset, zip_uint64_t length)
static int	dispatch (int argc, char *argv[])
static void	usage (const char *progname, const char *reason)
int	main (int argc, char *argv[])

Variables
int	optopt
zip_t *	za
zip_t *	z_in [16]
unsigned int	z_in_count
zip_flags_t	stat_flags
struct progress_userdata_s	progress_userdata
dispatch_table_t	dispatch_table []

Macro Definition Documentation

OPTIONS_REGRESS

#define OPTIONS_REGRESS   ""

Definition at line 75 of file ziptool.c.

USAGE_REGRESS

#define USAGE_REGRESS   ""

Definition at line 76 of file ziptool.c.

ziptool_open

#define ziptool_open   read_from_file

Definition at line 874 of file ziptool.c.

Typedef Documentation

dispatch_table_t

typedef struct dispatch_table_s dispatch_table_t

Function Documentation

add()

static int add ( char *  argv[] )

static

Definition at line 84 of file ziptool.c.

                  {
    zip_source_t *zs;
 
    if ((zs = zip_source_buffer(za, argv[1], strlen(argv[1]), 0)) == NULL) {
        fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
        return -1;
    }
 
    if (zip_add(za, argv[0], zs) == -1) {
        zip_source_free(zs);
        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, NULL, za, zip_add(), zip_source_buffer(), zip_source_free(), and zip_strerror().

Referenced by avr_il_update_indirect_address_reg(), bf_inc(), bf_right_arrow(), libps_snprint(), LZMA_API(), md5_process_bytes(), mnemonic(), print_loop(), rz_core_get_boundaries_prot(), rz_il_op_new_add(), rz_il_op_pure_dup(), rz_il_op_pure_free(), rz_range_add(), sdb_diff_report(), sdb_diff_report_kv(), sdb_diff_report_ns(), sh_il_mac(), str_to_uint64(), update_size(), and vle_snprint().

add_dir()

static int add_dir ( char *  argv[] )

static

Definition at line 101 of file ziptool.c.

                      {
    /* add directory */
    if (zip_add_dir(za, argv[0]) < 0) {
        fprintf(stderr, "can't add directory '%s': %s\n", argv[0], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, za, zip_add_dir(), and zip_strerror().

add_file()

static int add_file ( char *  argv[] )

static

Definition at line 111 of file ziptool.c.

                       {
    zip_source_t *zs;
    zip_uint64_t start = strtoull(argv[2], NULL, 10);
    zip_int64_t len = strtoll(argv[3], NULL, 10);
 
    if (strcmp(argv[1], "/dev/stdin") == 0) {
        if ((zs = zip_source_filep(za, stdin, start, len)) == NULL) {
            fprintf(stderr, "can't create zip_source from stdin: %s\n", zip_strerror(za));
            return -1;
        }
    }
    else {
        if ((zs = zip_source_file(za, argv[1], start, len)) == NULL) {
            fprintf(stderr, "can't create zip_source from file: %s\n", zip_strerror(za));
            return -1;
        }
    }
 
    if (zip_add(za, argv[0], zs) == -1) {
        zip_source_free(zs);
        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, len, NULL, start, za, zip_add(), zip_source_file(), zip_source_filep(), zip_source_free(), and zip_strerror().

add_from_zip()

static int add_from_zip ( char *  argv[] )

static

Definition at line 138 of file ziptool.c.

                           {
    zip_uint64_t idx, start;
    zip_int64_t len;
    int err;
    zip_source_t *zs;
    /* add from another zip file */
    idx = strtoull(argv[2], NULL, 10);
    start = strtoull(argv[3], NULL, 10);
    len = strtoll(argv[4], NULL, 10);
    if ((z_in[z_in_count] = zip_open(argv[1], ZIP_CHECKCONS, &err)) == NULL) {
        zip_error_t error;
        zip_error_init_with_code(&error, err);
        fprintf(stderr, "can't open zip archive '%s': %s\n", argv[1], zip_error_strerror(&error));
        zip_error_fini(&error);
        return -1;
    }
    if ((zs = zip_source_zip(za, z_in[z_in_count], idx, 0, start, len)) == NULL) {
        fprintf(stderr, "error creating file source from '%s' index '%" PRIu64 "': %s\n", argv[1], idx, zip_strerror(za));
        zip_close(z_in[z_in_count]);
        return -1;
    }
    if (zip_add(za, argv[0], zs) == -1) {
        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
        zip_source_free(zs);
        zip_close(z_in[z_in_count]);
        return -1;
    }
    z_in_count++;
    return 0;
}

References argv, err, error(), setup::idx, len, NULL, PRIu64, start, z_in, z_in_count, za, zip_add(), ZIP_CHECKCONS, zip_close(), zip_error_fini(), zip_error_init_with_code(), zip_error_strerror(), zip_open(), zip_source_free(), zip_source_zip(), and zip_strerror().

cat()

static int cat ( char *  argv[] )

static

Definition at line 170 of file ziptool.c.

                  {
    /* output file contents to stdout */
    zip_uint64_t idx;
    zip_int64_t n;
    zip_file_t *zf;
    char buf[8192];
    int err;
    idx = strtoull(argv[0], NULL, 10);
 
#ifdef _WIN32
    /* Need to set stdout to binary mode for Windows */
    setmode(fileno(stdout), _O_BINARY);
#endif
    if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
        fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
        return -1;
    }
    while ((n = zip_fread(zf, buf, sizeof(buf))) > 0) {
        if (fwrite(buf, (size_t)n, 1, stdout) != 1) {
            zip_fclose(zf);
            fprintf(stderr, "can't write file contents to stdout: %s\n", strerror(errno));
            return -1;
        }
    }
    if (n == -1) {
        fprintf(stderr, "can't read file at index '%" PRIu64 "': %s\n", idx, zip_file_strerror(zf));
        zip_fclose(zf);
        return -1;
    }
    if ((err = zip_fclose(zf)) != 0) {
        zip_error_t error;
 
        zip_error_init_with_code(&error, err);
        fprintf(stderr, "can't close file at index '%" PRIu64 "': %s\n", idx, zip_error_strerror(&error));
        return -1;
    }
 
    return 0;
}

References argv, err, error(), setup::idx, n, NULL, PRIu64, za, zip_error_init_with_code(), zip_error_strerror(), zip_fclose(), zip_file_strerror(), zip_fopen_index(), zip_fread(), and zip_strerror().

Referenced by categorize(), and hexagon_disasm_instruction().

count_extra()

static int count_extra ( char *  argv[] )

static

Definition at line 211 of file ziptool.c.

                          {
    zip_int16_t count;
    zip_uint64_t idx;
    zip_flags_t ceflags = 0;
    idx = strtoull(argv[0], NULL, 10);
    ceflags = get_flags(argv[1]);
    if ((count = zip_file_extra_fields_count(za, idx, ceflags)) < 0) {
        fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
        return -1;
    }
    else {
        printf("Extra field count: %d\n", count);
    }
    return 0;
}

References argv, count, get_flags(), setup::idx, NULL, printf(), PRIu64, za, zip_file_extra_fields_count(), and zip_strerror().

count_extra_by_id()

static int count_extra_by_id ( char *  argv[] )

static

Definition at line 228 of file ziptool.c.

                                {
    zip_int16_t count;
    zip_uint16_t eid;
    zip_flags_t ceflags = 0;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    ceflags = get_flags(argv[2]);
    if ((count = zip_file_extra_fields_count_by_id(za, idx, eid, ceflags)) < 0) {
        fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "' and for id '%d': %s\n", idx, eid, zip_strerror(za));
        return -1;
    }
    else {
        printf("Extra field count: %d\n", count);
    }
    return 0;
}

References argv, count, get_flags(), setup::idx, NULL, printf(), PRIu64, za, zip_file_extra_fields_count_by_id(), and zip_strerror().

delete()

static int delete ( char *  argv[] )

static

Definition at line 246 of file ziptool.c.

                                 {
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    if (zip_delete(za, idx) < 0) {
        fprintf(stderr, "can't delete file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_delete(), and zip_strerror().

delete_extra()

static int delete_extra ( char *  argv[] )

static

Definition at line 257 of file ziptool.c.

                           {
    zip_flags_t geflags;
    zip_uint16_t eid;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    geflags = get_flags(argv[2]);
    if ((zip_file_extra_field_delete(za, idx, eid, geflags)) < 0) {
        fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d': %s\n", idx, eid, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, get_flags(), setup::idx, NULL, PRIu64, za, zip_file_extra_field_delete(), and zip_strerror().

delete_extra_by_id()

static int delete_extra_by_id ( char *  argv[] )

static

Definition at line 272 of file ziptool.c.

                                 {
    zip_flags_t geflags;
    zip_uint16_t eid, eidx;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    eidx = (zip_uint16_t)strtoull(argv[2], NULL, 10);
    geflags = get_flags(argv[3]);
    if ((zip_file_extra_field_delete_by_id(za, idx, eid, eidx, geflags)) < 0) {
        fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d', extra field idx '%d': %s\n", idx, eid, eidx, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, get_flags(), setup::idx, NULL, PRIu64, za, zip_file_extra_field_delete_by_id(), and zip_strerror().

dispatch()

static int dispatch ( int  argc, char *  argv[]  )

static

Definition at line 773 of file ziptool.c.

                                 {
    unsigned int i;
    for (i = 0; i < sizeof(dispatch_table) / sizeof(dispatch_table_t); i++) {
        if (strcmp(dispatch_table[i].cmdline_name, argv[0]) == 0) {
            argc--;
            argv++;
            /* 1 for the command, argument_count for the arguments */
            if (argc < dispatch_table[i].argument_count) {
                fprintf(stderr, "not enough arguments for command '%s': %d available, %d needed\n", dispatch_table[i].cmdline_name, argc, dispatch_table[i].argument_count);
                return -1;
            }
            if (dispatch_table[i].function(argv) == 0)
                return 1 + dispatch_table[i].argument_count;
            return -1;
        }
    }
 
    fprintf(stderr, "unknown command '%s'\n", argv[0]);
    return -1;
}

References dispatch_table_s::argument_count, argv, dispatch_table, and i.

Referenced by main().

get_archive_comment()

static int get_archive_comment ( char *  argv[] )

static

Definition at line 288 of file ziptool.c.

                                  {
    const char *comment;
    int len;
    /* get archive comment */
    if ((comment = zip_get_archive_comment(za, &len, 0)) == NULL)
        printf("No archive comment\n");
    else
        printf("Archive comment: %.*s\n", len, comment);
    return 0;
}

References len, NULL, printf(), za, and zip_get_archive_comment().

get_compression_method()

static zip_int32_t get_compression_method ( const char *  arg )

static

Definition at line 641 of file ziptool.c.

                                        {
    if (strcasecmp(arg, "default") == 0)
        return ZIP_CM_DEFAULT;
    else if (strcasecmp(arg, "store") == 0)
        return ZIP_CM_STORE;
    else if (strcasecmp(arg, "deflate") == 0)
        return ZIP_CM_DEFLATE;
#if defined(HAVE_LIBBZ2)
    else if (strcasecmp(arg, "bzip2") == 0)
        return ZIP_CM_BZIP2;
#endif
#if defined(HAVE_LIBLZMA)
    /*  Disabled - because 7z isn't able to unpack ZIP+LZMA ZIP+LZMA2
        archives made this way - and vice versa.
 
        else if (strcasecmp(arg, "lzma2") == 0)
          return ZIP_CM_LZMA2;
    */
    else if (strcasecmp(arg, "lzma") == 0)
    return ZIP_CM_LZMA;
    else if (strcasecmp(arg, "xz") == 0)
        return ZIP_CM_XZ;
#endif
#if defined(HAVE_LIBZSTD)
    else if (strcasecmp(arg, "zstd") == 0)
        return ZIP_CM_ZSTD;
 
#endif
    else if (strcasecmp(arg, "unknown") == 0)
        return 100;
    return 0; /* TODO: error handling */
}

References ZIP_CM_BZIP2, ZIP_CM_DEFAULT, ZIP_CM_DEFLATE, ZIP_CM_LZMA, ZIP_CM_STORE, ZIP_CM_XZ, and ZIP_CM_ZSTD.

Referenced by set_file_compression().

get_encryption_method()

static zip_uint16_t get_encryption_method ( const char *  arg )

static

Definition at line 675 of file ziptool.c.

                                       {
    if (strcasecmp(arg, "none") == 0)
        return ZIP_EM_NONE;
    else if (strcasecmp(arg, "PKWARE") == 0)
        return ZIP_EM_TRAD_PKWARE;
    else if (strcasecmp(arg, "AES-128") == 0)
        return ZIP_EM_AES_128;
    else if (strcasecmp(arg, "AES-192") == 0)
        return ZIP_EM_AES_192;
    else if (strcasecmp(arg, "AES-256") == 0)
        return ZIP_EM_AES_256;
    else if (strcasecmp(arg, "unknown") == 0)
        return 100;
    return (zip_uint16_t)-1; /* TODO: error handling */
}

References ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_EM_NONE, and ZIP_EM_TRAD_PKWARE.

Referenced by set_file_encryption().

get_extra()

static int get_extra ( char *  argv[] )

static

Definition at line 300 of file ziptool.c.

                        {
    zip_flags_t geflags;
    zip_uint16_t id, eidx, eflen;
    const zip_uint8_t *efdata;
    zip_uint64_t idx;
    /* get extra field data */
    idx = strtoull(argv[0], NULL, 10);
    eidx = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    geflags = get_flags(argv[2]);
    if ((efdata = zip_file_extra_field_get(za, idx, eidx, &id, &eflen, geflags)) == NULL) {
        fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field %d, flags %u: %s\n", idx, eidx, geflags, zip_strerror(za));
        return -1;
    }
    printf("Extra field 0x%04x: len %d", id, eflen);
    if (eflen > 0) {
        printf(", data ");
        hexdump(efdata, eflen);
    }
    printf("\n");
    return 0;
}

References argv, get_flags(), hexdump(), id, setup::idx, NULL, printf(), PRIu64, za, zip_file_extra_field_get(), and zip_strerror().

get_extra_by_id()

static int get_extra_by_id ( char *  argv[] )

static

Definition at line 323 of file ziptool.c.

                              {
    zip_flags_t geflags;
    zip_uint16_t eid, eidx, eflen;
    const zip_uint8_t *efdata;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    eidx = (zip_uint16_t)strtoull(argv[2], NULL, 10);
    geflags = get_flags(argv[3]);
    if ((efdata = zip_file_extra_field_get_by_id(za, idx, eid, eidx, &eflen, geflags)) == NULL) {
        fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field id %d, ef index %d, flags %u: %s\n", idx, eid, eidx, geflags, zip_strerror(za));
        return -1;
    }
    printf("Extra field 0x%04x: len %d", eid, eflen);
    if (eflen > 0) {
        printf(", data ");
        hexdump(efdata, eflen);
    }
    printf("\n");
    return 0;
}

References argv, get_flags(), hexdump(), setup::idx, NULL, printf(), PRIu64, za, zip_file_extra_field_get_by_id(), and zip_strerror().

get_file_comment()

static int get_file_comment ( char *  argv[] )

static

Definition at line 346 of file ziptool.c.

                               {
    const char *comment;
    int len;
    zip_uint64_t idx;
    /* get file comment */
    idx = strtoull(argv[0], NULL, 10);
    if ((comment = zip_get_file_comment(za, idx, &len, 0)) == NULL) {
        fprintf(stderr, "can't get comment for '%s': %s\n", zip_get_name(za, idx, 0), zip_strerror(za));
        return -1;
    }
    else if (len == 0)
        printf("No comment for '%s'\n", zip_get_name(za, idx, 0));
    else
        printf("File comment for '%s': %.*s\n", zip_get_name(za, idx, 0), len, comment);
    return 0;
}

References argv, setup::idx, len, NULL, printf(), za, zip_get_file_comment(), zip_get_name(), and zip_strerror().

get_flags()

static zip_flags_t get_flags ( const char *  arg )

static

Definition at line 617 of file ziptool.c.

                           {
    zip_flags_t flags = 0;
    if (strchr(arg, 'C') != NULL)
        flags |= ZIP_FL_NOCASE;
    if (strchr(arg, 'c') != NULL)
        flags |= ZIP_FL_CENTRAL;
    if (strchr(arg, 'd') != NULL)
        flags |= ZIP_FL_NODIR;
    if (strchr(arg, 'l') != NULL)
        flags |= ZIP_FL_LOCAL;
    if (strchr(arg, 'u') != NULL)
        flags |= ZIP_FL_UNCHANGED;
    if (strchr(arg, '8') != NULL)
        flags |= ZIP_FL_ENC_UTF_8;
    if (strchr(arg, '4') != NULL)
        flags |= ZIP_FL_ENC_CP437;
    if (strchr(arg, 'r') != NULL)
        flags |= ZIP_FL_ENC_RAW;
    if (strchr(arg, 's') != NULL)
        flags |= ZIP_FL_ENC_STRICT;
    return flags;
}

References flags, NULL, ZIP_FL_CENTRAL, ZIP_FL_ENC_CP437, ZIP_FL_ENC_RAW, ZIP_FL_ENC_STRICT, ZIP_FL_ENC_UTF_8, ZIP_FL_LOCAL, ZIP_FL_NOCASE, ZIP_FL_NODIR, and ZIP_FL_UNCHANGED.

Referenced by count_extra(), count_extra_by_id(), delete_extra(), delete_extra_by_id(), get_extra(), get_extra_by_id(), get_num_entries(), name_locate(), and set_extra().

get_num_entries()

static int get_num_entries ( char *  argv[] )

static

Definition at line 364 of file ziptool.c.

                              {
    zip_int64_t count;
    zip_flags_t flags;
    /* get number of entries in archive */
    flags = get_flags(argv[0]);
    count = zip_get_num_entries(za, flags);
    printf("%" PRId64 " entr%s in archive\n", count, count == 1 ? "y" : "ies");
    return 0;
}

References argv, count, flags, get_flags(), PRId64, printf(), za, and zip_get_num_entries().

hexdump()

static void hexdump ( const zip_uint8_t *  data, zip_uint16_t  len  )

static

Definition at line 692 of file ziptool.c.

                                                   {
    zip_uint16_t i;
 
    if (len <= 0)
        return;
 
    printf("0x");
 
    for (i = 0; i < len; i++)
        printf("%02x", data[i]);
}

References i, len, and printf().

Referenced by get_extra(), get_extra_by_id(), and test_command().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 882 of file ziptool.c.

                             {
    const char *archive;
    unsigned int i;
    int c, arg, err, flags;
    const char *prg;
    zip_uint64_t len = 0, offset = 0;
    zip_error_t error;
 
    flags = 0;
    prg = argv[0];
 
    while ((c = getopt(argc, argv, "ceghl:no:rst" OPTIONS_REGRESS)) != -1) {
        switch (c) {
        case 'c':
            flags |= ZIP_CHECKCONS;
            break;
        case 'e':
            flags |= ZIP_EXCL;
            break;
        case 'g':
            stat_flags = ZIP_FL_ENC_GUESS;
            break;
        case 'h':
            usage(prg, NULL);
            break;
        case 'l':
            len = strtoull(optarg, NULL, 10);
            break;
        case 'n':
            flags |= ZIP_CREATE;
            break;
        case 'o':
            offset = strtoull(optarg, NULL, 10);
            break;
        case 'r':
            stat_flags = ZIP_FL_ENC_RAW;
            break;
        case 's':
            stat_flags = ZIP_FL_ENC_STRICT;
            break;
        case 't':
            flags |= ZIP_TRUNCATE;
            break;
#ifdef GETOPT_REGRESS
            GETOPT_REGRESS
#endif
 
        default: {
            char reason[128];
            snprintf(reason, sizeof(reason), "invalid option -%c", optopt);
            usage(prg, reason);
        }
        }
    }
 
    if (optind >= argc - 1)
        usage(prg, "too few arguments");
 
    arg = optind;
 
    archive = argv[arg++];
 
    if (flags == 0)
        flags = ZIP_CREATE;
 
    zip_error_init(&error);
    za = ziptool_open(archive, flags, &error, offset, len);
    if (za == NULL) {
        fprintf(stderr, "can't open zip archive '%s': %s\n", archive, zip_error_strerror(&error));
        zip_error_fini(&error);
        return 1;
    }
    zip_error_fini(&error);
 
    err = 0;
    while (arg < argc) {
        int ret;
        ret = dispatch(argc - arg, argv + arg);
        if (ret > 0) {
            arg += ret;
        }
        else {
            err = 1;
            break;
        }
    }
 
    if (zip_close(za) == -1) {
        fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
        return 1;
    }
    if (ziptool_post_close(archive) < 0) {
        err = 1;
    }
 
    for (i = 0; i < z_in_count; i++) {
        if (zip_close(z_in[i]) < 0) {
            err = 1;
        }
    }
 
    return err;
}

References arg(), argv, c, dispatch(), err, error(), flags, getopt(), GETOPT_REGRESS, i, len, NULL, optarg, optind, OPTIONS_REGRESS, optopt, prg, snprintf, stat_flags, usage(), z_in, z_in_count, za, ZIP_CHECKCONS, zip_close(), ZIP_CREATE, zip_error_fini(), zip_error_init(), zip_error_strerror(), ZIP_EXCL, ZIP_FL_ENC_GUESS, ZIP_FL_ENC_RAW, ZIP_FL_ENC_STRICT, zip_strerror(), ZIP_TRUNCATE, ziptool_open, and ziptool_post_close().

name_locate()

static int name_locate ( char *  argv[] )

static

Definition at line 375 of file ziptool.c.

                          {
    zip_flags_t flags;
    zip_int64_t idx;
    flags = get_flags(argv[1]);
 
    if ((idx = zip_name_locate(za, argv[0], flags)) < 0) {
        fprintf(stderr, "can't find entry with name '%s' using flags '%s'\n", argv[0], argv[1]);
    }
    else {
        printf("name '%s' using flags '%s' found at index %" PRId64 "\n", argv[0], argv[1], idx);
    }
 
    return 0;
}

References argv, flags, get_flags(), setup::idx, PRId64, printf(), za, and zip_name_locate().

print_progress()

static int print_progress ( char *  argv[] )

static

Definition at line 404 of file ziptool.c.

                             {
    zip_register_progress_callback_with_state(za, 0.001, progress_callback, NULL, NULL);
    return 0;
}

References NULL, progress_callback(), za, and zip_register_progress_callback_with_state().

progress_callback()

static void progress_callback ( zip_t *  archive, double  percentage, void *  ud  )

static

Definition at line 398 of file ziptool.c.

                                                               {
    printf("%.1f%% done\n", percentage * 100);
    progress_userdata.percentage = percentage;
}

References percentage, progress_userdata_s::percentage, printf(), and progress_userdata.

Referenced by print_progress(), and zip_register_progress_callback().

read_from_file()

static zip_t* read_from_file ( const char *  archive, int  flags, zip_error_t *  error, zip_uint64_t  offset, zip_uint64_t  length  )

static

Definition at line 706 of file ziptool.c.

                                                                                                             {
    zip_t *zaa;
    zip_source_t *source;
    int err;
 
    if (offset == 0 && length == 0) {
        if (strcmp(archive, "/dev/stdin") == 0) {
            zaa = zip_fdopen(STDIN_FILENO, flags & ~ZIP_CREATE, &err);
        }
        else {
            zaa = zip_open(archive, flags, &err);
        }
        if (zaa == NULL) {
            zip_error_set(error, err, errno);
            return NULL;
        }
    }
    else {
        if (length > ZIP_INT64_MAX) {
            zip_error_set(error, ZIP_ER_INVAL, 0);
            return NULL;
        }
        if ((source = zip_source_file_create(archive, offset, (zip_int64_t)length, error)) == NULL || (zaa = zip_open_from_source(source, flags, error)) == NULL) {
            zip_source_free(source);
            return NULL;
        }
    }
 
    return zaa;
}

References err, error(), flags, length, NULL, source, STDIN_FILENO, ZIP_CREATE, ZIP_ER_INVAL, zip_error_set(), zip_fdopen(), ZIP_INT64_MAX, zip_open(), zip_open_from_source(), zip_source_file_create(), and zip_source_free().

Referenced by ziptool_open().

replace_file_contents()

static int replace_file_contents ( char *  argv[] )

static

Definition at line 421 of file ziptool.c.

                                    {
    /* replace file contents with data from command line */
    const char *content;
    zip_source_t *s;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    content = argv[1];
    if ((s = zip_source_buffer(za, content, strlen(content), 0)) == NULL || zip_file_replace(za, idx, s, 0) < 0) {
        zip_source_free(s);
        fprintf(stderr, "error replacing file data: %s\n", zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, s, za, zip_file_replace(), zip_source_buffer(), zip_source_free(), and zip_strerror().

set_archive_comment()

static int set_archive_comment ( char *  argv[] )

static

Definition at line 455 of file ziptool.c.

                                  {
    if (zip_set_archive_comment(za, argv[0], (zip_uint16_t)strlen(argv[0])) < 0) {
        fprintf(stderr, "can't set archive comment to '%s': %s\n", argv[0], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, za, zip_set_archive_comment(), and zip_strerror().

set_extra()

static int set_extra ( char *  argv[] )

static

Definition at line 437 of file ziptool.c.

                        {
    zip_flags_t geflags;
    zip_uint16_t eid, eidx;
    const zip_uint8_t *efdata;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    eidx = (zip_uint16_t)strtoull(argv[2], NULL, 10);
    geflags = get_flags(argv[3]);
    efdata = (zip_uint8_t *)argv[4];
    if ((zip_file_extra_field_set(za, idx, eid, eidx, efdata, (zip_uint16_t)strlen((const char *)efdata), geflags)) < 0) {
        fprintf(stderr, "can't set extra field data for file at index '%" PRIu64 "', extra field id '%d', index '%d': %s\n", idx, eid, eidx, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, get_flags(), setup::idx, NULL, PRIu64, za, zip_file_extra_field_set(), and zip_strerror().

set_file_comment()

static int set_file_comment ( char *  argv[] )

static

Definition at line 464 of file ziptool.c.

                               {
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    if (zip_file_set_comment(za, idx, argv[1], (zip_uint16_t)strlen(argv[1]), 0) < 0) {
        fprintf(stderr, "can't set file comment at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_file_set_comment(), and zip_strerror().

set_file_compression()

static int set_file_compression ( char *  argv[] )

static

Definition at line 475 of file ziptool.c.

                                   {
    zip_int32_t method;
    zip_uint32_t flags;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    method = get_compression_method(argv[1]);
    flags = (zip_uint32_t)strtoull(argv[2], NULL, 10);
    if (zip_set_file_compression(za, idx, method, flags) < 0) {
        fprintf(stderr, "can't set file compression method at index '%" PRIu64 "' to '%s', flags '%" PRIu32 "': %s\n", idx, argv[1], flags, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, flags, get_compression_method(), setup::idx, NULL, PRIu32, PRIu64, za, zip_set_file_compression(), and zip_strerror().

set_file_dostime()

static int set_file_dostime ( char *  argv[] )

static

Definition at line 508 of file ziptool.c.

                               {
    /* set file last modification time (mtime) directly */
    zip_uint16_t dostime, dosdate;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    dostime = (zip_uint16_t)strtoull(argv[1], NULL, 10);
    dosdate = (zip_uint16_t)strtoull(argv[2], NULL, 10);
    if (zip_file_set_dostime(za, idx, dostime, dosdate, 0) < 0) {
        fprintf(stderr, "can't set file dostime at index '%" PRIu64 "' to '%d'/'%d': %s\n", idx, (int)dostime, (int)dosdate, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_file_set_dostime(), and zip_strerror().

set_file_encryption()

static int set_file_encryption ( char *  argv[] )

static

Definition at line 490 of file ziptool.c.

                                  {
    zip_uint16_t method;
    zip_uint64_t idx;
    char *password;
    idx = strtoull(argv[0], NULL, 10);
    method = get_encryption_method(argv[1]);
    password = argv[2];
    if (strlen(password) == 0) {
        password = NULL;
    }
    if (zip_file_set_encryption(za, idx, method, password) < 0) {
        fprintf(stderr, "can't set file encryption method at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, get_encryption_method(), setup::idx, NULL, PRIu64, za, zip_file_set_encryption(), and zip_strerror().

set_file_mtime()

static int set_file_mtime ( char *  argv[] )

static

Definition at line 523 of file ziptool.c.

                             {
    /* set file last modification time (mtime) */
    time_t mtime;
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    mtime = (time_t)strtoull(argv[1], NULL, 10);
    if (zip_file_set_mtime(za, idx, mtime, 0) < 0) {
        fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_file_set_mtime(), and zip_strerror().

set_file_mtime_all()

static int set_file_mtime_all ( char *  argv[] )

static

Definition at line 537 of file ziptool.c.

                                 {
    /* set last modification time (mtime) for all files */
    time_t mtime;
    zip_int64_t num_entries;
    zip_uint64_t idx;
    mtime = (time_t)strtoull(argv[0], NULL, 10);
 
    if ((num_entries = zip_get_num_entries(za, 0)) < 0) {
        fprintf(stderr, "can't get number of entries: %s\n", zip_strerror(za));
        return -1;
    }
    for (idx = 0; idx < (zip_uint64_t)num_entries; idx++) {
        if (zip_file_set_mtime(za, idx, mtime, 0) < 0) {
            fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
            return -1;
        }
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_file_set_mtime(), zip_get_num_entries(), and zip_strerror().

set_password()

static int set_password ( char *  argv[] )

static

Definition at line 558 of file ziptool.c.

                           {
    /* set default password */
    if (zip_set_default_password(za, argv[0]) < 0) {
        fprintf(stderr, "can't set default password to '%s'\n", argv[0]);
        return -1;
    }
    return 0;
}

References argv, za, and zip_set_default_password().

usage()

static void usage ( const char *  progname, const char *  reason  )

static

Definition at line 796 of file ziptool.c.

                                                {
    unsigned int i;
    FILE *out;
    if (reason == NULL)
        out = stdout;
    else
        out = stderr;
    fprintf(out, "usage: %s [-ceghnrst]" USAGE_REGRESS " [-l len] [-o offset] archive command1 [args] [command2 [args] ...]\n", progname);
    if (reason != NULL) {
        fprintf(out, "%s\n", reason);
        exit(1);
    }
 
    fprintf(out, "\nSupported options are:\n"
                 "\t-c\t\tcheck consistency\n"
                 "\t-e\t\terror if archive already exists (only useful with -n)\n"
#ifdef FOR_REGRESS
                 "\t-F size\t\tfragment size for in memory archive\n"
#endif
                 "\t-g\t\tguess file name encoding (for stat)\n"
#ifdef FOR_REGRESS
                 "\t-H\t\twrite files with holes compactly\n"
#endif
                 "\t-h\t\tdisplay this usage\n"
                 "\t-l len\t\tonly use len bytes of file\n"
#ifdef FOR_REGRESS
                 "\t-m\t\tread archive into memory, and modify there; write out at end\n"
#endif
                 "\t-n\t\tcreate archive if it doesn't exist\n"
                 "\t-o offset\tstart reading file at offset\n"
                 "\t-r\t\tprint raw file name encoding without translation (for stat)\n"
                 "\t-s\t\tfollow file name convention strictly (for stat)\n"
                 "\t-t\t\tdisregard current archive contents, if any\n");
    fprintf(out, "\nSupported commands and arguments are:\n");
    for (i = 0; i < sizeof(dispatch_table) / sizeof(dispatch_table_t); i++) {
        fprintf(out, "\t%s %s\n\t    %s\n\n", dispatch_table[i].cmdline_name, dispatch_table[i].arg_names, dispatch_table[i].description);
    }
    fprintf(out, "\nSupported flags are:\n"
                 "\t0\t(no flags)\n"
                 "\t4\tZIP_FL_ENC_CP437\n"
                 "\t8\tZIP_FL_ENC_UTF_8\n"
                 "\tC\tZIP_FL_NOCASE\n"
                 "\tc\tZIP_FL_CENTRAL\n"
                 "\td\tZIP_FL_NODIR\n"
                 "\tl\tZIP_FL_LOCAL\n"
                 "\tr\tZIP_FL_ENC_RAW\n"
                 "\ts\tZIP_FL_ENC_STRICT\n"
                 "\tu\tZIP_FL_UNCHANGED\n");
    fprintf(out, "\nSupported compression methods are:\n"
                 "\tdefault\n");
    if (zip_compression_method_supported(ZIP_CM_BZIP2, 1)) {
        fprintf(out, "\tbzip2\n");
    }
    fprintf(out, "\tdeflate\n"
                 "\tstore\n");
    if (zip_compression_method_supported(ZIP_CM_XZ, 1)) {
        fprintf(out, "\txz\n");
    }
    if (zip_compression_method_supported(ZIP_CM_ZSTD, 1)) {
        fprintf(out, "\tzstd\n");
    }
    fprintf(out, "\nSupported encryption methods are:\n"
                 "\tnone\n");
    if (zip_encryption_method_supported(ZIP_EM_AES_128, 1)) {
        fprintf(out, "\tAES-128\n");
    }
    if (zip_encryption_method_supported(ZIP_EM_AES_192, 1)) {
        fprintf(out, "\tAES-192\n");
    }
    if (zip_encryption_method_supported(ZIP_EM_AES_256, 1)) {
        fprintf(out, "\tAES-256\n");
    }
    fprintf(out, "\tPKWARE\n");
    fprintf(out, "\nThe index is zero-based.\n");
    exit(0);
}

References setup::description, dispatch_table, test-lz4-list::exit, benchmark::FILE, FOR_REGRESS, i, NULL, out, progname, USAGE_REGRESS, ZIP_CM_BZIP2, ZIP_CM_XZ, ZIP_CM_ZSTD, zip_compression_method_supported(), ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, and zip_encryption_method_supported().

Referenced by main().

ziptool_post_close()

int ziptool_post_close

(

const char *

archive

)

Definition at line 876 of file ziptool.c.

                                        {
    return 0;
}

Referenced by main().

zrename()

static int zrename ( char *  argv[] )

static

Definition at line 410 of file ziptool.c.

                      {
    zip_uint64_t idx;
    idx = strtoull(argv[0], NULL, 10);
    if (zip_rename(za, idx, argv[1]) < 0) {
        fprintf(stderr, "can't rename file at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_rename(), and zip_strerror().

zstat()

static int zstat ( char *  argv[] )

static

Definition at line 568 of file ziptool.c.

                    {
    zip_uint64_t idx;
    char buf[100];
    struct zip_stat sb;
    idx = strtoull(argv[0], NULL, 10);
 
    if (zip_stat_index(za, idx, stat_flags, &sb) < 0) {
        fprintf(stderr, "zip_stat_index failed on '%" PRIu64 "' failed: %s\n", idx, zip_strerror(za));
        return -1;
    }
 
    if (sb.valid & ZIP_STAT_NAME)
        printf("name: '%s'\n", sb.name);
    if (sb.valid & ZIP_STAT_INDEX)
        printf("index: '%" PRIu64 "'\n", sb.index);
    if (sb.valid & ZIP_STAT_SIZE)
        printf("size: '%" PRIu64 "'\n", sb.size);
    if (sb.valid & ZIP_STAT_COMP_SIZE)
        printf("compressed size: '%" PRIu64 "'\n", sb.comp_size);
    if (sb.valid & ZIP_STAT_MTIME) {
        struct tm *tpm;
#ifdef HAVE_LOCALTIME_R
        struct tm tm;
        tpm = localtime_r(&sb.mtime, &tm);
#else
        tpm = localtime(&sb.mtime);
#endif
        if (tpm == NULL) {
            printf("mtime: <not valid>\n");
        }
        else {
            strftime(buf, sizeof(buf), "%a %b %d %Y %H:%M:%S", tpm);
            printf("mtime: '%s'\n", buf);
        }
    }
    if (sb.valid & ZIP_STAT_CRC)
        printf("crc: '%0x'\n", sb.crc);
    if (sb.valid & ZIP_STAT_COMP_METHOD)
        printf("compression method: '%d'\n", sb.comp_method);
    if (sb.valid & ZIP_STAT_ENCRYPTION_METHOD)
        printf("encryption method: '%d'\n", sb.encryption_method);
    if (sb.valid & ZIP_STAT_FLAGS)
        printf("flags: '%ld'\n", (long)sb.flags);
    printf("\n");
 
    return 0;
}

References argv, setup::idx, NULL, printf(), PRIu64, sb, stat_flags, za, ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, ZIP_STAT_CRC, ZIP_STAT_ENCRYPTION_METHOD, ZIP_STAT_FLAGS, ZIP_STAT_INDEX, zip_stat_index(), ZIP_STAT_MTIME, ZIP_STAT_NAME, ZIP_STAT_SIZE, and zip_strerror().

Variable Documentation

dispatch_table

dispatch_table_t dispatch_table[]

Definition at line 737 of file ziptool.c.

Referenced by dispatch(), and usage().

optopt

int optopt

extern

Definition at line 7 of file getopt.h.

Referenced by main().

progress_userdata

struct progress_userdata_s progress_userdata

Definition at line 375 of file ziptool.c.

Referenced by cancel(), cancel_callback(), and progress_callback().

stat_flags

zip_flags_t stat_flags

Definition at line 81 of file ziptool.c.

Referenced by main(), and zstat().

z_in

zip_t * z_in[16]

Definition at line 79 of file ziptool.c.

Referenced by add_from_zip(), main(), and zin_close().

z_in_count

unsigned int z_in_count

Definition at line 80 of file ziptool.c.

Referenced by add_from_zip(), main(), and zin_close().

za

zip_t* za

Definition at line 79 of file ziptool.c.

Referenced by _zip_add_entry(), _zip_allocate_new(), _zip_cdir_write(), _zip_changed(), _zip_checkcons(), _zip_deregister_source(), _zip_dirent_write(), _zip_ef_write(), _zip_file_extra_field_prepare_for_change(), _zip_file_get_end(), _zip_file_get_offset(), _zip_file_new(), _zip_file_replace(), _zip_find_central_dir(), _zip_get_dirent(), _zip_get_name(), _zip_name_locate(), _zip_new(), _zip_open(), _zip_progress_new(), _zip_read_cdir(), _zip_read_local_ef(), _zip_register_source(), _zip_set_name(), _zip_source_set_source_archive(), _zip_string_write(), _zip_unchange(), _zip_write(), add(), add_data(), add_dir(), add_file(), add_from_zip(), add_nul(), cancel(), cat(), compare_zip(), compression_source_new(), confirm_replace(), copy_data(), copy_source(), count_extra(), count_extra_by_id(), delete(), delete_extra(), delete_extra_by_id(), ef_read(), get_archive_comment(), get_extra(), get_extra_by_id(), get_file_comment(), get_num_entries(), is_seekable(), list_zip(), LLVMFuzzerTestOneInput(), main(), merge_zip(), name_locate(), print_progress(), replace_file_contents(), seek(), set_archive_comment(), set_extra(), set_file_comment(), set_file_compression(), set_file_dostime(), set_file_encryption(), set_file_mtime(), set_file_mtime_all(), set_password(), test_file(), unchange_all(), unchange_one(), windows_open(), write_cdir(), write_data_descriptor(), zip_add(), zip_add_dir(), zip_close(), zip_delete(), zip_dir_add(), zip_discard(), zip_error_clear(), zip_error_get(), zip_fdopen(), zip_file_add(), zip_file_extra_field_delete(), zip_file_extra_field_delete_by_id(), zip_file_extra_field_get(), zip_file_extra_field_get_by_id(), zip_file_extra_field_set(), zip_file_extra_fields_count(), zip_file_extra_fields_count_by_id(), zip_file_get_comment(), zip_file_get_external_attributes(), zip_file_rename(), zip_file_replace(), zip_file_set_comment(), zip_file_set_dostime(), zip_file_set_encryption(), zip_file_set_external_attributes(), zip_file_set_mtime(), zip_fopen(), zip_fopen_encrypted(), zip_fopen_index(), zip_fopen_index_encrypted(), zip_get_archive_comment(), zip_get_archive_flag(), zip_get_error(), zip_get_file_comment(), zip_get_name(), zip_get_num_entries(), zip_get_num_files(), zip_name_locate(), zip_open(), zip_open_from_source(), zip_register_cancel_callback_with_state(), zip_register_progress_callback(), zip_register_progress_callback_with_state(), zip_rename(), zip_replace(), zip_set_archive_comment(), zip_set_archive_flag(), zip_set_default_password(), zip_set_file_comment(), zip_set_file_compression(), zip_source_buffer(), zip_source_buffer_fragment(), zip_source_buffer_with_attributes(), zip_source_compress(), zip_source_decompress(), zip_source_file(), zip_source_filep(), zip_source_function(), zip_source_layered(), zip_source_pkware_decode(), zip_source_pkware_encode(), zip_source_win32a(), zip_source_win32handle(), zip_source_win32w(), zip_source_winzip_aes_decode(), zip_source_winzip_aes_encode(), zip_source_zip(), zip_stat(), zip_stat_index(), zip_strerror(), zip_unchange(), zip_unchange_all(), zip_unchange_archive(), ziptool_open(), zrename(), and zstat().