files.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "winnls.h"
#include "winver.h"
#include "winternl.h"
#include "setupapi.h"
#include "advpub.h"
#include "fdi.h"
#include "wine/debug.h"
#include "advpack_private.h"

Include dependency graph for files.c:

Go to the source code of this file.

Classes
struct	FILELIST
struct	SESSION
struct	tagLANGANDCODEPAGE

Macros
#define	ROOT_LENGTH   3
#define	EXTRACT_FILLFILELIST   0x00000001
#define	EXTRACT_EXTRACTFILES   0x00000002

Typedefs
typedef struct tagLANGANDCODEPAGE	LANGANDCODEPAGE

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advpack)
static LPWSTR	ansi_to_unicode_list (LPCSTR ansi_list)
HRESULT WINAPI	AddDelBackupEntryA (LPCSTR lpcszFileList, LPCSTR lpcszBackupDir, LPCSTR lpcszBaseName, DWORD dwFlags)
HRESULT WINAPI	AddDelBackupEntryW (LPCWSTR lpcszFileList, LPCWSTR lpcszBackupDir, LPCWSTR lpcszBaseName, DWORD dwFlags)
static UINT CALLBACK	pQuietQueueCallback (PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
static UINT CALLBACK	pQueueCallback (PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
HRESULT WINAPI	AdvInstallFileA (HWND hwnd, LPCSTR lpszSourceDir, LPCSTR lpszSourceFile, LPCSTR lpszDestDir, LPCSTR lpszDestFile, DWORD dwFlags, DWORD dwReserved)
HRESULT WINAPI	AdvInstallFileW (HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSourceFile, LPCWSTR lpszDestDir, LPCWSTR lpszDestFile, DWORD dwFlags, DWORD dwReserved)
static HRESULT	DELNODE_recurse_dirtree (LPWSTR fname, DWORD flags)
HRESULT WINAPI	DelNodeA (LPCSTR pszFileOrDirName, DWORD dwFlags)
HRESULT WINAPI	DelNodeW (LPCWSTR pszFileOrDirName, DWORD dwFlags)
HRESULT WINAPI	DelNodeRunDLL32A (HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
HRESULT WINAPI	DelNodeRunDLL32W (HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
static	HRESULT (WINAPI *pExtract)(SESSION *
static LPSTR	convert_file_list (LPCSTR FileList, DWORD *dwNumFiles)
static void	free_file_node (struct FILELIST *pNode)
static BOOL	file_in_list (LPCSTR szFile, LPCSTR szFileList)
static DWORD	fill_file_list (SESSION *session, LPCSTR szCabName, LPCSTR szFileList)
static void	free_file_list (SESSION *session)
HRESULT WINAPI	ExtractFilesA (LPCSTR CabName, LPCSTR ExpandDir, DWORD Flags, LPCSTR FileList, LPVOID LReserved, DWORD Reserved)
HRESULT WINAPI	ExtractFilesW (LPCWSTR CabName, LPCWSTR ExpandDir, DWORD Flags, LPCWSTR FileList, LPVOID LReserved, DWORD Reserved)
HRESULT WINAPI	FileSaveMarkNotExistA (LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName)
HRESULT WINAPI	FileSaveMarkNotExistW (LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName)
HRESULT WINAPI	FileSaveRestoreA (HWND hDlg, LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName, DWORD dwFlags)
HRESULT WINAPI	FileSaveRestoreW (HWND hDlg, LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName, DWORD dwFlags)
HRESULT WINAPI	FileSaveRestoreOnINFA (HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF, LPCSTR pszSection, LPCSTR pszBackupDir, LPCSTR pszBaseBackupFile, DWORD dwFlags)
HRESULT WINAPI	FileSaveRestoreOnINFW (HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF, LPCWSTR pszSection, LPCWSTR pszBackupDir, LPCWSTR pszBaseBackupFile, DWORD dwFlags)
HRESULT WINAPI	GetVersionFromFileA (LPCSTR Filename, LPDWORD MajorVer, LPDWORD MinorVer, BOOL Version)
HRESULT WINAPI	GetVersionFromFileW (LPCWSTR Filename, LPDWORD MajorVer, LPDWORD MinorVer, BOOL Version)
HRESULT WINAPI	GetVersionFromFileExA (LPCSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion)
HRESULT WINAPI	GetVersionFromFileExW (LPCWSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion)

Variables
static	LPCSTR

Macro Definition Documentation

EXTRACT_EXTRACTFILES

#define EXTRACT_EXTRACTFILES   0x00000002

Definition at line 518 of file files.c.

EXTRACT_FILLFILELIST

#define EXTRACT_FILLFILELIST   0x00000001

Definition at line 517 of file files.c.

ROOT_LENGTH

#define ROOT_LENGTH   3

Definition at line 159 of file files.c.

Typedef Documentation

LANGANDCODEPAGE

typedef struct tagLANGANDCODEPAGE LANGANDCODEPAGE

Function Documentation

AddDelBackupEntryA()

HRESULT WINAPI AddDelBackupEntryA	(	LPCSTR	lpcszFileList,
		LPCSTR	lpcszBackupDir,
		LPCSTR	lpcszBaseName,
		DWORD	dwFlags
	)

Definition at line 59 of file files.c.

{
    UNICODE_STRING backupdir, basename;
    LPWSTR filelist;
    LPCWSTR backup;
    HRESULT res;
 
    TRACE("(%s, %s, %s, %ld)\n", debugstr_a(lpcszFileList),
          debugstr_a(lpcszBackupDir), debugstr_a(lpcszBaseName), dwFlags);
 
    if (lpcszFileList)
        filelist = ansi_to_unicode_list(lpcszFileList);
    else
        filelist = NULL;
 
    RtlCreateUnicodeStringFromAsciiz(&backupdir, lpcszBackupDir);
    RtlCreateUnicodeStringFromAsciiz(&basename, lpcszBaseName);
 
    if (lpcszBackupDir)
        backup = backupdir.Buffer;
    else
        backup = NULL;
 
    res = AddDelBackupEntryW(filelist, backup, basename.Buffer, dwFlags);
 
    free(filelist);
 
    RtlFreeUnicodeString(&backupdir);
    RtlFreeUnicodeString(&basename);
 
    return res;
}

Referenced by FileSaveMarkNotExistA().

AddDelBackupEntryW()

HRESULT WINAPI AddDelBackupEntryW	(	LPCWSTR	lpcszFileList,
		LPCWSTR	lpcszBackupDir,
		LPCWSTR	lpcszBaseName,
		DWORD	dwFlags
	)

Definition at line 117 of file files.c.

{
    WCHAR szIniPath[MAX_PATH];
    LPCWSTR szString = NULL;
 
    TRACE("(%s, %s, %s, %ld)\n", debugstr_w(lpcszFileList),
          debugstr_w(lpcszBackupDir), debugstr_w(lpcszBaseName), dwFlags);
 
    if (!lpcszFileList || !*lpcszFileList)
        return S_OK;
 
    if (lpcszBackupDir)
        lstrcpyW(szIniPath, lpcszBackupDir);
    else
        GetWindowsDirectoryW(szIniPath, MAX_PATH);
 
    lstrcatW(szIniPath, L"\\");
    lstrcatW(szIniPath, lpcszBaseName);
    lstrcatW(szIniPath, L".ini");
 
    SetFileAttributesW(szIniPath, FILE_ATTRIBUTE_NORMAL);
 
    if (dwFlags & AADBE_ADD_ENTRY)
        szString = L"-1,0,0,0,0,0,-1";
    else if (dwFlags & AADBE_DEL_ENTRY)
        szString = NULL;
 
    /* add or delete the INI entries */
    while (*lpcszFileList)
    {
        WritePrivateProfileStringW(L"backup", lpcszFileList, szString, szIniPath);
        lpcszFileList += lstrlenW(lpcszFileList) + 1;
    }
 
    /* hide the INI file */
    SetFileAttributesW(szIniPath, FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN);
 
    return S_OK;
}

Referenced by AddDelBackupEntryA(), and FileSaveMarkNotExistW().

AdvInstallFileA()

HRESULT WINAPI AdvInstallFileA	(	HWND	hwnd,
		LPCSTR	lpszSourceDir,
		LPCSTR	lpszSourceFile,
		LPCSTR	lpszDestDir,
		LPCSTR	lpszDestFile,
		DWORD	dwFlags,
		DWORD	dwReserved
	)

Definition at line 188 of file files.c.

{
    UNICODE_STRING sourcedir, sourcefile;
    UNICODE_STRING destdir, destfile;
    HRESULT res;
 
    TRACE("(%p, %s, %s, %s, %s, %ld, %ld)\n", hwnd, debugstr_a(lpszSourceDir),
          debugstr_a(lpszSourceFile), debugstr_a(lpszDestDir),
          debugstr_a(lpszDestFile), dwFlags, dwReserved);
 
    if (!lpszSourceDir || !lpszSourceFile || !lpszDestDir)
        return E_INVALIDARG;
 
    RtlCreateUnicodeStringFromAsciiz(&sourcedir, lpszSourceDir);
    RtlCreateUnicodeStringFromAsciiz(&sourcefile, lpszSourceFile);
    RtlCreateUnicodeStringFromAsciiz(&destdir, lpszDestDir);
    RtlCreateUnicodeStringFromAsciiz(&destfile, lpszDestFile);
 
    res = AdvInstallFileW(hwnd, sourcedir.Buffer, sourcefile.Buffer,
                          destdir.Buffer, destfile.Buffer, dwFlags, dwReserved);
 
    RtlFreeUnicodeString(&sourcedir);
    RtlFreeUnicodeString(&sourcefile);
    RtlFreeUnicodeString(&destdir);
    RtlFreeUnicodeString(&destfile);
 
    return res;
}

AdvInstallFileW()

HRESULT WINAPI AdvInstallFileW	(	HWND	hwnd,
		LPCWSTR	lpszSourceDir,
		LPCWSTR	lpszSourceFile,
		LPCWSTR	lpszDestDir,
		LPCWSTR	lpszDestFile,
		DWORD	dwFlags,
		DWORD	dwReserved
	)

Definition at line 241 of file files.c.

{
    PSP_FILE_CALLBACK_W pFileCallback;
    LPWSTR szDestFilename;
    LPCWSTR szPath;
    WCHAR szRootPath[ROOT_LENGTH];
    DWORD dwLastError;
    HSPFILEQ fileQueue;
    PVOID pContext;
 
    TRACE("(%p, %s, %s, %s, %s, %ld, %ld)\n", hwnd, debugstr_w(lpszSourceDir),
          debugstr_w(lpszSourceFile), debugstr_w(lpszDestDir),
          debugstr_w(lpszDestFile), dwFlags, dwReserved);
 
    if (!lpszSourceDir || !lpszSourceFile || !lpszDestDir)
        return E_INVALIDARG;
        
    fileQueue = SetupOpenFileQueue();
    if (fileQueue == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    pContext = NULL;
    dwLastError = ERROR_SUCCESS;
 
    lstrcpynW(szRootPath, lpszSourceDir, ROOT_LENGTH);
    szPath = lpszSourceDir + ROOT_LENGTH;
 
    /* use lpszSourceFile as destination filename if lpszDestFile is NULL */
    szDestFilename = wcsdup(lpszDestFile ? lpszDestFile : lpszSourceFile);
 
    /* add the file copy operation to the setup queue */
    if (!SetupQueueCopyW(fileQueue, szRootPath, szPath, lpszSourceFile, NULL,
                         NULL, lpszDestDir, szDestFilename, dwFlags))
    {
        dwLastError = GetLastError();
        goto done;
    }
 
    pContext = SetupInitDefaultQueueCallbackEx(hwnd, INVALID_HANDLE_VALUE,
                                               0, 0, NULL);
    if (!pContext)
    {
        dwLastError = GetLastError();
        goto done;
    }
 
    /* don't output anything for AIF_QUIET */
    if (dwFlags & AIF_QUIET)
        pFileCallback = pQuietQueueCallback;
    else
        pFileCallback = pQueueCallback;
 
    /* perform the file copy */
    if (!SetupCommitFileQueueW(hwnd, fileQueue, pFileCallback, pContext))
    {
        dwLastError = GetLastError();
        goto done;
    }
 
done:
    SetupTermDefaultQueueCallback(pContext);
    SetupCloseFileQueue(fileQueue);
 
    free(szDestFilename);
 
    return HRESULT_FROM_WIN32(dwLastError);
}

Referenced by AdvInstallFileA().

ansi_to_unicode_list()

static LPWSTR ansi_to_unicode_list ( LPCSTR  ansi_list )

static

Definition at line 40 of file files.c.

{
    DWORD len, wlen = 0;
    LPWSTR list;
    LPCSTR ptr = ansi_list;
 
    while (*ptr) ptr += lstrlenA(ptr) + 1;
    len = ptr + 1 - ansi_list;
    wlen = MultiByteToWideChar(CP_ACP, 0, ansi_list, len, NULL, 0);
    list = malloc(wlen * sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, ansi_list, len, list, wlen);
    return list;
}

Referenced by AddDelBackupEntryA().

convert_file_list()

static LPSTR convert_file_list ( LPCSTR  FileList, DWORD *  dwNumFiles  )

static

Definition at line 543 of file files.c.

{
    DWORD dwLen;
    const char *first = FileList;
    const char *last = FileList + strlen(FileList) - 1;
    LPSTR szConvertedList, temp;
    
    /* any number of these chars before the list is OK */
    while (first < last && (*first == ' ' || *first == '\t' || *first == ':'))
        first++;
 
    /* any number of these chars after the list is OK */
    while (last > first && (*last == ' ' || *last == '\t' || *last == ':'))
        last--;
 
    if (first == last)
        return NULL;
 
    dwLen = last - first + 3; /* room for double-null termination */
    szConvertedList = malloc(dwLen);
    lstrcpynA(szConvertedList, first, dwLen - 1);
    szConvertedList[dwLen - 1] = '\0';
 
    /* empty list */
    if (!szConvertedList[0])
    {
        free(szConvertedList);
        return NULL;
    }
        
    *dwNumFiles = 1;
 
    /* convert the colons to double-null termination */
    temp = szConvertedList;
    while (*temp)
    {
        if (*temp == ':')
        {
            *temp = '\0';
            (*dwNumFiles)++;
        }
 
        temp++;
    }
 
    return szConvertedList;
}

Referenced by ExtractFilesA().

DELNODE_recurse_dirtree()

static HRESULT DELNODE_recurse_dirtree ( LPWSTR  fname, DWORD  flags  )

static

Definition at line 311 of file files.c.

{
    DWORD fattrs = GetFileAttributesW(fname);
    HRESULT ret = E_FAIL;
 
    if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
    {
        HANDLE hFindFile;
        WIN32_FIND_DATAW w32fd;
        BOOL done = TRUE;
        int fname_len = lstrlenW(fname);
#ifdef __REACTOS__
        if (flags & ADN_DEL_IF_EMPTY)
            goto deleteinitialdirectory;
#endif
 
        /* Generate a path with wildcard suitable for iterating */
        if (fname_len && fname[fname_len-1] != '\\') fname[fname_len++] = '\\';
        lstrcpyW(fname + fname_len, L"*");
 
        if ((hFindFile = FindFirstFileW(fname, &w32fd)) != INVALID_HANDLE_VALUE)
        {
            /* Iterate through the files in the directory */
            for (done = FALSE; !done; done = !FindNextFileW(hFindFile, &w32fd))
            {
                TRACE("%s\n", debugstr_w(w32fd.cFileName));
                if (lstrcmpW(L".", w32fd.cFileName) != 0 && lstrcmpW(L"..", w32fd.cFileName) != 0)
                {
                    lstrcpyW(fname + fname_len, w32fd.cFileName);
                    if (DELNODE_recurse_dirtree(fname, flags) != S_OK)
                    {
                        break; /* Failure */
                    }
                }
            }
            FindClose(hFindFile);
        }
 
        /* We're done with this directory, so restore the old path without wildcard */
        *(fname + fname_len) = '\0';
 
        if (done)
        {
#ifdef __REACTOS__
deleteinitialdirectory:
#endif
            TRACE("%s: directory\n", debugstr_w(fname));
#ifdef __REACTOS__
            SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL);
            if (RemoveDirectoryW(fname))
#else
            if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && RemoveDirectoryW(fname))
#endif
            {
                ret = S_OK;
            }
        }
    }
    else
    {
        TRACE("%s: file\n", debugstr_w(fname));
#ifdef __REACTOS__
        SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL);
        if (DeleteFileW(fname))
#else
        if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && DeleteFileW(fname))
#endif
        {
            ret = S_OK;
        }
    }
    
    return ret;
}

Referenced by DELNODE_recurse_dirtree(), and DelNodeW().

DelNodeA()

HRESULT WINAPI DelNodeA	(	LPCSTR	pszFileOrDirName,
		DWORD	dwFlags
	)

Definition at line 391 of file files.c.

{
    UNICODE_STRING fileordirname;
    HRESULT res;
 
    TRACE("(%s, %ld)\n", debugstr_a(pszFileOrDirName), dwFlags);
 
    RtlCreateUnicodeStringFromAsciiz(&fileordirname, pszFileOrDirName);
 
    res = DelNodeW(fileordirname.Buffer, dwFlags);
 
    RtlFreeUnicodeString(&fileordirname);
 
    return res;
}

DelNodeRunDLL32A()

HRESULT WINAPI DelNodeRunDLL32A	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPSTR	cmdline,
		INT	show
	)

Definition at line 457 of file files.c.

{
    UNICODE_STRING params;
    HRESULT hr;
 
    TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
 
    RtlCreateUnicodeStringFromAsciiz(&params, cmdline);
 
    hr = DelNodeRunDLL32W(hWnd, hInst, params.Buffer, show);
 
    RtlFreeUnicodeString(&params);
 
    return hr;
}

DelNodeRunDLL32W()

HRESULT WINAPI DelNodeRunDLL32W	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPWSTR	cmdline,
		INT	show
	)

