zipcmp.c File Reference

#include "config.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <zlib.h>
#include "getopt.h"
#include "zip.h"
#include "compat.h"
#include "diff_output.h"

Go to the source code of this file.

Classes
struct	archive
struct	ef
struct	entry
struct	enum_map_t

Macros
#define	PROGRAM   "zipcmp"
#define	USAGE   "usage: %s [-hipqtVv] archive1 archive2\n"
#define	OPTIONS   "hVCipqstv"
#define	BOTH_ARE_ZIPS(a)   (a[0].za && a[1].za)
#define	INC(k)   (i[k]++, list[k] = ((const char *)list[k]) + element_size)
#define	PRINT(k)

Functions
static int	comment_compare (const char *c1, size_t l1, const char *c2, size_t l2)
static int	compare_list (char *const name[2], const void *list[2], const zip_uint64_t list_length[2], int element_size, int(*cmp)(const void *a, const void *b), int(*ignore)(const void *list, int last, const void *other), int(*check)(char *const name[2], const void *a, const void *b), void(*print)(char side, const void *element), void(*start_file)(const void *element))
static int	compare_zip (char *const zn[])
static int	ef_compare (char *const name[2], const struct entry *e1, const struct entry *e2)
static int	ef_order (const void *a, const void *b)
static void	ef_print (char side, const void *p)
static int	ef_read (zip_t *za, zip_uint64_t idx, struct entry *e)
static int	entry_cmp (const void *p1, const void *p2)
static int	entry_ignore (const void *p1, int last, const void *o)
static int	entry_paranoia_checks (char *const name[2], const void *p1, const void *p2)
static void	entry_print (char side, const void *p)
static void	entry_start_file (const void *p)
static const char *	map_enum (const enum_map_t *map, uint32_t value)
static int	is_directory (const char *name)
static int	list_zip (const char *name, struct archive *a)
static int	test_file (zip_t *za, zip_uint64_t idx, const char *zipname, const char *filename, zip_uint64_t size, zip_uint32_t crc)
int	main (int argc, char *const argv[])

Variables
const enum_map_t	comp_methods []
const enum_map_t	extra_fields []
const char *	progname
char	help_head [] = PROGRAM " (" PACKAGE ") by Dieter Baron and Thomas Klausner\n\n"
char	help []
char	version_string []
int	ignore_case
int	test_files
int	paranoid
int	verbose
int	have_directory
int	check_consistency
int	summary
int	plus_count = 0
int	minus_count = 0
diff_output_t	output

Macro Definition Documentation

BOTH_ARE_ZIPS

#define BOTH_ARE_ZIPS

(

a

)

(a[0].za && a[1].za)

Definition at line 211 of file zipcmp.c.

INC

#define INC

(

k

)

(i[k]++, list[k] = ((const char *)list[k]) + element_size)

OPTIONS

#define OPTIONS   "hVCipqstv"

Definition at line 208 of file zipcmp.c.

PRINT

#define PRINT

(

k

)

Value:

    do {                                                  \
        if (ignore && ignore(list[k], i[k] >= list_length[k] - 1, i[1-k] < list_length[1-k] ? list[1-k] : NULL)) {   \
            break;                                        \
        }                                                 \
        print((k) ? '+' : '-', list[k]);                  \
        (k) ? plus_count++ : minus_count++;       \
        diff = 1;                                         \
    } while (0)

PROGRAM

#define PROGRAM   "zipcmp"

Definition at line 185 of file zipcmp.c.

USAGE

#define USAGE   "usage: %s [-hipqtVv] archive1 archive2\n"

Definition at line 187 of file zipcmp.c.

Function Documentation

comment_compare()

static int comment_compare ( const char *  c1, size_t  l1, const char *  c2, size_t  l2  )

static

Definition at line 585 of file zipcmp.c.

                                                                      {
    if (l1 != l2)
        return 1;
 
    if (l1 == 0)
        return 0;
 
    if (c1 == NULL || c2 == NULL)
        return c1 == c2;
 
    return memcmp(c1, c2, (size_t)l2);
}

References c1, c2, and NULL.

Referenced by compare_zip(), and entry_paranoia_checks().

compare_list()

