TnbArchiverDllHandler.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbDynamicFunc.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
#ifndef ARC_DECSTRACT
    //[7ZIP]の提供ヘッダ
    #include "other/7-zip32.h"
#endif
#endif //_TnbDOXYGEN
 
 
 
#pragma pack(push, 1)
struct TIndividualInfo
{
    DWORD   dwOriginalSize;         
    DWORD   dwCompressedSize;       
    DWORD   dwCRC;                  
    UINT    uFlag;                  
    UINT    uOSType;                
    WORD    wRatio;                 
    WORD    wDate;                  
    WORD    wTime;                  
    char    szFileName[FNAME_MAX32 + 1];    
    char    dummy1[3];              
    char    szAttribute[8];         
    char    szMode[8];              
    #ifndef _UNICODE
    TIndividualInfo(void)
    {
        ASSERT0( sizeof(TNB::TIndividualInfo) == sizeof(INDIVIDUALINFO), "TIndividualInfo()",
                    "ローカルで宣言している型(TNB::TIndividualInfo)と\n"
                    "インクルードしている型(INDIVIDUALINFO)で差異があります。\n");
    }
    #endif
};
#pragma pack(pop)
 
 
 
class CArchiverDllHandler : CCopyImpossible
{
public:
 
    enum ECommand
    {
        EC_Delete,      
        EC_Extract,     
        EC_ExtractDir,  
        EC_Attract,     
    };
 
    CArchiverDllHandler(LPCSTR lpszDllName, LPCSTR lpszPrifix)
        : m_hModule(NULL), m_strPrifix(lpszPrifix), m_hWnd(NULL)
    {
        m_Init(lpszDllName);
    }
 
    virtual ~CArchiverDllHandler(void)
    {
        if ( m_hModule != NULL )
        {
            ::FreeLibrary(m_hModule);
            m_hModule = NULL;
        }
    }
 
    void SetParent(HWND hWnd)
    {
        m_hWnd = hWnd;
    }
 
    bool IsReady(void) const
    {
        return m_hModule != NULL;
    }
 
    template<typename R>
    R Func(R& _r, LPCSTR lpszFuncName)
    {
        R (WINAPI *pFunc0)(void); 
        _r = m_GetFuncAdd(pFunc0, lpszFuncName)();
        return _r;
    }
 
    template<typename R, typename T1>
    R Func(R& _r, LPCSTR lpszFuncName, T1 t1)
    {
        R (WINAPI *pFunc1)(T1 t1);
        _r = m_GetFuncAdd(pFunc1, lpszFuncName)(t1);
        return _r;
    }
 
    template<typename R, typename T1, typename T2>
    R Func(R& _r, LPCSTR lpszFuncName, T1 t1, T2 t2)
    {
        R (WINAPI *pFunc2)(T1, T2);
        _r = m_GetFuncAdd(pFunc2, lpszFuncName)(t1, t2);
        return _r;
    }
 
    template<typename R, typename T1, typename T2, typename T3>
    R Func(R& _r, LPCSTR lpszFuncName, T1 t1, T2 t2, T3 t3)
    {
        R (WINAPI *pFunc3)(T1, T2, T3);
        _r = m_GetFuncAdd(pFunc3, lpszFuncName)(t1, t2, t3);
        return _r;
    }
 
    template<typename R, typename T1, typename T2, typename T3, typename T4>
    R Func(R& _r, LPCSTR lpszFuncName, T1 t1, T2 t2, T3 t3, T4 t4)
    {
        R (WINAPI *pFunc4)(T1, T2, T3, T4);
        _r = m_GetFuncAdd(pFunc4, lpszFuncName)(t1, t2, t3, t4);
        return _r;
    }
 
    bool IsRunning(void)
    {
        BOOL r;
        return !! Func(r, "GetRunning");
    }
 
    CAscii GetResultString(void)
    {
        m_strResult.ReleaseBuffer();
        return m_strResult;
    }
 