Definition at line 488 of file files.c.

{
    LPWSTR szFilename, szFlags;
    LPWSTR cmdline_copy, cmdline_ptr;
    DWORD dwFlags = 0;
    HRESULT res;
 
    TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_w(cmdline), show);
 
    cmdline_copy = wcsdup(cmdline);
    cmdline_ptr = cmdline_copy;
 
    /* get the parameters at indexes 0 and 1 respectively */
    szFilename = get_parameter(&cmdline_ptr, ',', TRUE);
    szFlags = get_parameter(&cmdline_ptr, ',', TRUE);
 
    if (szFlags)
        dwFlags = wcstol(szFlags, NULL, 10);
 
    res = DelNodeW(szFilename, dwFlags);
 
    free(cmdline_copy);
 
    return res;
}

Referenced by DelNodeRunDLL32A().

DelNodeW()

HRESULT WINAPI DelNodeW	(	LPCWSTR	pszFileOrDirName,
		DWORD	dwFlags
	)

Definition at line 425 of file files.c.

{
    WCHAR fname[MAX_PATH];
    HRESULT ret = E_FAIL;
    
    TRACE("(%s, %ld)\n", debugstr_w(pszFileOrDirName), dwFlags);
    
#ifdef __REACTOS__
    if (dwFlags & ~ADN_DEL_IF_EMPTY)
        FIXME("Flags %#x ignored!\n", dwFlags & ~ADN_DEL_IF_EMPTY);
#else
    if (dwFlags)
        FIXME("Flags ignored!\n");
#endif
 
    if (pszFileOrDirName && *pszFileOrDirName)
    {
        lstrcpyW(fname, pszFileOrDirName);
 
        /* TODO: Should check for system directory deletion etc. here */
 
        ret = DELNODE_recurse_dirtree(fname, dwFlags);
    }
 
    return ret;
}

