extract.c

完整的解压zip文件的源码。包含密码功能

        while (members_remaining && (j < DIR_BLKSIZ)) {
            --members_remaining;
            G.pInfo = &G.info[j];

            if (readbuf(__G__ G.sig, 4) == 0) {
                error_in_archive = PK_EOF;
                members_remaining = 0;  /* ...so no more left to do */
                break;
            }
            if (strncmp(G.sig, central_hdr_sig, 4)) {  /* just to make sure */
                Info(slide, 0x401, ((char *)slide, LoadFarString(CentSigMsg),
                  j + blknum*DIR_BLKSIZ + 1));
                Info(slide, 0x401, ((char *)slide, LoadFarString(ReportMsg)));
                error_in_archive = PK_BADERR;
                members_remaining = 0;  /* ...so no more left to do */
                break;
            }
            /* process_cdir_file_hdr() sets pInfo->hostnum, pInfo->lcflag */
            if ((error = process_cdir_file_hdr(__G)) != PK_COOL) {
                error_in_archive = error;   /* only PK_EOF defined */
                members_remaining = 0;  /* ...so no more left to do */
                break;
            }
            if ((error = do_string(__G__ G.crec.filename_length, DS_FN)) !=
                 PK_COOL)
            {
                if (error > error_in_archive)
                    error_in_archive = error;
                if (error > PK_WARN) {  /* fatal:  no more left to do */
                    Info(slide, 0x401, ((char *)slide, LoadFarString(FilNamMsg),
                      FnFilter1(G.filename), "central"));
                    members_remaining = 0;
                    break;
                }
            }
            if ((error = do_string(__G__ G.crec.extra_field_length,
                EXTRA_FIELD)) != 0)
            {
                if (error > error_in_archive)
                    error_in_archive = error;
                if (error > PK_WARN) {  /* fatal */
                    Info(slide, 0x401, ((char *)slide,
                      LoadFarString(ExtFieldMsg),
                      FnFilter1(G.filename), "central"));
                    members_remaining = 0;
                    break;
                }
            }
#ifdef AMIGA
            G.filenote_slot = j;
            if ((error = do_string(__G__ G.crec.file_comment_length,
                                   uO.N_flag ? FILENOTE : SKIP)) != PK_COOL)
#else
            if ((error = do_string(__G__ G.crec.file_comment_length, SKIP))
                != PK_COOL)
#endif
            {
                if (error > error_in_archive)
                    error_in_archive = error;
                if (error > PK_WARN) {  /* fatal */
                    Info(slide, 0x421, ((char *)slide,
                      LoadFarString(BadFileCommLength),
                      FnFilter1(G.filename)));
                    members_remaining = 0;
                    break;
                }
            }
            if (G.process_all_files) {
                if (store_info(__G))
                    ++j;  /* file is OK; info[] stored; continue with next */
                else
                    ++num_skipped;
            } else {
                int   do_this_file;

                if (G.filespecs == 0)
                    do_this_file = TRUE;
                else {  /* check if this entry matches an `include' argument */
                    do_this_file = FALSE;
                    for (i = 0; i < G.filespecs; i++)
                        if (match(G.filename, G.pfnames[i], uO.C_flag)) {
                            do_this_file = TRUE;  /* ^-- ignore case or not? */
                            if (fn_matched)
                                fn_matched[i] = TRUE;
                            break;       /* found match, so stop looping */
                        }
                }
                if (do_this_file) {  /* check if this is an excluded file */
                    for (i = 0; i < G.xfilespecs; i++)
                        if (match(G.filename, G.pxnames[i], uO.C_flag)) {
                            do_this_file = FALSE; /* ^-- ignore case or not? */
                            if (xn_matched)
                                xn_matched[i] = TRUE;
                            break;
                        }
                }
                if (do_this_file) {
                    if (store_info(__G))
                        ++j;            /* file is OK */
                    else
                        ++num_skipped;  /* unsupp. compression or encryption */
                }
            } /* end if (process_all_files) */


        } /* end while-loop (adding files to current block) */

        /* save position in central directory so can come back later */
        cd_bufstart = G.cur_zipfile_bufstart;
        cd_inptr = G.inptr;
        cd_incnt = G.incnt;

    /*-----------------------------------------------------------------------
        Second loop:  process files in current block, extracting or testing
        each one.
      -----------------------------------------------------------------------*/

        for (i = 0; i < j; ++i) {
            filnum++;   /* filnum = i + blknum*DIR_BLKSIZ + 1; */
            G.pInfo = &G.info[i];
#ifdef NOVELL_BUG_FAILSAFE
            G.dne = FALSE;  /* assume file exists until stat() says otherwise */
#endif

            /* if the target position is not within the current input buffer
             * (either haven't yet read far enough, or (maybe) skipping back-
             * ward), skip to the target position and reset readbuf(). */

            /* ZLSEEK(pInfo->offset):  */
            request = G.pInfo->offset + G.extra_bytes;
            inbuf_offset = request % INBUFSIZ;
            bufstart = request - inbuf_offset;

            Trace((stderr, "\ndebug: request = %ld, inbuf_offset = %ld\n",
              request, inbuf_offset));
            Trace((stderr,
              "debug: bufstart = %ld, cur_zipfile_bufstart = %ld\n",
              bufstart, G.cur_zipfile_bufstart));
            if (request < 0) {
                Info(slide, 0x401, ((char *)slide, LoadFarStringSmall(SeekMsg),
                  G.zipfn, LoadFarString(ReportMsg)));
                error_in_archive = PK_ERR;
                if (filnum == 1 && G.extra_bytes != 0L) {
                    Info(slide, 0x401, ((char *)slide,
                      LoadFarString(AttemptRecompensate)));
                    old_extra_bytes = G.extra_bytes;
                    G.extra_bytes = 0L;
                    request = G.pInfo->offset;  /* could also check if != 0 */
                    inbuf_offset = request % INBUFSIZ;
                    bufstart = request - inbuf_offset;
                    Trace((stderr, "debug: request = %ld, inbuf_offset = %ld\n",
                      request, inbuf_offset));
                    Trace((stderr,
                      "debug: bufstart = %ld, cur_zipfile_bufstart = %ld\n",
                      bufstart, G.cur_zipfile_bufstart));
                } else {
                    error_in_archive = PK_BADERR;
                    continue;  /* this one hosed; try next */
                }
            }
            /* try again */
            if (request < 0) {
                Trace((stderr, "debug: recompensated request still < 0\n"));
                Info(slide, 0x401, ((char *)slide, LoadFarStringSmall(SeekMsg),
                  G.zipfn, LoadFarString(ReportMsg)));
                error_in_archive = PK_BADERR;
                continue;
            } else if (bufstart != G.cur_zipfile_bufstart) {
                Trace((stderr, "debug: bufstart != cur_zipfile_bufstart\n"));
#ifdef USE_STRM_INPUT
                fseek((FILE *)G.zipfd,(LONGINT)bufstart,SEEK_SET);
                G.cur_zipfile_bufstart = ftell((FILE *)G.zipfd);
#else /* !USE_STRM_INPUT */
                G.cur_zipfile_bufstart =
                  lseek(G.zipfd,(LONGINT)bufstart,SEEK_SET);
#endif /* ?USE_STRM_INPUT */
                if ((G.incnt = read(G.zipfd,(char *)G.inbuf,INBUFSIZ)) <= 0)
                {
                    Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
                      filnum, "lseek", bufstart));
                    error_in_archive = PK_BADERR;
                    continue;   /* can still do next file */
                }
                G.inptr = G.inbuf + (int)inbuf_offset;
                G.incnt -= (int)inbuf_offset;
            } else {
                G.incnt += (int)(G.inptr-G.inbuf) - (int)inbuf_offset;
                G.inptr = G.inbuf + (int)inbuf_offset;
            }

            /* should be in proper position now, so check for sig */
            if (readbuf(__G__ G.sig, 4) == 0) {  /* bad offset */
                Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
                  filnum, "EOF", request));
                error_in_archive = PK_BADERR;
                continue;   /* but can still try next one */
            }
            if (strncmp(G.sig, local_hdr_sig, 4)) {
                Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
                  filnum, LoadFarStringSmall(LocalHdrSig), request));
                /*
                    GRRDUMP(G.sig, 4)
                    GRRDUMP(local_hdr_sig, 4)
                 */
                error_in_archive = PK_ERR;
                if ((filnum == 1 && G.extra_bytes != 0L) ||
                    (G.extra_bytes == 0L && old_extra_bytes != 0L)) {
                    Info(slide, 0x401, ((char *)slide,
                      LoadFarString(AttemptRecompensate)));
                    if (G.extra_bytes) {
                        old_extra_bytes = G.extra_bytes;
                        G.extra_bytes = 0L;
                    } else
                        G.extra_bytes = old_extra_bytes;  /* third attempt */
                    ZLSEEK(G.pInfo->offset)
                    if (readbuf(__G__ G.sig, 4) == 0) {  /* bad offset */
                        Info(slide, 0x401, ((char *)slide,
                          LoadFarString(OffsetMsg), filnum, "EOF", request));
                        error_in_archive = PK_BADERR;
                        continue;   /* but can still try next one */
                    }
                    if (strncmp(G.sig, local_hdr_sig, 4)) {
                        Info(slide, 0x401, ((char *)slide,
                          LoadFarString(OffsetMsg), filnum,
                          LoadFarStringSmall(LocalHdrSig), request));
                        error_in_archive = PK_BADERR;
                        continue;
                    }
                } else
                    continue;  /* this one hosed; try next */
            }
            if ((error = process_local_file_hdr(__G)) != PK_COOL) {
                Info(slide, 0x421, ((char *)slide, LoadFarString(BadLocalHdr),
                  filnum));
                error_in_archive = error;   /* only PK_EOF defined */
                continue;   /* can still try next one */
            }
            if ((error = do_string(__G__ G.lrec.filename_length, DS_FN)) !=
                 PK_COOL)
            {
                if (error > error_in_archive)
                    error_in_archive = error;
                if (error > PK_WARN) {
                    Info(slide, 0x401, ((char *)slide, LoadFarString(FilNamMsg),
                      FnFilter1(G.filename), "local"));
                    continue;   /* go on to next one */
                }
            }
            if (G.extra_field != (uch *)NULL) {
                free(G.extra_field);
                G.extra_field = (uch *)NULL;
            }
            if ((error =
                 do_string(__G__ G.lrec.extra_field_length, EXTRA_FIELD)) != 0)
            {
                if (error > error_in_archive)
                    error_in_archive = error;
                if (error > PK_WARN) {
                    Info(slide, 0x401, ((char *)slide,
                      LoadFarString(ExtFieldMsg),
                      FnFilter1(G.filename), "local"));
                    continue;   /* go on */
                }
            }