    int Command(LPCSTR lpszCmdLine, const DWORD dwOutputSize)
    {
        int r;
        return Func(r, "", m_hWnd, lpszCmdLine, m_strResult.GetBuffer(dwOutputSize), dwOutputSize);
    }
 
    WORD GetVersion(void)
    {
        WORD r;
        return Func(r, "GetVersion");
    }
 
    WORD GetSubVersion(void)
    {
        WORD r;
        return Func(r, "GetSubVersion");
    }
 
    CStr GetVersionString(void)
    {
        CStr s;
        WORD w = GetVersion();
        try
        {
            WORD v = GetSubVersion();
            s.Format(_T("%d.%02d.%02d.%02d"), w / 100, w % 100, v / 100, v % 100);
        }
        catch(CNotSupportException& e)
        {
            e.OnCatch();
            s.Format(_T("%d.%02d"), w / 100, w % 100);
        }
        return s;
    }
 
    DWORD ConfigDialog(LPSTR _lpszOptionBuffer = NULL, const int iMode = 0)
    {
        BOOL r;
        return Func(r, "ConfigDialog", m_hWnd, _lpszOptionBuffer, iMode);
    }
 
    bool CheckArchive(LPCSTR lpszArcFile, const int iMode)
    {
        BOOL r;
        return !! Func(r, "CheckArchive", lpszArcFile, iMode);
    }
 
    int GetFileCount(LPCSTR lpszArcFile)
    {
        int r;
        return Func(r, "GetFileCount", lpszArcFile);
    }
 
    bool QueryFunctionList(const int iFunction)
    {
        BOOL r;
        return !! Func(r, "QueryFunctionList", iFunction);
    }
 
    HARC OpenArchive(LPCSTR lpszArcFile, const DWORD dwMode = 0)
    {
        HARC r;
        return Func(r, "OpenArchive", m_hWnd, lpszArcFile, dwMode);
    }
 
    int CloseArchive(HARC hArc)
    {
        int r;
        return Func(r, "CloseArchive", hArc);
    }
 
    virtual CAscii MakeCommand(ECommand cmd, LPCSTR lpszOption = NULL)
    {
        CAscii strOpt = lpszOption;
        if ( ! strOpt.IsEmpty() )
        {
            strOpt += " ";
        }
        CAscii strResult;
        CAscii strCmd = MakeCommandOption(cmd);
        if ( strCmd.IsEmpty() )
        {
            return strResult;
        }
        strResult.Format("%s%s\042%%s\042 \042%%s\\\042 \042%%s\042", strCmd, strOpt);
        return strResult;
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd) = 0;
 
    int Execute(ECommand cmd, LPCSTR lpszArcFile, LPCSTR lpszPath, LPCSTR lpszFilter, LPCSTR lpszOption = NULL)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除
        case EC_Extract: // 抽出
        case EC_ExtractDir: // 抽出(Directory付き)
        case EC_Attract: // 格納
            strCmd = MakeCommand(cmd, lpszOption);
            break;
        default:
            ASSERT(false);
            break;
        }
        if ( strCmd.IsEmpty() )
        {
            m_strResult.ReleaseBuffer();
            m_strResult.Empty();
            return -1;
        }
        CAscii s = CAscii::Fmt(strCmd, lpszArcFile, lpszPath, lpszFilter);
        s.Replace("\\\\","\\");
        return Command(s, RESULTMAX);
    }
 
    int ExtractMem(LPCSTR lpszArcFile, LPCSTR lpszName, BYTE* _lpBuf, size_t& dwSize, LPCSTR lpszOption = NULL)
    {
        ASSERT( ! ::IsBadWritePtr(_lpBuf, dwSize) );
        CAscii strCmd = CAscii::Fmt("%s \042%s\042 \042%s\042", CAscii(lpszOption), lpszArcFile, lpszName);
        strCmd.TrimLeft();
        DWORD dwOriginalSize = 0;
        int (WINAPI* pFunc)(const HWND, LPCSTR, BYTE*, const DWORD, time_t*, WORD*, DWORD*);
        int r = m_GetFuncAdd(pFunc, "ExtractMem")
                    (m_hWnd, strCmd, _lpBuf, static_cast<DWORD>(dwSize), NULL, NULL, &dwOriginalSize);
        dwSize = dwOriginalSize;
        return r;
    }
 
    int CompressMem(LPCSTR lpszArcFile, LPCSTR lpszName, time_t time, WORD wAttr,
                                        const BYTE* lpBuf, DWORD& _dwSize, LPCSTR lpszOption = NULL)
    {
        ASSERT( ! ::IsBadReadPtr(lpBuf, _dwSize) );
        CAscii strCmd = CAscii::Fmt("%s \042%s\042 \042%s\042", CAscii(lpszOption), lpszArcFile, lpszName);
        strCmd.TrimLeft();
        DWORD dwCompreSize = 0;
        int (WINAPI* pFunc)
                    (const HWND, LPCSTR, const BYTE*, const DWORD, const time_t*, const WORD*, DWORD*);
        int r = m_GetFuncAdd(pFunc, "CompressMem")
                    (m_hWnd, strCmd, lpBuf, _dwSize, &time, &wAttr, &dwCompreSize);
        _dwSize = dwCompreSize;
        return r;
    }
 
