cZipDir.h

Go to the documentation of this file.

//
 
#ifndef _INC_cZipDir_H
#define _INC_cZipDir_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Codec/cStreamZLib.h"       // ZIP_COMPLEV_TYPE
 
#ifdef USE_ZLIB
#include "../Cipher/cCipherBase.h"
#include "GrayCore/include/cFilePath.h"
#include "GrayCore/include/cTimeInt.h"
#include "GrayCore/include/cBits.h"
#include "GrayCore/include/cStream.h"
 
namespace GrayLib
{
        typedef INT32 ZIP_OFFSET_t;     
        typedef UINT32 ZIP_SIZE_t;      
 
        enum ZIP_MAGIC_TYPE
        {
                ZIP_MAGIC_LOCALENTRY = (0x04034b50),    
                ZIP_MAGIC_DIRENTRY = (0x02014b50),      
                ZIP_MAGIC_DIREND = (0x06054b50),        
                ZIP_MAGIC_EXTLOC = (0x08074b50),        
        };
 
        enum ZIP_CTRL_TYPE_
        {
                ZIP_CTRL_0 = 0,
                ZIP_CTRL_FLAT = 1,      // Make/Unzip a flat zip file. ignore child paths.
        };
        typedef BYTE ZIP_CTRL_TYPE;     // bitmask
 
        class GRAYLIB_LINK cZipData
        {
 
        public:
                enum COMPMETHOD_TYPE
                {
                        COMPMETHOD_Store = 0,           
                        COMPMETHOD_OLD_SHRINK,          
                        COMPMETHOD_OLD_REDUCE1,         
                        COMPMETHOD_OLD_REDUCE2,         
                        COMPMETHOD_OLD_REDUCE3,         
                        COMPMETHOD_OLD_REDUCE4,         
                        COMPMETHOD_OLD_IMPLODE,         
                        COMPMETHOD_OLD_TOKENIZE,        
                        // PKZIP 1.0
                        COMPMETHOD_Deflate = 8,         
                        // WinZip/PKZIP v2.0 stop
                        COMPMETHOD_Deflate64 = 9,       
                        COMPMETHOD_BZIP2 = 12,          
                        // WinZip v?? stop
                        COMPMETHOD_JPEG = 96,           
                        COMPMETHOD_WavPack = 97,        
                        COMPMETHOD_PPMd = 98,           
                        // WinZip v12.0 stop
                };
 
        private:
                static HRESULT GRAYCALL WriteValue(cStreamOutput& s, UINT32 x, size_t nbByte);
 
        protected:
                static HRESULT GRAYCALL ReadU16(cStreamInput& stmIn, WORD* pX);
                static HRESULT GRAYCALL ReadU32(cStreamInput& stmIn, UINT32* pX);
 
                static HRESULT WriteU16(cStreamOutput& s, WORD x)
                {
                        return WriteValue(s, x, 2);
                }
                static HRESULT WriteU32(cStreamOutput& s, UINT32 x)
                {
                        return WriteValue(s, x, 4);
                }
        };
 
        class GRAYLIB_LINK cZipDir : protected cZipData
        {
 
        public:
                STREAM_OFFSET_t m_nPosZipDir;   
 
                WORD m_nNumDisk;                                
                WORD m_nNumDisk_CD;                             
 
                WORD m_nNumberOfEntries;                
                WORD m_nNumberOfEntries_CD;             
 
                UINT32 m_nSizeCentralDir;               
                ZIP_SIZE_t m_nSizeLocalDir;                     
 
                cString m_sGlobalComment;               
 
        public:
                cZipDir();
                ~cZipDir();
 
                bool isValidParams() const;
 
                HRESULT ReadHeader(cStreamInput& s);
                HRESULT WriteHeader(cStreamOutput& s);
 
                HRESULT SeekZipDir(cStreamInput& s);
                HRESULT ReadZipDir(cStreamInput& s);
 
                STREAM_OFFSET_t get_PosLH0() const
                {
                        if (m_nPosZipDir == ((STREAM_OFFSET_t)-1))      // since its not set, assume that it starts at 0. we are writing.
                                return 0;
                        return m_nPosZipDir - (m_nSizeLocalDir + m_nSizeCentralDir);
                }
                STREAM_OFFSET_t get_PosCH0() const
                {
                        if (m_nPosZipDir == ((STREAM_OFFSET_t)-1))      // since its not set, assume that it starts at 0. we are writing.
                                return m_nSizeLocalDir;
                        return m_nPosZipDir - m_nSizeCentralDir;
                }
                size_t get_SizeCHD() const
                {
                        return 4 + 18 + m_sGlobalComment.GetLength();
                }
                int get_FileCount() const
                {
                        return (int)m_nNumberOfEntries;
                }
        };
 
#pragma pack(1)
        struct CATTR_PACKED cZipDataExtra
        {
                WORD m_wType;
                WORD m_wLen;    // USE_LITTLE_ENDIAN
        };
 
