kaeziparchiveimplement.h

zip解压源码.

#ifndef KAEZIPARCHIVEIMPLEMENT_H
#define KAEZIPARCHIVEIMPLEMENT_H

#include "KSFileImport.h"
#include "KSFileStdImport.h"
#include "KAEZipDefine.h"
#include "KAEArchive.h"
#include "KAEZipArchive.h"



class KAEZipArchive : public IKAEZipArchive
{
private:
    IUnknown *m_pUnknownOuter;
    IKAEArchiveCallBack *m_piArchiveCallBack;

public:

   // IUnknown
    virtual HRESULT STDMETHODCALLTYPE QueryInterface( 
        /* [in] */ REFIID riid,
        /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
    
    virtual ULONG STDMETHODCALLTYPE AddRef(void);
    
    virtual ULONG STDMETHODCALLTYPE Release(void);

	void SetUnknownOuter(IUnknown *pUnkOuter);

    virtual HRESULT STDMETHODCALLTYPE Init(/*[in]*/ void *pvContext);
    
    virtual HRESULT STDMETHODCALLTYPE UnInit( void);
    
    virtual HRESULT STDMETHODCALLTYPE SetCallBackFunc( 
        /* [in] */ IKAEArchiveCallBack __RPC_FAR *piArchiveCallBack
    );
    
    virtual HRESULT STDMETHODCALLTYPE Extract( 
        /* [in] */ int nArchivePathNameLen,
        /* [size_is][in] */ char __RPC_FAR szArchivePathName[  ]
    );

    virtual HRESULT STDMETHODCALLTYPE Extract2(
        /*[in]*/ IKSFile *piFile
    ); 

    virtual HRESULT STDMETHODCALLTYPE Stop(
        /*[in]*/ void * pvContext
    );

    virtual HRESULT STDMETHODCALLTYPE Pause(
        /*[in]*/ void * pvContext
    );

public:
    KAEZipArchive();

protected:

	static int exp_cmp(const void *a, const void *b);
	void extract_flush(void);
	int inf_dynamic(void);
	int inf_codes(HUFF * tl,HUFF * td,int bl,int bd);
	void inf_free(HUFF *t);
	int inf_build_tree(UINT *b,UINT n,UINT s,UINT *d,UINT *e,HUFF **t,UINT *m);
	int inf_fixed(void);
	void extract_inflate(LF *lfp);
	UINT exp_read(SFT *sf);
	UINT get_byte(void);
	void exp_load_tree(SFT *sf,int n);
	void extract_explode(LF *lfp);
	void extract_expand(LF *lfp);
	UINT lookat_code(int bits);
    UINT get_code(int bits);
	void extract_shrunk(void);
	void store_char(char c);
	void extract_copy(ULONG len);
	void extract_stored(void);
	int extract_open(LF *lfp);
	void extract_zip(int fnc,LF * lfp);
	int  initialization(const char * szZipPathName);
    int  initialization2(IKSFile *piFile);
	int read_ed(ED *edp);
	int read_fh(FH *fhp);
	int read_lf(LF *lfp);
	void scan_zip();

	ULONG   crc,                                // running crc 32 value
			bhold;                              // bits hold area
	
	long    rsize,                              // remaining size to process
			last_kpal,                          // keep alive message time
			total_size,                         // uncompressed sum
			total_csize;                        // compressed sum
	
	//int     rc /*= 1*/,                         // errorlevel return code
	int		pos_count,                          // positional parms count
			sf_count,                           // select file parms count
			e_count,                            // end of data counter/flag
			total_files;                        // files processed
	
	UINT    sb_size;                            // sliding buffer size
	
	BYTE    bsize,                              // bits left to process
			sb[BUFFER_SIZE];                    // sliding buffer
    BYTE    *sbp, *sbe;                         // sliding ptr, and end
	
	char	*init_path,                         // start up drive and path
			**pos_parms,                        // positional parms array
			//spin,                               // keep alive character index
			zfn[MAX_PATH],                      // zip filename and path
			output_path[MAX_PATH];              // base output path
			/*
            sw_dirs,                            // create directory switch
			sw_freshen,                         // freshen target files switch
			sw_new,                             // retrieve newer files switch
			sw_overwrite,                       // overwrite files switch
			sw_test,                            // test file integrity switch
			sw_view,                            // view ZIP directory option
			sw_extract,                         // extract file option
			*sw_exclude;                        // exclude files option
            */
	
	FILE	*ifile,                             // input file
			*ofile;                             // output file
	
	//extern int _fmode = O_BINARY;             // set global for binary files

	//SFS		*sf,                                // select files
    //		wf,                                 // working file
	//		ef;                                 // exclude file

    //seawind added
    SFS     wf;                                 //working file

protected:
	
    //char    m_szTempPath[MAX_PATH];
    char    m_szFullNameInArchive[MAX_PATH];
    char    m_szPathNameInTemp[MAX_PATH];

    int     m_nActionCancel;
	int		m_nTempFileCreated;
    int     m_nZipFileCracked;

    ULONG   m_uUnCompressedSize;
    ULONG   m_uCompressedSize;
    
};

inline KAEZipArchive::KAEZipArchive()
{
    sb_size = (UINT) BUFFER_SIZE;       // set up the dictionary size
    //sb = (BYTE *) malloc_chk(sb_size);
    sbe = &sb[sb_size];                 // set up end of buffer address
}

inline void KAEZipArchive::SetUnknownOuter(IUnknown *pUnkOuter)
{
    ASSERT(pUnkOuter);
    m_pUnknownOuter = pUnkOuter;
}



#endif