static int compare_list ( char *const  name[2], const void *  list[2], const zip_uint64_t  list_length[2], int  element_size, int(*)(const void *a, const void *b)  cmp, int(*)(const void *list, int last, const void *other)  ignore, int(*)(char *const name[2], const void *a, const void *b)  check, void(*)(char side, const void *element)  print, void(*)(const void *element)  start_file  )

static

Definition at line 599 of file zipcmp.c.

                                                                                                                                                                                                                                                                                                                                                                                        {
    unsigned int i[2];
    int j;
    int diff;
 
#define INC(k) (i[k]++, list[k] = ((const char *)list[k]) + element_size)
#define PRINT(k)                                          \
    do {                                                  \
        if (ignore && ignore(list[k], i[k] >= list_length[k] - 1, i[1-k] < list_length[1-k] ? list[1-k] : NULL)) {   \
            break;                                        \
        }                                                 \
        print((k) ? '+' : '-', list[k]);                  \
        (k) ? plus_count++ : minus_count++;       \
        diff = 1;                                         \
    } while (0)
 
    i[0] = i[1] = 0;
    diff = 0;
    while (i[0] < list_length[0] && i[1] < list_length[1]) {
        int c = cmp(list[0], list[1]);
 
        if (c == 0) {
            if (check) {
                if (start_file) {
                    start_file(list[0]);
                }
                diff |= check(name, list[0], list[1]);
                if (start_file) {
                    diff_output_end_file(&output);
                }
            }
            INC(0);
            INC(1);
        }
        else if (c < 0) {
            PRINT(0);
            INC(0);
        }
        else {
            PRINT(1);
            INC(1);
        }
    }
 
    for (j = 0; j < 2; j++) {
        while (i[j] < list_length[j]) {
            PRINT(j);
            INC(j);
        }
    }
 
    return diff;
}

References c, check, cmp(), diff_output_end_file(), i, INC, list(), output, and PRINT.

Referenced by compare_zip(), and ef_compare().

compare_zip()

static int compare_zip ( char *const  zn[] )

static

Definition at line 303 of file zipcmp.c.

                              {
    struct archive a[2];
    struct entry *e[2];
    zip_uint64_t n[2];
    int i;
    int res;
 
    for (i = 0; i < 2; i++) {
        a[i].name = zn[i];
        a[i].entry = NULL;
        a[i].nentry = 0;
        a[i].za = NULL;
        a[i].comment = NULL;
        a[i].comment_length = 0;
 
        if (is_directory(zn[i])) {
#ifndef HAVE_FTS_H
            fprintf(stderr, "%s: reading directories not supported\n", progname);
            exit(2);
#else
            if (list_directory(zn[i], a + i) < 0)
                exit(2);
            have_directory = 1;
            paranoid = 0; /* paranoid checks make no sense for directories, since they compare zip metadata */
#endif
        }
        else {
            if (list_zip(zn[i], a + i) < 0)
                exit(2);
        }
        if (a[i].nentry > 0)
            qsort(a[i].entry, a[i].nentry, sizeof(a[i].entry[0]), entry_cmp);
    }
 
    diff_output_init(&output, verbose, zn);
 
    e[0] = a[0].entry;
    e[1] = a[1].entry;
    n[0] = a[0].nentry;
    n[1] = a[1].nentry;
    res = compare_list(zn, (const void **)e, n, sizeof(e[i][0]), entry_cmp, have_directory ? entry_ignore : NULL, paranoid ? entry_paranoia_checks : NULL, entry_print, entry_start_file);
 
    if (paranoid) {
        if (comment_compare(a[0].comment, a[0].comment_length, a[1].comment, a[1].comment_length) != 0) {
            if (a[0].comment_length > 0) {
                diff_output_data(&output, '-', (const zip_uint8_t *)a[0].comment, a[0].comment_length, "archive comment");
        minus_count++;
            }
            if (a[1].comment_length > 0) {
                diff_output_data(&output, '+', (const zip_uint8_t *)a[1].comment, a[1].comment_length, "archive comment");
        plus_count++;
            }
            res = 1;
        }
    }
 
    for (i = 0; i < 2; i++) {
        zip_uint64_t j;
 
        if (a[i].za) {
            zip_close(a[i].za);
        }
        for (j = 0; j < a[i].nentry; j++) {
            free(a[i].entry[j].name);
        }
        free(a[i].entry);
    }
 
    if (summary) {
    printf("%d files removed, %d files added\n", minus_count, plus_count);
    }
 
    switch (res) {
    case 0:
        exit(0);
 
    case 1:
        exit(1);
 
    default:
        exit(2);
    }
}