Referenced by del_dirs_callback(), DelNodeA(), and DelNodeRunDLL32W().

ExtractFilesA()

HRESULT WINAPI ExtractFilesA	(	LPCSTR	CabName,
		LPCSTR	ExpandDir,
		DWORD	Flags,
		LPCSTR	FileList,
		LPVOID	LReserved,
		DWORD	Reserved
	)

Definition at line 685 of file files.c.

{   
    SESSION session;
    HMODULE hCabinet;
    HRESULT res = S_OK;
    DWORD dwFileCount = 0;
    DWORD dwFilesFound = 0;
    LPSTR szConvertedList = NULL;
 
    TRACE("(%s, %s, %ld, %s, %p, %ld)\n", debugstr_a(CabName), debugstr_a(ExpandDir),
          Flags, debugstr_a(FileList), LReserved, Reserved);
 
    if (!CabName || !ExpandDir)
        return E_INVALIDARG;
 
    if (GetFileAttributesA(ExpandDir) == INVALID_FILE_ATTRIBUTES)
        return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 
    hCabinet = LoadLibraryA("cabinet.dll");
    if (!hCabinet)
        return E_FAIL;
 
    ZeroMemory(&session, sizeof(SESSION));
 
    pExtract = (void *)GetProcAddress(hCabinet, "Extract");
    if (!pExtract)
    {
        res = E_FAIL;
        goto done;
    }
 
    lstrcpyA(session.Destination, ExpandDir);
 
    if (FileList)
    {
        szConvertedList = convert_file_list(FileList, &dwFileCount);
        if (!szConvertedList)
        {
            res = E_FAIL;
            goto done;
        }
 
        dwFilesFound = fill_file_list(&session, CabName, szConvertedList);
        if (dwFilesFound != dwFileCount)
        {
            res = E_FAIL;
            goto done;
        }
    }
    else
        session.Operation |= EXTRACT_FILLFILELIST;
 
    session.Operation |= EXTRACT_EXTRACTFILES;
    res = pExtract(&session, CabName);
 
done:
    free_file_list(&session);
    FreeLibrary(hCabinet);
    free(szConvertedList);
 
    return res;
}

