source: MondoRescue/branches/stable/mindi-busybox/archival/unzip.c

/* vi: set sw=4 ts=4: */
/*
 * Mini unzip implementation for busybox
 *
 * Copyright (C) 2004 by Ed Clark
 *
 * Loosely based on original busybox unzip applet by Laurence Anderson.
 * All options and features should work in this version.
 *
 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
 */

/* For reference see
 * http://www.pkware.com/company/standards/appnote/
 * http://www.info-zip.org/pub/infozip/doc/appnote-iz-latest.zip
 */

/* TODO
 * Endian issues
 * Zip64 + other methods
 * Improve handling of zip format, ie.
 * - deferred CRC, comp. & uncomp. lengths (zip header flags bit 3)
 * - unix file permissions, etc.
 * - central directory
 */

#include "libbb.h"
#include "unarchive.h"

#define ZIP_FILEHEADER_MAGIC        SWAP_LE32(0x04034b50)
#define ZIP_CDS_MAGIC           SWAP_LE32(0x02014b50)
#define ZIP_CDS_END_MAGIC       SWAP_LE32(0x06054b50)
#define ZIP_DD_MAGIC            SWAP_LE32(0x08074b50)

typedef union {
    unsigned char raw[26];
    struct {
        unsigned short version; /* 0-1 */
        unsigned short flags;   /* 2-3 */
        unsigned short method;  /* 4-5 */
        unsigned short modtime; /* 6-7 */
        unsigned short moddate; /* 8-9 */
        unsigned int crc32 ATTRIBUTE_PACKED;    /* 10-13 */
        unsigned int cmpsize ATTRIBUTE_PACKED;  /* 14-17 */
        unsigned int ucmpsize ATTRIBUTE_PACKED; /* 18-21 */
        unsigned short filename_len;    /* 22-23 */
        unsigned short extra_len;       /* 24-25 */
    } formatted ATTRIBUTE_PACKED;
} zip_header_t;

static void unzip_skip(int fd, off_t skip)
{
    if (lseek(fd, skip, SEEK_CUR) == (off_t)-1) {
        if (errno != ESPIPE)
            bb_error_msg_and_die("seek failure");
        bb_copyfd_exact_size(fd, -1, skip);
    }
}

static void unzip_create_leading_dirs(char *fn)
{
    /* Create all leading directories */
    char *name = xstrdup(fn);
    if (bb_make_directory(dirname(name), 0777, FILEUTILS_RECUR)) {
        bb_error_msg_and_die("exiting"); /* bb_make_directory is noisy */
    }
    free(name);
}

static int unzip_extract(zip_header_t *zip_header, int src_fd, int dst_fd)
{
    if (zip_header->formatted.method == 0) {
        /* Method 0 - stored (not compressed) */
        off_t size = zip_header->formatted.ucmpsize;
        if (size)
            bb_copyfd_exact_size(src_fd, dst_fd, size);
    } else {
        /* Method 8 - inflate */
        inflate_unzip_result res;
        /* err = */ inflate_unzip(&res, zip_header->formatted.cmpsize, src_fd, dst_fd);
// we should check for -1 error return
        /* Validate decompression - crc */
        if (zip_header->formatted.crc32 != (res.crc ^ 0xffffffffL)) {
            bb_error_msg("invalid compressed data--%s error", "crc");
            return 1;
        }
        /* Validate decompression - size */
        if (zip_header->formatted.ucmpsize != res.bytes_out) {
            bb_error_msg("invalid compressed data--%s error", "length");
            return 1;
        }
    }
    return 0;
}

