cablib.c

一个关于windows内置cab文件的源码,能够将cab文件解压缩

// _________________________________________________________________
//
//                           SBS CabLib.c
//             Windows Cabinet Management Library V1.00
//                   01-20-1997 Sven B. Schreiber
//                          [e-mail]
// _________________________________________________________________

#include <windows.h>
#include <fcntl.h>
#include <stat.h>
#include <fdi.h>
#include "CabLib.h"

// =================================================================
// REVISION HISTORY
// =================================================================

/*

01-20-1997  V1.00  SBS  Original version.

*/

// =================================================================
// GLOBAL VARIABLES
// =================================================================

HINSTANCE hInst = NULL;
HFDI      hfdi  = NULL;
ERF       erf;

// =================================================================
// GLOBAL STRINGS
// =================================================================

BYTE abMainError     [] = "CabLib Error";

BYTE abTitleSaveFile [] = "Save File";
BYTE abNone          [] = "<none>";
BYTE abNull          [] = "";

BYTE abErrorCreate   [] = "Unable to create file";
BYTE abErrorOpen     [] = "Unable to open file";
BYTE abErrorClose    [] = "Unable to close file";
BYTE abErrorExtract  [] = "Unable to extract file";

// =================================================================
// AUXILIARY ROUTINES
// =================================================================

PBYTE WINAPI GetFileName (PBYTE pbPath)
    {
    DWORD i, j;

    j = i = (pbPath [0] ? (pbPath [1] == ':' ? 2 : 0) : 0);

    while (pbPath [i++])
        {
        if (pbPath [i-1] == '\\') j = i;
        }
    return pbPath+j;
    }

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

PBYTE WINAPI RemoveFileName (PBYTE pbPath)
    {
    PBYTE pbFileName;
    DWORD i;

    i = (pbPath [0] ? (pbPath [1] == ':' ? 2 : 0) : 0);
    pbFileName = GetFileName (pbPath+i);

    if ((pbFileName != (pbPath+i)) && (pbFileName [-1] == '\\'))
        {
        pbFileName--;
        }
    if ((pbFileName == (pbPath+i)) && (pbFileName [0] == '\\'))
        {
        pbFileName++;
        }
    pbFileName [0] = 0;
    return pbPath;
    }

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

BOOL WINAPI GetDefaultDestination (PBYTE pbProfile,
                                   PBYTE pbSection,
                                   PBYTE pbKey,
                                   PBYTE pbPath,
                                   DWORD dBytes)
    {
    DWORD dSize;

    if (dBytes || (dSize = 0))
        {
        dSize = GetPrivateProfileString (pbSection,
                                         pbKey,
                                         abNull,
                                         pbPath,
                                         dBytes,
                                         pbProfile);
        }
    return (dSize != 0);
    }

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

BOOL WINAPI SetDefaultDestination (PBYTE pbProfile,
                                   PBYTE pbSection,
                                   PBYTE pbKey,
                                   PBYTE pbPath)
    {
    return WritePrivateProfileString (pbSection,
                                      pbKey,
                                      pbPath,
                                      pbProfile);
    }

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

BOOL WINAPI NormalizePath (PBYTE pbPath,
                           DWORD dBytes)
    {
    DWORD n;
    BOOL  fOK = TRUE;

    if ((n = lstrlen (pbPath)) &&
        (pbPath [n-1] != '\\') &&
        (fOK = ((n+1) < dBytes)))
        {
        pbPath [n]   = '\\';
        pbPath [n+1] = 0;
        }
    return fOK;
    }

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

int printfMessage (HWND  hWnd,
                   UINT  uType,
                   PBYTE pbCaption,
                   PBYTE pbFormat,
                   ...)
    {
    BYTE abBuffer [MAX_MESSAGE];

    wvsprintf (abBuffer, pbFormat, (PVOID) ((&pbFormat)+1));
    return MessageBox (hWnd, abBuffer, pbCaption, uType);
    }

// =================================================================
// FDI CALLBACKS
// =================================================================

PVOID DIAMONDAPI FDIAlloc (ULONG cb)
    {
    return LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, cb);
    }

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

void DIAMONDAPI FDIFree (PVOID pv)
    {
    if (pv != NULL) LocalFree (pv);
    return;
    }

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

int DIAMONDAPI FDIOpen (PSTR pszFile,
                        int  oflag,
                        int  pmode)
    {
    HANDLE hFile;
    DWORD  dRwMask  = (_O_RDONLY | _O_WRONLY | _O_RDWR);
    DWORD  dAccess  = 0;
    DWORD  dOptions = 0;
    DWORD  dFlags   = 0;

    if ((oflag & dRwMask) == _O_RDONLY)
        {
        dAccess |= GENERIC_READ;
        }
    if ((oflag & dRwMask) == _O_WRONLY)
        {
        dAccess |= GENERIC_WRITE;
        }
    if ((oflag & dRwMask) == _O_RDWR)
        {
        dAccess |= (GENERIC_READ | GENERIC_WRITE);
        }
    if (oflag & _O_CREAT)
        {
        dOptions |= (oflag & _O_EXCL ? CREATE_NEW : OPEN_ALWAYS);

        if (oflag & _O_SHORT_LIVED)
            {
            dFlags |= FILE_ATTRIBUTE_TEMPORARY;
            }
        if (oflag & _O_TEMPORARY)
            {
            dFlags |= (FILE_ATTRIBUTE_TEMPORARY |
                       FILE_FLAG_DELETE_ON_CLOSE);
            }
        if (pmode & _S_IWRITE)
            {
            dFlags |= FILE_ATTRIBUTE_NORMAL;
            }
        else
            {
            dFlags |= FILE_ATTRIBUTE_READONLY;
            }
        }
    else
        {
        dOptions |= OPEN_EXISTING;
        }
    if (oflag & _O_RANDOM)
        {
        dFlags |= FILE_FLAG_RANDOM_ACCESS;
        }
    if (oflag & _O_SEQUENTIAL)
        {
        dFlags |= FILE_FLAG_SEQUENTIAL_SCAN;
        }
    hFile = CreateFile (pszFile,
                        dAccess,
                        FILE_SHARE_READ,
                        NULL,
                        dOptions,
                        dFlags,
                        NULL);

    if ((hFile != INVALID_HANDLE_VALUE) && (oflag & _O_TRUNC))
        {
        if (!SetEndOfFile (hFile))
            {
            CloseHandle (hFile);
            hFile = INVALID_HANDLE_VALUE;
            }
        }
    if ((hFile != INVALID_HANDLE_VALUE) && (oflag & _O_APPEND))
        {
        if (SetFilePointer (hFile, 0, NULL, FILE_END) == MAXDWORD)
            {
            CloseHandle (hFile);
            hFile = INVALID_HANDLE_VALUE;
            }
        }
    return (hFile != INVALID_HANDLE_VALUE ? (int) hFile : -1);
    }

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