Referenced by ExtractFilesW().

ExtractFilesW()

HRESULT WINAPI ExtractFilesW	(	LPCWSTR	CabName,
		LPCWSTR	ExpandDir,
		DWORD	Flags,
		LPCWSTR	FileList,
		LPVOID	LReserved,
		DWORD	Reserved
	)

Definition at line 777 of file files.c.

{
    char *cab_name = NULL, *expand_dir = NULL, *file_list = NULL;
    HRESULT hres = S_OK;
 
    TRACE("(%s, %s, %ld, %s, %p, %ld)\n", debugstr_w(CabName), debugstr_w(ExpandDir),
          Flags, debugstr_w(FileList), LReserved, Reserved);
 
    if(CabName) {
        cab_name = strdupWtoA(CabName);
        if(!cab_name)
            return E_OUTOFMEMORY;
    }
 
    if(ExpandDir) {
        expand_dir = strdupWtoA(ExpandDir);
        if(!expand_dir)
            hres = E_OUTOFMEMORY;
    }
 
    if(SUCCEEDED(hres) && FileList) {
        file_list = strdupWtoA(FileList);
        if(!file_list)
            hres = E_OUTOFMEMORY;
    }
 
    /* cabinet.dll, which does the real job of extracting files, doesn't have UNICODE API,
       so we need W->A conversion at some point anyway. */
    if(SUCCEEDED(hres))
        hres = ExtractFilesA(cab_name, expand_dir, Flags, file_list, LReserved, Reserved);
 
    free(cab_name);
    free(expand_dir);
    free(file_list);
    return hres;
}

