Subversion Repositories Kolibri OS

/*

  Copyright (c) 1990-2009 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2009-Jan-02 or later

  (the contents of which are also included in unzip.h) for terms of use.

  If, for some reason, all these files are missing, the Info-ZIP license

  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

*/

/*---------------------------------------------------------------------------

  process.c

  This file contains the top-level routines for processing multiple zipfiles.

  Contains:  process_zipfiles()

             free_G_buffers()

             do_seekable()

             file_size()

             rec_find()

             find_ecrec64()

             find_ecrec()

             process_zip_cmmnt()

             process_cdir_file_hdr()

             get_cdir_ent()

             process_local_file_hdr()

             getZip64Data()

             ef_scan_for_izux()

             getRISCOSexfield()

  ---------------------------------------------------------------------------*/

#define UNZIP_INTERNAL

#include "unzip.h"

#ifdef WINDLL

#  ifdef POCKET_UNZIP

#    include "wince/intrface.h"

#  else

#    include "windll/windll.h"

#  endif

#endif

#if defined(DYNALLOC_CRCTAB) || defined(UNICODE_SUPPORT)

#  include "crc32.h"

#endif

static int    do_seekable        OF((__GPRO__ int lastchance));

#ifdef DO_SAFECHECK_2GB

# ifdef USE_STRM_INPUT

static zoff_t file_size          OF((FILE *file));

# else

static zoff_t file_size          OF((int fh));

# endif

#endif /* DO_SAFECHECK_2GB */

static int    rec_find           OF((__GPRO__ zoff_t, char *, int));

static int    find_ecrec64       OF((__GPRO__ zoff_t searchlen));

static int    find_ecrec         OF((__GPRO__ zoff_t searchlen));

static int    process_zip_cmmnt  OF((__GPRO));

static int    get_cdir_ent       OF((__GPRO));

#ifdef IZ_HAVE_UXUIDGID

static int    read_ux3_value     OF((ZCONST uch *dbuf, unsigned uidgid_sz,

                                     ulg *p_uidgid));

#endif /* IZ_HAVE_UXUIDGID */

static ZCONST char Far CannotAllocateBuffers[] =

  "error:  cannot allocate unzip buffers\n";

#ifdef SFX

   static ZCONST char Far CannotFindMyself[] =

     "unzipsfx:  cannot find myself! [%s]\n";

# ifdef CHEAP_SFX_AUTORUN

   static ZCONST char Far AutorunPrompt[] =

     "\nAuto-run command: %s\nExecute this command? [y/n] ";

   static ZCONST char Far NotAutoRunning[] =

     "Not executing auto-run command.";

# endif

#else /* !SFX */

   /* process_zipfiles() strings */

# if (defined(IZ_CHECK_TZ) && defined(USE_EF_UT_TIME))

     static ZCONST char Far WarnInvalidTZ[] =

       "Warning: TZ environment variable not found, cannot use UTC times!!\n";

# endif

# if !(defined(UNIX) || defined(AMIGA))

   static ZCONST char Far CannotFindWildcardMatch[] =

     "%s:  cannot find any matches for wildcard specification \"%s\".\n";

# endif /* !(UNIX || AMIGA) */

   static ZCONST char Far FilesProcessOK[] =

     "%d archive%s successfully processed.\n";

   static ZCONST char Far ArchiveWarning[] =

     "%d archive%s had warnings but no fatal errors.\n";

   static ZCONST char Far ArchiveFatalError[] =

     "%d archive%s had fatal errors.\n";

   static ZCONST char Far FileHadNoZipfileDir[] =

     "%d file%s had no zipfile directory.\n";

   static ZCONST char Far ZipfileWasDir[] = "1 \"zipfile\" was a directory.\n";

   static ZCONST char Far ManyZipfilesWereDir[] =

     "%d \"zipfiles\" were directories.\n";

   static ZCONST char Far NoZipfileFound[] = "No zipfiles found.\n";

   /* do_seekable() strings */

# ifdef UNIX

   static ZCONST char Far CannotFindZipfileDirMsg[] =

     "%s:  cannot find zipfile directory in one of %s or\n\

        %s%s.zip, and cannot find %s, period.\n";

   static ZCONST char Far CannotFindEitherZipfile[] =

     "%s:  cannot find or open %s, %s.zip or %s.\n";

# else /* !UNIX */

   static ZCONST char Far CannotFindZipfileDirMsg[] =

     "%s:  cannot find zipfile directory in %s,\n\

        %sand cannot find %s, period.\n";

# ifdef VMS

   static ZCONST char Far CannotFindEitherZipfile[] =

     "%s:  cannot find %s (%s).\n";

# else /* !VMS */

   static ZCONST char Far CannotFindEitherZipfile[] =

     "%s:  cannot find either %s or %s.\n";

# endif /* ?VMS */

# endif /* ?UNIX */

   extern ZCONST char Far Zipnfo[];       /* in unzip.c */

#ifndef WINDLL

   static ZCONST char Far Unzip[] = "unzip";

#else

   static ZCONST char Far Unzip[] = "UnZip DLL";

#endif

#ifdef DO_SAFECHECK_2GB

   static ZCONST char Far ZipfileTooBig[] =

     "Trying to read large file (> 2 GiB) without large file support\n";

