Subversion Repositories autosfx

//---------------------------------------------------------------------------

#ifndef ZipFncH

#define ZipFncH

/*

  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 "common.h"

#include "DZRaw.h"

#include "dzoper.h"

#include "ZipDflt.h"

/* Lengths of headers after signatures in bytes */

#define LOCHEAD 26

#define CENHEAD 42

#define ENDHEAD 18

#define OS_NTFS 0x0B00

#include "Crypt.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 ZFT_DEVICE (-1)

#define ZFT_LABEL (-2)

#pragma pack(push, 4)

union FOpts

{

    struct

    {

        unsigned dosflag: 2;  // nz forces dos

        unsigned level:   4;

        unsigned noext:   1;

        unsigned keepver: 1;    // version was active

        unsigned enc:       3;  // do encoded

        unsigned copyold:   1;  // copy from old zip

                unsigned needver:   1;  // need unique version name

        unsigned needutf8:  1;  // need utf8 name

        unsigned nameutf8:  1;  // name is utf8

                unsigned nameextd:  1;  // has extended chars

                unsigned cmntextd:  1;  // has extended chars

                unsigned namenew:   1;  // name has been changed

                unsigned nameuser:  1;  // user changed name

    };

    unsigned long _opts;      // make copying/clearing easier

};// FOpts;

// hname = zname = name in header (8 bit char)

// iname = internal name

// xname = xname = external name of found file

// common fields

class XItem //: public ZIName

{

protected:

    char* fhname;        // header name field

    const TCHAR* fxname;

    const TCHAR* finame;

    bool __fastcall GetIsFolder(void) const;

    inline int  __fastcall GetEnc(void) const {return (int)options.enc;}

    void __fastcall SetEnc(int value) {options.enc = (unsigned)value & 7;}

    void __fastcall Setiname(const TCHAR *value);

    void __fastcall Setxname(const TCHAR *value);

    inline DZStrW GetXName(void) const {return DZStrW(fxname);}

    inline void __fastcall SetXName(const DZStrW& value) {Setxname(value.c_str());}

    inline DZStrW GetIName(void) const {return DZStrW(finame);}

    inline void __fastcall SetIName(const DZStrW& value) {Setiname(value.c_str());}

    inline const char* Gethname(void) const {return (const char*)fhname;}  

    void __fastcall Sethname(const char* value);  

    inline DZStrA GetHName(void) const {return DZStrA(fhname);}

    inline void __fastcall SetHName(const DZStrA& value) {Sethname(value.c_str());}

public:

    FOpts       options;

    const TCHAR *Base;

    const char  *Passw;     //* Password if set on a per file base -P switch added R.Aelbrecht */

    ZInt64        len;           // uncompressed Size of the file. RCV Added

    XItem();

    XItem(const XItem& other);

    virtual ~XItem();

    XItem& operator=(const XItem& other);

    DZStrW __fastcall FullPath(void) const;  // full path of name

    __property const TCHAR *xname = {read=fxname, write=Setxname};

    __property DZStrW XName = {read=GetXName, write=SetXName};

    __property const TCHAR *iname = {read=finame, write=Setiname};

    __property DZStrW IName = {read=GetIName, write=SetIName};

    __property const char *hname = {read=Gethname, write=Sethname};

    __property DZStrA HName = {read=GetHName, write=SetHName};

    __property int Enc = {read=GetEnc, write=SetEnc};

    __property bool IsFolder = {read=GetIsFolder};

};

// found files

class FndItem : public XItem

{

public:

    FndItem  *nxt;       //* Link to next name

    FndItem();

    FndItem(const XItem& other);

        ~FndItem();

};

// as read or for processing

class ZipItem : public XItem

{

private:

        char* fhname;        // header name field

    DZRawData fextra;

    DZRawData fcextra;

    XNTFSData* fntfs;

        wchar_t* fcomment;

    inline WORD GetExt(void) const {return (WORD)extra.Length();}

    inline WORD GetCext(void) const {return (WORD)cextra.Length();}

    inline void SetExt(WORD value) {extra.SetLength(value);}

    inline void SetCext(WORD value) {cextra.SetLength(value);}