        class CATTR_PACKED cZipDataExUT : public cZipDataExtra
        {
 
        public:
                enum FLG_TYPE   // m_bFlags
                {
                        FLG_MTIME = (1 << 0),      // mtime = modification.
                        FLG_ATIME = (1 << 1),      // atime = access.
                        FLG_CTIME = (1 << 2),      // ctime = creation
                };
 
#ifdef USE_LITTLE_ENDIAN
                static const WORD k_Type = MAKEWORD('U', 'T'); // USE_LITTLE_ENDIAN "UT" = b[0]='U', b[1]='T'
#else
                static const WORD k_Type = MAKEWORD('T', 'U');
#endif
 
                BYTE m_bFlags;          // what m_atTime[] are populated ?
                UINT32 m_atTime[3];     // TIMESEC_t as UINT32. convert to cTimeFile
 
        public:
                cZipDataExUT(BYTE bFlags)
                : m_bFlags(bFlags)
                {
                        m_wType = k_Type;
                        m_wLen = get_Size();
                }
                WORD get_Size() const
                {
                        int iTimes = cBits::Count1Bits(m_bFlags);
                        return (WORD)(4 + 1 + (iTimes * 4));
                }
                void InitFlags(BYTE bFlags)
                {
                        m_wType = k_Type;
                        m_bFlags = bFlags;
                        m_wLen = get_Size();
                }
                int get_TimeIdx(FLG_TYPE bFlag) const
                {
                        if (!(m_bFlags & bFlag))
                                return -1;      // doesn't exist.
                        int j = 0;
                        for (int i = 0; i < 3; i++)
                        {
                                BYTE bFlagTmp = (1 << i);
                                if (!(bFlagTmp & m_bFlags))
                                        continue;
                                if (bFlagTmp & bFlag)
                                        return j;
                                j++;
                        }
                        ASSERT(0);
                        return -1;
                }
        };
#pragma pack()
 
        class GRAYLIB_LINK cZipFileEntry0 : protected cZipData
        {
 
        public:
                enum ZFLG_TYPE
                {
                        ZFLG_CRYPT = 0x01,      
                        ZFLG_COMPLVL1 = 0x02,   
                        ZFLG_COMPLVL2 = 0x04,   
                        ZFLG_SUMS_FOLLOW = 0x08,        
                        ZFLG_ENHANCED = 0x0010,
                        ZFLG_PATCH = 0x0020,
                        ZFLG_STRONG_ENC = 0x0040,
                        ZFLG_UNUSED = 0x0F80,
                        ZFLG_RESERVED = 0xF000
                };
 
                static const int k_nFileNameMax = 256;
                static const int k_nOffsetU = 14;       // Bytes offset from start to update WriteHeader0U()
 
        public:
                WORD m_wVersionNeeded;                  
                WORD m_wZFlags;                                 
 
                // stored (no compression), Shrunk, Reduced (methods 1-4), Imploded, Tokenizing, Deflated, Deflate64, BZIP2, LZMA (EFS), WavPack, PPMd.
                COMPMETHOD_TYPE m_eCompressionMethod;           
 
                UINT32 m_dwDosDate;             
                UINT32 m_dwCRC;                                 
                ZIP_SIZE_t m_dwCompressedSize;          
                ZIP_SIZE_t m_dwUncompressedSize;        
 
                WORD m_wSize_FileName;          
                WORD m_wSize_Extra;                     
 
                cStringF m_sFileName;           
                cHeapBlock m_Extra;                     
 
        public:
                cZipFileEntry0()
                {
                        SetZeroData();
                }
                ~cZipFileEntry0()
                {
                }
 
                void SetZeroData();
 
                size_t get_SizeLH() const
                {
                        return 4 + 6 + 16 + 4 + m_wSize_FileName + m_wSize_Extra;
                }
 
                bool isValidParams() const;
                bool ValidateParams();
 
                cStringF get_Name() const
                {
                        return m_sFileName;
                }
                void put_FileName(cStringF sFileName)
                {
                        m_sFileName = sFileName;
                        m_wSize_FileName = (WORD)m_sFileName.GetLength();
                }
 
                void SetCopy(const cZipFileEntry0& h)
                {
                        ASSERT(&h != this);
                        m_wVersionNeeded = h.m_wVersionNeeded;
                        m_wZFlags = h.m_wZFlags;
                        m_eCompressionMethod = h.m_eCompressionMethod;
                        m_dwDosDate = h.m_dwDosDate;
                        m_dwCRC = h.m_dwCRC;
                        m_dwCompressedSize = h.m_dwCompressedSize;
                        m_dwUncompressedSize = h.m_dwUncompressedSize;
                        m_wSize_FileName = h.m_wSize_FileName;          
                        m_wSize_Extra = h.m_wSize_Extra;                        
                        m_sFileName = h.m_sFileName;
                        m_Extra.SetCopy(h.m_Extra);
                }
 