#endif /* DO_SAFECHECK_2GB */

   static ZCONST char Far MaybeExe[] =

     "note:  %s may be a plain executable, not an archive\n";

   static ZCONST char Far CentDirNotInZipMsg[] = "\n\

   [%s]:\n\

     Zipfile is disk %lu of a multi-disk archive, and this is not the disk on\n\

     which the central zipfile directory begins (disk %lu).\n";

   static ZCONST char Far EndCentDirBogus[] =

     "\nwarning [%s]:  end-of-central-directory record claims this\n\

  is disk %lu but that the central directory starts on disk %lu; this is a\n\

  contradiction.  Attempting to process anyway.\n";

# ifdef NO_MULTIPART

   static ZCONST char Far NoMultiDiskArcSupport[] =

     "\nerror [%s]:  zipfile is part of multi-disk archive\n\

  (sorry, not yet supported).\n";

   static ZCONST char Far MaybePakBug[] = "warning [%s]:\

  zipfile claims to be 2nd disk of a 2-part archive;\n\

  attempting to process anyway.  If no further errors occur, this archive\n\

  was probably created by PAK v2.51 or earlier.  This bug was reported to\n\

  NoGate in March 1991 and was supposed to have been fixed by mid-1991; as\n\

  of mid-1992 it still hadn't been.  (If further errors do occur, archive\n\

  was probably created by PKZIP 2.04c or later; UnZip does not yet support\n\

  multi-part archives.)\n";

# else

   static ZCONST char Far MaybePakBug[] = "warning [%s]:\

  zipfile claims to be last disk of a multi-part archive;\n\

  attempting to process anyway, assuming all parts have been concatenated\n\

  together in order.  Expect \"errors\" and warnings...true multi-part support\

\n  doesn't exist yet (coming soon).\n";

# endif

   static ZCONST char Far ExtraBytesAtStart[] =

     "warning [%s]:  %s extra byte%s at beginning or within zipfile\n\

  (attempting to process anyway)\n";

#endif /* ?SFX */

#if ((!defined(WINDLL) && !defined(SFX)) || !defined(NO_ZIPINFO))

   static ZCONST char Far LogInitline[] = "Archive:  %s\n";

#endif

static ZCONST char Far MissingBytes[] =

  "error [%s]:  missing %s bytes in zipfile\n\

  (attempting to process anyway)\n";

static ZCONST char Far NullCentDirOffset[] =

  "error [%s]:  NULL central directory offset\n\

  (attempting to process anyway)\n";

static ZCONST char Far ZipfileEmpty[] = "warning [%s]:  zipfile is empty\n";

static ZCONST char Far CentDirStartNotFound[] =

  "error [%s]:  start of central directory not found;\n\

  zipfile corrupt.\n%s";

static ZCONST char Far Cent64EndSigSearchErr[] =

  "fatal error: read failure while seeking for End-of-centdir-64 signature.\n\

  This zipfile is corrupt.\n";

static ZCONST char Far Cent64EndSigSearchOff[] =

  "error: End-of-centdir-64 signature not where expected (prepended bytes?)\n\

  (attempting to process anyway)\n";

#ifndef SFX

   static ZCONST char Far CentDirTooLong[] =

     "error [%s]:  reported length of central directory is\n\

  %s bytes too long (Atari STZip zipfile?  J.H.Holm ZIPSPLIT 1.1\n\

  zipfile?).  Compensating...\n";

   static ZCONST char Far CentDirEndSigNotFound[] = "\

  End-of-central-directory signature not found.  Either this file is not\n\

  a zipfile, or it constitutes one disk of a multi-part archive.  In the\n\

  latter case the central directory and zipfile comment will be found on\n\

  the last disk(s) of this archive.\n";

#else /* SFX */

   static ZCONST char Far CentDirEndSigNotFound[] =

     "  End-of-central-directory signature not found.\n";

#endif /* ?SFX */

#ifdef TIMESTAMP

   static ZCONST char Far ZipTimeStampFailed[] =

     "warning:  cannot set time for %s\n";

   static ZCONST char Far ZipTimeStampSuccess[] =

     "Updated time stamp for %s.\n";

#endif

static ZCONST char Far ZipfileCommTrunc1[] =

  "\ncaution:  zipfile comment truncated\n";

#ifndef NO_ZIPINFO

   static ZCONST char Far NoZipfileComment[] =

     "There is no zipfile comment.\n";

   static ZCONST char Far ZipfileCommentDesc[] =

     "The zipfile comment is %u bytes long and contains the following text:\n";

   static ZCONST char Far ZipfileCommBegin[] =

     "======================== zipfile comment begins\

 ==========================\n";

   static ZCONST char Far ZipfileCommEnd[] =

     "========================= zipfile comment ends\

 ===========================\n";

   static ZCONST char Far ZipfileCommTrunc2[] =

     "\n  The zipfile comment is truncated.\n";

#endif /* !NO_ZIPINFO */

#ifdef UNICODE_SUPPORT

   static ZCONST char Far UnicodeVersionError[] =

     "\nwarning:  Unicode Path version > 1\n";

   static ZCONST char Far UnicodeMismatchError[] =

     "\nwarning:  Unicode Path checksum invalid\n";

#endif

/*******************************/

/* Function process_zipfiles() */

/*******************************/

int process_zipfiles(__G)    /* return PK-type error code */

    __GDEF