    inline DZStrW GetComment(void) const {return DZStrW(fcomment);}

        void __fastcall SetComment(const DZStrW& value);

protected:

        void __fastcall Copy(const ZipItem& other);

public:

#pragma pack(push, 2)

        ush           vem,      // version made

    ver,                    // version required

    flg,                    // general bit flag

    how;                    // method

        ::extent nam,           // length zname

//    ext,                  // length local header extra data

//    cext,                 // length central header extra data

    com;                    // length comment

    ush           dsk,      // disk number of local header

    att,

    lflg;                   // local header flag

#pragma pack(pop)

    ulg           atx;

    ulg           tim,        // file time (dos)

    crc;                    // crc

    ZInt64        siz;        // compressed

    ZInt64        off;        // offset local header

    int           mark;       // Marker for files to operate on

        int           trash;      // Marker for files to delete

    __property DZRawData extra = {read=fextra, write=fextra};

    __property DZRawData cextra = {read=fcextra, write=fcextra};

    __property XNTFSData* ntfs = {read=fntfs, write=fntfs};

    __property DZStrW Comment = {read=GetComment, write=SetComment};

    __property WORD ext = {read =GetExt, write=SetExt};

    __property WORD cext = {read =GetCext, write=SetCext};

    ZipItem  *nxt;       // Pointer to next header in list

    ZipItem();

    ZipItem(const FndItem* f);

    ZipItem(const ZipItem& other);

        ZipItem& operator=(const ZipItem& other);

    ~ZipItem();

};

#pragma pack(pop)

// node used for duplicate checks

class HL_node

{

public:

    struct HL_node *nxt;

    ulg hash;

    const XItem *xdata;

    HL_node();//:nxt(NULL),hash(0),xdata(NULL){};

};

#define NODE_BLOCK_SIZE 5000

class HL_block

{

private:

    HL_block(void);

    HL_block(const HL_block&);

    HL_block& operator=(const HL_block&);

public:

    HL_node nodes[NODE_BLOCK_SIZE];

    HL_block *prv;   // link for removal

    HL_block(HL_block *prev);

    ~HL_block(void);

};

class HashList

{

private:

    HashList(void);

    HashList(const HashList&);

    HashList& operator=(const HashList&);

public:

    HashList(int siz);

    virtual ~HashList(void);

protected:

    HL_node **Table;

    HL_block *blocks;

    int nno;

    unsigned Mask;

    unsigned Hash;

    unsigned Index;

    HL_node * NewNode(const XItem *x, ulg hash);

    const XItem *AddANode(const XItem *xname);

    XItem *FindAName(void);

    virtual bool Matches(const HL_node *node) const = 0;

    virtual HL_node* Prepare(void) = 0;

};

class HashListExt : public HashList

{

private:

    DZStrW fxname;

    HashListExt(void);

    HashListExt(const HashListExt&);

    HashListExt& operator=(const HashList&);

public:

    HashListExt(int siz): HashList(siz){;}

    ~HashListExt(void);                    

    XItem *FindName(const DZStrW& name);

    const XItem *AddNode(const XItem *xname);

protected:

    bool Matches(const HL_node *node) const;

    HL_node* Prepare(void);

};

class HashListInt : public HashList

{

private:

    HashListInt(void);

    HashListInt(const HashList&);

    HashListInt& operator=(const HashList&);

protected:

    DZStrW finame;

    bool Matches(const HL_node *node) const;

    HL_node* Prepare(void);

public:

    HashListInt(int siz): HashList(siz){;}

    ~HashListInt(void);

    XItem *FindName(const DZStrW& name);

    const XItem *AddNode(const XItem *xname);

};

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

/*  ZGlobals  */

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

class ZipFunc : public ZipDflt

{

private:

    ZipFunc(void);

    ZipFunc(const ZipFunc&);

    ZipFunc& operator=(const ZipFunc&);

protected:

    int fglobal_error_code; // in UnzErr() in dllmain

    int ffiles_acted_on;

    unsigned fEncodeAs;

    char ffnamebuf[MAX_PATH + 1];

    DZStrW fRootDir;

