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 521 of file files.c.

EXTRACT_FILLFILELIST

#define EXTRACT_FILLFILELIST   0x00000001

Definition at line 520 of file files.c.

ROOT_LENGTH

#define ROOT_LENGTH   3

Definition at line 167 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, %d)\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);
 
    HeapFree(GetProcessHeap(), 0, 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;
 
    static const WCHAR szBackupEntry[] = {
        '-','1',',','0',',','0',',','0',',','0',',','0',',','-','1',0
    };
    
    static const WCHAR backslash[] = {'\\',0};
    static const WCHAR ini[] = {'.','i','n','i',0};
    static const WCHAR backup[] = {'b','a','c','k','u','p',0};
 
    TRACE("(%s, %s, %s, %d)\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, backslash);
    lstrcatW(szIniPath, lpcszBaseName);
    lstrcatW(szIniPath, ini);
 
    SetFileAttributesW(szIniPath, FILE_ATTRIBUTE_NORMAL);
 
    if (dwFlags & AADBE_ADD_ENTRY)
        szString = szBackupEntry;
    else if (dwFlags & AADBE_DEL_ENTRY)
        szString = NULL;
 
    /* add or delete the INI entries */
    while (*lpcszFileList)
    {
        WritePrivateProfileStringW(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 196 of file files.c.

{
    UNICODE_STRING sourcedir, sourcefile;
    UNICODE_STRING destdir, destfile;
    HRESULT res;
 
    TRACE("(%p, %s, %s, %s, %s, %d, %d)\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 249 of file files.c.

{
    PSP_FILE_CALLBACK_W pFileCallback;
    LPWSTR szDestFilename;
    LPCWSTR szPath;
    WCHAR szRootPath[ROOT_LENGTH];
    DWORD dwLen, dwLastError;
    HSPFILEQ fileQueue;
    PVOID pContext;
 
    TRACE("(%p, %s, %s, %s, %s, %d, %d)\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 */
    if (lpszDestFile)
    {
        dwLen = lstrlenW(lpszDestFile);
        szDestFilename = HeapAlloc(GetProcessHeap(), 0, (dwLen+1) * sizeof(WCHAR));
        lstrcpyW(szDestFilename, lpszDestFile);
    }
    else
    {
        dwLen = lstrlenW(lpszSourceFile);
        szDestFilename = HeapAlloc(GetProcessHeap(), 0, (dwLen+1) * sizeof(WCHAR));
        lstrcpyW(szDestFilename, 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);
    
    HeapFree(GetProcessHeap(), 0, 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 = HeapAlloc(GetProcessHeap(), 0, 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 546 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 = HeapAlloc(GetProcessHeap(), 0, dwLen);
    lstrcpynA(szConvertedList, first, dwLen - 1);
    szConvertedList[dwLen - 1] = '\0';
 
    /* empty list */
    if (!szConvertedList[0])
    {
        HeapFree(GetProcessHeap(), 0, 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 330 of file files.c.

{
    DWORD fattrs = GetFileAttributesW(fname);
    HRESULT ret = E_FAIL;
 
    static const WCHAR asterisk[] = {'*',0};
    static const WCHAR dot[] = {'.',0};
    static const WCHAR dotdot[] = {'.','.',0};
 
    if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
    {
        HANDLE hFindFile;
        WIN32_FIND_DATAW w32fd;
        BOOL done = TRUE;
        int fname_len = lstrlenW(fname);
 
        /* Generate a path with wildcard suitable for iterating */
        if (fname_len && fname[fname_len-1] != '\\') fname[fname_len++] = '\\';
        lstrcpyW(fname + fname_len, asterisk);
 
        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(dot, w32fd.cFileName) != 0 &&
                    lstrcmpW(dotdot, 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)
        {
            TRACE("%s: directory\n", debugstr_w(fname));
            if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && RemoveDirectoryW(fname))
            {
                ret = S_OK;
            }
        }
    }
    else
    {
        TRACE("%s: file\n", debugstr_w(fname));
        if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && DeleteFileW(fname))
        {
            ret = S_OK;
        }
    }
    
    return ret;
}

Referenced by DELNODE_recurse_dirtree(), and DelNodeW().

DelNodeA()

HRESULT WINAPI DelNodeA	(	LPCSTR	pszFileOrDirName,
		DWORD	dwFlags
	)

Definition at line 398 of file files.c.

{
    UNICODE_STRING fileordirname;
    HRESULT res;
 
    TRACE("(%s, %d)\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 459 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 490 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 = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
    cmdline_ptr = cmdline_copy;
    lstrcpyW(cmdline_copy, cmdline);
 
    /* 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);
 
    HeapFree(GetProcessHeap(), 0, cmdline_copy);
 
    return res;
}

Referenced by DelNodeRunDLL32A().

DelNodeW()

HRESULT WINAPI DelNodeW	(	LPCWSTR	pszFileOrDirName,
		DWORD	dwFlags
	)

Definition at line 432 of file files.c.

{
    WCHAR fname[MAX_PATH];
    HRESULT ret = E_FAIL;
    
    TRACE("(%s, %d)\n", debugstr_w(pszFileOrDirName), dwFlags);
    
    if (dwFlags)
        FIXME("Flags ignored!\n");
 
    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 688 of file files.c.

{   
    SESSION session;
    HMODULE hCabinet;
    HRESULT res = S_OK;
    DWORD dwFileCount = 0;
    DWORD dwFilesFound = 0;
    LPSTR szConvertedList = NULL;
 
    TRACE("(%s, %s, %d, %s, %p, %d)\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);
    HeapFree(GetProcessHeap(), 0, 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 780 of file files.c.

{
    char *cab_name = NULL, *expand_dir = NULL, *file_list = NULL;
    HRESULT hres = S_OK;
 
    TRACE("(%s, %s, %d, %s, %p, %d)\n", debugstr_w(CabName), debugstr_w(ExpandDir),
          Flags, debugstr_w(FileList), LReserved, Reserved);
 
    if(CabName) {
        cab_name = heap_strdupWtoA(CabName);
        if(!cab_name)
            return E_OUTOFMEMORY;
    }
 
    if(ExpandDir) {
        expand_dir = heap_strdupWtoA(ExpandDir);
        if(!expand_dir)
            hres = E_OUTOFMEMORY;
    }
 
    if(SUCCEEDED(hres) && FileList) {
        file_list = heap_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);
 
    heap_free(cab_name);
    heap_free(expand_dir);
    heap_free(file_list);
    return hres;
}

Referenced by extract_cab_file().

file_in_list()

static BOOL file_in_list ( LPCSTR  szFile, LPCSTR  szFileList  )

static

Definition at line 601 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 823 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 846 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 859 of file files.c.

{
    UNICODE_STRING filelist, dir, basename;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %d)\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 918 of file files.c.

{
    UNICODE_STRING title, inf, section;
    UNICODE_STRING backupdir, backupfile;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %s, %s, %d)\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 971 of file files.c.

{
    FIXME("(%p, %s, %s, %s, %s, %s, %d): 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 904 of file files.c.

{
    FIXME("(%p, %s, %s, %s, %d) 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 624 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 651 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 594 of file files.c.

{
    HeapFree(GetProcessHeap(), 0, pNode->FileName);
    HeapFree(GetProcessHeap(), 0, pNode);
}

Referenced by free_file_list().

GetVersionFromFileA()

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

Definition at line 987 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 1018 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 1054 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;
 
    static const WCHAR backslash[] = {'\\',0};
    static const WCHAR translation[] = {
        '\\','V','a','r','F','i','l','e','I','n','f','o',
        '\\','T','r','a','n','s','l','a','t','i','o','n',0
    };
 
    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 = HeapAlloc(GetProcessHeap(), 0, dwInfoSize);
    if (!pVersionInfo)
        goto done;
 
    if (!GetFileVersionInfoW(szFile, dwHandle, dwInfoSize, pVersionInfo))
        goto done;
 
    if (bVersion)
    {
        if (!VerQueryValueW(pVersionInfo, backslash,
            (LPVOID *)&pFixedVersionInfo, &uValueLen))
            goto done;
 
        if (!uValueLen)
            goto done;
 
        *pdwMSVer = pFixedVersionInfo->dwFileVersionMS;
        *pdwLSVer = pFixedVersionInfo->dwFileVersionLS;
    }
    else
    {
        if (!VerQueryValueW(pVersionInfo, translation,
             (LPVOID *)&pLangAndCodePage, &uValueLen))
            goto done;
 
        if (!uValueLen)
            goto done;
 
        *pdwMSVer = pLangAndCodePage->wLanguage;
        *pdwLSVer = pLangAndCodePage->wCodePage;
    }
 
done:
    HeapFree(GetProcessHeap(), 0, 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 999 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 175 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 169 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 541 of file files.c.