{

#ifndef SFX

    char *lastzipfn = (char *)NULL;

    int NumWinFiles, NumLoseFiles, NumWarnFiles;

    int NumMissDirs, NumMissFiles;

#endif

    int error=0, error_in_archive=0;

/*---------------------------------------------------------------------------

    Start by allocating buffers and (re)constructing the various PK signature

    strings.

  ---------------------------------------------------------------------------*/

    G.inbuf = (uch *)malloc(INBUFSIZ + 4);    /* 4 extra for hold[] (below) */

    G.outbuf = (uch *)malloc(OUTBUFSIZ + 1);  /* 1 extra for string term. */

    if ((G.inbuf == (uch *)NULL) || (G.outbuf == (uch *)NULL)) {

        Info(slide, 0x401, ((char *)slide,

          LoadFarString(CannotAllocateBuffers)));

        return(PK_MEM);

    }

    G.hold = G.inbuf + INBUFSIZ;     /* to check for boundary-spanning sigs */

#ifndef VMS     /* VMS uses its own buffer scheme for textmode flush(). */

#ifdef SMALL_MEM

    G.outbuf2 = G.outbuf+RAWBUFSIZ;  /* never changes */

#endif

#endif /* !VMS */

#if 0 /* CRC_32_TAB has been NULLified by CONSTRUCTGLOBALS !!!! */

    /* allocate the CRC table later when we know we can read zipfile data */

    CRC_32_TAB = NULL;

#endif /* 0 */

    /* finish up initialization of magic signature strings */

    local_hdr_sig[0]  /* = extd_local_sig[0] */ =       /* ASCII 'P', */

      central_hdr_sig[0] = end_central_sig[0] =         /* not EBCDIC */

      end_centloc64_sig[0] = end_central64_sig[0] = 0x50;

    local_hdr_sig[1]  /* = extd_local_sig[1] */ =       /* ASCII 'K', */

      central_hdr_sig[1] = end_central_sig[1] =         /* not EBCDIC */

      end_centloc64_sig[1] = end_central64_sig[1] = 0x4B;

/*---------------------------------------------------------------------------

    Make sure timezone info is set correctly; localtime() returns GMT on some

    OSes (e.g., Solaris 2.x) if this isn't done first.  The ifdefs around

    tzset() were initially copied from dos_to_unix_time() in fileio.c.  They

    may still be too strict; any listed OS that supplies tzset(), regardless

    of whether the function does anything, should be removed from the ifdefs.

  ---------------------------------------------------------------------------*/

#if (defined(WIN32) && defined(USE_EF_UT_TIME))

    /* For the Win32 environment, we may have to "prepare" the environment

       prior to the tzset() call, to work around tzset() implementation bugs.

     */

    iz_w32_prepareTZenv();

#endif

#if (defined(IZ_CHECK_TZ) && defined(USE_EF_UT_TIME))

#  ifndef VALID_TIMEZONE

#     define VALID_TIMEZONE(tmp) \

             (((tmp = getenv("TZ")) != NULL) && (*tmp != '\0'))

#  endif

    {

        char *p;

        G.tz_is_valid = VALID_TIMEZONE(p);

#  ifndef SFX

        if (!G.tz_is_valid) {

            Info(slide, 0x401, ((char *)slide, LoadFarString(WarnInvalidTZ)));

            error_in_archive = error = PK_WARN;

        }

#  endif /* !SFX */

    }

#endif /* IZ_CHECK_TZ && USE_EF_UT_TIME */

/* For systems that do not have tzset() but supply this function using another

   name (_tzset() or something similar), an appropiate "#define tzset ..."

   should be added to the system specifc configuration section.  */

#if (!defined(T20_VMS) && !defined(MACOS) && !defined(RISCOS) && !defined(QDOS))

#if (!defined(BSD) && !defined(MTS) && !defined(CMS_MVS) && !defined(TANDEM))

    tzset();

#endif

#endif

/* Initialize UnZip's built-in pseudo hard-coded "ISO <--> OEM" translation,

   depending on the detected codepage setup.  */

#ifdef NEED_ISO_OEM_INIT

    prepare_ISO_OEM_translat(__G);

#endif

/*---------------------------------------------------------------------------

    Initialize the internal flag holding the mode of processing "overwrite

    existing file" cases.  We do not use the calling interface flags directly

    because the overwrite mode may be changed by user interaction while

    processing archive files.  Such a change should not affect the option

    settings as passed through the DLL calling interface.

    In case of conflicting options, the 'safer' flag uO.overwrite_none takes

    precedence.

  ---------------------------------------------------------------------------*/

    G.overwrite_mode = (uO.overwrite_none ? OVERWRT_NEVER :

                        (uO.overwrite_all ? OVERWRT_ALWAYS : OVERWRT_QUERY));

/*---------------------------------------------------------------------------

    Match (possible) wildcard zipfile specification with existing files and

    attempt to process each.  If no hits, try again after appending ".zip"

    suffix.  If still no luck, give up.

  ---------------------------------------------------------------------------*/

#ifdef SFX

    if ((error = do_seekable(__G__ 0)) == PK_NOZIP) {

#ifdef EXE_EXTENSION

        int len=strlen(G.argv0);

        /* append .exe if appropriate; also .sfx? */

        if ( (G.zipfn = (char *)malloc(len+sizeof(EXE_EXTENSION))) !=

             (char *)NULL ) {

            strcpy(G.zipfn, G.argv0);

            strcpy(G.zipfn+len, EXE_EXTENSION);

            error = do_seekable(__G__ 0);

            free(G.zipfn);

            G.zipfn = G.argv0;  /* for "cannot find myself" message only */

        }

#endif /* EXE_EXTENSION */

#ifdef WIN32

        G.zipfn = G.argv0;  /* for "cannot find myself" message only */

#endif

    }

    if (error) {

        if (error == IZ_DIR)

            error_in_archive = PK_NOZIP;

        else

            error_in_archive = error;

        if (error == PK_NOZIP)

            Info(slide, 1, ((char *)slide, LoadFarString(CannotFindMyself),

              G.zipfn));

    }

#ifdef CHEAP_SFX_AUTORUN

    if (G.autorun_command[0] && !uO.qflag) { /* NO autorun without prompt! */

        Info(slide, 0x81, ((char *)slide, LoadFarString(AutorunPrompt),

                      FnFilter1(G.autorun_command)));

        if (fgets(G.answerbuf, 9, stdin) != (char *)NULL

            && toupper(*G.answerbuf) == 'Y')

            system(G.autorun_command);

        else

            Info(slide, 1, ((char *)slide, LoadFarString(NotAutoRunning)));

    }

#endif /* CHEAP_SFX_AUTORUN */

#else /* !SFX */

    NumWinFiles = NumLoseFiles = NumWarnFiles = 0;

    NumMissDirs = NumMissFiles = 0;

    while ((G.zipfn = do_wild(__G__ G.wildzipfn)) != (char *)NULL) {

        Trace((stderr, "do_wild( %s ) returns %s\n", G.wildzipfn, G.zipfn));

        lastzipfn = G.zipfn;

        /* print a blank line between the output of different zipfiles */

        if (!uO.qflag  &&  error != PK_NOZIP  &&  error != IZ_DIR

#ifdef TIMESTAMP

            && (!uO.T_flag || uO.zipinfo_mode)

#endif

            && (NumWinFiles+NumLoseFiles+NumWarnFiles+NumMissFiles) > 0)

            (*G.message)((zvoid *)&G, (uch *)"\n", 1L, 0);

        if ((error = do_seekable(__G__ 0)) == PK_WARN)

            ++NumWarnFiles;

        else if (error == IZ_DIR)

            ++NumMissDirs;

        else if (error == PK_NOZIP)

            ++NumMissFiles;

        else if (error != PK_OK)

            ++NumLoseFiles;

        else

            ++NumWinFiles;

        Trace((stderr, "do_seekable(0) returns %d\n", error));

        if (error != IZ_DIR && error > error_in_archive)

            error_in_archive = error;

#ifdef WINDLL

        if (error == IZ_CTRLC) {

            free_G_buffers(__G);

            return error;

        }

#endif

    } /* end while-loop (wildcard zipfiles) */

    if ((NumWinFiles + NumWarnFiles + NumLoseFiles) == 0  &&

        (NumMissDirs + NumMissFiles) == 1  &&  lastzipfn != (char *)NULL)

    {

#if (!defined(UNIX) && !defined(AMIGA)) /* filenames with wildcard characters */

        if (iswild(G.wildzipfn)) {

            if (iswild(lastzipfn)) {

                NumMissDirs = NumMissFiles = 0;

                error_in_archive = PK_COOL;

                if (uO.qflag < 3)

                    Info(slide, 0x401, ((char *)slide,

                      LoadFarString(CannotFindWildcardMatch),

                      LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                      G.wildzipfn));

            }

        } else

#endif

        {

#ifndef VMS

            /* 2004-11-24 SMS.

             * VMS has already tried a default file type of ".zip" in

             * do_wild(), so adding ZSUFX here only causes confusion by

             * corrupting some valid (though nonexistent) file names.

             * Complaining below about "fred;4.zip" is unlikely to be

             * helpful to the victim.

             */

            /* 2005-08-14 Chr. Spieler

             * Although we already "know" the failure result, we call

             * do_seekable() again with the same zipfile name (and the

             * lastchance flag set), just to trigger the error report...

             */

#if defined(UNIX) || defined(QDOS)

            char *p =

#endif

              strcpy(lastzipfn + strlen(lastzipfn), ZSUFX);

#endif /* !VMS */

            G.zipfn = lastzipfn;

            NumMissDirs = NumMissFiles = 0;

            error_in_archive = PK_COOL;

#if defined(UNIX) || defined(QDOS)

   /* only Unix has case-sensitive filesystems */

   /* Well FlexOS (sometimes) also has them,  but support is per media */

   /* and a pig to code for,  so treat as case insensitive for now */

   /* we do this under QDOS to check for .zip as well as _zip */

            if ((error = do_seekable(__G__ 0)) == PK_NOZIP || error == IZ_DIR) {

                if (error == IZ_DIR)

                    ++NumMissDirs;

                strcpy(p, ALT_ZSUFX);

                error = do_seekable(__G__ 1);

            }

#else

            error = do_seekable(__G__ 1);

#endif

            Trace((stderr, "do_seekable(1) returns %d\n", error));

            switch (error) {

              case PK_WARN:

                ++NumWarnFiles;

                break;

              case IZ_DIR:

                ++NumMissDirs;

                error = PK_NOZIP;

                break;

              case PK_NOZIP:

                /* increment again => bug:

                   "1 file had no zipfile directory." */

                /* ++NumMissFiles */ ;

                break;

              default:

                if (error)

                    ++NumLoseFiles;

                else

                    ++NumWinFiles;

                break;

            }

            if (error > error_in_archive)

                error_in_archive = error;

#ifdef WINDLL

            if (error == IZ_CTRLC) {

                free_G_buffers(__G);

                return error;

            }

#endif

        }

    }

#endif /* ?SFX */

/*---------------------------------------------------------------------------

    Print summary of all zipfiles, assuming zipfile spec was a wildcard (no

    need for a summary if just one zipfile).

  ---------------------------------------------------------------------------*/

#ifndef SFX

    if (iswild(G.wildzipfn) && uO.qflag < 3

#ifdef TIMESTAMP

        && !(uO.T_flag && !uO.zipinfo_mode && uO.qflag > 1)

#endif

                                                    )

    {

        if ((NumMissFiles + NumLoseFiles + NumWarnFiles > 0 || NumWinFiles != 1)

#ifdef TIMESTAMP

            && !(uO.T_flag && !uO.zipinfo_mode && uO.qflag)

#endif

            && !(uO.tflag && uO.qflag > 1))

            (*G.message)((zvoid *)&G, (uch *)"\n", 1L, 0x401);

        if ((NumWinFiles > 1) ||

            (NumWinFiles == 1 &&

             NumMissDirs + NumMissFiles + NumLoseFiles + NumWarnFiles > 0))

            Info(slide, 0x401, ((char *)slide, LoadFarString(FilesProcessOK),

              NumWinFiles, (NumWinFiles == 1)? " was" : "s were"));

        if (NumWarnFiles > 0)

            Info(slide, 0x401, ((char *)slide, LoadFarString(ArchiveWarning),

              NumWarnFiles, (NumWarnFiles == 1)? "" : "s"));

        if (NumLoseFiles > 0)

            Info(slide, 0x401, ((char *)slide, LoadFarString(ArchiveFatalError),

              NumLoseFiles, (NumLoseFiles == 1)? "" : "s"));

        if (NumMissFiles > 0)

            Info(slide, 0x401, ((char *)slide,

              LoadFarString(FileHadNoZipfileDir), NumMissFiles,

              (NumMissFiles == 1)? "" : "s"));

        if (NumMissDirs == 1)

            Info(slide, 0x401, ((char *)slide, LoadFarString(ZipfileWasDir)));

        else if (NumMissDirs > 0)

            Info(slide, 0x401, ((char *)slide,

              LoadFarString(ManyZipfilesWereDir), NumMissDirs));

        if (NumWinFiles + NumLoseFiles + NumWarnFiles == 0)

            Info(slide, 0x401, ((char *)slide, LoadFarString(NoZipfileFound)));

    }

#endif /* !SFX */

    /* free allocated memory */

    free_G_buffers(__G);

    return error_in_archive;

} /* end function process_zipfiles() */