#if CRYPT
            if (G.pInfo->encrypted &&
                (error = decrypt(__G__ uO.pwdarg)) != PK_COOL) {
                if (error == PK_WARN) {
                    if (!((uO.tflag && uO.qflag) || (!uO.tflag && !QCOND2)))
                        Info(slide, 0x401, ((char *)slide,
                          LoadFarString(SkipIncorrectPasswd),
                          FnFilter1(G.filename)));
                    ++num_bad_pwd;
                } else {  /* (error > PK_WARN) */
                    if (error > error_in_archive)
                        error_in_archive = error;
                    Info(slide, 0x401, ((char *)slide,
                      LoadFarString(SkipCannotGetPasswd),
                      FnFilter1(G.filename)));
                }
                continue;   /* go on to next file */
            }
#endif /* CRYPT */

            /*
             * just about to extract file:  if extracting to disk, check if
             * already exists, and if so, take appropriate action according to
             * fflag/uflag/overwrite_all/etc. (we couldn't do this in upper
             * loop because we don't store the possibly renamed filename[] in
             * info[])
             */
#ifdef DLL
            if (!uO.tflag && !uO.cflag && !G.redirect_data)
#else
            if (!uO.tflag && !uO.cflag)
#endif
            {
                renamed = FALSE;   /* user hasn't renamed output file yet */

startover:
                query = FALSE;
                /* for files from DOS FAT, check for use of backslash instead
                 *  of slash as directory separator (bug in some zipper(s); so
                 *  far, not a problem in HPFS, NTFS or VFAT systems)
                 */
#ifndef SFX
                if (G.pInfo->hostnum == FS_FAT_ && !strchr(G.filename, '/')) {
                    char *p=G.filename-1;

                    while (*++p) {
                        if (*p == '\\') {
                            if (!G.reported_backslash) {
                                Info(slide, 0x21, ((char *)slide,
                                  LoadFarString(BackslashPathSep), G.zipfn));
                                G.reported_backslash = TRUE;
                                if (!error_in_archive)
                                    error_in_archive = PK_WARN;
                            }
                            *p = '/';
                        }
                    }
                }