cablib.c

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

            break;
        }
    return iResult;
    }

// =================================================================
// CABINET MANAGEMENT
// =================================================================

int WINAPI LoadCabinetHeader (PBYTE       pbCabinet,
                              PCAB_HEADER pch)
    {
    int hf;

    if ((hf = FDIOpen (pbCabinet, _O_RDONLY, 0)) != -1)
        {
        if ((FDIRead (hf, pch, CAB_HEADER_) != CAB_HEADER_  ) ||
            (pch->sig                       != CAB_SIGNATURE) ||
            (pch->version                   != CAB_VERSION  ) ||
            (pch->cFolders                  == 0            ) ||
            (pch->cFiles                    == 0            ) ||
            (pch->coffFiles                 <= CAB_HEADER_  ))
            {
            FDIClose (hf);
            hf = -1;
            }
        }
    return hf;
    }

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

BOOL WINAPI TestCabinetHeader (PBYTE pbCabinet)
    {
    int        hf;
    CAB_HEADER ch;

    if ((hf = LoadCabinetHeader (pbCabinet, &ch)) != -1)
        {
        FDIClose (hf);
        }
    return (hf != -1);
    }

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

BOOL WINAPI ReadCabinetBlock (int   hf,
                              PBYTE pbData,
                              DWORD dOffset,
                              DWORD dTotal)
    {
    return ((dOffset <= dTotal) &&
            (FDIRead (hf, pbData+dOffset, dTotal-dOffset)
             == dTotal-dOffset));
    }

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

DWORD WINAPI CloseCabinet (HCABINET hc)
    {
    DWORD dOffset = 0;

    if (hc != NULL)
        {
        dOffset = hc->dOffset;
        if (hc->hf     != -1)   FDIClose  (hc->hf);
        if (hc->pbData != NULL) LocalFree (hc->pbData);
        LocalFree (hc);
        }
    return dOffset;
    }

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

HCABINET WINAPI OpenCabinet (PBYTE pbCabinet)
    {
    HCABINET hc;
    PBYTE    pbData;
    DWORD    i;
    BOOL     fOK = FALSE;

    hc = LocalAlloc (LMEM_FIXED, CAB_CONTROL_);

    if (hc != NULL)
        {
        hc->hf = -1;
        pbData = LocalAlloc (LMEM_FIXED, CAB_HEADER_);

        if (pbData != NULL)
            {
            hc->hf = LoadCabinetHeader (pbCabinet,
                                        (PCAB_HEADER) pbData);

            if (hc->hf != -1)
                {
                hc->dFileList = ((PCAB_HEADER) pbData)->coffFiles;

                pbData  = LocalReAlloc (pbData,
                                        hc->dFileList,
                                        LMEM_MOVEABLE);

                if ((pbData != NULL) &&
                    ReadCabinetBlock (hc->hf,
                                      pbData,
                                      CAB_HEADER_,
                                      hc->dFileList))
                    {
                    hc->dExtraData = i = CAB_HEADER_;

                    if (((PCAB_HEADER) pbData)->flags &
                        CAB_FLAG_RESERVE)
                        {
                        hc->dReserve  = *((PDWORD) (pbData+i));
                        i            += sizeof (DWORD);

                        hc->pReserve  = (PVOID) (pbData+i);
                        i            += hc->dReserve;
                        }
                    else
                        {
                        hc->dReserve = 0;
                        hc->pReserve = NULL;
                        }
                    hc->dCabList = i;

                    if (((PCAB_HEADER) pbData)->flags &
                        CAB_FLAG_HASPREV)
                        {
                        hc->pbPrevCab  = pbData+i;
                        while ((i < hc->dFileList) &&
                               (pbData [i++]));

                        hc->pbPrevDisk = pbData+i;
                        while ((i < hc->dFileList) &&
                               (pbData [i++]));
                        }
                    else
                        {
                        hc->pbPrevCab  = abNone;
                        hc->pbPrevDisk = abNull;
                        }
                    if (((PCAB_HEADER) pbData)->flags &
                        CAB_FLAG_HASNEXT)
                        {
                        hc->pbNextCab  = pbData+i;
                        while ((i < hc->dFileList) &&
                               (pbData [i++]));

                        hc->pbNextDisk = pbData+i;
                        while ((i < hc->dFileList) &&
                               (pbData [i++]));
                        }
                    else
                        {
                        hc->pbNextCab  = abNone;
                        hc->pbNextDisk = abNull;
                        }
                    if (i+CAB_FOLDER_ <= hc->dFileList)
                        {
                        hc->dFolderList = i;
                        hc->dFileData   = ((PCAB_FOLDER) (pbData+i))
                                          ->coffCabStart;

                        pbData  = LocalReAlloc (pbData,
                                                hc->dFileData,
                                                LMEM_MOVEABLE);

                        if ((pbData != NULL) &&
                            ReadCabinetBlock (hc->hf,
                                              pbData,
                                              hc->dFileList,
                                              hc->dFileData))
                            {
                            fOK = TRUE;
                            }
                        }
                    }
                }
            }
        if (fOK)
            {
            hc->dSetId     = ((PCAB_HEADER) pbData)->setID;
            hc->dCabNumber = ((PCAB_HEADER) pbData)->iCabinet;
            hc->dFolders   = ((PCAB_HEADER) pbData)->cFolders;
            hc->dFiles     = ((PCAB_HEADER) pbData)->cFiles;
            hc->dCabSize   = ((PCAB_HEADER) pbData)->cbCabinet;
            hc->dOffset    = hc->dFileList;
            hc->dSize      = hc->dFileData;
            hc->pbData     = pbData;
            }
        else
            {
            CloseCabinet (hc);
            hc = NULL;
            }
        }
    return hc;
    }

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