int unzip_main(int argc, char **argv);
int unzip_main(int argc, char **argv)
{
    zip_header_t zip_header;
    enum {v_silent, v_normal, v_list} verbosity = v_normal;
    enum {o_prompt, o_never, o_always} overwrite = o_prompt;
    unsigned int total_size = 0;
    unsigned int total_entries = 0;
    int src_fd = -1, dst_fd = -1;
    char *src_fn = NULL, *dst_fn = NULL;
    llist_t *zaccept = NULL;
    llist_t *zreject = NULL;
    char *base_dir = NULL;
    int failed, i, opt, opt_range = 0, list_header_done = 0;
    char key_buf[512];
    struct stat stat_buf;

    while ((opt = getopt(argc, argv, "-d:lnopqx")) != -1) {
        switch (opt_range) {
        case 0: /* Options */
            switch (opt) {
            case 'l': /* List */
                verbosity = v_list;
                break;

            case 'n': /* Never overwrite existing files */
                overwrite = o_never;
                break;

            case 'o': /* Always overwrite existing files */
                overwrite = o_always;
                break;

            case 'p': /* Extract files to stdout and fall through to set verbosity */
                dst_fd = STDOUT_FILENO;

            case 'q': /* Be quiet */
                verbosity = (verbosity == v_normal) ? v_silent : verbosity;
                break;

            case 1 : /* The zip file */
                src_fn = xmalloc(strlen(optarg)+4);
                strcpy(src_fn, optarg);
                opt_range++;
                break;

            default:
                bb_show_usage();

            }
            break;

        case 1: /* Include files */
            if (opt == 1) {
                llist_add_to(&zaccept, optarg);

            } else if (opt == 'd') {
                base_dir = optarg;
                opt_range += 2;

            } else if (opt == 'x') {
                opt_range++;

            } else {
                bb_show_usage();
            }
            break;

        case 2 : /* Exclude files */
            if (opt == 1) {
                llist_add_to(&zreject, optarg);

            } else if (opt == 'd') { /* Extract to base directory */
                base_dir = optarg;
                opt_range++;

            } else {
                bb_show_usage();
            }
            break;

        default:
            bb_show_usage();
        }
    }

    if (src_fn == NULL) {
        bb_show_usage();
    }

    /* Open input file */
    if (LONE_DASH(src_fn)) {
        src_fd = STDIN_FILENO;
        /* Cannot use prompt mode since zip data is arriving on STDIN */
        overwrite = (overwrite == o_prompt) ? o_never : overwrite;
    } else {
        static const char *const extn[] = {"", ".zip", ".ZIP"};
        int orig_src_fn_len = strlen(src_fn);
        for (i = 0; (i < 3) && (src_fd == -1); i++) {
            strcpy(src_fn + orig_src_fn_len, extn[i]);
            src_fd = open(src_fn, O_RDONLY);
        }
        if (src_fd == -1) {
            src_fn[orig_src_fn_len] = '\0';
            bb_error_msg_and_die("cannot open %s, %s.zip, %s.ZIP", src_fn, src_fn, src_fn);
        }
    }

    /* Change dir if necessary */
    if (base_dir)
        xchdir(base_dir);

    if (verbosity != v_silent)
        printf("Archive:  %s\n", src_fn);

    failed = 0;

    while (1) {
        unsigned int magic;

        /* Check magic number */
        xread(src_fd, &magic, 4);
        if (magic == ZIP_CDS_MAGIC) {
            break;
        } else if (magic != ZIP_FILEHEADER_MAGIC) {
            bb_error_msg_and_die("invalid zip magic %08X", magic);
        }

        /* Read the file header */
        xread(src_fd, zip_header.raw, 26);
        zip_header.formatted.version = SWAP_LE32(zip_header.formatted.version);
        zip_header.formatted.flags = SWAP_LE32(zip_header.formatted.flags);
        zip_header.formatted.method = SWAP_LE32(zip_header.formatted.method);
        zip_header.formatted.modtime = SWAP_LE32(zip_header.formatted.modtime);
        zip_header.formatted.moddate = SWAP_LE32(zip_header.formatted.moddate);
        zip_header.formatted.crc32 = SWAP_LE32(zip_header.formatted.crc32);
        zip_header.formatted.cmpsize = SWAP_LE32(zip_header.formatted.cmpsize);
        zip_header.formatted.ucmpsize = SWAP_LE32(zip_header.formatted.ucmpsize);
        zip_header.formatted.filename_len = SWAP_LE32(zip_header.formatted.filename_len);
        zip_header.formatted.extra_len = SWAP_LE32(zip_header.formatted.extra_len);
        if ((zip_header.formatted.method != 0) && (zip_header.formatted.method != 8)) {
            bb_error_msg_and_die("unsupported compression method %d", zip_header.formatted.method);
        }

        /* Read filename */
        free(dst_fn);
        dst_fn = xzalloc(zip_header.formatted.filename_len + 1);
        xread(src_fd, dst_fn, zip_header.formatted.filename_len);

        /* Skip extra header bytes */
        unzip_skip(src_fd, zip_header.formatted.extra_len);

        if ((verbosity == v_list) && !list_header_done){
            puts("  Length     Date   Time    Name\n"
                 " --------    ----   ----    ----");
            list_header_done = 1;
        }

        /* Filter zip entries */
        if (find_list_entry(zreject, dst_fn) ||
            (zaccept && !find_list_entry(zaccept, dst_fn))) { /* Skip entry */
            i = 'n';

        } else { /* Extract entry */
            total_size += zip_header.formatted.ucmpsize;

            if (verbosity == v_list) { /* List entry */
                unsigned int dostime = zip_header.formatted.modtime | (zip_header.formatted.moddate << 16);
                printf("%9u  %02u-%02u-%02u %02u:%02u   %s\n",
                       zip_header.formatted.ucmpsize,
                       (dostime & 0x01e00000) >> 21,
                       (dostime & 0x001f0000) >> 16,
                       (((dostime & 0xfe000000) >> 25) + 1980) % 100,
                       (dostime & 0x0000f800) >> 11,
                       (dostime & 0x000007e0) >> 5,
                       dst_fn);
                total_entries++;
                i = 'n';
            } else if (dst_fd == STDOUT_FILENO) { /* Extracting to STDOUT */
                i = -1;
            } else if (last_char_is(dst_fn, '/')) { /* Extract directory */
                if (stat(dst_fn, &stat_buf) == -1) {
                    if (errno != ENOENT) {
                        bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
                    }
                    if (verbosity == v_normal) {
                        printf("   creating: %s\n", dst_fn);
                    }
                    unzip_create_leading_dirs(dst_fn);
                    if (bb_make_directory(dst_fn, 0777, 0)) {
                        bb_error_msg_and_die("exiting");
                    }
                } else {
                    if (!S_ISDIR(stat_buf.st_mode)) {
                        bb_error_msg_and_die("'%s' exists but is not directory", dst_fn);
                    }
                }
                i = 'n';

            } else {  /* Extract file */
 _check_file:
                if (stat(dst_fn, &stat_buf) == -1) { /* File does not exist */
                    if (errno != ENOENT) {
                        bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
                    }
                    i = 'y';
                } else { /* File already exists */
                    if (overwrite == o_never) {
                        i = 'n';
                    } else if (S_ISREG(stat_buf.st_mode)) { /* File is regular file */
                        if (overwrite == o_always) {
                            i = 'y';
                        } else {
                            printf("replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ", dst_fn);
                            if (!fgets(key_buf, 512, stdin)) {
                                bb_perror_msg_and_die("cannot read input");
                            }
                            i = key_buf[0];
                        }
                    } else { /* File is not regular file */
                        bb_error_msg_and_die("'%s' exists but is not regular file",dst_fn);
                    }
                }
            }
        }

        switch (i) {
        case 'A':
            overwrite = o_always;
        case 'y': /* Open file and fall into unzip */
            unzip_create_leading_dirs(dst_fn);
            dst_fd = xopen(dst_fn, O_WRONLY | O_CREAT | O_TRUNC);
        case -1: /* Unzip */
            if (verbosity == v_normal) {
                printf("  inflating: %s\n", dst_fn);
            }
            if (unzip_extract(&zip_header, src_fd, dst_fd)) {
                failed = 1;
            }
            if (dst_fd != STDOUT_FILENO) {
                /* closing STDOUT is potentially bad for future business */
                close(dst_fd);
            }
            break;

        case 'N':
            overwrite = o_never;
        case 'n':
            /* Skip entry data */
            unzip_skip(src_fd, zip_header.formatted.cmpsize);
            break;

        case 'r':
            /* Prompt for new name */
            printf("new name: ");
            if (!fgets(key_buf, 512, stdin)) {
                bb_perror_msg_and_die("cannot read input");
            }
            free(dst_fn);
            dst_fn = xstrdup(key_buf);
            chomp(dst_fn);
            goto _check_file;

        default:
            printf("error: invalid response [%c]\n",(char)i);
            goto _check_file;
        }

        /* Data descriptor section */
        if (zip_header.formatted.flags & 4) {
            /* skip over duplicate crc, compressed size and uncompressed size */
            unzip_skip(src_fd, 12);
        }
    }

    if (verbosity == v_list) {
        printf(" --------                   -------\n"
               "%9d                   %d files\n", total_size, total_entries);
    }

    return failed;
}