/*****************************/

/* Function free_G_buffers() */

/*****************************/

void free_G_buffers(__G)     /* releases all memory allocated in global vars */

    __GDEF

{

#ifndef SFX

    unsigned i;

#endif

#ifdef SYSTEM_SPECIFIC_DTOR

    SYSTEM_SPECIFIC_DTOR(__G);

#endif

    inflate_free(__G);

    checkdir(__G__ (char *)NULL, END);

#ifdef DYNALLOC_CRCTAB

    if (CRC_32_TAB) {

        free_crc_table();

        CRC_32_TAB = NULL;

    }

#endif

   if (G.key != (char *)NULL) {

        free(G.key);

        G.key = (char *)NULL;

   }

   if (G.extra_field != (uch *)NULL) {

        free(G.extra_field);

        G.extra_field = (uch *)NULL;

   }

#if (!defined(VMS) && !defined(SMALL_MEM))

    /* VMS uses its own buffer scheme for textmode flush() */

    if (G.outbuf2) {

        free(G.outbuf2);   /* malloc'd ONLY if unshrink and -a */

        G.outbuf2 = (uch *)NULL;

    }

#endif

    if (G.outbuf)

        free(G.outbuf);

    if (G.inbuf)

        free(G.inbuf);

    G.inbuf = G.outbuf = (uch *)NULL;

#ifdef UNICODE_SUPPORT

    if (G.filename_full) {

        free(G.filename_full);

        G.filename_full = (char *)NULL;

        G.fnfull_bufsize = 0;

    }

#endif /* UNICODE_SUPPORT */

#ifndef SFX

    for (i = 0; i < DIR_BLKSIZ; i++) {

        if (G.info[i].cfilname != (char Far *)NULL) {

            zffree(G.info[i].cfilname);

            G.info[i].cfilname = (char Far *)NULL;

        }

    }

#endif

#ifdef MALLOC_WORK

    if (G.area.Slide) {

        free(G.area.Slide);

        G.area.Slide = (uch *)NULL;

    }

#endif

} /* end function free_G_buffers() */

