cabinet_main.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include <fcntl.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "shlwapi.h"
#include "cabinet.h"
#include "wine/debug.h"

Include dependency graph for cabinet_main.c:

Go to the source code of this file.

Macros
#define	NO_SHLWAPI_REG

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (cabinet)
HRESULT WINAPI	DllGetVersion (DLLVERSIONINFO *pdvi)
static void *CDECL	mem_alloc (ULONG cb)
static void CDECL	mem_free (void *memory)
static INT_PTR CDECL	fdi_open (char *pszFile, int oflag, int pmode)
static UINT CDECL	fdi_read (INT_PTR hf, void *pv, UINT cb)
static UINT CDECL	fdi_write (INT_PTR hf, void *pv, UINT cb)
static int CDECL	fdi_close (INT_PTR hf)
static LONG CDECL	fdi_seek (INT_PTR hf, LONG dist, int seektype)
static void	fill_file_node (struct FILELIST *pNode, LPCSTR szFilename)
static BOOL	file_in_list (struct FILELIST *pNode, LPCSTR szFilename, struct FILELIST **pOut)
static INT_PTR CDECL	fdi_notify_extract (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
HRESULT WINAPI	Extract (SESSION *dest, LPCSTR szCabName)

Macro Definition Documentation

NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 29 of file cabinet_main.c.

Function Documentation

DllGetVersion()

HRESULT WINAPI DllGetVersion

(

DLLVERSIONINFO *

pdvi

)

Definition at line 55 of file cabinet_main.c.

{
  WARN("hmmm... not right version number \"5.1.1106.1\"?\n");
 
  if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) return E_INVALIDARG;
 
  pdvi->dwMajorVersion = 5;
  pdvi->dwMinorVersion = 1;
  pdvi->dwBuildNumber = 1106;
  pdvi->dwPlatformID = 1;
 
  return S_OK;
}

Extract()

HRESULT WINAPI Extract	(	SESSION *	dest,
		LPCSTR	szCabName
	)

Definition at line 327 of file cabinet_main.c.

{
    HRESULT res = S_OK;
    HFDI hfdi;
    char *str, *end, *path = NULL, *name = NULL;
 
    TRACE("(%p, %s)\n", dest, debugstr_a(szCabName));
 
    hfdi = FDICreate(mem_alloc,
                     mem_free,
                     fdi_open,
                     fdi_read,
                     fdi_write,
                     fdi_close,
                     fdi_seek,
                     cpuUNKNOWN,
                     &dest->Error);
 
    if (!hfdi)
        return E_FAIL;
 
    if (GetFileAttributesA(dest->Destination) == INVALID_FILE_ATTRIBUTES)
    {
        res = S_OK;
        goto end;
    }
 
    /* split the cabinet name into path + name */
    str = HeapAlloc(GetProcessHeap(), 0, lstrlenA(szCabName)+1);
    if (!str)
    {
        res = E_OUTOFMEMORY;
        goto end;
    }
    lstrcpyA(str, szCabName);
 
    if ((end = strrchr(str, '\\')))
    {
        path = str;
        end++;
        name = HeapAlloc( GetProcessHeap(), 0, strlen(end) + 1 );
        if (!name)
        {
            res = E_OUTOFMEMORY;
            goto end;
        }
        strcpy( name, end );
        *end = 0;
    }
    else
    {
        name = str;
        path = NULL;
    }
 
    dest->FileSize = 0;
 
    if (!FDICopy(hfdi, name, path, 0,
         fdi_notify_extract, NULL, dest))
        res = HRESULT_FROM_WIN32(GetLastError());
 
end:
    HeapFree(GetProcessHeap(), 0, path);
    HeapFree(GetProcessHeap(), 0, name);
    FDIDestroy(hfdi);
    return res;
}

Referenced by CabinetSetEventHandlers().

fdi_close()

static int CDECL fdi_close ( INT_PTR  hf )

