• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <errno.h>
18 #include <fcntl.h>
19 #include <fnmatch.h>
20 #include <getopt.h>
21 #include <inttypes.h>
22 #include <libgen.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28 #include <time.h>
29 #include <unistd.h>
30 
31 #include <set>
32 #include <string>
33 
34 #include <android-base/file.h>
35 #include <android-base/strings.h>
36 #include <ziparchive/zip_archive.h>
37 
38 using android::base::EndsWith;
39 using android::base::StartsWith;
40 
41 enum OverwriteMode {
42   kAlways,
43   kNever,
44   kPrompt,
45 };
46 
47 enum Role {
48   kUnzip,
49   kZipinfo,
50 };
51 
52 static Role role;
53 static OverwriteMode overwrite_mode = kPrompt;
54 static bool flag_1 = false;
55 static std::string flag_d;
56 static bool flag_l = false;
57 static bool flag_p = false;
58 static bool flag_q = false;
59 static bool flag_v = false;
60 static bool flag_x = false;
61 static const char* archive_name = nullptr;
62 static std::set<std::string> includes;
63 static std::set<std::string> excludes;
64 static uint64_t total_uncompressed_length = 0;
65 static uint64_t total_compressed_length = 0;
66 static size_t file_count = 0;
67 
68 static const char* g_progname;
69 
die(int error,const char * fmt,...)70 static void die(int error, const char* fmt, ...) {
71   va_list ap;
72 
73   va_start(ap, fmt);
74   fprintf(stderr, "%s: ", g_progname);
75   vfprintf(stderr, fmt, ap);
76   if (error != 0) fprintf(stderr, ": %s", strerror(error));
77   fprintf(stderr, "\n");
78   va_end(ap);
79   exit(1);
80 }
81 
ShouldInclude(const std::string & name)82 static bool ShouldInclude(const std::string& name) {
83   // Explicitly excluded?
84   if (!excludes.empty()) {
85     for (const auto& exclude : excludes) {
86       if (!fnmatch(exclude.c_str(), name.c_str(), 0)) return false;
87     }
88   }
89 
90   // Implicitly included?
91   if (includes.empty()) return true;
92 
93   // Explicitly included?
94   for (const auto& include : includes) {
95     if (!fnmatch(include.c_str(), name.c_str(), 0)) return true;
96   }
97   return false;
98 }
99 
MakeDirectoryHierarchy(const std::string & path)100 static bool MakeDirectoryHierarchy(const std::string& path) {
101   // stat rather than lstat because a symbolic link to a directory is fine too.
102   struct stat sb;
103   if (stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) return true;
104 
105   // Ensure the parent directories exist first.
106   if (!MakeDirectoryHierarchy(android::base::Dirname(path))) return false;
107 
108   // Then try to create this directory.
109   return (mkdir(path.c_str(), 0777) != -1);
110 }
111 
CompressionRatio(int64_t uncompressed,int64_t compressed)112 static float CompressionRatio(int64_t uncompressed, int64_t compressed) {
113   if (uncompressed == 0) return 0;
114   return static_cast<float>(100LL * (uncompressed - compressed)) /
115          static_cast<float>(uncompressed);
116 }
117 
MaybeShowHeader(ZipArchiveHandle zah)118 static void MaybeShowHeader(ZipArchiveHandle zah) {
119   if (role == kUnzip) {
120     // unzip has three formats.
121     if (!flag_q) printf("Archive:  %s\n", archive_name);
122     if (flag_v) {
123       printf(
124           " Length   Method    Size  Cmpr    Date    Time   CRC-32   Name\n"
125           "--------  ------  ------- ---- ---------- ----- --------  ----\n");
126     } else if (flag_l) {
127       printf(
128           "  Length      Date    Time    Name\n"
129           "---------  ---------- -----   ----\n");
130     }
131   } else {
132     // zipinfo.
133     if (!flag_1 && includes.empty() && excludes.empty()) {
134       ZipArchiveInfo info{GetArchiveInfo(zah)};
135       printf("Archive:  %s\n", archive_name);
136       printf("Zip file size: %" PRId64 " bytes, number of entries: %zu\n", info.archive_size,
137              info.entry_count);
138     }
139   }
140 }
141 
MaybeShowFooter()142 static void MaybeShowFooter() {
143   if (role == kUnzip) {
144     if (flag_v) {
145       printf(
146           "--------          -------  ---                            -------\n"
147           "%8" PRId64 "         %8" PRId64 " %3.0f%%                            %zu file%s\n",
148           total_uncompressed_length, total_compressed_length,
149           CompressionRatio(total_uncompressed_length, total_compressed_length), file_count,
150           (file_count == 1) ? "" : "s");
151     } else if (flag_l) {
152       printf(
153           "---------                     -------\n"
154           "%9" PRId64 "                     %zu file%s\n",
155           total_uncompressed_length, file_count, (file_count == 1) ? "" : "s");
156     }
157   } else {
158     if (!flag_1 && includes.empty() && excludes.empty()) {
159       printf("%zu files, %" PRId64 " bytes uncompressed, %" PRId64 " bytes compressed:  %.1f%%\n",
160              file_count, total_uncompressed_length, total_compressed_length,
161              CompressionRatio(total_uncompressed_length, total_compressed_length));
162     }
163   }
164 }
165 
PromptOverwrite(const std::string & dst)166 static bool PromptOverwrite(const std::string& dst) {
167   // TODO: [r]ename not implemented because it doesn't seem useful.
168   printf("replace %s? [y]es, [n]o, [A]ll, [N]one: ", dst.c_str());
169   fflush(stdout);
170   while (true) {
171     char* line = nullptr;
172     size_t n;
173     if (getline(&line, &n, stdin) == -1) {
174       die(0, "(EOF/read error; assuming [N]one...)");
175       overwrite_mode = kNever;
176       return false;
177     }
178     if (n == 0) continue;
179     char cmd = line[0];
180     free(line);
181     switch (cmd) {
182       case 'y':
183         return true;
184       case 'n':
185         return false;
186       case 'A':
187         overwrite_mode = kAlways;
188         return true;
189       case 'N':
190         overwrite_mode = kNever;
191         return false;
192     }
193   }
194 }
195 
ExtractToPipe(ZipArchiveHandle zah,ZipEntry & entry,const std::string & name)196 static void ExtractToPipe(ZipArchiveHandle zah, ZipEntry& entry, const std::string& name) {
197   // We need to extract to memory because ExtractEntryToFile insists on
198   // being able to seek and truncate, and you can't do that with stdout.
199   uint8_t* buffer = new uint8_t[entry.uncompressed_length];
200   int err = ExtractToMemory(zah, &entry, buffer, entry.uncompressed_length);
201   if (err < 0) {
202     die(0, "failed to extract %s: %s", name.c_str(), ErrorCodeString(err));
203   }
204   if (!android::base::WriteFully(1, buffer, entry.uncompressed_length)) {
205     die(errno, "failed to write %s to stdout", name.c_str());
206   }
207   delete[] buffer;
208 }
209 
ExtractOne(ZipArchiveHandle zah,ZipEntry & entry,const std::string & name)210 static void ExtractOne(ZipArchiveHandle zah, ZipEntry& entry, const std::string& name) {
211   // Bad filename?
212   if (StartsWith(name, "/") || StartsWith(name, "../") || name.find("/../") != std::string::npos) {
213     die(0, "bad filename %s", name.c_str());
214   }
215 
216   // Where are we actually extracting to (for human-readable output)?
217   // flag_d is the empty string if -d wasn't used, or has a trailing '/'
218   // otherwise.
219   std::string dst = flag_d + name;
220 
221   // Ensure the directory hierarchy exists.
222   if (!MakeDirectoryHierarchy(android::base::Dirname(name))) {
223     die(errno, "couldn't create directory hierarchy for %s", dst.c_str());
224   }
225 
226   // An entry in a zip file can just be a directory itself.
227   if (EndsWith(name, "/")) {
228     if (mkdir(name.c_str(), entry.unix_mode) == -1) {
229       // If the directory already exists, that's fine.
230       if (errno == EEXIST) {
231         struct stat sb;
232         if (stat(name.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) return;
233       }
234       die(errno, "couldn't extract directory %s", dst.c_str());
235     }
236     return;
237   }
238 
239   // Create the file.
240   int fd = open(name.c_str(), O_CREAT | O_WRONLY | O_CLOEXEC | O_EXCL, entry.unix_mode);
241   if (fd == -1 && errno == EEXIST) {
242     if (overwrite_mode == kNever) return;
243     if (overwrite_mode == kPrompt && !PromptOverwrite(dst)) return;
244     // Either overwrite_mode is kAlways or the user consented to this specific case.
245     fd = open(name.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC | O_TRUNC, entry.unix_mode);
246   }
247   if (fd == -1) die(errno, "couldn't create file %s", dst.c_str());
248 
249   // Actually extract into the file.
250   if (!flag_q) printf("  inflating: %s\n", dst.c_str());
251   int err = ExtractEntryToFile(zah, &entry, fd);
252   if (err < 0) die(0, "failed to extract %s: %s", dst.c_str(), ErrorCodeString(err));
253   close(fd);
254 }
255 
ListOne(const ZipEntry & entry,const std::string & name)256 static void ListOne(const ZipEntry& entry, const std::string& name) {
257   tm t = entry.GetModificationTime();
258   char time[32];
259   snprintf(time, sizeof(time), "%04d-%02d-%02d %02d:%02d", t.tm_year + 1900, t.tm_mon + 1,
260            t.tm_mday, t.tm_hour, t.tm_min);
261   if (flag_v) {
262     printf("%8d  %s  %7d %3.0f%% %s %08x  %s\n", entry.uncompressed_length,
263            (entry.method == kCompressStored) ? "Stored" : "Defl:N", entry.compressed_length,
264            CompressionRatio(entry.uncompressed_length, entry.compressed_length), time, entry.crc32,
265            name.c_str());
266   } else {
267     printf("%9d  %s   %s\n", entry.uncompressed_length, time, name.c_str());
268   }
269 }
270 
InfoOne(const ZipEntry & entry,const std::string & name)271 static void InfoOne(const ZipEntry& entry, const std::string& name) {
272   if (flag_1) {
273     // "android-ndk-r19b/sources/android/NOTICE"
274     printf("%s\n", name.c_str());
275     return;
276   }
277 
278   int version = entry.version_made_by & 0xff;
279   int os = (entry.version_made_by >> 8) & 0xff;
280 
281   // TODO: Support suid/sgid? Non-Unix/non-FAT host file system attributes?
282   const char* src_fs = "???";
283   char mode[] = "???       ";
284   if (os == 0) {
285     src_fs = "fat";
286     // https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
287     int attrs = entry.external_file_attributes & 0xff;
288     mode[0] = (attrs & 0x10) ? 'd' : '-';
289     mode[1] = 'r';
290     mode[2] = (attrs & 0x01) ? '-' : 'w';
291     // The man page also mentions ".btm", but that seems to be obsolete?
292     mode[3] = EndsWith(name, ".exe") || EndsWith(name, ".com") || EndsWith(name, ".bat") ||
293                       EndsWith(name, ".cmd")
294                   ? 'x'
295                   : '-';
296     mode[4] = (attrs & 0x20) ? 'a' : '-';
297     mode[5] = (attrs & 0x02) ? 'h' : '-';
298     mode[6] = (attrs & 0x04) ? 's' : '-';
299   } else if (os == 3) {
300     src_fs = "unx";
301     mode[0] = S_ISDIR(entry.unix_mode) ? 'd' : (S_ISREG(entry.unix_mode) ? '-' : '?');
302     mode[1] = entry.unix_mode & S_IRUSR ? 'r' : '-';
303     mode[2] = entry.unix_mode & S_IWUSR ? 'w' : '-';
304     mode[3] = entry.unix_mode & S_IXUSR ? 'x' : '-';
305     mode[4] = entry.unix_mode & S_IRGRP ? 'r' : '-';
306     mode[5] = entry.unix_mode & S_IWGRP ? 'w' : '-';
307     mode[6] = entry.unix_mode & S_IXGRP ? 'x' : '-';
308     mode[7] = entry.unix_mode & S_IROTH ? 'r' : '-';
309     mode[8] = entry.unix_mode & S_IWOTH ? 'w' : '-';
310     mode[9] = entry.unix_mode & S_IXOTH ? 'x' : '-';
311   }
312 
313   char method[5] = "stor";
314   if (entry.method == kCompressDeflated) {
315     snprintf(method, sizeof(method), "def%c", "NXFS"[(entry.gpbf >> 1) & 0x3]);
316   }
317 
318   // TODO: zipinfo (unlike unzip) sometimes uses time zone?
319   // TODO: this uses 4-digit years because we're not barbarians unless interoperability forces it.
320   tm t = entry.GetModificationTime();
321   char time[32];
322   snprintf(time, sizeof(time), "%04d-%02d-%02d %02d:%02d", t.tm_year + 1900, t.tm_mon + 1,
323            t.tm_mday, t.tm_hour, t.tm_min);
324 
325   // "-rw-r--r--  3.0 unx      577 t- defX 19-Feb-12 16:09 android-ndk-r19b/sources/android/NOTICE"
326   printf("%s %2d.%d %s %8d %c%c %s %s %s\n", mode, version / 10, version % 10, src_fs,
327          entry.uncompressed_length, entry.is_text ? 't' : 'b',
328          entry.has_data_descriptor ? 'X' : 'x', method, time, name.c_str());
329 }
330 
ProcessOne(ZipArchiveHandle zah,ZipEntry & entry,const std::string & name)331 static void ProcessOne(ZipArchiveHandle zah, ZipEntry& entry, const std::string& name) {
332   if (role == kUnzip) {
333     if (flag_l || flag_v) {
334       // -l or -lv or -lq or -v.
335       ListOne(entry, name);
336     } else {
337       // Actually extract.
338       if (flag_p) {
339         ExtractToPipe(zah, entry, name);
340       } else {
341         ExtractOne(zah, entry, name);
342       }
343     }
344   } else {
345     // zipinfo or zipinfo -1.
346     InfoOne(entry, name);
347   }
348   total_uncompressed_length += entry.uncompressed_length;
349   total_compressed_length += entry.compressed_length;
350   ++file_count;
351 }
352 
ProcessAll(ZipArchiveHandle zah)353 static void ProcessAll(ZipArchiveHandle zah) {
354   MaybeShowHeader(zah);
355 
356   // libziparchive iteration order doesn't match the central directory.
357   // We could sort, but that would cost extra and wouldn't match either.
358   void* cookie;
359   int err = StartIteration(zah, &cookie);
360   if (err != 0) {
361     die(0, "couldn't iterate %s: %s", archive_name, ErrorCodeString(err));
362   }
363 
364   ZipEntry entry;
365   std::string name;
366   while ((err = Next(cookie, &entry, &name)) >= 0) {
367     if (ShouldInclude(name)) ProcessOne(zah, entry, name);
368   }
369 
370   if (err < -1) die(0, "failed iterating %s: %s", archive_name, ErrorCodeString(err));
371   EndIteration(cookie);
372 
373   MaybeShowFooter();
374 }
375 
ShowHelp(bool full)376 static void ShowHelp(bool full) {
377   if (role == kUnzip) {
378     fprintf(full ? stdout : stderr, "usage: unzip [-d DIR] [-lnopqv] ZIP [FILE...] [-x FILE...]\n");
379     if (!full) exit(EXIT_FAILURE);
380 
381     printf(
382         "\n"
383         "Extract FILEs from ZIP archive. Default is all files. Both the include and\n"
384         "exclude (-x) lists use shell glob patterns.\n"
385         "\n"
386         "-d DIR	Extract into DIR\n"
387         "-l	List contents (-lq excludes archive name, -lv is verbose)\n"
388         "-n	Never overwrite files (default: prompt)\n"
389         "-o	Always overwrite files\n"
390         "-p	Pipe to stdout\n"
391         "-q	Quiet\n"
392         "-v	List contents verbosely\n"
393         "-x FILE	Exclude files\n");
394   } else {
395     fprintf(full ? stdout : stderr, "usage: zipinfo [-1] ZIP [FILE...] [-x FILE...]\n");
396     if (!full) exit(EXIT_FAILURE);
397 
398     printf(
399         "\n"
400         "Show information about FILEs from ZIP archive. Default is all files.\n"
401         "Both the include and exclude (-x) lists use shell glob patterns.\n"
402         "\n"
403         "-1	Show filenames only, one per line\n"
404         "-x FILE	Exclude files\n");
405   }
406   exit(EXIT_SUCCESS);
407 }
408 
HandleCommonOption(int opt)409 static void HandleCommonOption(int opt) {
410   switch (opt) {
411     case 'h':
412       ShowHelp(true);
413       break;
414     case 'x':
415       flag_x = true;
416       break;
417     case 1:
418       // -x swallows all following arguments, so we use '-' in the getopt
419       // string and collect files here.
420       if (!archive_name) {
421         archive_name = optarg;
422       } else if (flag_x) {
423         excludes.insert(optarg);
424       } else {
425         includes.insert(optarg);
426       }
427       break;
428     default:
429       ShowHelp(false);
430       break;
431   }
432 }
433 
main(int argc,char * argv[])434 int main(int argc, char* argv[]) {
435   // Who am I, and what am I doing?
436   g_progname = basename(argv[0]);
437   if (!strcmp(g_progname, "ziptool") && argc > 1) return main(argc - 1, argv + 1);
438   if (!strcmp(g_progname, "unzip")) {
439     role = kUnzip;
440   } else if (!strcmp(g_progname, "zipinfo")) {
441     role = kZipinfo;
442   } else {
443     die(0, "run as ziptool with unzip or zipinfo as the first argument, or symlink");
444   }
445 
446   static const struct option opts[] = {
447       {"help", no_argument, 0, 'h'},
448       {},
449   };
450 
451   if (role == kUnzip) {
452     // `unzip -Z` is "zipinfo mode", so in that case just restart...
453     if (argc > 1 && !strcmp(argv[1], "-Z")) {
454       argv[1] = const_cast<char*>("zipinfo");
455       return main(argc - 1, argv + 1);
456     }
457 
458     int opt;
459     while ((opt = getopt_long(argc, argv, "-d:hlnopqvx", opts, nullptr)) != -1) {
460       switch (opt) {
461         case 'd':
462           flag_d = optarg;
463           if (!EndsWith(flag_d, "/")) flag_d += '/';
464           break;
465         case 'l':
466           flag_l = true;
467           break;
468         case 'n':
469           overwrite_mode = kNever;
470           break;
471         case 'o':
472           overwrite_mode = kAlways;
473           break;
474         case 'p':
475           flag_p = flag_q = true;
476           break;
477         case 'q':
478           flag_q = true;
479           break;
480         case 'v':
481           flag_v = true;
482           break;
483         default:
484           HandleCommonOption(opt);
485           break;
486       }
487     }
488   } else {
489     int opt;
490     while ((opt = getopt_long(argc, argv, "-1hx", opts, nullptr)) != -1) {
491       switch (opt) {
492         case '1':
493           flag_1 = true;
494           break;
495         default:
496           HandleCommonOption(opt);
497           break;
498       }
499     }
500   }
501 
502   if (!archive_name) die(0, "missing archive filename");
503 
504   // We can't support "-" to unzip from stdin because libziparchive relies on mmap.
505   ZipArchiveHandle zah;
506   int32_t err;
507   if ((err = OpenArchive(archive_name, &zah)) != 0) {
508     die(0, "couldn't open %s: %s", archive_name, ErrorCodeString(err));
509   }
510 
511   // Implement -d by changing into that directory.
512   // We'll create implicit directories based on paths in the zip file, and we'll create
513   // the -d directory itself, but we require that *parents* of the -d directory already exists.
514   // This is pretty arbitrary, but it's the behavior of the original unzip.
515   if (!flag_d.empty()) {
516     if (mkdir(flag_d.c_str(), 0777) == -1 && errno != EEXIST) {
517       die(errno, "couldn't created %s", flag_d.c_str());
518     }
519     if (chdir(flag_d.c_str()) == -1) {
520       die(errno, "couldn't chdir to %s", flag_d.c_str());
521     }
522   }
523 
524   ProcessAll(zah);
525 
526   CloseArchive(zah);
527   return 0;
528 }
529