    DZStrA fzcomment;

    DZStrW ftempath;

    DZStrW ftempzip;

    DZStrA fGPassword;

    DZStrW fStartCDir;

    const char* fuser_key; // user entered key or NULL RP 1.73

    int fzcomlen;

    int fResetArchiveBit;

    bool fHowToMove;

    DWORD fStrFileAttr;

    DWORD fStrFileDate;  

    DZStrW fExcludes;

    ZFilter *fSpecials;

    int fpcount;

    FndItem *ffound;

    FndItem **ffnxt;

    ZipItem *fzfiles;

    ZipItem *fzfound;   // list of prepared found

    ::extent fzcount;

    ZipItem* VerFiles;

    int flatest;

    int fNoExtChk;// method;

        int fadjust;

    int faction;

    int fversion;

    int fdirnames;

//    int fpathput;

        int fjunk_sfx;

    int frecurse;

    ulg fbefore;

    int flinkput;

    int ffcount;

    int fNoPrecalc;

    int fGEncrypt;

    ulg VerDate;

    DZStrW flabel;

    int fzipstate;

    struct stati64 fzipstatb;

    ulg flabel_time;

    ulg flabel_mode;

    time_t flabel_utim;

    ZInt64 fOutPosn; //tempzn;

    ZInt64 fcenbeg;

    ZInt64 fzipbeg;

    int fAllowGrow;                // new 1.73

    int fCallback_Exception;       // new 1.73.2.6

    int fBatchStarted;             // new 1.73.4.2

    DZStrW fFullPath;               // 1,74

    int fdoall;                    // new 178.5.0

    uch *fhwbuf;                  // allocated buffer

        int  fhwsize;                  // size of buffer

    int  fhwcnt;                   // current byte count

    HashListInt *fndlist;           // existing files

        HashListInt *IntList;           // internal names

public:

    int fArchiveFiles;

    ZipFunc(const DllCommands *C);

    ~ZipFunc(void);

    void ZipCleanup(void);        //ZipSel            

    int Init(void); // after construction

protected:

    int     ZipProcess(void);

    DZStrW __fastcall     CleanedPath(const DZStrW &pth);

        ZipItem    *zsearch(const DZStrW &name);

        int     trash(void);

        DZStrW tempname(void);

private:

    int  LocXData;              // offset to local header extra data (for redo)

        void    finish(void);                      //ZipSel

    int     replace(const DZStrW &oldname, const DZStrW &newname);

    int     replaceOrig(const DZStrW &d, const DZStrW &s);

        int     TrashDir(const DZStrW &dir);

    int   check_dupExt(void);

    int zipup(ZipItem *);

    int zipVersion(ZipItem *);

    int __fastcall SetVers(ZipItem* z, int mthd);

    int __fastcall  PutLocal(ZipItem *);

    int __fastcall  UpdateLocal(ZipItem *);

    int __fastcall  putextended(ZipItem *);

    int __fastcall  putcentral(ZipItem *);

    int __fastcall  zipcopy(ZipItem *);

    int __fastcall  PutEnd(unsigned CentralCnt, __int64 CentralOffs);

    int     fcopy(ZInt64);

    ulg     zfiletime(const DZStrW &name, ulg *, __int64 *, ztimbuf *);

    int     filecopy(HANDLE f, HANDLE g);

    void    HWriteInit(void);

    int     HWrite(const void *arg, int siz);

        char *  ChangeBWSlash(char *fn);

    int     __fastcall NameVer(ZipItem* z);

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

    int __fastcall PrepareHeaderName(ZipItem* z, bool NoComment);

}; /* end of struct ZGlobals */

void  stamp(const DZStrW &name, ulg);

ulg     FileTime2DosTime(_FILETIME ftime);

int     NtfsFileTime2utime(const FILETIME *pft, time_t *ut);

int     percent(__int64 n, __int64 m);

int     setfileattr(const DZStrW&, int);

int __fastcall SameNameExt(const DZStrW &fname, const DZStrW &oname);

DZStrW last(const DZStrW &s, int);

int __fastcall IsShExp(const DZStrW &p);

#endif