Referenced by ExecuteCabW(), and extract_cab_file().

file_in_list()

static BOOL file_in_list ( LPCSTR  szFile, LPCSTR  szFileList  )

static

Definition at line 598 of file files.c.

{
    DWORD dwLen = lstrlenA(szFile);
    DWORD dwTestLen;
 
    while (*szFileList)
    {
        dwTestLen = lstrlenA(szFileList);
 
        if (dwTestLen == dwLen)
        {
            if (!lstrcmpiA(szFile, szFileList))
                return TRUE;
        }
 
        szFileList += dwTestLen + 1;
    }
 
    return FALSE;
}

Referenced by fill_file_list().

FileSaveMarkNotExistA()

HRESULT WINAPI FileSaveMarkNotExistA	(	LPSTR	pszFileList,
		LPSTR	pszDir,
		LPSTR	pszBaseName
	)

Definition at line 820 of file files.c.

{
    TRACE("(%s, %s, %s)\n", debugstr_a(pszFileList),
          debugstr_a(pszDir), debugstr_a(pszBaseName));
 
    return AddDelBackupEntryA(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
}

FileSaveMarkNotExistW()

HRESULT WINAPI FileSaveMarkNotExistW	(	LPWSTR	pszFileList,
		LPWSTR	pszDir,
		LPWSTR	pszBaseName
	)

Definition at line 843 of file files.c.

{
    TRACE("(%s, %s, %s)\n", debugstr_w(pszFileList),
          debugstr_w(pszDir), debugstr_w(pszBaseName));
 
    return AddDelBackupEntryW(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
}

FileSaveRestoreA()

HRESULT WINAPI FileSaveRestoreA	(	HWND	hDlg,
		LPSTR	pszFileList,
		LPSTR	pszDir,
		LPSTR	pszBaseName,
		DWORD	dwFlags
	)

Definition at line 856 of file files.c.

{
    UNICODE_STRING filelist, dir, basename;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %ld)\n", hDlg, debugstr_a(pszFileList),
          debugstr_a(pszDir), debugstr_a(pszBaseName), dwFlags);
 
    RtlCreateUnicodeStringFromAsciiz(&filelist, pszFileList);
    RtlCreateUnicodeStringFromAsciiz(&dir, pszDir);
    RtlCreateUnicodeStringFromAsciiz(&basename, pszBaseName);
 
    hr = FileSaveRestoreW(hDlg, filelist.Buffer, dir.Buffer,
                          basename.Buffer, dwFlags);
 
    RtlFreeUnicodeString(&filelist);
    RtlFreeUnicodeString(&dir);
    RtlFreeUnicodeString(&basename);
 
    return hr;
}                         