UINT DIAMONDAPI FDIRead (int   hf,
                         PVOID pv,
                         UINT  cb)
    {
    DWORD n;

    return (hf == -1
            ? (UINT) -1
            : (!cb
               ? 0
               : (ReadFile ((HANDLE) hf, pv, cb, &n, NULL)
                  ? n
                  : (UINT) -1)));
    }

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

UINT DIAMONDAPI FDIWrite (int   hf,
                          PVOID pv,
                          UINT  cb)
    {
    DWORD n;

    return (hf == -1
            ? (UINT) -1
            : (!cb
               ? 0
               : (WriteFile ((HANDLE) hf, pv, cb, &n, NULL)
                  ? n
                  : (UINT) -1)));
    }

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

int DIAMONDAPI FDIClose (int hf)
    {
    return (hf == -1
            ? -1
            : (CloseHandle ((HANDLE) hf) ? 0 : -1));
    }

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

long DIAMONDAPI FDISeek (int  hf,
                         long dist,
                         int  seektype)
    {
    DWORD dMethod = 0;
    BOOL  fOK     = (hf != -1);

    switch (seektype)
        {
        case SEEK_SET: dMethod = FILE_BEGIN;   break;
        case SEEK_CUR: dMethod = FILE_CURRENT; break;
        case SEEK_END: dMethod = FILE_END;     break;
        default:       fOK     = FALSE;        break;
        }
    return (!fOK
            ? -1
            : SetFilePointer ((HANDLE) hf, dist, NULL, dMethod));
    }

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

int DIAMONDAPI FDIExtract (FDINOTIFICATIONTYPE fdint,
                           PFDINOTIFICATION    pfdin)
    {
    FILETIME ft, lft;
    BYTE     abFile [MAX_PATH];
    int      hf, iResult;

    switch (fdint)
        {
        case fdintCOPY_FILE:

            if (lstrcmpi (pfdin->psz1,
                          ((PEXTRACT_FILE) pfdin->pv)->pbEntry))
                {
                iResult = CAB_NOTIFY_SKIP;
                }
            else
                {
                hf = FDIOpen (((PEXTRACT_FILE) pfdin->pv)->pbFile,
                              _O_RDWR | _O_CREAT | _O_TRUNC,
                              _S_IREAD | _S_IWRITE);
                if (hf != -1)
                    {
                    iResult = hf;
                    }
                else
                    {
                    printfMessage
                        (((PEXTRACT_FILE) pfdin->pv)->hWnd,
                          MB_ICONERROR | MB_OK,
                          abMainError,
                          "%s \"%s\"",
                          abErrorCreate,
                          ((PEXTRACT_FILE) pfdin->pv)->pbFile);

                    iResult = CAB_NOTIFY_ABORT;
                    }
                }
            break;

        case fdintNEXT_CABINET:

            if (lstrlen (pfdin->psz3) + lstrlen (pfdin->psz1)
                < MAX_PATH)
                {
                lstrcpy (abFile, pfdin->psz3);
                lstrcat (abFile, pfdin->psz1);
                hf = FDIOpen (abFile, _O_RDONLY, 0);
                }
            else
                {
                hf = -1;
                }
            if (hf != -1)
                {
                FDIClose (hf);
                iResult = CAB_NOTIFY_OK;
                }
            else
                {
                printfMessage (((PEXTRACT_FILE) pfdin->pv)->hWnd,
                               MB_ICONERROR | MB_OK,
                               abMainError,
                               "%s \"%s%s\"",
                               abErrorOpen,
                               pfdin->psz3,
                               pfdin->psz1);

                iResult = CAB_NOTIFY_ABORT;
                }
            break;

        case fdintCLOSE_FILE_INFO:

            DosDateTimeToFileTime (pfdin->date, pfdin->time, &lft);
            LocalFileTimeToFileTime (&lft, &ft);
            SetFileTime ((HANDLE) pfdin->hf, &ft, &ft, &ft);

            if (FDIClose (pfdin->hf) == -1)
                {
                printfMessage (((PEXTRACT_FILE) pfdin->pv)->hWnd,
                               MB_ICONERROR | MB_OK,
                               abMainError,
                               "%s \"%s\"",
                               abErrorClose,
                               ((PEXTRACT_FILE) pfdin->pv)->pbFile);
                }
            iResult = CAB_NOTIFY_OK;
            break;

        default:

            iResult = CAB_NOTIFY_OK;