Subversion Repositories autosfx

#include "stdafx.h"

#pragma hdrstop

#include "ZipOp.h"

#include "dz_errs.h"

#undef _DZ_FILE_

#define _DZ_FILE_ DZ_ZIPPRC_CPP

/* DLLzip.c * Copyright (C) 1990-1996 Mark Adler, Richard B. Wales, Jean-loup Gailly,

 * Kai Uwe Rommel, Onno van der Linden and Igor Mandrichenko.

 * This version modified by Chris Vleghert and Eric Engler for BCB/Delphi Zip.

 ** distributed under LGPL license

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

  See the accompanying file LICENSE, version 2007-Mar-4 or later

  (the contents of which are also included in zip.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

  parts Copyright (C) 1997 Mike White, Eric W. Engler

************************************************************************

 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).

    updates: http://www.delphizip.org

    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip

************************************************************************

*/

#include <process.h>

#include <signal.h>

#include <errno.h>

#include <stdlib.h>

#include <io.h>

// Local option flags

#define PURGE   0 // RCV Changed: was DELETE. (delete is also a function)

#define ADD     1

#define UPDATE  2

#define FRESHEN 3

#define MARK_PURGE      -1

#define MARK_KEEP       0

#define MARK_UPDATE     1

#define MARK_RENAMED    2

#define MARK_VERSION    3

#define MARK_NEW        4

#ifndef UNICODE

#define __access _access

#endif

// Process -o and -m options (if specified), free up malloc'ed stuff, and

//   exit with the code e. e :: Exit code.

void ZipFunc::finish(void)

{

    int r; // return value from trash()

    ulg t; // latest time in zip file

        ZipItem *z; // pointer into zfile list

    if (flatest && fzipfile.Compare(_T("-")))

    {

        diag(_T("changing time of zip file to time of latest file in it"));

        // find latest time in zip file

        if (fzfiles == NULL)

        {

            Notify(IWARNING,

                   _T("zip file is empty, can't make it as old as latest entry"));

        }

        else

        {

            t = 0;

                        for (z = fzfiles; z != NULL; z = z->nxt) // Ignore directories in time comparisons

            if (!z->IsFolder && t < z->tim)

                                t = z->tim;

            // set modified time of zip file to that time

            if (t != 0)

                stamp(fzipfile, t);

            else

                Notify(IWARNING,

                       _T("zip file has only directories, can't make it as old as latest entry"));

        }

    }

    // If dispose, delete all files in the zfiles list that are marked

    if (fdispose && !Abort_Flag)

    {

        // v1.6017

        diag(_T("deleting files that were added to zip file"));

        if ((r = trash()) != DZ_ERR_GOOD)

            DZError(r);

    }

}

void ZipFunc::ZipCleanup(void)

{

    delete [] fhwbuf;

    fhwbuf = NULL;

    if (ftempzip && (ftempzip != fzipfile))

    {

        // using temp file

        if (fZipOutfile)

        {

            delete fZipOutfile;

            fZipOutfile = NULL;

        }

        // remove bad file - if it exists

        EraseFile(ftempzip, false);

    }

    Close_Handle(&fhInz);

    if (fZipOutfile)

    {

        bool wasopen =  fZipOutfile->IsOpen() && fZipOutfile->IsFile;

        delete fZipOutfile;

        fZipOutfile = NULL;

        // remove damaged file

        if (wasopen)

        {

            if (Verbose)

                Notify(IVERBOSE, _T("deleting damaged %s"), fzipfile.c_str());

            EraseFile(fzipfile, false);

        }

    }

    ftempzip = "";

}

int DriveType(const DZStrW& pth)

{

    TCHAR root[3];

    root[0] = pth.IsEmpty() ? (char)0 : pth[0];

    root[1] = ':';

    root[2] = 0;

    if (root[0] == BSLASH)

        root[1] = 0;

    return GetDriveType(root);

}

const char hx[16] = "0123456789ABCDEF";

char hxbuf[16];

char* toHex(unsigned val)