private:
    enum 
    {
        RESULTMAX = 1024 
    };
    // DLLの読み込み(最初の1回目のみ)とワークエリアの初期化を行います。
    bool m_Init(LPCSTR lpszDllName)
    {
        if ( m_hModule != NULL )
        {
            return true;
        }
        HINSTANCE h = ::LoadLibraryA(lpszDllName);
        if ( h == NULL )
        {
            return false;
        }
        // エクスポート関数の確認
        bool r = true;
        WORD (WINAPI *pGetVersion)(void);
        r &= GetFuncAddress(pGetVersion, h, m_strPrifix + "GetVersion");
        if ( r )
        {
            m_hModule = h;
        }
        else 
        {
            ::FreeLibrary(h);
        }
        return r;
    }
    template<typename T>
    T& m_GetFuncAdd(T& _t, LPCSTR lpszFuncName)
    {
        if ( m_hModule == NULL )
        {
            throw CNullPointerException();
        }
        if ( ! GetFuncAddress(_t, m_hModule, m_strPrifix + lpszFuncName) )
        {
            throw CNotSupportException(); 
        }
        return _t;
    }
    HMODULE     m_hModule;          
    CAscii      m_strPrifix;        
    CAscii      m_strResult;        
    HWND        m_hWnd;             
};
 
 
 
class CUnZipDllHandler : public CArchiverDllHandler
{
    DEFSUPER(CArchiverDllHandler);
public:
 
    CUnZipDllHandler(void) : _super("UnZip32.dll", "UnZip")
    {
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除
            strCmd = "-d ";
            break;
        case EC_Extract: // 抽出
            strCmd = " ";
            break;
        case EC_ExtractDir: // 抽出(Directory付き)
            strCmd = " ";
            break;
        case EC_Attract: // 格納
            strCmd = "";
            break;
        default:
            ASSERT(false);
            break;
        }
        return strCmd;
    }
};
 
 
 
class C7zDllHandler : public CArchiverDllHandler
{
    DEFSUPER(CArchiverDllHandler);
public:
 
    C7zDllHandler(void) : _super("7-zip32.dll", "SevenZip")
    {
    }
 
    int GetArchiveType(LPCSTR lpszArcFile)
    {
        int r;
        return Func(r, "GetArchiveType", lpszArcFile);
    }
    
    bool SetUnicodeMode(bool boIsUtf8)
    {
        BOOL r = boIsUtf8;
        return !! Func(r, "SetUnicodeMode", boIsUtf8);
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除
            strCmd = "d ";
            break;
        case EC_Extract: // 抽出
            strCmd = "e ";
            break;
        case EC_ExtractDir: // 抽出(Directory付き)
            strCmd = "x ";
            break;
        case EC_Attract: // 格納
            strCmd = "a ";
            break;
        default:
            ASSERT(false);
            break;
        }
        return strCmd;
    }
};
 
 
 
