git.maemo.org Git - busybox4maemo/blob - archival/unzip.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini unzip implementation for busybox
   4  *
   5  * Copyright (C) 2004 by Ed Clark
   6  *
   7  * Loosely based on original busybox unzip applet by Laurence Anderson.
   8  * All options and features should work in this version.
   9  *
  10  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  11  */
  12
  13 /* For reference see
  14  * http://www.pkware.com/company/standards/appnote/
  15  * http://www.info-zip.org/pub/infozip/doc/appnote-iz-latest.zip
  16  */
  17
  18 /* TODO
  19  * Endian issues
  20  * Zip64 + other methods
  21  * Improve handling of zip format, ie.
  22  * - deferred CRC, comp. & uncomp. lengths (zip header flags bit 3)
  23  * - unix file permissions, etc.
  24  * - central directory
  25  */
  26
  27 #include "libbb.h"
  28 #include "unarchive.h"
  29
  30 enum {
  31 #if BB_BIG_ENDIAN
  32         ZIP_FILEHEADER_MAGIC = 0x504b0304,
  33         ZIP_CDS_MAGIC        = 0x504b0102,
  34         ZIP_CDS_END_MAGIC    = 0x504b0506,
  35         ZIP_DD_MAGIC         = 0x504b0708,
  36 #else
  37         ZIP_FILEHEADER_MAGIC = 0x04034b50,
  38         ZIP_CDS_MAGIC        = 0x02014b50,
  39         ZIP_CDS_END_MAGIC    = 0x06054b50,
  40         ZIP_DD_MAGIC         = 0x08074b50,
  41 #endif
  42 };
  43
  44 #define ZIP_HEADER_LEN 26
  45
  46 typedef union {
  47         uint8_t raw[ZIP_HEADER_LEN];
  48         struct {
  49                 uint16_t version;                       /* 0-1 */
  50                 uint16_t flags;                         /* 2-3 */
  51                 uint16_t method;                        /* 4-5 */
  52                 uint16_t modtime;                       /* 6-7 */
  53                 uint16_t moddate;                       /* 8-9 */
  54                 uint32_t crc32 ATTRIBUTE_PACKED;        /* 10-13 */
  55                 uint32_t cmpsize ATTRIBUTE_PACKED;      /* 14-17 */
  56                 uint32_t ucmpsize ATTRIBUTE_PACKED;     /* 18-21 */
  57                 uint16_t filename_len;                  /* 22-23 */
  58                 uint16_t extra_len;                     /* 24-25 */
  59         } formatted ATTRIBUTE_PACKED;
  60 } zip_header_t; /* ATTRIBUTE_PACKED - gcc 4.2.1 doesn't like it (spews warning) */
  61
  62 /* Check the offset of the last element, not the length.  This leniency
  63  * allows for poor packing, whereby the overall struct may be too long,
  64  * even though the elements are all in the right place.
  65  */
  66 struct BUG_zip_header_must_be_26_bytes {
  67         char BUG_zip_header_must_be_26_bytes[
  68                 offsetof(zip_header_t, formatted.extra_len) + 2 ==
  69                         ZIP_HEADER_LEN ? 1 : -1];
  70 };
  71
  72 #define FIX_ENDIANNESS(zip_header) do { \
  73         (zip_header).formatted.version      = SWAP_LE16((zip_header).formatted.version     ); \
  74         (zip_header).formatted.flags        = SWAP_LE16((zip_header).formatted.flags       ); \
  75         (zip_header).formatted.method       = SWAP_LE16((zip_header).formatted.method      ); \
  76         (zip_header).formatted.modtime      = SWAP_LE16((zip_header).formatted.modtime     ); \
  77         (zip_header).formatted.moddate      = SWAP_LE16((zip_header).formatted.moddate     ); \
  78         (zip_header).formatted.crc32        = SWAP_LE32((zip_header).formatted.crc32       ); \
  79         (zip_header).formatted.cmpsize      = SWAP_LE32((zip_header).formatted.cmpsize     ); \
  80         (zip_header).formatted.ucmpsize     = SWAP_LE32((zip_header).formatted.ucmpsize    ); \
  81         (zip_header).formatted.filename_len = SWAP_LE16((zip_header).formatted.filename_len); \
  82         (zip_header).formatted.extra_len    = SWAP_LE16((zip_header).formatted.extra_len   ); \
  83 } while (0)
  84
  85 static void unzip_skip(int fd, off_t skip)
  86 {
  87         bb_copyfd_exact_size(fd, -1, skip);
  88 }
  89
  90 static void unzip_create_leading_dirs(const char *fn)
  91 {
  92         /* Create all leading directories */
  93         char *name = xstrdup(fn);
  94         if (bb_make_directory(dirname(name), 0777, FILEUTILS_RECUR)) {
  95                 bb_error_msg_and_die("exiting"); /* bb_make_directory is noisy */
  96         }
  97         free(name);
  98 }
  99
 100 static void unzip_extract(zip_header_t *zip_header, int src_fd, int dst_fd)
 101 {
 102         if (zip_header->formatted.method == 0) {
 103                 /* Method 0 - stored (not compressed) */
 104                 off_t size = zip_header->formatted.ucmpsize;
 105                 if (size)
 106                         bb_copyfd_exact_size(src_fd, dst_fd, size);
 107         } else {
 108                 /* Method 8 - inflate */
 109                 inflate_unzip_result res;
 110                 if (inflate_unzip(&res, zip_header->formatted.cmpsize, src_fd, dst_fd) < 0)
 111                         bb_error_msg_and_die("inflate error");
 112                 /* Validate decompression - crc */
 113                 if (zip_header->formatted.crc32 != (res.crc ^ 0xffffffffL)) {
 114                         bb_error_msg_and_die("crc error");
 115                 }
 116                 /* Validate decompression - size */
 117                 if (zip_header->formatted.ucmpsize != res.bytes_out) {
 118                         /* Don't die. Who knows, maybe len calculation
 119                          * was botched somewhere. After all, crc matched! */
 120                         bb_error_msg("bad length");
 121                 }
 122         }
 123 }
 124
 125 int unzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 126 int unzip_main(int argc, char **argv)
 127 {
 128         enum { O_PROMPT, O_NEVER, O_ALWAYS };
 129
 130         zip_header_t zip_header;
 131         smallint verbose = 1;
 132         smallint listing = 0;
 133         smallint overwrite = O_PROMPT;
 134         unsigned total_size;
 135         unsigned total_entries;
 136         int src_fd = -1;
 137         int dst_fd = -1;
 138         char *src_fn = NULL;
 139         char *dst_fn = NULL;
 140         llist_t *zaccept = NULL;
 141         llist_t *zreject = NULL;
 142         char *base_dir = NULL;
 143         int i, opt;
 144         int opt_range = 0;
 145         char key_buf[80];
 146         struct stat stat_buf;
 147
 148         /* '-' makes getopt return 1 for non-options */
 149         while ((opt = getopt(argc, argv, "-d:lnopqx")) != -1) {
 150                 switch (opt_range) {
 151                 case 0: /* Options */
 152                         switch (opt) {
 153                         case 'l': /* List */
 154                                 listing = 1;
 155                                 break;
 156
 157                         case 'n': /* Never overwrite existing files */
 158                                 overwrite = O_NEVER;
 159                                 break;
 160
 161                         case 'o': /* Always overwrite existing files */
 162                                 overwrite = O_ALWAYS;
 163                                 break;
 164
 165                         case 'p': /* Extract files to stdout and fall through to set verbosity */
 166                                 dst_fd = STDOUT_FILENO;
 167
 168                         case 'q': /* Be quiet */
 169                                 verbose = 0;
 170                                 break;
 171
 172                         case 1: /* The zip file */
 173                                 /* +5: space for ".zip" and NUL */
 174                                 src_fn = xmalloc(strlen(optarg) + 5);
 175                                 strcpy(src_fn, optarg);
 176                                 opt_range++;
 177                                 break;
 178
 179                         default:
 180                                 bb_show_usage();
 181
 182                         }
 183                         break;
 184
 185                 case 1: /* Include files */
 186                         if (opt == 1) {
 187                                 llist_add_to(&zaccept, optarg);
 188                                 break;
 189                         }
 190                         if (opt == 'd') {
 191                                 base_dir = optarg;
 192                                 opt_range += 2;
 193                                 break;
 194                         }
 195                         if (opt == 'x') {
 196                                 opt_range++;
 197                                 break;
 198                         }
 199                         bb_show_usage();
 200
 201                 case 2 : /* Exclude files */
 202                         if (opt == 1) {
 203                                 llist_add_to(&zreject, optarg);
 204                                 break;
 205                         }
 206                         if (opt == 'd') { /* Extract to base directory */
 207                                 base_dir = optarg;
 208                                 opt_range++;
 209                                 break;
 210                         }
 211                         /* fall through */
 212
 213                 default:
 214                         bb_show_usage();
 215                 }
 216         }
 217
 218         if (src_fn == NULL) {
 219                 bb_show_usage();
 220         }
 221
 222         /* Open input file */
 223         if (LONE_DASH(src_fn)) {
 224                 src_fd = STDIN_FILENO;
 225                 /* Cannot use prompt mode since zip data is arriving on STDIN */
 226                 if (overwrite == O_PROMPT)
 227                         overwrite = O_NEVER;
 228         } else {
 229                 static const char extn[][5] = {"", ".zip", ".ZIP"};
 230                 int orig_src_fn_len = strlen(src_fn);
 231
 232                 for (i = 0; (i < 3) && (src_fd == -1); i++) {
 233                         strcpy(src_fn + orig_src_fn_len, extn[i]);
 234                         src_fd = open(src_fn, O_RDONLY);
 235                 }
 236                 if (src_fd == -1) {
 237                         src_fn[orig_src_fn_len] = '\0';
 238                         bb_error_msg_and_die("can't open %s, %s.zip, %s.ZIP", src_fn, src_fn, src_fn);
 239                 }
 240         }
 241
 242         /* Change dir if necessary */
 243         if (base_dir)
 244                 xchdir(base_dir);
 245
 246         if (verbose) {
 247                 printf("Archive:  %s\n", src_fn);
 248                 if (listing){
 249                         puts("  Length     Date   Time    Name\n"
 250                              " --------    ----   ----    ----");
 251                 }
 252         }
 253
 254         total_size = 0;
 255         total_entries = 0;
 256         while (1) {
 257                 uint32_t magic;
 258
 259                 /* Check magic number */
 260                 xread(src_fd, &magic, 4);
 261                 if (magic == ZIP_CDS_MAGIC)
 262                         break;
 263                 if (magic != ZIP_FILEHEADER_MAGIC)
 264                         bb_error_msg_and_die("invalid zip magic %08X", magic);
 265
 266                 /* Read the file header */
 267                 xread(src_fd, zip_header.raw, ZIP_HEADER_LEN);
 268                 FIX_ENDIANNESS(zip_header);
 269                 if ((zip_header.formatted.method != 0) && (zip_header.formatted.method != 8)) {
 270                         bb_error_msg_and_die("unsupported method %d", zip_header.formatted.method);
 271                 }
 272
 273                 /* Read filename */
 274                 free(dst_fn);
 275                 dst_fn = xzalloc(zip_header.formatted.filename_len + 1);
 276                 xread(src_fd, dst_fn, zip_header.formatted.filename_len);
 277
 278                 /* Skip extra header bytes */
 279                 unzip_skip(src_fd, zip_header.formatted.extra_len);
 280
 281                 /* Filter zip entries */
 282                 if (find_list_entry(zreject, dst_fn)
 283                  || (zaccept && !find_list_entry(zaccept, dst_fn))
 284                 ) { /* Skip entry */
 285                         i = 'n';
 286
 287                 } else { /* Extract entry */
 288                         if (listing) { /* List entry */
 289                                 if (verbose) {
 290                                         unsigned dostime = zip_header.formatted.modtime | (zip_header.formatted.moddate << 16);
 291                                         printf("%9u  %02u-%02u-%02u %02u:%02u   %s\n",
 292                                            zip_header.formatted.ucmpsize,
 293                                            (dostime & 0x01e00000) >> 21,
 294                                            (dostime & 0x001f0000) >> 16,
 295                                            (((dostime & 0xfe000000) >> 25) + 1980) % 100,
 296                                            (dostime & 0x0000f800) >> 11,
 297                                            (dostime & 0x000007e0) >> 5,
 298                                            dst_fn);
 299                                         total_size += zip_header.formatted.ucmpsize;
 300                                         total_entries++;
 301                                 } else {
 302                                         /* short listing -- filenames only */
 303                                         puts(dst_fn);
 304                                 }
 305                                 i = 'n';
 306                         } else if (dst_fd == STDOUT_FILENO) { /* Extracting to STDOUT */
 307                                 i = -1;
 308                         } else if (last_char_is(dst_fn, '/')) { /* Extract directory */
 309                                 if (stat(dst_fn, &stat_buf) == -1) {
 310                                         if (errno != ENOENT) {
 311                                                 bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
 312                                         }
 313                                         if (verbose) {
 314                                                 printf("   creating: %s\n", dst_fn);
 315                                         }
 316                                         unzip_create_leading_dirs(dst_fn);
 317                                         if (bb_make_directory(dst_fn, 0777, 0)) {
 318                                                 bb_error_msg_and_die("exiting");
 319                                         }
 320                                 } else {
 321                                         if (!S_ISDIR(stat_buf.st_mode)) {
 322                                                 bb_error_msg_and_die("'%s' exists but is not directory", dst_fn);
 323                                         }
 324                                 }
 325                                 i = 'n';
 326
 327                         } else {  /* Extract file */
 328  _check_file:
 329                                 if (stat(dst_fn, &stat_buf) == -1) { /* File does not exist */
 330                                         if (errno != ENOENT) {
 331                                                 bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
 332                                         }
 333                                         i = 'y';
 334                                 } else { /* File already exists */
 335                                         if (overwrite == O_NEVER) {
 336                                                 i = 'n';
 337                                         } else if (S_ISREG(stat_buf.st_mode)) { /* File is regular file */
 338                                                 if (overwrite == O_ALWAYS) {
 339                                                         i = 'y';
 340                                                 } else {
 341                                                         printf("replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ", dst_fn);
 342                                                         if (!fgets(key_buf, sizeof(key_buf), stdin)) {
 343                                                                 bb_perror_msg_and_die("cannot read input");
 344                                                         }
 345                                                         i = key_buf[0];
 346                                                 }
 347                                         } else { /* File is not regular file */
 348                                                 bb_error_msg_and_die("'%s' exists but is not regular file",dst_fn);
 349                                         }
 350                                 }
 351                         }
 352                 }
 353
 354                 switch (i) {
 355                 case 'A':
 356                         overwrite = O_ALWAYS;
 357                 case 'y': /* Open file and fall into unzip */
 358                         unzip_create_leading_dirs(dst_fn);
 359                         dst_fd = xopen(dst_fn, O_WRONLY | O_CREAT | O_TRUNC);
 360                 case -1: /* Unzip */
 361                         if (verbose) {
 362                                 printf("  inflating: %s\n", dst_fn);
 363                         }
 364                         unzip_extract(&zip_header, src_fd, dst_fd);
 365                         if (dst_fd != STDOUT_FILENO) {
 366                                 /* closing STDOUT is potentially bad for future business */
 367                                 close(dst_fd);
 368                         }
 369                         break;
 370
 371                 case 'N':
 372                         overwrite = O_NEVER;
 373                 case 'n':
 374                         /* Skip entry data */
 375                         unzip_skip(src_fd, zip_header.formatted.cmpsize);
 376                         break;
 377
 378                 case 'r':
 379                         /* Prompt for new name */
 380                         printf("new name: ");
 381                         if (!fgets(key_buf, sizeof(key_buf), stdin)) {
 382                                 bb_perror_msg_and_die("cannot read input");
 383                         }
 384                         free(dst_fn);
 385                         dst_fn = xstrdup(key_buf);
 386                         chomp(dst_fn);
 387                         goto _check_file;
 388
 389                 default:
 390                         printf("error: invalid response [%c]\n",(char)i);
 391                         goto _check_file;
 392                 }
 393
 394                 /* Data descriptor section */
 395                 if (zip_header.formatted.flags & 4) {
 396                         /* skip over duplicate crc, compressed size and uncompressed size */
 397                         unzip_skip(src_fd, 12);
 398                 }
 399         }
 400
 401         if (listing && verbose) {
 402                 printf(" --------                   -------\n"
 403                        "%9d                   %d files\n",
 404                        total_size, total_entries);
 405         }
 406
 407         return 0;
 408 }