References a, entry::comment, comment_compare(), entry::comment_length, compare_list(), diff_output_data(), diff_output_init(), e, entry_cmp(), entry_ignore(), entry_paranoia_checks(), entry_print(), entry_start_file(), test-lz4-list::exit, free(), have_directory, i, is_directory(), list_zip(), minus_count, n, NULL, output, paranoid, plus_count, printf(), progname, qsort(), summary, verbose, za, and zip_close().

Referenced by main().

ef_compare()

static int ef_compare ( char *const  name[2], const struct entry *  e1, const struct entry *  e2  )

static

Definition at line 690 of file zipcmp.c.

                                                                                {
    struct ef *ef[2];
    zip_uint64_t n[2];
 
    ef[0] = e1->extra_fields;
    ef[1] = e2->extra_fields;
    n[0] = e1->n_extra_fields;
    n[1] = e2->n_extra_fields;
 
    return compare_list(name, (const void **)ef, n, sizeof(struct ef), ef_order, NULL, NULL, ef_print, NULL);
}

References compare_list(), ef_order(), ef_print(), entry::extra_fields, n, entry::n_extra_fields, and NULL.

Referenced by entry_paranoia_checks().

ef_order()

static int ef_order ( const void *  a, const void *  b  )

static

Definition at line 704 of file zipcmp.c.

                                         {
    const struct ef *a, *b;
 
    a = (struct ef *)ap;
    b = (struct ef *)bp;
 
    if (a->flags != b->flags)
        return a->flags - b->flags;
    if (a->id != b->id)
        return a->id - b->id;
    if (a->size != b->size)
        return a->size - b->size;
    return memcmp(a->data, b->data, a->size);
}

References a, and b.

Referenced by ef_compare(), and ef_read().

ef_print()

static void ef_print ( char  side, const void *  p  )

static

Definition at line 721 of file zipcmp.c.

                                   {
    const struct ef *ef = (struct ef *)p;
 
    diff_output_data(&output, side, ef->data, ef->size, "  %s extra field %s", ef->flags == ZIP_FL_LOCAL ? "local" : "central", map_enum(extra_fields, ef->id));
}

References ef::data, diff_output_data(), extra_fields, ef::flags, ef::id, map_enum(), output, p, ef::size, and ZIP_FL_LOCAL.

Referenced by ef_compare().

ef_read()

static int ef_read ( zip_t *  za, zip_uint64_t  idx, struct entry *  e  )

static

Definition at line 655 of file zipcmp.c.

                                                      {
    zip_int16_t n_local, n_central;
    zip_uint16_t i;
 
    if ((n_local = zip_file_extra_fields_count(za, idx, ZIP_FL_LOCAL)) < 0 || (n_central = zip_file_extra_fields_count(za, idx, ZIP_FL_CENTRAL)) < 0) {
        return -1;
    }
 
    e->n_extra_fields = (zip_uint16_t)(n_local + n_central);
 
    if ((e->extra_fields = (struct ef *)malloc(sizeof(e->extra_fields[0]) * e->n_extra_fields)) == NULL)
        return -1;
 
    for (i = 0; i < n_local; i++) {
        e->extra_fields[i].name = e->name;
        e->extra_fields[i].data = zip_file_extra_field_get(za, idx, i, &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_LOCAL);
        if (e->extra_fields[i].data == NULL)
            return -1;
        e->extra_fields[i].flags = ZIP_FL_LOCAL;
    }
    for (; i < e->n_extra_fields; i++) {
        e->extra_fields[i].name = e->name;
        e->extra_fields[i].data = zip_file_extra_field_get(za, idx, (zip_uint16_t)(i - n_local), &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_CENTRAL);
        if (e->extra_fields[i].data == NULL)
            return -1;
        e->extra_fields[i].flags = ZIP_FL_CENTRAL;
    }
 
    qsort(e->extra_fields, e->n_extra_fields, sizeof(e->extra_fields[0]), ef_order);
 
    return 0;
}