class CUnLhaDllHandler : public CArchiverDllHandler
{
    DEFSUPER(CArchiverDllHandler);
public:
 
    CUnLhaDllHandler(void) : _super("UnLha32.dll", "Unlha")
    {
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除
            strCmd = "d ";
            break;
        case EC_Extract: // 抽出
            strCmd = "e ";
            break;
        case EC_ExtractDir: // 抽出(Directory付き)
            strCmd = "x ";
            break;
        case EC_Attract: // 格納
            strCmd = "a -r1 -x1 ";
            break;
        default:
            ASSERT(false);
            break;
        }
        return strCmd;
    }
};
 
 
 
class CCabDllHandler : public CArchiverDllHandler
{
    DEFSUPER(CArchiverDllHandler);
public:
 
    CCabDllHandler(void) : _super("Cab32.dll", "Cab")
    {
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除       -- 未サポート
            break;
        case EC_Extract: // 抽出
            strCmd = "-x -j";
            break;
        case EC_ExtractDir: // 抽出(Directory付き)
            strCmd = "-x ";
            break;
        case EC_Attract: // 格納
            strCmd = "-a -r ";
            break;
        default:
            ASSERT(false);
            break;
        }
        return strCmd;
    }
};
 
 
 
class CTarDllHandler : public CArchiverDllHandler
{
    DEFSUPER(CArchiverDllHandler);
public:
 
    CTarDllHandler(void) : _super("Tar32.dll", "Tar")
    {
    }
 
    virtual CAscii MakeCommandOption(ECommand cmd)
    {
        CAscii strCmd;
        switch ( cmd )
        {
        case EC_Delete: // 削除       -- 未サポート
            break;
        case EC_Extract: // 抽出
            strCmd = "-x ";
            break;
        case EC_ExtractDir: // 抽出(Directory付き)
            strCmd = "-xf ";
            break;
        case EC_Attract: // 格納
            strCmd = "-cf ";
            break;
        default:
            break;
        }
        return strCmd;
    }
};
 
 
 
}; // TNB
 
#if 0
アーカイバDLL    圧縮  N圧縮 解凍  F解凍     更新  検査  一覧  SFX     詳細  削除  注釈  ヘ変 
------------------------------------------------------------------------------------------------------------
7-Zip32.DLL     a       ****    e       x       u       t       l       ****    ****    d       ****    **** 
UNLHA32.DLL     a       u       e       x       f       t       l       s       v       d       c       y 
CAB32.DLL       a       ****    x       x       ****    c,t     l       f       ****    ****    ****    **** 
TAR32.DLL       -cvf    ****    -xvf    -xvf    ****    ****    -tvf    ****    ****    ****    ****    **** 
------------------------------------------------------------------------------------------------------------
UNZIP32.DLL     ****    ****    -x,-xv  -x,-xv  ****    -t      -l,-lv  ****    -v      -d      -z,-Z   **** 
ZIP32J.DLL      -r      -r      ****    ****    -f,-u   ****    ****    -sfx    ****    -d      -z      **** 
UNARJ32J.DLL    ****    ****    e,ev    x,xv    ****    t       l,lv    ****    v       ****    ****    **** 
UNRAR32.DLL     ****    ****    -e      -x      ****    ****    -l      ****    -v      ****    ****    **** 
BGA32.DLL       a       ****    x       x       ****    t       l,lv    s       ****    d       ****    **** 
YZ1.DLL         c       ****    x       x       ****    ****    ****    ****    ****    ****    ****    **** 
UNGCA32.DLL     ****    ****    e,ex    e,ex    ****    t       l       ****    ****    ****    ****    **** 
UNIMP32.DLL     ****    ****    ****    -o      ****    ****    ****    ****    ****    ****    ****    **** 
UNBEL32.DLL     ＜＜コマンドは不要＞＞ 
    備考：N圧縮:新規追加圧縮, F解凍:フォルダ解凍, SFX:自己解凍書庫を作成, へ変:ヘッダ変更, **** は未対応
 
#endif