BOOL WINAPI ScanCabinet (HCABINET   hc,
                         PCAB_ENTRY pce,
                         PBYTE      pbEntry,
                         DWORD      dBytes)
    {
    DWORD i;
    BOOL  fOK = FALSE;

    if (hc->dFiles)
        {
        i = hc->dOffset + CAB_ENTRY_;
        while ((i < hc->dSize) && hc->pbData [i]) i++;
        if (i < hc->dSize)
            {
            if (dBytes)
                {
                lstrcpyn (pbEntry,
                          hc->pbData + hc->dOffset + CAB_ENTRY_,
                          dBytes);
                }
            CopyMemory (pce, hc->pbData + hc->dOffset, CAB_ENTRY_);
            hc->dFiles--;
            hc->dOffset = i+1;
            fOK = TRUE;
            }
        }
    return fOK;
    }

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

BOOL WINAPI FindCabinetEntry (PBYTE      pbCabinet,
                              PBYTE      pbEntry,
                              DWORD      dOffset,
                              PCAB_ENTRY pce)
    {
    PBYTE pbData;
    int   hf;
    DWORD i, n;
    BOOL  fOK = FALSE;

    if (dOffset && (dOffset != MAXDWORD))
        {
        if ((pbData = LocalAlloc (LMEM_FIXED, dOffset)) != NULL)
            {
            if ((hf = FDIOpen (pbCabinet, _O_RDONLY, 0)) != -1)
                {
                if (FDIRead (hf, pbData, dOffset) == dOffset)
                    {
                    i = ((PCAB_HEADER) pbData)->coffFiles;
                    n = ((PCAB_HEADER) pbData)->cFiles;

                    while ((!fOK) && (n--))
                        {
                        if (!lstrcmp (pbData+i+CAB_ENTRY_, pbEntry))
                            {
                            CopyMemory (pce, pbData+i, CAB_ENTRY_);
                            fOK = TRUE;
                            }
                        else
                            {
                            i += (CAB_ENTRY_ +
                                  lstrlen (pbData+i+CAB_ENTRY_) +
                                  1);
                            }
                        }
                    }
                FDIClose (hf);
                }
            LocalFree (pbData);
            }
        }
    return fOK;
    }

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