References e, ef_order(), i, setup::idx, malloc(), NULL, qsort(), za, zip_file_extra_field_get(), zip_file_extra_fields_count(), ZIP_FL_CENTRAL, and ZIP_FL_LOCAL.

Referenced by list_zip().

entry_cmp()

static int entry_cmp ( const void *  p1, const void *  p2  )

static

Definition at line 729 of file zipcmp.c.

                                          {
    const struct entry *e1, *e2;
    int c;
 
    e1 = (struct entry *)p1;
    e2 = (struct entry *)p2;
 
    if ((c = (ignore_case ? strcasecmp : strcmp)(e1->name, e2->name)) != 0)
        return c;
    if (e1->size != e2->size) {
        if (e1->size > e2->size)
            return 1;
        else
            return -1;
    }
    if (e1->crc != e2->crc)
        return (int)e1->crc - (int)e2->crc;
 
    return 0;
}

References c, entry::crc, ignore_case, int, entry::name, and entry::size.

Referenced by compare_zip().

entry_ignore()

static int entry_ignore ( const void *  p1, int  last, const void *  o  )

static

Definition at line 752 of file zipcmp.c.

                                                     {
    const struct entry *e = (const struct entry *)p;
    const struct entry *other = (const struct entry *)o;
    
    size_t length = strlen(e[0].name);
    
    if (length == 0 || e[0].name[length - 1] != '/') {
        /* not a directory */
        return 0;
    }
    
    if (other != NULL && strlen(other->name) > length && strncmp(other->name, e[0].name, length) == 0) {
        /* not empty in other archive */
        return 1;
    }
    
    if (last || (strlen(e[1].name) < length || strncmp(e[0].name, e[1].name, length) != 0)) {
        /* empty in this archive */
        return 0;
    }
    
    /* not empty in this archive */
    return 1;
}

References e, length, entry::name, NULL, and p.

Referenced by compare_zip().

entry_paranoia_checks()

static int entry_paranoia_checks ( char *const  name[2], const void *  p1, const void *  p2  )

static

Definition at line 779 of file zipcmp.c.

                                                                           {
    const struct entry *e1, *e2;
    int ret;
 
    e1 = (struct entry *)p1;
    e2 = (struct entry *)p2;
 
    ret = 0;
 
    if (e1->comp_method != e2->comp_method) {
        diff_output(&output, '-', "  compression method %s", map_enum(comp_methods, e1->comp_method));
        diff_output(&output, '+', "  compression method %s", map_enum(comp_methods, e2->comp_method));
        ret = 1;
    }
 
    if (ef_compare(name, e1, e2) != 0) {
        ret = 1;
    }
 
    if (comment_compare(e1->comment, e1->comment_length, e2->comment, e2->comment_length) != 0) {
        diff_output_data(&output, '-', (const zip_uint8_t *)e1->comment, e1->comment_length, "  comment");
        diff_output_data(&output, '+', (const zip_uint8_t *)e2->comment, e2->comment_length, "  comment");
        ret = 1;
    }
 
    return ret;
}

References entry::comment, comment_compare(), entry::comment_length, entry::comp_method, comp_methods, diff_output(), diff_output_data(), ef_compare(), map_enum(), and output.

Referenced by compare_zip().

entry_print()

static void entry_print ( char  side, const void *  p  )

static

Definition at line 808 of file zipcmp.c.

                                                  {
    const struct entry *e = (struct entry *)p;
 
    diff_output_file(&output, side, e->name, e->size, e->crc);
}

References diff_output_file(), e, output, and p.

Referenced by compare_zip().

entry_start_file()

static void entry_start_file ( const void *  p )

static

Definition at line 815 of file zipcmp.c.

                                            {
    const struct entry *e = (struct entry *)p;
    
    diff_output_start_file(&output, e->name, e->size, e->crc);
}

References diff_output_start_file(), e, output, and p.

Referenced by compare_zip().

is_directory()

static int is_directory ( const char *  name )

static

Definition at line 419 of file zipcmp.c.

                               {
    struct stat st;
 
    if (stat(name, &st) < 0)
        return 0;
 
    return S_ISDIR(st.st_mode);
}