FileSaveRestoreOnINFA()

HRESULT WINAPI FileSaveRestoreOnINFA	(	HWND	hWnd,
		LPCSTR	pszTitle,
		LPCSTR	pszINF,
		LPCSTR	pszSection,
		LPCSTR	pszBackupDir,
		LPCSTR	pszBaseBackupFile,
		DWORD	dwFlags
	)

Definition at line 915 of file files.c.

{
    UNICODE_STRING title, inf, section;
    UNICODE_STRING backupdir, backupfile;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %s, %s, %ld)\n", hWnd, debugstr_a(pszTitle),
          debugstr_a(pszINF), debugstr_a(pszSection), debugstr_a(pszBackupDir),
          debugstr_a(pszBaseBackupFile), dwFlags);
 
    RtlCreateUnicodeStringFromAsciiz(&title, pszTitle);
    RtlCreateUnicodeStringFromAsciiz(&inf, pszINF);
    RtlCreateUnicodeStringFromAsciiz(&section, pszSection);
    RtlCreateUnicodeStringFromAsciiz(&backupdir, pszBackupDir);
    RtlCreateUnicodeStringFromAsciiz(&backupfile, pszBaseBackupFile);
 
    hr = FileSaveRestoreOnINFW(hWnd, title.Buffer, inf.Buffer, section.Buffer,
                               backupdir.Buffer, backupfile.Buffer, dwFlags);
 
    RtlFreeUnicodeString(&title);
    RtlFreeUnicodeString(&inf);
    RtlFreeUnicodeString(&section);
    RtlFreeUnicodeString(&backupdir);
    RtlFreeUnicodeString(&backupfile);
 
    return hr;
}