{

    char* p = &hxbuf[15];

    *p = 0;

    while (val)

    {

        *--p = hx[val & 0x0f];

        val >>= 4;

    }

    return p;

}

int __fastcall ZipFunc::NameVer(ZipItem* z)

{

        int r;

        DZStrW name = z->IName;

        int i = name.ReverseFind(_T('.'));

    if (!VerDate)

    {

        FILETIME now;

        WORD d, t;

        GetSystemTimeAsFileTime(&now);

        if (FileTimeToDosDateTime(&now, &d, &t))

            VerDate = (d << 16) | t;

        else

            VerDate = z->tim;

    }

    DZStrW nx, nn(name);

    nx = _T("}");

    if (i >= 0)

    {

        nn = name.Left(i);

        nx += name.Mid(i);

    }

    i = -1;

    nn.AppendFormat(_T(".{%X"), VerDate);

    name = nn;

        name += nx;

        DZStrA hn = StrIntSep(name);

        const XItem* n;

        while ((n = IntList->FindName(name)) != NULL)

        {

                // exists

                if (++i == MAXINT)

                        return -2;  // give up

                name.Format(_T("%s-%X%s"), nn.c_str(), i, nx.c_str());

        }

        hn = StrIntSep(name);

        if (Verbose < 0)

                Notify(IVERBOSE, _T("%s versioned as %s"), z->iname, name.c_str());

        z->IName = name;

        z->HName = hn;

        // prepare header name

        if ((r = PrepareHeaderName(z, true)) != 0)

                return r;

    if (!n)

        n = IntList->AddNode(z);

    return n ? -1 : 0;

}

void ZipFunc::DupName(bool fatal, const XItem* o, const XItem* n, const DZStrW name)

{

    // duplicate found

        Notify(IWARNING, _T("internal name in zip file repeated: %s"), name.c_str());

    Notify(IWARNING, _T("  first full name: %s"), o->xname);

    Notify(IWARNING, _T(" second full name: %s"), n->xname);

    if (fatal)

                throw DZException(DZ_ERM_DUPNAME);

        Notify(IWARNING, _T(" rejecting: %s"), n->xname);

}

int __fastcall ZipFunc::PrepareHeaderName(ZipItem* z, bool NoComment)

{

        if (!NoComment)

    {

//        // free any old data - probably obsolete

//        z->cextra.Empty();

//        z->extra.Empty();

        if (z->ntfs)

        {

            delete z->ntfs;

            z->ntfs = NULL;

        }

        // get or change the comment

        CB->Msg2 = z->Comment;

        if (CB->UserCB(zacComment, z->IName) == CALLBACK_TRUE)

        {

            // User changed the comment

            z->Comment.Empty();

            z->com = CB->Arg1;

            if (z->com)

            {

                DZStrW tc(CB->Msg, z->com);

                z->Comment = tc;

            }

        }

    }

        // ****** set header name and encoding

        z->options.needutf8 = 0;

        z->options.nameextd = z->IName.BadDOS();

        z->options.cmntextd = z->com && z->Comment.BadDOS();

        z->options.namenew = 0;

        DZStrW iiname = StrIntSep(z->IName);

        bool wantOEM = true;

        int bad = 0;

        if (!z->options.nameextd && !z->options.cmntextd)

        {

                // mimic WinZip

                z->Enc = zeoOEM;

        }

        else

        {

        unsigned doenc = fEncodeAs;

        if (doenc == zeoAuto)

        {

                        doenc = zeoUPATH;

                        if (z->options.nameextd && z->options.cmntextd)

                                doenc = zeoUTF8; // recommended

        }

                z->Enc = doenc;

                if (doenc == zeoUPATH)

                {

                        z->HName = iiname.SafeNarrow(CP_OEM); // default oem name

                        z->options.dosflag = 2;                 // FAT

                        wantOEM = false;

                }

                else

                if (doenc == zeoUTF8)

                {

                        z->HName = StrToUTF8(iiname);

                        z->options.nameutf8 = 1;   // so we set the flag

                        z->options.dosflag = 2;  // assume header strings usable on MSDOS

                        wantOEM = false;

                }

                else

                if (doenc == zeoNone)

                {

                        z->HName = iiname.SafeNarrow(CP_ACP, bad);

                        z->options.nameutf8 = 0;   // so we set the flag

                        bool ntfs = z->HName.BadDOS();

                        if (!ntfs && z->options.cmntextd)

                        {

                                DZStrA tmp = z->Comment.SafeNarrow(CP_ACP);

                                ntfs = tmp.BadDOS();

                        }

                        z->options.dosflag = ntfs ? 0 : 1;  // assume header strings usable on NTFS

                        wantOEM = false;

                }

        }

        if (wantOEM)

        {

                z->HName = iiname.SafeNarrow(CP_OEM, bad); // default oem name

                z->options.dosflag = 2;                 // FAT

        }

        if (bad)

        {

                z->options.namenew = 1; // name was made safe

                unsigned cp = wantOEM ? CP_OEM : CP_ACP;

                DZStrW xname(cp, z->hname, z->HName.length());

                if (Verbose < 0)

                        Notify(IVERBOSE, _T("%s made safe as %hs"),     iiname.c_str(), xname.c_str());

        }

#ifdef ZDEBUG

        if (Verbose < 0)

        {

                Notify(ITRACE, _T("Prepare %s need %x dos %X"), z->iname, z->ver,

                           z->options.dosflag);

        }

#endif

    return 0;

}