/**************************/

/* Function do_seekable() */

/**************************/

static int do_seekable(__G__ lastchance)        /* return PK-type error code */

    __GDEF

    int lastchance;

{

#ifndef SFX

    /* static int no_ecrec = FALSE;  SKM: moved to globals.h */

    int maybe_exe=FALSE;

    int too_weird_to_continue=FALSE;

#ifdef TIMESTAMP

    time_t uxstamp;

    ulg nmember = 0L;

#endif

#endif

    int error=0, error_in_archive;

/*---------------------------------------------------------------------------

    Open the zipfile for reading in BINARY mode to prevent CR/LF translation,

    which would corrupt the bit streams.

  ---------------------------------------------------------------------------*/

    if (SSTAT(G.zipfn, &G.statbuf) ||

#ifdef THEOS

        (error = S_ISLIB(G.statbuf.st_mode)) != 0 ||

#endif

        (error = S_ISDIR(G.statbuf.st_mode)) != 0)

    {

#ifndef SFX

        if (lastchance && (uO.qflag < 3)) {

#if defined(UNIX) || defined(QDOS)

            if (G.no_ecrec)

                Info(slide, 1, ((char *)slide,

                  LoadFarString(CannotFindZipfileDirMsg),

                  LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                  G.wildzipfn, uO.zipinfo_mode? "  " : "", G.wildzipfn,

                  G.zipfn));

            else

                Info(slide, 1, ((char *)slide,

                  LoadFarString(CannotFindEitherZipfile),

                  LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                  G.wildzipfn, G.wildzipfn, G.zipfn));

#else /* !(UNIX || QDOS) */

            if (G.no_ecrec)

                Info(slide, 0x401, ((char *)slide,

                  LoadFarString(CannotFindZipfileDirMsg),

                  LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                  G.wildzipfn, uO.zipinfo_mode? "  " : "", G.zipfn));

            else

#ifdef VMS

                Info(slide, 0x401, ((char *)slide,

                  LoadFarString(CannotFindEitherZipfile),

                  LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                  G.wildzipfn,

                  (*G.zipfn ? G.zipfn : vms_msg_text())));

#else /* !VMS */

                Info(slide, 0x401, ((char *)slide,

                  LoadFarString(CannotFindEitherZipfile),

                  LoadFarStringSmall((uO.zipinfo_mode ? Zipnfo : Unzip)),

                  G.wildzipfn, G.zipfn));

#endif /* ?VMS */

#endif /* ?(UNIX || QDOS) */

        }

#endif /* !SFX */

        return error? IZ_DIR : PK_NOZIP;

    }

    G.ziplen = G.statbuf.st_size;

#ifndef SFX

#if defined(UNIX) || defined(DOS_OS2_W32) || defined(THEOS)

    if (G.statbuf.st_mode & S_IEXEC)   /* no extension on Unix exes:  might */

        maybe_exe = TRUE;               /*  find unzip, not unzip.zip; etc. */

#endif

#endif /* !SFX */

#ifdef VMS

    if (check_format(__G))              /* check for variable-length format */

        return PK_ERR;

#endif

    if (open_input_file(__G))   /* this should never happen, given */

        return PK_NOZIP;        /*  the stat() test above, but... */

#ifdef DO_SAFECHECK_2GB

    /* Need more care: Do not trust the size returned by stat() but

       determine it by reading beyond the end of the file. */

    G.ziplen = file_size(G.zipfd);

    if (G.ziplen == EOF) {

        Info(slide, 0x401, ((char *)slide, LoadFarString(ZipfileTooBig)));

        /*

        printf(

" We need a better error message for: 64-bit file, 32-bit program.\n");

        */

        CLOSE_INFILE();

        return IZ_ERRBF;

    }

#endif /* DO_SAFECHECK_2GB */

/*---------------------------------------------------------------------------

    Find and process the end-of-central-directory header.  UnZip need only

    check last 65557 bytes of zipfile:  comment may be up to 65535, end-of-

    central-directory record is 18 bytes, and signature itself is 4 bytes;

    add some to allow for appended garbage.  Since ZipInfo is often used as

    a debugging tool, search the whole zipfile if zipinfo_mode is true.

  ---------------------------------------------------------------------------*/

    G.cur_zipfile_bufstart = 0;

    G.inptr = G.inbuf;

#if ((!defined(WINDLL) && !defined(SFX)) || !defined(NO_ZIPINFO))

# if (!defined(WINDLL) && !defined(SFX))

    if ( (!uO.zipinfo_mode && !uO.qflag

#  ifdef TIMESTAMP

          && !uO.T_flag

#  endif

         )

#  ifndef NO_ZIPINFO

         || (uO.zipinfo_mode && uO.hflag)

#  endif

       )

# else /* not (!WINDLL && !SFX) ==> !NO_ZIPINFO !! */

    if (uO.zipinfo_mode && uO.hflag)

# endif /* if..else..: (!WINDLL && !SFX) */

# ifdef WIN32   /* Win32 console may require codepage conversion for G.zipfn */

        Info(slide, 0, ((char *)slide, LoadFarString(LogInitline),

          FnFilter1(G.zipfn)));

# else

        Info(slide, 0, ((char *)slide, LoadFarString(LogInitline), G.zipfn));

# endif

#endif /* (!WINDLL && !SFX) || !NO_ZIPINFO */

    if ( (error_in_archive = find_ecrec(__G__

#ifndef NO_ZIPINFO

                                        uO.zipinfo_mode ? G.ziplen :

#endif

                                        MIN(G.ziplen, 66000L)))

         > PK_WARN )

    {

        CLOSE_INFILE();

#ifdef SFX

        ++lastchance;   /* avoid picky compiler warnings */

        return error_in_archive;

#else

        if (maybe_exe)

            Info(slide, 0x401, ((char *)slide, LoadFarString(MaybeExe),

            G.zipfn));

        if (lastchance)

            return error_in_archive;

        else {

            G.no_ecrec = TRUE;    /* assume we found wrong file:  e.g., */

            return PK_NOZIP;       /*  unzip instead of unzip.zip */

        }

#endif /* ?SFX */

    }

    if ((uO.zflag > 0) && !uO.zipinfo_mode) { /* unzip: zflag = comment ONLY */

        CLOSE_INFILE();

        return error_in_archive;

    }

/*---------------------------------------------------------------------------

    Test the end-of-central-directory info for incompatibilities (multi-disk

    archives) or inconsistencies (missing or extra bytes in zipfile).

  ---------------------------------------------------------------------------*/

#ifdef NO_MULTIPART

    error = !uO.zipinfo_mode && (G.ecrec.number_this_disk == 1) &&

            (G.ecrec.num_disk_start_cdir == 1);

#else

    error = !uO.zipinfo_mode && (G.ecrec.number_this_disk != 0);

#endif

#ifndef SFX

    if (uO.zipinfo_mode &&

        G.ecrec.number_this_disk != G.ecrec.num_disk_start_cdir)

    {

        if (G.ecrec.number_this_disk > G.ecrec.num_disk_start_cdir) {

            Info(slide, 0x401, ((char *)slide,

              LoadFarString(CentDirNotInZipMsg), G.zipfn,

              (ulg)G.ecrec.number_this_disk,

              (ulg)G.ecrec.num_disk_start_cdir));

            error_in_archive = PK_FIND;

            too_weird_to_continue = TRUE;

        } else {

            Info(slide, 0x401, ((char *)slide,

              LoadFarString(EndCentDirBogus), G.zipfn,

              (ulg)G.ecrec.number_this_disk,

              (ulg)G.ecrec.num_disk_start_cdir));

            error_in_archive = PK_WARN;

        }

#ifdef NO_MULTIPART   /* concatenation of multiple parts works in some cases */

    } else if (!uO.zipinfo_mode && !error && G.ecrec.number_this_disk != 0) {

        Info(slide, 0x401, ((char *)slide, LoadFarString(NoMultiDiskArcSupport),

          G.zipfn));

        error_in_archive = PK_FIND;

        too_weird_to_continue = TRUE;

#endif

    }

    if (!too_weird_to_continue) {  /* (relatively) normal zipfile:  go for it */

        if (error) {

            Info(slide, 0x401, ((char *)slide, LoadFarString(MaybePakBug),

              G.zipfn));

            error_in_archive = PK_WARN;

        }

#endif /* !SFX */

        if ((G.extra_bytes = G.real_ecrec_offset-G.expect_ecrec_offset) <

            (zoff_t)0)

        {

            Info(slide, 0x401, ((char *)slide, LoadFarString(MissingBytes),

              G.zipfn, FmZofft((-G.extra_bytes), NULL, NULL)));

            error_in_archive = PK_ERR;

        } else if (G.extra_bytes > 0) {

            if ((G.ecrec.offset_start_central_directory == 0) &&

                (G.ecrec.size_central_directory != 0))   /* zip 1.5 -go bug */

            {

                Info(slide, 0x401, ((char *)slide,

                  LoadFarString(NullCentDirOffset), G.zipfn));

                G.ecrec.offset_start_central_directory = G.extra_bytes;

                G.extra_bytes = 0;

                error_in_archive = PK_ERR;

            }

#ifndef SFX

            else {

                Info(slide, 0x401, ((char *)slide,

                  LoadFarString(ExtraBytesAtStart), G.zipfn,

                  FmZofft(G.extra_bytes, NULL, NULL),

                  (G.extra_bytes == 1)? "":"s"));

                error_in_archive = PK_WARN;

            }

#endif /* !SFX */

        }

    /*-----------------------------------------------------------------------

        Check for empty zipfile and exit now if so.

      -----------------------------------------------------------------------*/

        if (G.expect_ecrec_offset==0L && G.ecrec.size_central_directory==0) {

            if (uO.zipinfo_mode)

                Info(slide, 0, ((char *)slide, "%sEmpty zipfile.\n",

                  uO.lflag>9? "\n  " : ""));

            else

                Info(slide, 0x401, ((char *)slide, LoadFarString(ZipfileEmpty),

                                    G.zipfn));

            CLOSE_INFILE();

            return (error_in_archive > PK_WARN)? error_in_archive : PK_WARN;

        }

    /*-----------------------------------------------------------------------

        Compensate for missing or extra bytes, and seek to where the start

        of central directory should be.  If header not found, uncompensate

        and try again (necessary for at least some Atari archives created

        with STZip, as well as archives created by J.H. Holm's ZIPSPLIT 1.1).

      -----------------------------------------------------------------------*/

        error = seek_zipf(__G__ G.ecrec.offset_start_central_directory);

        if (error == PK_BADERR) {

            CLOSE_INFILE();

            return PK_BADERR;

        }

#ifdef OLD_SEEK_TEST

        if (error != PK_OK || readbuf(__G__ G.sig, 4) == 0) {

            CLOSE_INFILE();

            return PK_ERR;  /* file may be locked, or possibly disk error(?) */

        }

        if (memcmp(G.sig, central_hdr_sig, 4))

#else

        if ((error != PK_OK) || (readbuf(__G__ G.sig, 4) == 0) ||

            memcmp(G.sig, central_hdr_sig, 4))

#endif

        {

#ifndef SFX

            zoff_t tmp = G.extra_bytes;

#endif

            G.extra_bytes = 0;

            error = seek_zipf(__G__ G.ecrec.offset_start_central_directory);

            if ((error != PK_OK) || (readbuf(__G__ G.sig, 4) == 0) ||

                memcmp(G.sig, central_hdr_sig, 4))

            {

                if (error != PK_BADERR)

                  Info(slide, 0x401, ((char *)slide,

                    LoadFarString(CentDirStartNotFound), G.zipfn,

                    LoadFarStringSmall(ReportMsg)));

                CLOSE_INFILE();

                return (error != PK_OK ? error : PK_BADERR);

            }

#ifndef SFX

            Info(slide, 0x401, ((char *)slide, LoadFarString(CentDirTooLong),

              G.zipfn, FmZofft((-tmp), NULL, NULL)));

#endif

            error_in_archive = PK_ERR;

        }

    /*-----------------------------------------------------------------------

        Seek to the start of the central directory one last time, since we

        have just read the first entry's signature bytes; then list, extract

        or test member files as instructed, and close the zipfile.

      -----------------------------------------------------------------------*/

        error = seek_zipf(__G__ G.ecrec.offset_start_central_directory);

        if (error != PK_OK) {

            CLOSE_INFILE();

            return error;

        }

        Trace((stderr, "about to extract/list files (error = %d)\n",

          error_in_archive));

#ifdef DLL

        /* G.fValidate is used only to look at an archive to see if

           it appears to be a valid archive.  There is no interest

           in what the archive contains, nor in validating that the

           entries in the archive are in good condition.  This is

           currently used only in the Windows DLLs for purposes of

           checking archives within an archive to determine whether

           or not to display the inner archives.

         */

        if (!G.fValidate)

#endif

        {

#ifndef NO_ZIPINFO

            if (uO.zipinfo_mode)

                error = zipinfo(__G);                 /* ZIPINFO 'EM */

            else

#endif

#ifndef SFX

#ifdef TIMESTAMP

            if (uO.T_flag)

                error = get_time_stamp(__G__ &uxstamp, &nmember);

            else

#endif

            if (uO.vflag && !uO.tflag && !uO.cflag)

                error = list_files(__G);              /* LIST 'EM */

            else

#endif /* !SFX */

                error = extract_or_test_files(__G);   /* EXTRACT OR TEST 'EM */

            Trace((stderr, "done with extract/list files (error = %d)\n",

                   error));

        }

        if (error > error_in_archive)   /* don't overwrite stronger error */

            error_in_archive = error;   /*  with (for example) a warning */

#ifndef SFX

    } /* end if (!too_weird_to_continue) */

#endif

    CLOSE_INFILE();

#ifdef TIMESTAMP

    if (uO.T_flag && !uO.zipinfo_mode && (nmember > 0L)) {

# ifdef WIN32

        if (stamp_file(__G__ G.zipfn, uxstamp)) {       /* TIME-STAMP 'EM */

# else

        if (stamp_file(G.zipfn, uxstamp)) {             /* TIME-STAMP 'EM */

# endif

            if (uO.qflag < 3)

                Info(slide, 0x201, ((char *)slide,

                  LoadFarString(ZipTimeStampFailed), G.zipfn));

            if (error_in_archive < PK_WARN)

                error_in_archive = PK_WARN;

        } else {

            if (!uO.qflag)

                Info(slide, 0, ((char *)slide,

                  LoadFarString(ZipTimeStampSuccess), G.zipfn));

        }

    }

#endif

    return error_in_archive;

} /* end function do_seekable() */

#ifdef DO_SAFECHECK_2GB

/************************/

/* Function file_size() */

/************************/

/* File size determination which does not mislead for large files in a

   small-file program.  Probably should be somewhere else.

   The file has to be opened previously

*/

#ifdef USE_STRM_INPUT

static zoff_t file_size(file)

    FILE *file;

{

    int sts;

    size_t siz;

#else /* !USE_STRM_INPUT */

static zoff_t file_size(fh)

    int fh;

{

    int siz;

#endif /* ?USE_STRM_INPUT */

    zoff_t ofs;

    char waste[4];

#ifdef USE_STRM_INPUT

    /* Seek to actual EOF. */

    sts = zfseeko(file, 0, SEEK_END);

    if (sts != 0) {

        /* fseeko() failed.  (Unlikely.) */

        ofs = EOF;

    } else {

        /* Get apparent offset at EOF. */

        ofs = zftello(file);

        if (ofs < 0) {

            /* Offset negative (overflow).  File too big. */

            ofs = EOF;

        } else {

            /* Seek to apparent EOF offset.

               Won't be at actual EOF if offset was truncated.

            */

            sts = zfseeko(file, ofs, SEEK_SET);

            if (sts != 0) {

                /* fseeko() failed.  (Unlikely.) */

                ofs = EOF;

            } else {

                /* Read a byte at apparent EOF.  Should set EOF flag. */

                siz = fread(waste, 1, 1, file);

                if (feof(file) == 0) {

                    /* Not at EOF, but should be.  File too big. */

                    ofs = EOF;

                }

            }

        }

    }

#else /* !USE_STRM_INPUT */

    /* Seek to actual EOF. */

    ofs = zlseek(fh, 0, SEEK_END);

    if (ofs == (zoff_t) -1) {

        /* zlseek() failed.  (Unlikely.) */

        ofs = EOF;

    } else if (ofs < 0) {

        /* Offset negative (overflow).  File too big. */

        ofs = EOF;

    } else {

        /* Seek to apparent EOF offset.

           Won't be at actual EOF if offset was truncated.

        */

        ofs = zlseek(fh, ofs, SEEK_SET);

        if (ofs == (zoff_t) -1) {

            /* zlseek() failed.  (Unlikely.) */

            ofs = EOF;

        } else {

            /* Read a byte at apparent EOF.  Should set EOF flag. */

            siz = read(fh, waste, 1);

            if (siz != 0) {

                /* Not at EOF, but should be.  File too big. */

                ofs = EOF;

            }

        }

    }

#endif /* ?USE_STRM_INPUT */

    return ofs;

} /* end function file_size() */

#endif /* DO_SAFECHECK_2GB */

/***********************/

/* Function rec_find() */

/***********************/

static int rec_find(__G__ searchlen, signature, rec_size)

    /* return 0 when rec found, 1 when not found, 2 in case of read error */

    __GDEF

    zoff_t searchlen;

    char* signature;

    int rec_size;

{

    int i, numblks, found=FALSE;

    zoff_t tail_len;

/*---------------------------------------------------------------------------

    Zipfile is longer than INBUFSIZ:  may need to loop.  Start with short

    block at end of zipfile (if not TOO short).