FileSaveRestoreOnINFW()

HRESULT WINAPI FileSaveRestoreOnINFW	(	HWND	hWnd,
		LPCWSTR	pszTitle,
		LPCWSTR	pszINF,
		LPCWSTR	pszSection,
		LPCWSTR	pszBackupDir,
		LPCWSTR	pszBaseBackupFile,
		DWORD	dwFlags
	)

Definition at line 968 of file files.c.

{
    FIXME("(%p, %s, %s, %s, %s, %s, %ld): stub\n", hWnd, debugstr_w(pszTitle),
          debugstr_w(pszINF), debugstr_w(pszSection), debugstr_w(pszBackupDir),
          debugstr_w(pszBaseBackupFile), dwFlags);
 
    return E_FAIL;
}

Referenced by FileSaveRestoreOnINFA().

FileSaveRestoreW()

HRESULT WINAPI FileSaveRestoreW	(	HWND	hDlg,
		LPWSTR	pszFileList,
		LPWSTR	pszDir,
		LPWSTR	pszBaseName,
		DWORD	dwFlags
	)

Definition at line 901 of file files.c.

{
    FIXME("(%p, %s, %s, %s, %ld) stub\n", hDlg, debugstr_w(pszFileList),
          debugstr_w(pszDir), debugstr_w(pszBaseName), dwFlags);
 
    return E_FAIL;
}

Referenced by FileSaveRestoreA().

fill_file_list()

static DWORD fill_file_list ( SESSION *  session, LPCSTR  szCabName, LPCSTR  szFileList  )

static

Definition at line 621 of file files.c.

{
    DWORD dwNumFound = 0;
    struct FILELIST *pNode;
 
    session->Operation |= EXTRACT_FILLFILELIST;
    if (pExtract(session, szCabName) != S_OK)
    {
        session->Operation &= ~EXTRACT_FILLFILELIST;
        return -1;
    }
 
    pNode = session->FileList;
    while (pNode)
    {
        if (!file_in_list(pNode->FileName, szFileList))
            pNode->DoExtract = FALSE;
        else
            dwNumFound++;
 
        pNode = pNode->next;
    }
 
    session->Operation &= ~EXTRACT_FILLFILELIST;
    return dwNumFound;
}

Referenced by ExtractFilesA().

free_file_list()

static void free_file_list ( SESSION *  session )

static

Definition at line 648 of file files.c.

{
    struct FILELIST *next, *curr = session->FileList;
 
    while (curr)
    {
        next = curr->next;
        free_file_node(curr);
        curr = next;
    }
}

Referenced by ExtractFilesA().

free_file_node()

static void free_file_node ( struct FILELIST *  pNode )

static

Definition at line 591 of file files.c.

{
    free(pNode->FileName);
    free(pNode);
}

Referenced by free_file_list().

GetVersionFromFileA()

HRESULT WINAPI GetVersionFromFileA	(	LPCSTR	Filename,
		LPDWORD	MajorVer,
		LPDWORD	MinorVer,
		BOOL	Version
	)

Definition at line 984 of file files.c.

{
    TRACE("(%s, %p, %p, %d)\n", debugstr_a(Filename), MajorVer, MinorVer, Version);
    return GetVersionFromFileExA(Filename, MajorVer, MinorVer, Version);
}

GetVersionFromFileExA()

HRESULT WINAPI GetVersionFromFileExA	(	LPCSTR	lpszFilename,
		LPDWORD	pdwMSVer,
		LPDWORD	pdwLSVer,
		BOOL	bVersion
	)

Definition at line 1015 of file files.c.

{
    UNICODE_STRING filename;
    HRESULT res;
 
    TRACE("(%s, %p, %p, %d)\n", debugstr_a(lpszFilename),
          pdwMSVer, pdwLSVer, bVersion);
 
    RtlCreateUnicodeStringFromAsciiz(&filename, lpszFilename);
 
    res = GetVersionFromFileExW(filename.Buffer, pdwMSVer, pdwLSVer, bVersion);
 
    RtlFreeUnicodeString(&filename);
 
    return res;
}