// Add, update, freshen, or delete zip entries in a zip file. argc; /*

//   Number of tokens in command line. argv; /* Command line tokens.

int ZipFunc::ZipProcess(void)

{

    int a;                // attributes of zip file

    ZInt64 censtt;        // start of central directory

    FndItem *f;           // steps through "found" linked list

    FndItem *tempf;

    int k;                // next argument type, marked counter, comment size, entry count

    int marks;            // replaces k as marked counter

        int r;                // temporary variable

        int err;                          // temporary error variable

    ulg t;                // file time, length of central directory

        ZipItem *v;           // temporary variable

    ZipItem *z;           // steps through "zfiles" linked list

    const TCHAR *Actions[4] = {_T("PURGE"), _T("ADD"), _T("UPDATE"), _T("FRESHEN")};

    int DestType;         //  destination drive type

    unsigned long TotFiles = 0;

    __int64 TotSize = 0;

        unsigned long KeptCnt = 0;  // number of 'kept' files

        __int64 KeptSize = 0;       // size of 'kept' files

    __int64 VerSize = 0;        // size of 'kept' files

        __int64 fsz;                // file size;

    int No_File;                // 1.75 try if file does not exist

    // Process arguments

    diag(_T("processing lists"));

        if (Verbose)

        {

                Notify(IVERBOSE, _T("action = %s"), Actions[faction]);

        // zcount is no. of entries in linked-list

        // zfiles is name of the linked-list of filenames for the archive

        Notify(IVERBOSE, _T("zcount=%d (no. of files in ZIP already)"), fzcount);

    }

    if (!fzipbeg)

        fjunk_sfx = 0;   // nothing to junk

    if (!fzfiles)

        fadjust = 0;     // nothing to adjust

    if ((r = check_dupExt()) != DZ_ERR_GOOD)   // remove duplicates in ffound

        return DZError(r);

    // Check option combinations

    // ?????

    if (faction == PURGE && (fdispose || frecurse || fkey))

                return DZError(DZ_ERM_BAD_OPTIONS);

    // AllowGrow is the "allow append" indicator

    if (!fzcount && ((faction == ADD) || (faction == UPDATE)))

        fAllowGrow = 55; // create new file normally

    // if zcount is 0, then zipfile doesn't exist, or is empty

    if (fzcount == 0 && ((faction != ADD && faction != UPDATE)

                         || !fAllowGrow))

    {

        // RCV150199 added UPDATE

        Notify(IWARNING, _T("%s: not found or empty"), fzipfile.c_str());

        return 0;

    }

    if (fndlist)

    {

        delete fndlist;

        fndlist = NULL;

    }

    DestType = DriveType(fzipfile);

    if (Verbose < 0)

        Notify(IVERBOSE, _T("Destination type = %d"), DestType);

    // RP - check destination type - if CD set tempath to Windows Temp

    if (ftempath.IsEmpty() && (DestType != DRIVE_FIXED &&

                               DestType != DRIVE_RAMDISK))

    {

        GetTempPath(2047, ftempath.GetBuffer(2047));

        ftempath.ReleaseBuffer();

    }

    // If -b not specified, set temporary path to zipfile path

    int pp;

    if (ftempath.IsEmpty() && ((pp = fzipfile.ReverseFind(BSLASH)) >= 0

                               || (pp = fzipfile.ReverseFind(_T(':'))) >= 0))

    {

        if (fzipfile[pp] == _T(':'))

            pp++;

        ftempath = fzipfile.Left(pp);

    }

    // if first_listarg is 0, then we didn't got any fspecs on cmd line

    if (fdoall && (faction == UPDATE || faction == FRESHEN))

    {

        // if -update or -freshen with no args, do all, but, when present, apply

        //   filters

        for (z = fzfiles; z != NULL; z = z->nxt)

            z->mark = fpcount ? !ZMatch(fExcludes, z->IName) : 1;

    }

    // NOTE: "k" is being redefined below this point. Now, it going to

    // track the no. of marked files in the "zfiles" linked list.

    // For each marked entry in "zfiles" linked list, if not deleting, check

    //   if a corresponding "external" file exists. If updating or freshening,

    //   compare date of "external" file with entry in orig zipfile. Unmark if it

    //   external file doesn't exist or is too old, else mark it. Entries that

    //   are marked will cause that file to be rezipped.

    diag(_T("checking marked entries"));

    marks = 0; // Initialize marked count

    ZipItem **zlast;          // pointer to last link in "zfiles" list

    ZipItem **verlast = &VerFiles;   // pointer to last link

        ZipItem **fndlast = &fzfound;

        int vercount = 0;

                for (z = fzfiles; z != NULL; z = z->nxt)

                {

                        if (z->mark)

                        {

                                ulg FileAttr;

                                if (faction != PURGE)

                                {

                    t = zfiletime(z->FullPath(), &FileAttr, &fsz, NULL);

                    if ((t == 0 || t < fbefore

                            || ((faction == UPDATE || faction == FRESHEN) &&

                                t <= z->tim)

                            || (fArchiveFiles && faction == FRESHEN &&

                                !(FileAttr &A_ARCHIVE)))

                       )

                    {

                        z->mark = MARK_KEEP;      // keep

                        z->trash = (t && t >= fbefore);

                        // delete if -um or -fm

                        if (Verbose)

                        {

                            const TCHAR *expl;

                            if (t)

                                expl = z->trash ?  _T("up to date") : _T("early");

                            else

                                expl = _T("missing");

                                                        Notify(0, _T("%s is %s"), z->xname, expl);

                        }

                    }

                    else

                    {

                                                // replace

                        TotSize += fsz;

                        TotFiles++;

                        marks++;

                        z->mark = MARK_UPDATE;    // marker for replace

                        if (z->options.keepver)

                        {

                                                        ZipItem* vz = new ZipItem(*z);

                                                        *(verlast) = vz;

                                                        verlast = &vz->nxt;

                                                        vz->nxt = NULL;

                                                        vz->Passw = fkey;

                                                        vz->Base = CurBase->Base;

                            vercount++;

                        }

                    }

                }

                else

                {

                    // PURGE

                    marks++;    // incr. number of marked entries

                                        z->mark = MARK_PURGE;  // marker for Purge

                                }

            }

                }

    // RP - verify file specified to 'Purge'

    if (faction == PURGE && !marks)

        return DZError(DZ_ERM_NOTHING_TO_DO);

    // Remove entries from "found" linked list if: Action is PURGE or FRESHEN

    //   or No "external" matching file is found, or if found, but is too old or

    //   The external file is equal to the ziparchive name while ziparchive name

    //   != "-" If filetime() returns any valid time, then at least we know the

    //   file was found.

    diag(_T("checking new entries"));

        FndItem *prev = NULL;

        // fileio.c built the found list

        for (f = ffound; f != NULL;)

        {

                if (faction == PURGE || faction == FRESHEN

                                || (t = zfiletime(f->xname, NULL, NULL, NULL)) == 0

                                || t < fbefore

                                || (ZMatch(f->FullPath(), fzipfile)))

                {

                        if (Verbose && t < fbefore)

                                Notify(IVERBOSE, _T("rejecting %s as too early"), f->xname);

                        if (Verbose < 0)

                                Notify(ITRACE, _T("expel being called for %s"), f->xname);

                        tempf = f;

                        f = f->nxt;

                        if (prev)

                                prev->nxt = f;

                        else

                                ffound = f;     // new first

                        delete tempf;

                        ffcount--;

                }

                else                 // file found, and not too old.

                {

                        prev = f;

                        f = f->nxt;         // save this one, link it up.

                }

        }

    if (Verbose)

    {

        if (ffound == NULL)

            Notify(IVERBOSE, _T("found list empty - a"));

        else

            Notify(IVERBOSE, _T("found list has at least one entry - a"));

    }

    // 'fix' safe and header names

        IntList = new HashListInt(ffcount + fzcount + vercount);

        // add 'keep' files - no duplicate allowed but should not happen

        ZipItem  *prv = NULL;

        for (z = fzfiles; z != NULL; /* z = z->nxt */)

        {

                FndItem  *e;

                if (z->mark >= MARK_KEEP)

                {

                        // add internal name to list - check for duplicate

                        if ((e = (FndItem*) IntList->AddNode(z)) != 0)

                        {

                                DupName(Skipping(z->XName, DZ_ERM_DUPNAME, SKIPPED_DUP_NAME),

                                                e, z, z->IName);

                                // delete later duplicate

                                ZipItem  *x = z->nxt;

                                if (prv)

                                        prv->nxt = x;

                                else

                                        fzfiles = x;

                                delete z;

                                z = x;

                                fzcount--;

                                continue;

                        }

                }

                prv = z;

                z = z->nxt;

    }

        // now new files - no duplicates

    while ((f = ffound) != NULL)

        {

                ZipItem **prvlast = fndlast;            // save

                ZipItem *prvlastnxt = *(fndlast);   // save

        ZipItem *zi = new ZipItem(f);       // copy as ZipItem

                *(fndlast) = zi;

        fndlast = &zi->nxt;

                zi->mark = MARK_NEW;

        ffound = f->nxt;

        delete f;

                // set comment and header name

                if ((r = PrepareHeaderName(zi, false)) != 0)

                        return r;

                FndItem  *e;

                if ((e = (FndItem*) IntList->AddNode(zi)) != 0)

                {

                        DupName(Skipping(zi->XName, 0, SKIPPED_DUP_NAME),

                                        e, f, f->IName);

                        // delete later duplicate

                        fndlast = prvlast;              // restore

                        *(fndlast) = prvlastnxt;        // restore

                        delete zi;

                        ffcount--;

        }

        }

        // now rename versions to unique internal names

        if (vercount)

        {

                fAllowGrow = 0; // append not allowed

        }

        //

        if (fadjust <= 0)

        fadjust = 0;

    // Make sure there's something left to do

    if (marks == 0 && fzfound == NULL && !(fzfiles != NULL && (flatest ||

                                          fadjust || fjunk_sfx)))

    {

        // FOUND WAS NULL HERE, so just figure out which error message to show

        if (faction == UPDATE || faction == FRESHEN)

        {

            finish();

            Notify(IWARNING, _T("no files %s"), (faction == UPDATE) ? _T("updated")

                   : _T("freshened"));

            return 0;

        }

        else

        {

            if (fzfiles == NULL && (flatest || fadjust || fjunk_sfx))

                return DZError(DZ_ERM_EMPTY_ZIP);

            return DZError(DZ_ERM_NOTHING_TO_DO);

        }

    }

    // AllowGrow is false if writing temporary file

    fAllowGrow = (fAllowGrow && (marks == 0)

                  // is allowed and no changes to existing

                  && (fzipbeg || fzfiles != NULL) // something to append to

                 );

    // continue on to add new files

    a = 0;

    // ignore self-extracting code in front of the zip file (for -J)

    if (fjunk_sfx)

        fzipbeg = 0;

    // Calc size of version files

    for (z = VerFiles; z; z = z->nxt)

    {

        if (Abort_Flag)

                        Fatal(DZ_ERM_ABORT, 0);

        VerSize += (z->siz + (ulg)(4 + LOCHEAD) + (ulg)z->nam + (ulg)z->ext);

        if (z->lflg &8)

            VerSize += 16;

    }

    // Count files and sizes which we have to Keep; RP Added

    zlast = &fzfiles;

    while ((z =  *zlast) != NULL)

    {

        if (Abort_Flag)

                        Fatal(DZ_ERM_ABORT, 0);

        if (!z->mark)

        {

            KeptSize += (z->siz + (ulg)(4 + LOCHEAD) + (ulg)z->nam + (ulg)z->ext);

            if (z->lflg &8)

                KeptSize += 16;

            KeptCnt++;

        }

        zlast = &z->nxt;

    }

    //Inform(pG, 0, IDIAG, "Kept = %u %Lu Total = %Lu %Lu", KeptCnt, KeptSize, TotFiles, TotSize);

    // Count files and sizes which we have to process; RCV Added

    // First the files in the old zip file...

    // RP - already calculated with new sizes

    // And the found list...

    z = fzfound;

    while (z)

    {

                if (Abort_Flag)

            Fatal(DZ_ERM_ABORT, 0);

        TotSize += z->len;

        TotFiles++;

        z = z->nxt;

        }

    fhInz = INVALID_HANDLE_VALUE;

    fOutPosn = 0;

    if (!fAllowGrow)

    {

        // check file exists

        No_File = _taccess(fzipfile, 0) && errno == ENOENT;

        if (No_File && DestType == DRIVE_FIXED || DestType == DRIVE_RAMDISK)

        {

            // create file using given name

                        diag(_T("Processing - ready to create new file"));

            fZipOutfile = new ZFile(this, fzipfile, GENERIC_WRITE, 0, NULL,

                                    CREATE_NEW, FILE_ATTRIBUTE_NORMAL);

            if (fZipOutfile->IsOpen())

            {

                ftempzip = fzipfile;

                fAllowGrow =  -1; // new files do grow

            }

            else

                if (Verbose < 0)

                    Notify(DZ_ERM_ERROR_CREATE, _T("CreateFile failed %s [%s]"),

                           fzipfile.c_str(), SysMsg().c_str());

        }

    }

    if (fAllowGrow > 0)

    {

        // zipfile is not stdout, and we are allowed to append

        // AllowGrow is true if we're just appending (-g)

                diag(_T("Processing - ready to open for appending"));

        fZipOutfile = new ZFile(this, fzipfile, GENERIC_READ | GENERIC_WRITE, 0,

                                NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL);

        if (!fZipOutfile->IsOpen())

        {

            if (Verbose < 0)

                Notify(DZ_ERM_ERROR_CREATE, _T("CreateFile failed 2 %s [%s]"),

                       fzipfile.c_str(), SysMsg().c_str());

            return DZError(DZ_ERM_ERROR_CREATE);

        }

        ftempzip = fzipfile;

        if (fZipOutfile->SetPosition(fcenbeg, FILE_BEGIN) == -1)

            return DZError(GetLastError() ? DZ_ERM_ERROR_SEEK : DZ_ERM_ZIP_EOF);