References S_ISDIR, and stat.

Referenced by compare_zip().

list_zip()

static int list_zip ( const char *  name, struct archive *  a  )

static

Definition at line 526 of file zipcmp.c.

                                              {
    zip_t *za;
    int err;
    struct zip_stat st;
    unsigned int i;
 
    if ((za = zip_open(name, check_consistency ? ZIP_CHECKCONS : 0, &err)) == NULL) {
        zip_error_t error;
        zip_error_init_with_code(&error, err);
        fprintf(stderr, "%s: cannot open zip archive '%s': %s\n", progname, name, zip_error_strerror(&error));
        zip_error_fini(&error);
        return -1;
    }
 
    a->za = za;
    a->nentry = (zip_uint64_t)zip_get_num_entries(za, 0);
 
    if (a->nentry == 0)
        a->entry = NULL;
    else {
        if ((a->nentry > SIZE_MAX / sizeof(a->entry[0])) || (a->entry = (struct entry *)malloc(sizeof(a->entry[0]) * a->nentry)) == NULL) {
            fprintf(stderr, "%s: malloc failure\n", progname);
            exit(1);
        }
 
        for (i = 0; i < a->nentry; i++) {
            zip_stat_index(za, i, 0, &st);
            a->entry[i].name = strdup(st.name);
            a->entry[i].size = st.size;
            a->entry[i].crc = st.crc;
            if (test_files)
                test_file(za, i, name, st.name, st.size, st.crc);
            if (paranoid) {
                a->entry[i].comp_method = st.comp_method;
                ef_read(za, i, a->entry + i);
                a->entry[i].comment = zip_file_get_comment(za, i, &a->entry[i].comment_length, 0);
            }
            else {
                a->entry[i].comp_method = 0;
                a->entry[i].n_extra_fields = 0;
            }
        }
 
        if (paranoid) {
            int length;
            a->comment = zip_get_archive_comment(za, &length, 0);
            a->comment_length = (size_t)length;
        }
        else {
            a->comment = NULL;
            a->comment_length = 0;
        }
    }
 
    return 0;
}

References a, check_consistency, zip_stat::comp_method, zip_stat::crc, ef_read(), err, error(), test-lz4-list::exit, i, length, malloc(), zip_stat::name, NULL, paranoid, progname, zip_stat::size, SIZE_MAX, strdup(), test_file(), test_files, za, ZIP_CHECKCONS, zip_error_fini(), zip_error_init_with_code(), zip_error_strerror(), zip_file_get_comment(), zip_get_archive_comment(), zip_get_num_entries(), zip_open(), and zip_stat_index().

Referenced by compare_zip().

main()

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

Definition at line 241 of file zipcmp.c.

                                   {
    int c;
 
    progname = argv[0];
 
    ignore_case = 0;
    test_files = 0;
    check_consistency = 0;
    paranoid = 0;
    have_directory = 0;
    verbose = 1;
    summary = 0;
 
    while ((c = getopt(argc, argv, OPTIONS)) != -1) {
        switch (c) {
            case 'C':
                check_consistency = 1;
                break;
            case 'i':
                ignore_case = 1;
                break;
            case 'p':
                paranoid = 1;
                break;
            case 'q':
                verbose = 0;
                break;
        case 's':
        summary = 1;
        break;
            case 't':
                test_files = 1;
                break;
            case 'v':
                verbose = 1;
                break;
                
            case 'h':
                fputs(help_head, stdout);
                printf(USAGE, progname);
                fputs(help, stdout);
                exit(0);
            case 'V':
                fputs(version_string, stdout);
                exit(0);
                
            default:
                fprintf(stderr, USAGE, progname);
                exit(2);
        }
    }
 
    if (argc != optind + 2) {
        fprintf(stderr, USAGE, progname);
        exit(2);
    }
 
    exit((compare_zip(argv + optind) == 0) ? 0 : 1);
}

References argv, c, check_consistency, compare_zip(), test-lz4-list::exit, getopt(), have_directory, help, help_head, ignore_case, optind, OPTIONS, paranoid, printf(), progname, summary, test_files, USAGE, verbose, and version_string.

map_enum()

static const char * map_enum ( const enum_map_t *  map, uint32_t  value  )