static

Definition at line 144 of file cabinet_main.c.

{
    HANDLE handle = (HANDLE) hf;
    return CloseHandle(handle) ? 0 : -1;
}

Referenced by Extract().

fdi_notify_extract()

static INT_PTR CDECL fdi_notify_extract ( FDINOTIFICATIONTYPE  fdint, PFDINOTIFICATION  pfdin  )

static

Definition at line 184 of file cabinet_main.c.

{
    switch (fdint)
    {
        case fdintCOPY_FILE:
        {
            struct FILELIST *fileList, *node = NULL;
            SESSION *pDestination = pfdin->pv;
            LPSTR szFullPath, szDirectory;
            HANDLE hFile = 0;
            DWORD dwSize;
 
            dwSize = lstrlenA(pDestination->Destination) +
                    lstrlenA("\\") + lstrlenA(pfdin->psz1) + 1;
            szFullPath = HeapAlloc(GetProcessHeap(), 0, dwSize);
 
            lstrcpyA(szFullPath, pDestination->Destination);
            lstrcatA(szFullPath, "\\");
            lstrcatA(szFullPath, pfdin->psz1);
 
            /* pull out the destination directory string from the full path */
            dwSize = strrchr(szFullPath, '\\') - szFullPath + 1;
            szDirectory = HeapAlloc(GetProcessHeap(), 0, dwSize);
            lstrcpynA(szDirectory, szFullPath, dwSize);
 
            pDestination->FileSize += pfdin->cb;
 
            if (pDestination->Operation & EXTRACT_FILLFILELIST)
            {
                fileList = HeapAlloc(GetProcessHeap(), 0,
                                     sizeof(struct FILELIST));
 
                fill_file_node(fileList, pfdin->psz1);
                fileList->DoExtract = TRUE;
                fileList->next = pDestination->FileList;
                pDestination->FileList = fileList;
                lstrcpyA(pDestination->CurrentFile, szFullPath);
                pDestination->FileCount++;
            }
 
            if ((pDestination->Operation & EXTRACT_EXTRACTFILES) ||
                file_in_list(pDestination->FilterList, pfdin->psz1, NULL))
            {
        /* find the file node */
                file_in_list(pDestination->FileList, pfdin->psz1, &node);
 
                if (node && !node->DoExtract)
                {
                    HeapFree(GetProcessHeap(), 0, szFullPath);
                    HeapFree(GetProcessHeap(), 0, szDirectory);
                    return 0;
                }
 
                /* create the destination directory if it doesn't exist */
                if (GetFileAttributesA(szDirectory) == INVALID_FILE_ATTRIBUTES)
                {
                    char *ptr;
 
                    for(ptr = szDirectory + strlen(pDestination->Destination)+1; *ptr; ptr++) {
                        if(*ptr == '\\') {
                            *ptr = 0;
                            CreateDirectoryA(szDirectory, NULL);
                            *ptr = '\\';
                        }
                    }
                    CreateDirectoryA(szDirectory, NULL);
                }
 
                hFile = CreateFileA(szFullPath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                                    CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
                if (hFile != INVALID_HANDLE_VALUE && node)
                    node->DoExtract = FALSE;
            }
 
            HeapFree(GetProcessHeap(), 0, szFullPath);
            HeapFree(GetProcessHeap(), 0, szDirectory);
 
            return (INT_PTR) hFile;
        }
 
        case fdintCLOSE_FILE_INFO:
        {
            FILETIME ft;
            FILETIME ftLocal;
            HANDLE handle = (HANDLE) pfdin->hf;
 
            if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
                return FALSE;
 
            if (!LocalFileTimeToFileTime(&ft, &ftLocal))
                return FALSE;
 
            if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
                return FALSE;
 
            CloseHandle(handle);
            return TRUE;
        }
 
        default:
            return 0;
    }
}

Referenced by Extract().

fdi_open()

static INT_PTR CDECL fdi_open ( char *  pszFile, int  oflag, int  pmode  )

static

Definition at line 81 of file cabinet_main.c.

{
    HANDLE handle;
    DWORD dwAccess = 0;
    DWORD dwShareMode = 0;
    DWORD dwCreateDisposition;
 
    switch (oflag & _O_ACCMODE)
    {
        case _O_RDONLY:
            dwAccess = GENERIC_READ;
            dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
            break;
        case _O_WRONLY:
            dwAccess = GENERIC_WRITE;
            dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
            break;
        case _O_RDWR:
            dwAccess = GENERIC_READ | GENERIC_WRITE;
            dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
            break;
    }
 
    if (oflag & _O_CREAT)
    {
        dwCreateDisposition = OPEN_ALWAYS;
        if (oflag & _O_EXCL) dwCreateDisposition = CREATE_NEW;
        else if (oflag & _O_TRUNC) dwCreateDisposition = CREATE_ALWAYS;
    }
    else
    {
        dwCreateDisposition = OPEN_EXISTING;
        if (oflag & _O_TRUNC) dwCreateDisposition = TRUNCATE_EXISTING;
    }
 
    handle = CreateFileA(pszFile, dwAccess, dwShareMode, NULL,
                         dwCreateDisposition, 0, NULL);
 
    return (INT_PTR) handle;
}

Referenced by Extract().

fdi_read()

static UINT CDECL fdi_read ( INT_PTR  hf, void *  pv, UINT  cb  )

static

Definition at line 122 of file cabinet_main.c.

{
    HANDLE handle = (HANDLE) hf;
    DWORD dwRead;
    
    if (ReadFile(handle, pv, cb, &dwRead, NULL))
        return dwRead;
 
    return 0;
}

Referenced by Extract().

fdi_seek()

static LONG CDECL fdi_seek ( INT_PTR  hf, LONG  dist, int  seektype  )

static

Definition at line 150 of file cabinet_main.c.

{
    HANDLE handle = (HANDLE) hf;
    return SetFilePointer(handle, dist, NULL, seektype);
}

Referenced by Extract().

fdi_write()

static UINT CDECL fdi_write ( INT_PTR  hf, void *  pv, UINT  cb  )

static

Definition at line 133 of file cabinet_main.c.

{
    HANDLE handle = (HANDLE) hf;
    DWORD dwWritten;
 
    if (WriteFile(handle, pv, cb, &dwWritten, NULL))
        return dwWritten;
 
    return 0;
}

Referenced by Extract().

file_in_list()

static BOOL file_in_list ( struct FILELIST *  pNode, LPCSTR  szFilename, struct FILELIST **  pOut  )

static

Definition at line 165 of file cabinet_main.c.

{
    while (pNode)
    {
        if (!lstrcmpiA(pNode->FileName, szFilename))
        {
            if (pOut)
                *pOut = pNode;
 
            return TRUE;
        }
 
        pNode = pNode->next;
    }
 
    return FALSE;
}

Referenced by fdi_notify_extract().

fill_file_node()

static void fill_file_node ( struct FILELIST *  pNode, LPCSTR  szFilename  )

static

Definition at line 156 of file cabinet_main.c.

{
    pNode->next = NULL;
    pNode->DoExtract = FALSE;
 
    pNode->FileName = HeapAlloc(GetProcessHeap(), 0, strlen(szFilename) + 1);
    lstrcpyA(pNode->FileName, szFilename);
}

Referenced by fdi_notify_extract().

mem_alloc()

static void *CDECL mem_alloc ( ULONG  cb )

static

Definition at line 71 of file cabinet_main.c.

{
    return HeapAlloc(GetProcessHeap(), 0, cb);
}

mem_free()

static void CDECL mem_free ( void *  memory )

static

Definition at line 76 of file cabinet_main.c.

{
    HeapFree(GetProcessHeap(), 0, memory);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

cabinet

)