Referenced by GetVersionFromFileA().

GetVersionFromFileExW()

HRESULT WINAPI GetVersionFromFileExW	(	LPCWSTR	lpszFilename,
		LPDWORD	pdwMSVer,
		LPDWORD	pdwLSVer,
		BOOL	bVersion
	)

Definition at line 1051 of file files.c.

{
    VS_FIXEDFILEINFO *pFixedVersionInfo;
    LANGANDCODEPAGE *pLangAndCodePage;
    DWORD dwHandle, dwInfoSize;
    WCHAR szWinDir[MAX_PATH];
    WCHAR szFile[MAX_PATH];
    LPVOID pVersionInfo = NULL;
    BOOL bFileCopied = FALSE;
    UINT uValueLen;
 
    TRACE("(%s, %p, %p, %d)\n", debugstr_w(lpszFilename),
          pdwMSVer, pdwLSVer, bVersion);
 
    *pdwLSVer = 0;
    *pdwMSVer = 0;
 
    lstrcpynW(szFile, lpszFilename, MAX_PATH);
 
    dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
    if (!dwInfoSize)
    {
        /* check that the file exists */
        if (GetFileAttributesW(szFile) == INVALID_FILE_ATTRIBUTES)
            return S_OK;
 
        /* file exists, but won't be found by GetFileVersionInfoSize,
        * so copy it to the temp dir where it will be found.
        */
        GetWindowsDirectoryW(szWinDir, MAX_PATH);
        GetTempFileNameW(szWinDir, NULL, 0, szFile);
        CopyFileW(lpszFilename, szFile, FALSE);
        bFileCopied = TRUE;
 
        dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
        if (!dwInfoSize)
            goto done;
    }
 
    pVersionInfo = malloc(dwInfoSize);
    if (!pVersionInfo)
        goto done;
 
    if (!GetFileVersionInfoW(szFile, dwHandle, dwInfoSize, pVersionInfo))
        goto done;
 
    if (bVersion)
    {
        if (!VerQueryValueW(pVersionInfo, L"\\", (void **)&pFixedVersionInfo, &uValueLen))
            goto done;
 
        if (!uValueLen)
            goto done;
 
        *pdwMSVer = pFixedVersionInfo->dwFileVersionMS;
        *pdwLSVer = pFixedVersionInfo->dwFileVersionLS;
    }
    else
    {
        if (!VerQueryValueW(pVersionInfo, L"\\VarFileInfo\\Translation",
             (LPVOID *)&pLangAndCodePage, &uValueLen))
            goto done;
 
        if (!uValueLen)
            goto done;
 
        *pdwMSVer = pLangAndCodePage->wLanguage;
        *pdwLSVer = pLangAndCodePage->wCodePage;
    }
 
done:
    free(pVersionInfo);
 
    if (bFileCopied)
        DeleteFileW(szFile);
 
    return S_OK;
}

Referenced by GetVersionFromFileExA(), and GetVersionFromFileW().

GetVersionFromFileW()

HRESULT WINAPI GetVersionFromFileW	(	LPCWSTR	Filename,
		LPDWORD	MajorVer,
		LPDWORD	MinorVer,
		BOOL	Version
	)

Definition at line 996 of file files.c.

{
    TRACE("(%s, %p, %p, %d)\n", debugstr_w(Filename), MajorVer, MinorVer, Version);
    return GetVersionFromFileExW(Filename, MajorVer, MinorVer, Version);
}

HRESULT()

static HRESULT ( WINAPI *  pExtract )

static

pQueueCallback()

static UINT CALLBACK pQueueCallback ( PVOID  Context, UINT  Notification, UINT_PTR  Param1, UINT_PTR  Param2  )

static

Definition at line 167 of file files.c.

{
    /* only be verbose for error notifications */
    if (!Notification ||
        Notification == SPFILENOTIFY_RENAMEERROR ||
        Notification == SPFILENOTIFY_DELETEERROR ||
        Notification == SPFILENOTIFY_COPYERROR)
    {
        return SetupDefaultQueueCallbackW(Context, Notification,
                                          Param1, Param2);
    }
 
    return 1;
}

Referenced by AdvInstallFileW().

pQuietQueueCallback()

static UINT CALLBACK pQuietQueueCallback ( PVOID  Context, UINT  Notification, UINT_PTR  Param1, UINT_PTR  Param2  )

static

Definition at line 161 of file files.c.

{
    return 1;
}

Referenced by AdvInstallFileW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advpack

)

Variable Documentation

LPCSTR

LPCSTR

Definition at line 538 of file files.c.