static

Definition at line 864 of file zipcmp.c.

                                                                   {
    static char unknown[16];
    size_t i = 0;
    
    while (map[i].value < UINT32_MAX) {
        if (map[i].value == value) {
            return map[i].name;
        }
        i++;
    }
    
    snprintf(unknown, sizeof(unknown), "unknown (%u)", value);
    unknown[sizeof(unknown) - 1] = '\0';
    
    return unknown;
}

References i, map(), snprintf, UINT32_MAX, and value.

Referenced by ef_print(), and entry_paranoia_checks().

test_file()

static int test_file ( zip_t *  za, zip_uint64_t  idx, const char *  zipname, const char *  filename, zip_uint64_t  size, zip_uint32_t  crc  )

static

Definition at line 823 of file zipcmp.c.

                                                                                                                       {
    zip_file_t *zf;
    char buf[8192];
    zip_uint64_t nsize;
    zip_int64_t n;
    zip_uint32_t ncrc;
 
    if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
        fprintf(stderr, "%s: %s: cannot open file %s (index %" PRIu64 "): %s\n", progname, zipname, filename, idx, zip_strerror(za));
        return -1;
    }
 
    ncrc = (zip_uint32_t)crc32(0, NULL, 0);
    nsize = 0;
 
    while ((n = zip_fread(zf, buf, sizeof(buf))) > 0) {
        nsize += (zip_uint64_t)n;
        ncrc = (zip_uint32_t)crc32(ncrc, (const Bytef *)buf, (unsigned int)n);
    }
 
    if (n < 0) {
        fprintf(stderr, "%s: %s: error reading file %s (index %" PRIu64 "): %s\n", progname, zipname, filename, idx, zip_file_strerror(zf));
        zip_fclose(zf);
        return -1;
    }
 
    zip_fclose(zf);
 
    if (nsize != size) {
        fprintf(stderr, "%s: %s: file %s (index %" PRIu64 "): unexpected length %" PRId64 " (should be %" PRId64 ")\n", progname, zipname, filename, idx, nsize, size);
        return -2;
    }
    if (ncrc != crc) {
        fprintf(stderr, "%s: %s: file %s (index %" PRIu64 "): unexpected length %x (should be %x)\n", progname, zipname, filename, idx, ncrc, crc);
        return -2;
    }
 
    return 0;
}

References entry::crc, crc32(), setup::idx, int, n, NULL, PRId64, PRIu64, progname, za, zip_fclose(), zip_file_strerror(), zip_fopen_index(), zip_fread(), and zip_strerror().

Referenced by list_zip().

Variable Documentation

check_consistency

int check_consistency

Definition at line 234 of file zipcmp.c.

Referenced by list_zip(), and main().

comp_methods

const enum_map_t comp_methods[]

Initial value:

= {
    { 0, "Stored (no compression)" },
    { 1, "Shrunk" },
    { 2, "Reduced with compression factor 1" },
    { 3, "Reduced with compression factor 2" },
    { 4, "Reduced with compression factor 3" },
    { 5, "Reduced with compression factor 4" },
    { 6, "Imploded" },
    { 7, "Reserved for Tokenizing compression algorithm" },
    { 8, "Deflated" },
    { 9, "Enhanced Deflating using Deflate64(tm)" },
    { 10, "PKWARE Data Compression Library Imploding (old IBM TERSE)" },
    { 11, "11 (Reserved by PKWARE)" },
    { 12, "BZIP2" },
    { 13, "13 (Reserved by PKWARE)" },
    { 14, "LZMA (EFS)" },
    { 15, "15 (Reserved by PKWARE)" },
    { 16, "16 (Reserved by PKWARE)" },
    { 17, "17 (Reserved by PKWARE)" },
    { 18, "IBM TERSE (new)" },
    { 19, "IBM LZ77 z Architecture (PFS)" },
    { 20, "Zstandard compressed data (obsolete)" },
    { 93, "Zstandard compressed data" },
    { 95, "XZ compressed data" },
    { 97, "WavPack compressed data" },
    { 98, "PPMd version I, Rev 1" },
    { 99, "WinZIP AES Encryption" },
    { UINT32_MAX, NULL }
}

Definition at line 94 of file zipcmp.c.