BOOL WINAPI ExtractFileFromCabinet (HWND  hWnd,
                                    PBYTE pbCabinet,
                                    PBYTE pbEntry,
                                    PBYTE pbProfile,
                                    PBYTE pbSection,
                                    PBYTE pbKey)
    {
    OPENFILENAME ofn;
    EXTRACT_FILE ef;
    HCURSOR      hCursor;
    BYTE         abDirectory [MAX_PATH];
    BYTE         abPath      [MAX_PATH];
    BYTE         abFile      [MAX_PATH];
    BOOL         fOK = FALSE;

    GetCurrentDirectory (MAX_PATH, abDirectory);

    GetDefaultDestination (pbProfile,
                           pbSection,
                           pbKey,
                           abPath,
                           MAX_PATH);

    lstrcpyn (abFile, pbEntry, MAX_PATH);

    ofn.lStructSize       = sizeof (OPENFILENAME);
    ofn.hInstance         = hInst;
    ofn.hwndOwner         = hWnd;
    ofn.lpstrFilter       = "Unspecified\0*\0";
    ofn.lpstrCustomFilter = NULL;
    ofn.nMaxCustFilter    = 0;
    ofn.nFilterIndex      = 1;
    ofn.lpstrFile         = abFile;
    ofn.nMaxFile          = MAX_PATH;
    ofn.lpstrFileTitle    = NULL;
    ofn.nMaxFileTitle     = 0;
    ofn.lpstrInitialDir   = (abPath [0] ? abPath : NULL);
    ofn.lpstrTitle        = abTitleSaveFile;
    ofn.nFileOffset       = 0;
    ofn.nFileExtension    = 0;
    ofn.lpstrDefExt       = NULL;
    ofn.lCustData         = (LPARAM) NULL;
    ofn.lpfnHook          = NULL;
    ofn.lpTemplateName    = NULL;
    ofn.Flags             = OFN_OVERWRITEPROMPT |
                            OFN_HIDEREADONLY    |
                            OFN_EXPLORER;

    fOK = GetSaveFileName (&ofn);
    SetCurrentDirectory (abDirectory);

    if (fOK)
        {
        if (NormalizePath (abDirectory, MAX_PATH))
            {
            hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
            UpdateWindow (hWnd);

            ef.hWnd    = hWnd;
            ef.pbEntry = pbEntry;
            ef.pbFile  = abFile;

            fOK = FDICopy (hfdi,
                           pbCabinet,
                           abDirectory,
                           0,
                           FDIExtract,
                           NULL,
                           &ef);

            SetCursor (hCursor);

            if (!fOK)
                {
                printfMessage (hWnd,
                               MB_ICONERROR | MB_OK,
                               abMainError,
                               "%s \"%s\"",
                               abErrorExtract,
                               pbEntry);

                DeleteFile (abFile);
                }
            }
        SetDefaultDestination (pbProfile,
                               pbSection,
                               pbKey,
                               RemoveFileName (abFile));
        }
    return fOK;
    }

// =================================================================
// DLL ENTRY POINT
// =================================================================

BOOL WINAPI DllMain (HINSTANCE hInstance,
                     DWORD     dReason,
                     PVOID     pReserved)
    {
    switch (dReason)
        {
        case DLL_PROCESS_ATTACH:

            hInst = hInstance;

            hfdi = FDICreate (FDIAlloc,
                              FDIFree,
                              FDIOpen,
                              FDIRead,
                              FDIWrite,
                              FDIClose,
                              FDISeek,
                              cpuUNKNOWN,
                              &erf);

            return (hfdi != NULL);

        case DLL_PROCESS_DETACH:

            if (hfdi != NULL)
                {
                FDIDestroy (hfdi);
                hfdi = NULL;
                }
            return TRUE;

        default:

            return TRUE;
        }
    }

// =================================================================
// END OF PROGRAM
// =================================================================