Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 1 | /* |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 2 | zipcmp.c -- compare zip files |
Thomas Klausner | 80491c8 | 2019-09-16 07:06:39 +0200 | [diff] [blame] | 3 | Copyright (C) 2003-2019 Dieter Baron and Thomas Klausner |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 4 | |
Dieter Baron | dd9afca | 2003-10-02 14:13:37 +0000 | [diff] [blame] | 5 | This file is part of libzip, a library to manipulate ZIP archives. |
Dieter Baron | 40a2197 | 2007-11-07 00:11:26 +0100 | [diff] [blame] | 6 | The authors can be contacted at <libzip@nih.at> |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 7 | |
Dieter Baron | dd9afca | 2003-10-02 14:13:37 +0000 | [diff] [blame] | 8 | Redistribution and use in source and binary forms, with or without |
| 9 | modification, are permitted provided that the following conditions |
| 10 | are met: |
| 11 | 1. Redistributions of source code must retain the above copyright |
| 12 | notice, this list of conditions and the following disclaimer. |
| 13 | 2. Redistributions in binary form must reproduce the above copyright |
| 14 | notice, this list of conditions and the following disclaimer in |
| 15 | the documentation and/or other materials provided with the |
| 16 | distribution. |
| 17 | 3. The names of the authors may not be used to endorse or promote |
| 18 | products derived from this software without specific prior |
| 19 | written permission. |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 20 | |
Dieter Baron | dd9afca | 2003-10-02 14:13:37 +0000 | [diff] [blame] | 21 | THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS |
| 22 | OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| 23 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 24 | ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY |
| 25 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 26 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE |
| 27 | GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 28 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER |
| 29 | IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| 30 | OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| 31 | IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 32 | */ |
| 33 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 34 | |
Dieter Baron | a6192cf | 2011-02-04 16:25:01 +0100 | [diff] [blame] | 35 | #include "config.h" |
| 36 | |
Dieter Baron | e3f91ef | 2003-10-06 02:50:14 +0000 | [diff] [blame] | 37 | #include <errno.h> |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 38 | #include <stdio.h> |
| 39 | #include <stdlib.h> |
| 40 | #include <string.h> |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 41 | #include <sys/stat.h> |
Dieter Baron | c086611 | 2012-08-08 16:54:19 +0200 | [diff] [blame] | 42 | #ifdef HAVE_STRINGS_H |
| 43 | #include <strings.h> |
| 44 | #endif |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 45 | #ifdef HAVE_FTS_H |
| 46 | #include <fts.h> |
| 47 | #endif |
Thomas Klausner | 24a722b | 2004-11-30 21:51:30 +0000 | [diff] [blame] | 48 | #include <zlib.h> |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 49 | |
Thomas Klausner | 81e9433 | 2011-03-08 14:10:27 +0100 | [diff] [blame] | 50 | #ifndef HAVE_GETOPT |
| 51 | #include "getopt.h" |
| 52 | #endif |
| 53 | |
Thomas Klausner | 069aee6 | 2017-06-21 10:11:01 +0200 | [diff] [blame] | 54 | #include "zip.h" |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 55 | |
Thomas Klausner | b49e8c8 | 2020-04-19 18:00:47 +0200 | [diff] [blame] | 56 | #include "compat.h" |
| 57 | |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 58 | struct archive { |
| 59 | const char *name; |
Dieter Baron | 1d9dfeb | 2014-09-28 23:02:54 +0200 | [diff] [blame] | 60 | zip_t *za; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 61 | zip_uint64_t nentry; |
| 62 | struct entry *entry; |
| 63 | const char *comment; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 64 | size_t comment_length; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 65 | }; |
| 66 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 67 | struct ef { |
| 68 | const char *name; |
| 69 | zip_uint16_t flags; |
| 70 | zip_uint16_t id; |
| 71 | zip_uint16_t size; |
| 72 | const zip_uint8_t *data; |
| 73 | }; |
| 74 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 75 | struct entry { |
| 76 | char *name; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 77 | zip_uint64_t size; |
| 78 | zip_uint32_t crc; |
| 79 | zip_uint32_t comp_method; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 80 | struct ef *extra_fields; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 81 | zip_uint16_t n_extra_fields; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 82 | const char *comment; |
Thomas Klausner | 216701e | 2013-03-14 11:47:39 +0100 | [diff] [blame] | 83 | zip_uint32_t comment_length; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 84 | }; |
| 85 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 86 | |
Thomas Klausner | 5061edd | 2018-09-29 18:13:16 +0200 | [diff] [blame] | 87 | const char *progname; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 88 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 89 | #define PROGRAM "zipcmp" |
Dieter Baron | 80d9ff3 | 2004-12-22 17:31:32 +0000 | [diff] [blame] | 90 | |
Thomas Klausner | 199a91f | 2014-03-10 16:17:10 +0100 | [diff] [blame] | 91 | #define USAGE "usage: %s [-hipqtVv] archive1 archive2\n" |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 92 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 93 | char help_head[] = PROGRAM " (" PACKAGE ") by Dieter Baron and Thomas Klausner\n\n"; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 94 | |
| 95 | char help[] = "\n\ |
| 96 | -h display this help message\n\ |
Dieter Baron | 3014e88 | 2003-10-03 23:54:32 +0000 | [diff] [blame] | 97 | -i compare names ignoring case distinctions\n\ |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 98 | -p compare as many details as possible\n\ |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 99 | -q be quiet\n\ |
Thomas Klausner | af2c40e | 2014-08-06 00:02:25 +0200 | [diff] [blame] | 100 | -t test zip files (compare file contents to checksum)\n\ |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 101 | -V display version number\n\ |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 102 | -v be verbose (print differences, default)\n\ |
| 103 | \n\ |
Dieter Baron | 40a2197 | 2007-11-07 00:11:26 +0100 | [diff] [blame] | 104 | Report bugs to <libzip@nih.at>.\n"; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 105 | |
Dieter Baron | 80d9ff3 | 2004-12-22 17:31:32 +0000 | [diff] [blame] | 106 | char version_string[] = PROGRAM " (" PACKAGE " " VERSION ")\n\ |
Thomas Klausner | 93f0339 | 2020-01-08 15:04:57 +0100 | [diff] [blame] | 107 | Copyright (C) 2003-2019 Dieter Baron and Thomas Klausner\n\ |
Dieter Baron | 79aca39 | 2007-11-08 16:00:37 +0100 | [diff] [blame] | 108 | " PACKAGE " comes with ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n"; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 109 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 110 | #define OPTIONS "hVipqtv" |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 111 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 112 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 113 | #define BOTH_ARE_ZIPS(a) (a[0].za && a[1].za) |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 114 | |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 115 | static int comment_compare(const char *c1, size_t l1, const char *c2, size_t l2); |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 116 | static int compare_list(char *const name[], const void *l[], const zip_uint64_t n[], int size, int (*cmp)(const void *, const void *), int (*checks)(char *const name[2], const void *, const void *), void (*print)(const void *)); |
| 117 | static int compare_zip(char *const zn[]); |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 118 | static int ef_compare(char *const name[2], const struct entry *e1, const struct entry *e2); |
| 119 | static int ef_order(const void *a, const void *b); |
| 120 | static void ef_print(const void *p); |
Dieter Baron | 1d9dfeb | 2014-09-28 23:02:54 +0200 | [diff] [blame] | 121 | static int ef_read(zip_t *za, zip_uint64_t idx, struct entry *e); |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 122 | static int entry_cmp(const void *p1, const void *p2); |
| 123 | static int entry_paranoia_checks(char *const name[2], const void *p1, const void *p2); |
| 124 | static void entry_print(const void *p); |
| 125 | static int is_directory(const char *name); |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 126 | #ifdef HAVE_FTS_H |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 127 | static int list_directory(const char *name, struct archive *a); |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 128 | #endif |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 129 | static int list_zip(const char *name, struct archive *a); |
Dieter Baron | 1d9dfeb | 2014-09-28 23:02:54 +0200 | [diff] [blame] | 130 | static int test_file(zip_t *za, zip_uint64_t idx, zip_uint64_t size, zip_uint32_t crc); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 131 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 132 | int ignore_case, test_files, paranoid, verbose; |
| 133 | int header_done; |
Dieter Baron | 3014e88 | 2003-10-03 23:54:32 +0000 | [diff] [blame] | 134 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 135 | |
| 136 | int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 137 | main(int argc, char *const argv[]) { |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 138 | int c; |
| 139 | |
Thomas Klausner | 5061edd | 2018-09-29 18:13:16 +0200 | [diff] [blame] | 140 | progname = argv[0]; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 141 | |
Dieter Baron | 3014e88 | 2003-10-03 23:54:32 +0000 | [diff] [blame] | 142 | ignore_case = 0; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 143 | test_files = 0; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 144 | paranoid = 0; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 145 | verbose = 1; |
| 146 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 147 | while ((c = getopt(argc, argv, OPTIONS)) != -1) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 148 | switch (c) { |
| 149 | case 'i': |
| 150 | ignore_case = 1; |
| 151 | break; |
| 152 | case 'p': |
| 153 | paranoid = 1; |
| 154 | break; |
| 155 | case 'q': |
| 156 | verbose = 0; |
| 157 | break; |
| 158 | case 't': |
| 159 | test_files = 1; |
| 160 | break; |
| 161 | case 'v': |
| 162 | verbose = 1; |
| 163 | break; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 164 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 165 | case 'h': |
| 166 | fputs(help_head, stdout); |
| 167 | printf(USAGE, progname); |
| 168 | fputs(help, stdout); |
| 169 | exit(0); |
| 170 | case 'V': |
| 171 | fputs(version_string, stdout); |
| 172 | exit(0); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 173 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 174 | default: |
| 175 | fprintf(stderr, USAGE, progname); |
| 176 | exit(2); |
| 177 | } |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 178 | } |
| 179 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 180 | if (argc != optind + 2) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 181 | fprintf(stderr, USAGE, progname); |
| 182 | exit(2); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 183 | } |
| 184 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 185 | exit((compare_zip(argv + optind) == 0) ? 0 : 1); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 186 | } |
| 187 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 188 | |
| 189 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 190 | compare_zip(char *const zn[]) { |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 191 | struct archive a[2]; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 192 | struct entry *e[2]; |
Dieter Baron | a1f8e2c | 2013-05-14 22:21:34 +0200 | [diff] [blame] | 193 | zip_uint64_t n[2]; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 194 | int i; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 195 | int res; |
| 196 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 197 | for (i = 0; i < 2; i++) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 198 | a[i].name = zn[i]; |
| 199 | a[i].entry = NULL; |
| 200 | a[i].nentry = 0; |
| 201 | a[i].za = NULL; |
| 202 | a[i].comment = NULL; |
| 203 | a[i].comment_length = 0; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 204 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 205 | if (is_directory(zn[i])) { |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 206 | #ifndef HAVE_FTS_H |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 207 | fprintf(stderr, "%s: reading directories not supported\n", progname); |
| 208 | exit(2); |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 209 | #else |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 210 | if (list_directory(zn[i], a + i) < 0) |
| 211 | exit(2); |
| 212 | paranoid = 0; /* paranoid checks make no sense for directories, since they compare zip metadata */ |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 213 | #endif |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 214 | } |
| 215 | else { |
| 216 | if (list_zip(zn[i], a + i) < 0) |
| 217 | exit(2); |
| 218 | } |
| 219 | if (a[i].nentry > 0) |
| 220 | qsort(a[i].entry, a[i].nentry, sizeof(a[i].entry[0]), entry_cmp); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 221 | } |
| 222 | |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 223 | header_done = 0; |
| 224 | |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 225 | e[0] = a[0].entry; |
| 226 | e[1] = a[1].entry; |
| 227 | n[0] = a[0].nentry; |
| 228 | n[1] = a[1].nentry; |
| 229 | res = compare_list(zn, (const void **)e, n, sizeof(e[i][0]), entry_cmp, paranoid ? entry_paranoia_checks : NULL, entry_print); |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 230 | |
| 231 | if (paranoid) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 232 | if (comment_compare(a[0].comment, a[0].comment_length, a[1].comment, a[1].comment_length) != 0) { |
| 233 | if (verbose) { |
| 234 | printf("--- archive comment (%zu)\n", a[0].comment_length); |
| 235 | printf("+++ archive comment (%zu)\n", a[1].comment_length); |
| 236 | } |
| 237 | res = 1; |
| 238 | } |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 239 | } |
| 240 | |
Thomas Klausner | 80491c8 | 2019-09-16 07:06:39 +0200 | [diff] [blame] | 241 | for (i = 0; i < 2; i++) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 242 | zip_uint64_t j; |
Thomas Klausner | 80491c8 | 2019-09-16 07:06:39 +0200 | [diff] [blame] | 243 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 244 | if (a[i].za) { |
| 245 | zip_close(a[i].za); |
| 246 | } |
| 247 | for (j = 0; j < a[i].nentry; j++) { |
| 248 | free(a[i].entry[j].name); |
| 249 | } |
| 250 | free(a[i].entry); |
Thomas Klausner | 80491c8 | 2019-09-16 07:06:39 +0200 | [diff] [blame] | 251 | } |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 252 | |
| 253 | switch (res) { |
Dieter Baron | 9afd7bd | 2003-10-01 18:27:46 +0000 | [diff] [blame] | 254 | case 0: |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 255 | exit(0); |
Dieter Baron | 9afd7bd | 2003-10-01 18:27:46 +0000 | [diff] [blame] | 256 | |
| 257 | case 1: |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 258 | exit(1); |
Dieter Baron | 9afd7bd | 2003-10-01 18:27:46 +0000 | [diff] [blame] | 259 | |
| 260 | default: |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 261 | exit(2); |
Dieter Baron | 9afd7bd | 2003-10-01 18:27:46 +0000 | [diff] [blame] | 262 | } |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 263 | } |
Thomas Klausner | 3a2ce0e | 2005-05-20 21:56:54 +0000 | [diff] [blame] | 264 | |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 265 | #ifdef HAVE_FTS_H |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 266 | static zip_int64_t |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 267 | compute_crc(const char *fname) { |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 268 | FILE *f; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 269 | uLong crc = crc32(0L, Z_NULL, 0); |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 270 | size_t n; |
| 271 | Bytef buffer[8192]; |
| 272 | |
| 273 | |
Michał Janiszewski | a9bf616 | 2020-03-08 21:34:36 +0100 | [diff] [blame] | 274 | if ((f = fopen(fname, "rb")) == NULL) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 275 | fprintf(stderr, "%s: can't open %s: %s\n", progname, fname, strerror(errno)); |
| 276 | return -1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 277 | } |
| 278 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 279 | while ((n = fread(buffer, 1, sizeof(buffer), f)) > 0) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 280 | crc = crc32(crc, buffer, (unsigned int)n); |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | if (ferror(f)) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 284 | fprintf(stderr, "%s: read error on %s: %s\n", progname, fname, strerror(errno)); |
| 285 | fclose(f); |
| 286 | return -1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | fclose(f); |
| 290 | |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 291 | return (zip_int64_t)crc; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 292 | } |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 293 | #endif |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 294 | |
| 295 | |
| 296 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 297 | is_directory(const char *name) { |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 298 | struct stat st; |
| 299 | |
| 300 | if (stat(name, &st) < 0) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 301 | return 0; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 302 | |
| 303 | return S_ISDIR(st.st_mode); |
| 304 | } |
| 305 | |
| 306 | |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 307 | #ifdef HAVE_FTS_H |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 308 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 309 | list_directory(const char *name, struct archive *a) { |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 310 | FTS *fts; |
| 311 | FTSENT *ent; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 312 | zip_uint64_t nalloc; |
Thomas Klausner | dceead5 | 2017-02-26 11:01:57 +0100 | [diff] [blame] | 313 | size_t prefix_length; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 314 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 315 | char *const names[2] = {(char *)name, NULL}; |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 316 | |
| 317 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 318 | if ((fts = fts_open(names, FTS_NOCHDIR | FTS_LOGICAL, NULL)) == NULL) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 319 | fprintf(stderr, "%s: can't open directory '%s': %s\n", progname, name, strerror(errno)); |
| 320 | return -1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 321 | } |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 322 | prefix_length = strlen(name) + 1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 323 | |
| 324 | nalloc = 0; |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 325 | |
| 326 | while ((ent = fts_read(fts))) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 327 | zip_int64_t crc; |
Thomas Klausner | 9091840 | 2014-03-08 22:13:47 +0100 | [diff] [blame] | 328 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 329 | switch (ent->fts_info) { |
| 330 | case FTS_D: |
| 331 | case FTS_DOT: |
| 332 | case FTS_DP: |
| 333 | case FTS_DEFAULT: |
| 334 | case FTS_SL: |
| 335 | case FTS_NSOK: |
| 336 | break; |
Thomas Klausner | 9091840 | 2014-03-08 22:13:47 +0100 | [diff] [blame] | 337 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 338 | case FTS_DC: |
| 339 | case FTS_DNR: |
| 340 | case FTS_ERR: |
| 341 | case FTS_NS: |
| 342 | case FTS_SLNONE: |
| 343 | /* TODO: error */ |
| 344 | fts_close(fts); |
| 345 | return -1; |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 346 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 347 | case FTS_F: |
| 348 | if (a->nentry >= nalloc) { |
| 349 | nalloc += 16; |
| 350 | if (nalloc > SIZE_MAX / sizeof(a->entry[0])) { |
| 351 | fprintf(stderr, "%s: malloc failure\n", progname); |
| 352 | exit(1); |
| 353 | } |
| 354 | a->entry = realloc(a->entry, sizeof(a->entry[0]) * nalloc); |
| 355 | if (a->entry == NULL) { |
| 356 | fprintf(stderr, "%s: malloc failure\n", progname); |
| 357 | exit(1); |
| 358 | } |
| 359 | } |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 360 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 361 | a->entry[a->nentry].name = strdup(ent->fts_path + prefix_length); |
| 362 | a->entry[a->nentry].size = (zip_uint64_t)ent->fts_statp->st_size; |
| 363 | if ((crc = compute_crc(ent->fts_accpath)) < 0) { |
| 364 | fts_close(fts); |
| 365 | return -1; |
| 366 | } |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 367 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 368 | a->entry[a->nentry].crc = (zip_uint32_t)crc; |
| 369 | a->nentry++; |
| 370 | break; |
| 371 | } |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 372 | } |
| 373 | |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 374 | if (fts_close(fts)) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 375 | fprintf(stderr, "%s: error closing directory '%s': %s\n", progname, a->name, strerror(errno)); |
| 376 | return -1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | return 0; |
| 380 | } |
Thomas Klausner | de610c3 | 2014-05-08 12:19:28 +0200 | [diff] [blame] | 381 | #endif |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 382 | |
| 383 | |
| 384 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 385 | list_zip(const char *name, struct archive *a) { |
Dieter Baron | 1d9dfeb | 2014-09-28 23:02:54 +0200 | [diff] [blame] | 386 | zip_t *za; |
Thomas Klausner | 199a91f | 2014-03-10 16:17:10 +0100 | [diff] [blame] | 387 | int err; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 388 | struct zip_stat st; |
Thomas Klausner | 199a91f | 2014-03-10 16:17:10 +0100 | [diff] [blame] | 389 | unsigned int i; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 390 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 391 | if ((za = zip_open(name, paranoid ? ZIP_CHECKCONS : 0, &err)) == NULL) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 392 | zip_error_t error; |
| 393 | zip_error_init_with_code(&error, err); |
| 394 | fprintf(stderr, "%s: cannot open zip archive '%s': %s\n", progname, name, zip_error_strerror(&error)); |
| 395 | zip_error_fini(&error); |
| 396 | return -1; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 397 | } |
| 398 | |
| 399 | a->za = za; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 400 | a->nentry = (zip_uint64_t)zip_get_num_entries(za, 0); |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 401 | |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 402 | if (a->nentry == 0) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 403 | a->entry = NULL; |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 404 | else { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 405 | if ((a->nentry > SIZE_MAX / sizeof(a->entry[0])) || (a->entry = (struct entry *)malloc(sizeof(a->entry[0]) * a->nentry)) == NULL) { |
| 406 | fprintf(stderr, "%s: malloc failure\n", progname); |
| 407 | exit(1); |
| 408 | } |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 409 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 410 | for (i = 0; i < a->nentry; i++) { |
| 411 | zip_stat_index(za, i, 0, &st); |
| 412 | a->entry[i].name = strdup(st.name); |
| 413 | a->entry[i].size = st.size; |
| 414 | a->entry[i].crc = st.crc; |
| 415 | if (test_files) |
| 416 | test_file(za, i, st.size, st.crc); |
| 417 | if (paranoid) { |
| 418 | a->entry[i].comp_method = st.comp_method; |
| 419 | ef_read(za, i, a->entry + i); |
| 420 | a->entry[i].comment = zip_file_get_comment(za, i, &a->entry[i].comment_length, 0); |
| 421 | } |
| 422 | else { |
| 423 | a->entry[i].comp_method = 0; |
| 424 | a->entry[i].n_extra_fields = 0; |
| 425 | } |
| 426 | } |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 427 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 428 | if (paranoid) { |
| 429 | int length; |
| 430 | a->comment = zip_get_archive_comment(za, &length, 0); |
| 431 | a->comment_length = (size_t)length; |
| 432 | } |
| 433 | else { |
| 434 | a->comment = NULL; |
| 435 | a->comment_length = 0; |
| 436 | } |
Thomas Klausner | a191f7b | 2014-01-29 15:14:37 +0100 | [diff] [blame] | 437 | } |
| 438 | |
| 439 | return 0; |
| 440 | } |
| 441 | |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 442 | |
| 443 | static int |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 444 | comment_compare(const char *c1, size_t l1, const char *c2, size_t l2) { |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 445 | if (l1 != l2) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 446 | return 1; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 447 | |
| 448 | if (l1 == 0) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 449 | return 0; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 450 | |
Dieter Baron | a205a4d | 2012-08-08 16:52:57 +0200 | [diff] [blame] | 451 | if (c1 == NULL || c2 == NULL) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 452 | return c1 == c2; |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 453 | |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 454 | return memcmp(c1, c2, (size_t)l2); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 455 | } |
| 456 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 457 | |
| 458 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 459 | compare_list(char *const name[2], const void *l[2], const zip_uint64_t n[2], int size, int (*cmp)(const void *, const void *), int (*check)(char *const name[2], const void *, const void *), void (*print)(const void *)) { |
Thomas Klausner | 199a91f | 2014-03-10 16:17:10 +0100 | [diff] [blame] | 460 | unsigned int i[2]; |
| 461 | int j, c; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 462 | int diff; |
| 463 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 464 | #define INC(k) (i[k]++, l[k] = ((const char *)l[k]) + size) |
| 465 | #define PRINT(k) \ |
| 466 | do { \ |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 467 | if (header_done == 0 && verbose) { \ |
| 468 | printf("--- %s\n+++ %s\n", name[0], name[1]); \ |
| 469 | header_done = 1; \ |
| 470 | } \ |
| 471 | if (verbose) { \ |
| 472 | printf("%c ", (k) ? '+' : '-'); \ |
| 473 | print(l[k]); \ |
| 474 | } \ |
| 475 | diff = 1; \ |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 476 | } while (0) |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 477 | |
| 478 | i[0] = i[1] = 0; |
| 479 | diff = 0; |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 480 | while (i[0] < n[0] && i[1] < n[1]) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 481 | c = cmp(l[0], l[1]); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 482 | |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 483 | if (c == 0) { |
| 484 | if (check) |
| 485 | diff |= check(name, l[0], l[1]); |
| 486 | INC(0); |
| 487 | INC(1); |
| 488 | } |
| 489 | else if (c < 0) { |
| 490 | PRINT(0); |
| 491 | INC(0); |
| 492 | } |
| 493 | else { |
| 494 | PRINT(1); |
| 495 | INC(1); |
| 496 | } |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 497 | } |
| 498 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 499 | for (j = 0; j < 2; j++) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 500 | while (i[j] < n[j]) { |
| 501 | PRINT(j); |
| 502 | INC(j); |
| 503 | } |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 504 | } |
| 505 | |
| 506 | return diff; |
| 507 | } |
| 508 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 509 | |
| 510 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 511 | ef_read(zip_t *za, zip_uint64_t idx, struct entry *e) { |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 512 | zip_int16_t n_local, n_central; |
Thomas Klausner | 03ca1c1 | 2014-09-24 01:02:15 +0200 | [diff] [blame] | 513 | zip_uint16_t i; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 514 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 515 | 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) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 516 | return -1; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 517 | } |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 518 | |
Thomas Klausner | 03ca1c1 | 2014-09-24 01:02:15 +0200 | [diff] [blame] | 519 | e->n_extra_fields = (zip_uint16_t)(n_local + n_central); |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 520 | |
| 521 | if ((e->extra_fields = (struct ef *)malloc(sizeof(e->extra_fields[0]) * e->n_extra_fields)) == NULL) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 522 | return -1; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 523 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 524 | for (i = 0; i < n_local; i++) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 525 | e->extra_fields[i].name = e->name; |
| 526 | 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); |
| 527 | if (e->extra_fields[i].data == NULL) |
| 528 | return -1; |
| 529 | e->extra_fields[i].flags = ZIP_FL_LOCAL; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 530 | } |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 531 | for (; i < e->n_extra_fields; i++) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 532 | e->extra_fields[i].name = e->name; |
| 533 | 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); |
| 534 | if (e->extra_fields[i].data == NULL) |
| 535 | return -1; |
| 536 | e->extra_fields[i].flags = ZIP_FL_CENTRAL; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 537 | } |
| 538 | |
| 539 | qsort(e->extra_fields, e->n_extra_fields, sizeof(e->extra_fields[0]), ef_order); |
| 540 | |
| 541 | return 0; |
| 542 | } |
| 543 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 544 | |
| 545 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 546 | ef_compare(char *const name[2], const struct entry *e1, const struct entry *e2) { |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 547 | struct ef *ef[2]; |
Dieter Baron | a1f8e2c | 2013-05-14 22:21:34 +0200 | [diff] [blame] | 548 | zip_uint64_t n[2]; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 549 | |
| 550 | ef[0] = e1->extra_fields; |
| 551 | ef[1] = e2->extra_fields; |
| 552 | n[0] = e1->n_extra_fields; |
| 553 | n[1] = e2->n_extra_fields; |
| 554 | |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 555 | return compare_list(name, (const void **)ef, n, sizeof(struct ef), ef_order, NULL, ef_print); |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 556 | } |
| 557 | |
| 558 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 559 | static int |
| 560 | ef_order(const void *ap, const void *bp) { |
| 561 | const struct ef *a, *b; |
| 562 | |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 563 | a = (struct ef *)ap; |
| 564 | b = (struct ef *)bp; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 565 | |
| 566 | if (a->flags != b->flags) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 567 | return a->flags - b->flags; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 568 | if (a->id != b->id) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 569 | return a->id - b->id; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 570 | if (a->size != b->size) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 571 | return a->size - b->size; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 572 | return memcmp(a->data, b->data, a->size); |
| 573 | } |
| 574 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 575 | |
| 576 | static void |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 577 | ef_print(const void *p) { |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 578 | const struct ef *ef = (struct ef *)p; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 579 | int i; |
| 580 | |
| 581 | printf(" %s ", ef->name); |
Dieter Baron | ff40b57 | 2012-07-15 15:19:32 +0200 | [diff] [blame] | 582 | printf("%04x %c <", ef->id, ef->flags == ZIP_FL_LOCAL ? 'l' : 'c'); |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 583 | for (i = 0; i < ef->size; i++) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 584 | printf("%s%02x", i ? " " : "", ef->data[i]); |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 585 | printf(">\n"); |
| 586 | } |
| 587 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 588 | |
| 589 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 590 | entry_cmp(const void *p1, const void *p2) { |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 591 | const struct entry *e1, *e2; |
| 592 | int c; |
| 593 | |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 594 | e1 = (struct entry *)p1; |
| 595 | e2 = (struct entry *)p2; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 596 | |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 597 | if ((c = (ignore_case ? strcasecmp : strcmp)(e1->name, e2->name)) != 0) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 598 | return c; |
Dieter Baron | a205a4d | 2012-08-08 16:52:57 +0200 | [diff] [blame] | 599 | if (e1->size != e2->size) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 600 | if (e1->size > e2->size) |
| 601 | return 1; |
| 602 | else |
| 603 | return -1; |
Dieter Baron | a205a4d | 2012-08-08 16:52:57 +0200 | [diff] [blame] | 604 | } |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 605 | if (e1->crc != e2->crc) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 606 | return (int)e1->crc - (int)e2->crc; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 607 | |
| 608 | return 0; |
| 609 | } |
| 610 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 611 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 612 | static int |
| 613 | entry_paranoia_checks(char *const name[2], const void *p1, const void *p2) { |
| 614 | const struct entry *e1, *e2; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 615 | int ret; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 616 | |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 617 | e1 = (struct entry *)p1; |
| 618 | e2 = (struct entry *)p2; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 619 | |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 620 | ret = 0; |
| 621 | |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 622 | if (ef_compare(name, e1, e2) != 0) |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 623 | ret = 1; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 624 | |
Thomas Klausner | 563e6f5 | 2012-04-24 19:08:41 +0200 | [diff] [blame] | 625 | if (e1->comp_method != e2->comp_method) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 626 | if (verbose) { |
| 627 | if (header_done == 0) { |
| 628 | printf("--- %s\n+++ %s\n", name[0], name[1]); |
| 629 | header_done = 1; |
| 630 | } |
| 631 | printf("--- %s ", e1->name); |
| 632 | printf("method %u\n", e1->comp_method); |
| 633 | printf("+++ %s ", e1->name); |
| 634 | printf("method %u\n", e2->comp_method); |
| 635 | } |
| 636 | ret = 1; |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 637 | } |
| 638 | if (comment_compare(e1->comment, e1->comment_length, e2->comment, e2->comment_length) != 0) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 639 | if (verbose) { |
| 640 | if (header_done == 0) { |
| 641 | printf("--- %s\n+++ %s\n", name[0], name[1]); |
| 642 | header_done = 1; |
| 643 | } |
| 644 | printf("--- %s ", e1->name); |
| 645 | printf("comment %" PRIu32 "\n", e1->comment_length); |
| 646 | printf("+++ %s ", e1->name); |
| 647 | printf("comment %" PRIu32 "\n", e2->comment_length); |
| 648 | } |
| 649 | ret = 1; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 650 | } |
| 651 | |
Dieter Baron | 3efab99 | 2012-05-04 09:29:29 +0200 | [diff] [blame] | 652 | return ret; |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 653 | } |
| 654 | |
| 655 | |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 656 | static void |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 657 | entry_print(const void *p) { |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 658 | const struct entry *e; |
| 659 | |
Thomas Klausner | f5d96cb | 2013-03-20 00:31:18 +0100 | [diff] [blame] | 660 | e = (struct entry *)p; |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 661 | |
Thomas Klausner | b52bda0 | 2013-11-28 18:01:40 +0100 | [diff] [blame] | 662 | /* TODO PRId64 */ |
Dieter Baron | 0e5eeab | 2012-04-24 18:47:12 +0200 | [diff] [blame] | 663 | printf("%10lu %08x %s\n", (unsigned long)e->size, e->crc, e->name); |
Dieter Baron | 392787a | 2003-03-14 14:53:29 +0000 | [diff] [blame] | 664 | } |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 665 | |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 666 | |
| 667 | static int |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 668 | test_file(zip_t *za, zip_uint64_t idx, zip_uint64_t size, zip_uint32_t crc) { |
Dieter Baron | 1d9dfeb | 2014-09-28 23:02:54 +0200 | [diff] [blame] | 669 | zip_file_t *zf; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 670 | char buf[8192]; |
Thomas Klausner | ea8ba49 | 2014-09-23 16:54:47 +0200 | [diff] [blame] | 671 | zip_uint64_t nsize; |
| 672 | zip_int64_t n; |
Dieter Baron | a205a4d | 2012-08-08 16:52:57 +0200 | [diff] [blame] | 673 | zip_uint32_t ncrc; |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 674 | |
| 675 | if ((zf = zip_fopen_index(za, idx, 0)) == NULL) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 676 | fprintf(stderr, "%s: cannot open file %" PRIu64 " in archive: %s\n", progname, idx, zip_strerror(za)); |
| 677 | return -1; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 678 | } |
| 679 | |
Dieter Baron | a205a4d | 2012-08-08 16:52:57 +0200 | [diff] [blame] | 680 | ncrc = (zip_uint32_t)crc32(0, NULL, 0); |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 681 | nsize = 0; |
Thomas Klausner | 8eab1a2 | 2018-01-15 14:10:11 +0100 | [diff] [blame] | 682 | |
| 683 | while ((n = zip_fread(zf, buf, sizeof(buf))) > 0) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 684 | nsize += (zip_uint64_t)n; |
| 685 | ncrc = (zip_uint32_t)crc32(ncrc, (const Bytef *)buf, (unsigned int)n); |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 686 | } |
| 687 | |
| 688 | if (n < 0) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 689 | fprintf(stderr, "%s: error reading file %" PRIu64 " in archive: %s\n", progname, idx, zip_file_strerror(zf)); |
| 690 | zip_fclose(zf); |
| 691 | return -1; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 692 | } |
| 693 | |
Thomas Klausner | 6be5981 | 2004-11-18 17:11:24 +0000 | [diff] [blame] | 694 | zip_fclose(zf); |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 695 | |
| 696 | if (nsize != size) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 697 | fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %" PRId64 " (should be %" PRId64 ")\n", progname, idx, nsize, size); |
| 698 | return -2; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 699 | } |
| 700 | if (ncrc != crc) { |
Thomas Klausner | a14fded | 2020-07-21 16:07:23 +0200 | [diff] [blame] | 701 | fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %x (should be %x)\n", progname, idx, ncrc, crc); |
| 702 | return -2; |
Dieter Baron | b2ed74d | 2004-04-14 14:01:31 +0000 | [diff] [blame] | 703 | } |
| 704 | |
| 705 | return 0; |
| 706 | } |