Referenced by entry_paranoia_checks().

extra_fields

const enum_map_t extra_fields[]

Definition at line 124 of file zipcmp.c.

Referenced by ef_print().

have_directory

int have_directory

Definition at line 234 of file zipcmp.c.

Referenced by compare_zip(), and main().

help

char help[]

(

void

)

Initial value:

= "\n\
  -h       display this help message\n\
  -C       check archive consistencies\n\
  -i       compare names ignoring case distinctions\n\
  -p       compare as many details as possible\n\
  -q       be quiet\n\
  -s       print a summary\n\
  -t       test zip files (compare file contents to checksum)\n\
  -V       display version number\n\
  -v       be verbose (print differences, default)\n\
\n\
Report bugs to <libzip@nih.at>.\n"

Definition at line 191 of file zipcmp.c.

Referenced by main().

help_head

char help_head[] = PROGRAM " (" PACKAGE ") by Dieter Baron and Thomas Klausner\n\n"

Definition at line 189 of file zipcmp.c.

Referenced by main().

ignore_case

int ignore_case

Definition at line 234 of file zipcmp.c.

Referenced by entry_cmp(), main(), rz_search_keyword_new_str(), and rz_search_keyword_new_wide().

minus_count

int minus_count = 0

Definition at line 235 of file zipcmp.c.

Referenced by compare_zip().

output

diff_output_t output

Definition at line 237 of file zipcmp.c.

Referenced by __core_visual_view_graph_update(), __dumpSections(), _zip_crypto_pbkdf2(), avr_assembler(), compare_list(), compare_zip(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), des_decrypt(), des_encrypt(), diff_output(), diff_output_data(), diff_output_end_file(), diff_output_file(), diff_output_init(), diff_output_start_file(), ef_print(), encode_addr16(), encode_addr32(), encode_atype(), encode_const_pool16(), encode_const_pool16_ut8(), encode_const_pool8(), encode_only_bcode(), encode_st16(), encode_st8(), encode_ut8(), encode_ut8x2(), ensure_header(), entry_paranoia_checks(), entry_print(), entry_start_file(), execute_command(), FUZ_AddressOverflow(), go_string(), java_assembler(), kwajd_decompress(), lang_pipe_run(), lzxd_init(), main(), mpc_parse_run(), mpcf_escape_new(), mpcf_unescape_new(), mszipd_init(), oabd_decompress(), oabd_decompress_incremental(), print_diff(), qtmd_init(), rabin_do_operation(), rz_cmd_info_demangle_handler(), rz_cmd_shell_echo_handler(), rz_cons_newline(), rz_core_visual_analysis_refresh(), rz_core_visual_analysis_refresh_column(), rz_core_visual_view_rop(), rz_demangler_resolve(), rz_egg_Cfile_getCompiler(), rz_egg_Cfile_parser(), rz_egg_Cfile_set_cEnv(), rz_main_rz_bin(), rz_sys_cmd_str(), rz_sys_cmd_str_full(), rz_test_cmp_cmd_output(), sanitize_cab_filename(), system_exec(), system_exec_stdin(), szddd_decompress(), and update().

paranoid

int paranoid

Definition at line 234 of file zipcmp.c.

Referenced by compare_zip(), list_zip(), and main().

plus_count

int plus_count = 0

Definition at line 235 of file zipcmp.c.

Referenced by compare_zip().

progname

const char* progname

Definition at line 183 of file zipcmp.c.

Referenced by compare_zip(), list_zip(), main(), and test_file().

summary

int summary

Definition at line 234 of file zipcmp.c.

Referenced by compare_zip(), do_print_child_help(), fill_argv_modes_help_strbuf(), main(), and ts_parser__recover().

test_files

int test_files

Definition at line 234 of file zipcmp.c.

Referenced by list_zip(), and main().

verbose

int verbose

Definition at line 234 of file zipcmp.c.

Referenced by compare_zip(), and main().

version_string

char version_string[]

Initial value:

= PROGRAM " (" PACKAGE " " VERSION ")\n\
Copyright (C) 2003-2022 Dieter Baron and Thomas Klausner\n\
" PACKAGE " comes with ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n"

Definition at line 204 of file zipcmp.c.

Referenced by main().