                HRESULT ReadHeader0(cStreamInput& s, bool bLH);
                HRESULT WriteHeader0U(cStreamOutput& s) const;
                HRESULT WriteHeader0(cStreamOutput& s, bool bLH) const;
 
                void AddExUT(const cZipDataExUT* pEx);
                cZipDataExUT* FindExUT() const;
 
                cTimeInt get_DosDateAsTime() const;
                cTimeInt get_TimeCreated() const;
                cTimeInt get_TimeModified() const;
 
                void SetFileTimes(cTimeInt tCreated, cTimeInt tModified);
 
                ZIP_COMPLEV_TYPE get_CompLevel() const;
                bool put_CompLevel(ZIP_COMPLEV_TYPE nCompLevel);
        };
 
        class GRAYLIB_LINK cZipFileEntry1 : public cZipFileEntry0
        {
 
                typedef cZipFileEntry0 SUPER_t;
 
        public:
                enum SYSTEM_TYPE
                {
 
                        SYSTEM_MSDOS,           
                        SYSTEM_AMIGA,
                        SYSTEM_OPENVMS,         
                        SYSTEM_UNIX,            
                        SYSTEM_VM_CMS,
                        SYSTEM_ATARI_ST,        
                        SYSTEM_OS2_HPFS,
                        SYSTEM_MACINTOSH,
                        SYSTEM_Z_SYSTEM,
                        SYSTEM_CPM,
                        SYSTEM_WINDOWS_NTFS,    
                        SYSTEM_MVS,
                        SYSTEM_VSE,
                        SYSTEM_ACORN_RISC,      
                        SYSTEM_VFAT,            
                        SYSTEM_ALTERNATE_MVS,
                        SYSTEM_BEOS,            
                        SYSTEM_TANDEM,          
                        SYSTEM_OS_400
                };
 
        public:
                BYTE m_bVersion;                                
                SYSTEM_TYPE m_eSystemMadeBy;    
 
                cString m_sComment;                     
                WORD m_wDisk_num_start;                 
 
                WORD m_wDataTypeGuess;                  
                UINT32 m_dwFileAttrFlags;               
 
                ZIP_SIZE_t m_nOffsetLocal;                      
 
        public:
                cZipFileEntry1()
                {
                        SetZeroData();
                }
                cZipFileEntry1(const cZipFileEntry1& cp)
                {
                        SetCopy(cp);
                }
                ~cZipFileEntry1()
                {
                }
 
                bool isValidParams() const;
                bool isMatch(const cZipFileEntry0& entry) const;
 
                cZipFileEntry1& operator =(const cZipFileEntry1& cp)
                {
                        SetCopy(cp);
                        return *this;
                }
 
                size_t get_SizeCH() const
                {
                        return 46 + m_wSize_FileName + m_wSize_Extra + m_sComment.GetLength();
                }
                bool isAttrDir() const;
                void SetZeroData();
                void SetCopy(const cZipFileEntry1& h);
 
                HRESULT ReadHeader1(cStreamInput& s);
                HRESULT WriteHeader1(cStreamOutput& s) const;
        };
 
        class cZipCrypt : public ICipherBase
        {
 
        public:
                static const size_t k_LEN_HEAD = 12;    
 
        private:
                bool m_bEncodeMode;
                UINT32 m_keys[3];                       
                const UINT32* m_pcrc_32_tab;    
 
        private:
                void InitKeys();
                void InitKeys(const char* pszPass);
 
                UINT32 GetCRC32(UINT32 crc, BYTE b) const
                {
                        return(m_pcrc_32_tab[(crc ^ b) & 0xff] ^ (crc >> 8));
                }
                BYTE CryptByte()
                {
                        UINT32 nTmp = ((UINT32)(m_keys[2]) & 0xffff) | 2;
                        return (BYTE)(((nTmp * (nTmp ^ 1)) >> 8) & 0xff);
                }
                void UpdateKeys(BYTE c);
 
        public:
                cZipCrypt();
                ~cZipCrypt();
 
                bool InitDecrypt(const char* pszPass, BYTE* pBuffer);
                void InitEncrypt(const char* pszPass, BYTE* pBuffer, UINT32 dwCRCForCrypting);
 
                BYTE EncryptByte(BYTE c)
                {
                        BYTE t = CryptByte();
                        UpdateKeys(c);
                        return t ^ (c);
                }
                BYTE DecryptByte(BYTE c)
                {
                        c ^= CryptByte();
                        UpdateKeys(c);
                        return c;
                }
 
                virtual size_t get_BlockAlignSize() const override
                {
                        return 1;
                }
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSizeBytes) override
                {
                        if (m_bEncodeMode)
                        {
                                for (size_t i = 0; i < nSizeBytes; i++)
                                {
                                        pOutput[i] = EncryptByte(pInput[i]);
                                }
                        }
                        else
                        {
                                for (size_t i = 0; i < nSizeBytes; i++)
                                {
                                        pOutput[i] = DecryptByte(pInput[i]);
                                }
                        }
                        return (HRESULT)nSizeBytes;
                }
        };
};
#endif
#endif