files.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "fdi.h"
#include "msi.h"
#include "msidefs.h"
#include "msipriv.h"
#include "winuser.h"
#include "winreg.h"
#include "shlwapi.h"
#include "patchapi.h"
#include "wine/debug.h"

Include dependency graph for files.c:

Go to the source code of this file.

Classes
struct	file_list

Macros
#define	COBJMACROS
#define	is_dot_dir(x)   ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)
BOOL	msi_get_temp_file_name (MSIPACKAGE *package, const WCHAR *tmp_path, const WCHAR *prefix, WCHAR *tmp_filename)
HANDLE	msi_create_file (MSIPACKAGE *package, const WCHAR *filename, DWORD access, DWORD sharing, DWORD creation, DWORD flags)
static BOOL	copy_file (MSIPACKAGE *package, const WCHAR *src, const WCHAR *dst, BOOL fail_if_exists)
BOOL	msi_delete_file (MSIPACKAGE *package, const WCHAR *filename)
static BOOL	create_directory (MSIPACKAGE *package, const WCHAR *path)
BOOL	msi_remove_directory (MSIPACKAGE *package, const WCHAR *path)
BOOL	msi_set_file_attributes (MSIPACKAGE *package, const WCHAR *filename, DWORD attrs)
DWORD	msi_get_file_attributes (MSIPACKAGE *package, const WCHAR *path)
HANDLE	msi_find_first_file (MSIPACKAGE *package, const WCHAR *filename, WIN32_FIND_DATAW *data)
BOOL	msi_find_next_file (MSIPACKAGE *package, HANDLE handle, WIN32_FIND_DATAW *data)
BOOL	msi_move_file (MSIPACKAGE *package, const WCHAR *from, const WCHAR *to, DWORD flags)
static BOOL	apply_filepatch (MSIPACKAGE *package, const WCHAR *patch, const WCHAR *old, const WCHAR *new)
DWORD	msi_get_file_version_info (MSIPACKAGE *package, const WCHAR *path, DWORD buflen, BYTE *buffer)
VS_FIXEDFILEINFO *	msi_get_disk_file_version (MSIPACKAGE *package, const WCHAR *filename)
DWORD	msi_get_disk_file_size (MSIPACKAGE *package, const WCHAR *filename)
BOOL	msi_create_full_path (MSIPACKAGE *package, const WCHAR *path)
static void	file_update_ui (MSIPACKAGE *package, MSIFILE *f, const WCHAR *action)
static BOOL	is_registered_patch_media (MSIPACKAGE *package, UINT disk_id)
static BOOL	is_obsoleted_by_patch (MSIPACKAGE *package, MSIFILE *file)
static BOOL	file_hash_matches (MSIPACKAGE *package, MSIFILE *file)
static msi_file_state	calculate_install_state (MSIPACKAGE *package, MSIFILE *file)
static void	schedule_install_files (MSIPACKAGE *package)
static UINT	copy_file_attributes (MSIPACKAGE *package, MSIFILE *file, WCHAR *source)
static UINT	copy_install_file (MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
static UINT	create_folder (MSIPACKAGE *package, const WCHAR *dir)
static MSIFILE *	find_file (MSIPACKAGE *package, UINT disk_id, const WCHAR *filename)
static BOOL	installfiles_cb (MSIPACKAGE *package, LPCWSTR filename, DWORD action, LPWSTR *path, DWORD *attrs, PVOID user)
WCHAR *	msi_resolve_file_source (MSIPACKAGE *package, MSIFILE *file)
UINT	ACTION_InstallFiles (MSIPACKAGE *package)
static MSIFILEPATCH *	find_filepatch (MSIPACKAGE *package, UINT disk_id, const WCHAR *key)
static BOOL	patchfiles_cb (MSIPACKAGE *package, LPCWSTR file, DWORD action, LPWSTR *path, DWORD *attrs, PVOID user)
static UINT	patch_file (MSIPACKAGE *package, MSIFILEPATCH *patch)
UINT	msi_patch_assembly (MSIPACKAGE *package, MSIASSEMBLY *assembly, MSIFILEPATCH *patch)
UINT	ACTION_PatchFiles (MSIPACKAGE *package)
static BOOL	move_file (MSIPACKAGE *package, const WCHAR *source, const WCHAR *dest, int options)
static WCHAR *	wildcard_to_file (const WCHAR *wildcard, const WCHAR *filename)
static void	free_file_entry (struct file_list *file)
static void	free_list (struct file_list *list)
static BOOL	add_wildcard (struct file_list *files, const WCHAR *source, WCHAR *dest)
static BOOL	move_files_wildcard (MSIPACKAGE *package, const WCHAR *source, WCHAR *dest, int options)
void	msi_reduce_to_long_filename (WCHAR *filename)
static UINT	ITERATE_MoveFiles (MSIRECORD *rec, LPVOID param)
UINT	ACTION_MoveFiles (MSIPACKAGE *package)
static WCHAR *	get_duplicate_filename (MSIPACKAGE *package, MSIRECORD *row, const WCHAR *file_key, const WCHAR *src)
static UINT	ITERATE_DuplicateFiles (MSIRECORD *row, LPVOID param)
UINT	ACTION_DuplicateFiles (MSIPACKAGE *package)
static UINT	ITERATE_RemoveDuplicateFiles (MSIRECORD *row, LPVOID param)
UINT	ACTION_RemoveDuplicateFiles (MSIPACKAGE *package)
static BOOL	verify_comp_for_removal (MSICOMPONENT *comp, UINT install_mode)
static UINT	ITERATE_RemoveFiles (MSIRECORD *row, LPVOID param)
static void	remove_folder (MSIFOLDER *folder)
UINT	ACTION_RemoveFiles (MSIPACKAGE *package)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 34 of file files.c.

is_dot_dir

#define is_dot_dir

(

x

)

((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))

Definition at line 852 of file files.c.

Function Documentation

ACTION_DuplicateFiles()

UINT ACTION_DuplicateFiles

(

MSIPACKAGE *

package

)

Definition at line 1315 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"DuplicateFiles");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `DuplicateFile`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
    msiobj_release(&view->hdr);
    return rc;
}

ACTION_InstallFiles()

UINT ACTION_InstallFiles

(

MSIPACKAGE *

package

)

Definition at line 564 of file files.c.

{
    MSIMEDIAINFO *mi;
    UINT rc = ERROR_SUCCESS;
    MSIFILE *file;
 
    msi_set_sourcedir_props(package, FALSE);
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"InstallFiles");
 
    schedule_install_files(package);
    mi = calloc(1, sizeof(MSIMEDIAINFO));
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        BOOL is_global_assembly = msi_is_global_assembly( file->Component );
 
        file_update_ui( package, file, L"InstallFiles" );
 
        rc = msi_load_media_info( package, file->Sequence, mi );
        if (rc != ERROR_SUCCESS)
        {
            ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
            rc = ERROR_FUNCTION_FAILED;
            goto done;
        }
 
        if (file->state != msifs_hashmatch &&
            file->state != msifs_skipped &&
            (file->state != msifs_present || !msi_get_property_int( package->db, L"Installed", 0 )) &&
            (rc = ready_media( package, file->IsCompressed, mi )))
        {
            ERR("Failed to ready media for %s\n", debugstr_w(file->File));
            goto done;
        }
 
        if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
            continue;
 
        if (file->Sequence > mi->last_sequence || mi->is_continuous ||
            (file->IsCompressed && !mi->is_extracted))
        {
            MSICABDATA data;
            MSIFILE *cursor = file;
 
            data.mi = mi;
            data.package = package;
            data.cb = installfiles_cb;
            data.user = &cursor;
 
            if (file->IsCompressed && !msi_cabextract(package, mi, &data))
            {
                ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
                rc = ERROR_INSTALL_FAILURE;
                goto done;
            }
        }
 
        if (!file->IsCompressed)
        {
            WCHAR *source = msi_resolve_file_source(package, file);
 
            TRACE("copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 
            if (!is_global_assembly)
            {
                create_folder(package, file->Component->Directory);
            }
            rc = copy_install_file(package, file, source);
            if (rc != ERROR_SUCCESS)
            {
                ERR("Failed to copy %s to %s (%u)\n", debugstr_w(source), debugstr_w(file->TargetPath), rc);
                rc = ERROR_INSTALL_FAILURE;
                free(source);
                goto done;
            }
            if (!is_global_assembly) file->state = msifs_installed;
            free(source);
        }
        else if (!is_global_assembly && file->state != msifs_installed &&
                 !(file->Attributes & msidbFileAttributesPatchAdded))
        {
            ERR("compressed file wasn't installed (%s)\n", debugstr_w(file->File));
            rc = ERROR_INSTALL_FAILURE;
            goto done;
        }
    }
 
done:
    msi_free_media_info(mi);
    return rc;
}

ACTION_MoveFiles()

UINT ACTION_MoveFiles

(

MSIPACKAGE *

package

)

Definition at line 1185 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"MoveFiles");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `MoveFile`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
    msiobj_release(&view->hdr);
    return rc;
}

ACTION_PatchFiles()

UINT ACTION_PatchFiles

(

MSIPACKAGE *

package

)

Definition at line 776 of file files.c.

{
    MSIFILEPATCH *patch;
    MSIMEDIAINFO *mi;
    UINT rc = ERROR_SUCCESS;
 
    TRACE("%p\n", package);
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"PatchFiles");
 
    mi = calloc( 1, sizeof(MSIMEDIAINFO) );
 
    TRACE("extracting files\n");
 
    LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
    {
        MSIFILE *file = patch->File;
        MSICOMPONENT *comp = file->Component;
 
        rc = msi_load_media_info( package, patch->Sequence, mi );
        if (rc != ERROR_SUCCESS)
        {
            ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
            rc = ERROR_FUNCTION_FAILED;
            goto done;
        }
        comp->Action = msi_get_component_action( package, comp );
        if (!comp->Enabled || comp->Action != INSTALLSTATE_LOCAL) continue;
 
        if (!patch->extracted)
        {
            MSICABDATA data;
            MSIFILEPATCH *cursor = patch;
 
            rc = ready_media( package, TRUE, mi );
            if (rc != ERROR_SUCCESS)
            {
                ERR("Failed to ready media for %s\n", debugstr_w(file->File));
                goto done;
            }
            data.mi      = mi;
            data.package = package;
            data.cb      = patchfiles_cb;
            data.user    = &cursor;
 
            if (!msi_cabextract( package, mi, &data ))
            {
                ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
                rc = ERROR_INSTALL_FAILURE;
                goto done;
            }
        }
    }
 
    TRACE("applying patches\n");
 
    LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
    {
        MSICOMPONENT *comp = patch->File->Component;
 
        if (msi_is_global_assembly( comp ) || !patch->path) continue;
 
        rc = patch_file( package, patch );
        if (rc && !(patch->Attributes & msidbPatchAttributesNonVital))
        {
            ERR("Failed to apply patch to file: %s\n", debugstr_w(patch->File->File));
            break;
        }
    }
 
done:
    msi_free_media_info(mi);
    return rc;
}

ACTION_RemoveDuplicateFiles()

UINT ACTION_RemoveDuplicateFiles

(

MSIPACKAGE *

package

)

Definition at line 1390 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveDuplicateFiles");
 
    rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `DuplicateFile`", &view );
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveDuplicateFiles, package );
    msiobj_release( &view->hdr );
    return rc;
}

ACTION_RemoveFiles()

UINT ACTION_RemoveFiles

(

MSIPACKAGE *

package

)

Definition at line 1528 of file files.c.

{
    MSIQUERY *view;
    MSICOMPONENT *comp;
    MSIFILE *file;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveFiles");
 
    r = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `RemoveFile`", &view);
    if (r == ERROR_SUCCESS)
    {
        r = MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
        msiobj_release(&view->hdr);
        if (r != ERROR_SUCCESS)
            return r;
    }
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        MSIRECORD *uirow;
        VS_FIXEDFILEINFO *ver;
 
        comp = file->Component;
        file_update_ui( package, file, L"RemoveFiles" );
 
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_ABSENT || comp->Installed == INSTALLSTATE_SOURCE)
            continue;
 
        if (comp->assembly && !comp->assembly->application)
            continue;
 
        if (comp->Attributes & msidbComponentAttributesPermanent)
        {
            TRACE("permanent component, not removing file\n");
            continue;
        }
 
        if (file->Version)
        {
            ver = msi_get_disk_file_version( package, file->TargetPath );
            if (ver && msi_compare_file_versions( ver, file->Version ) > 0)
            {
                TRACE("newer version detected, not removing file\n");
                free( ver );
                continue;
            }
            free( ver );
        }
 
        if (file->state == msifs_installed)
            WARN("removing installed file %s\n", debugstr_w(file->TargetPath));
 
        TRACE("removing %s\n", debugstr_w(file->File) );
 
        msi_set_file_attributes( package, file->TargetPath, FILE_ATTRIBUTE_NORMAL );
        if (!msi_delete_file( package, file->TargetPath ))
        {
            WARN( "failed to delete %s (%lu)\n",  debugstr_w(file->TargetPath), GetLastError() );
        }
        file->state = msifs_missing;
 
        uirow = MSI_CreateRecord( 9 );
        MSI_RecordSetStringW( uirow, 1, file->FileName );
        MSI_RecordSetStringW( uirow, 9, comp->Directory );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
 
    LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
    {
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_ABSENT) continue;
 
        if (comp->Attributes & msidbComponentAttributesPermanent)
        {
            TRACE("permanent component, not removing directory\n");
            continue;
        }
        if (comp->assembly && !comp->assembly->application)
            msi_uninstall_assembly( package, comp );
        else
        {
            MSIFOLDER *folder = msi_get_loaded_folder( package, comp->Directory );
            if (folder) remove_folder( folder );
        }
    }
    return ERROR_SUCCESS;
}

add_wildcard()

static BOOL add_wildcard ( struct file_list *  files, const WCHAR *  source, WCHAR *  dest  )

static

Definition at line 934 of file files.c.

{
    struct file_list *new, *file;
    WCHAR *ptr, *filename;
    DWORD size;
 
    new = calloc(1, sizeof(*new));
    if (!new)
        return FALSE;
 
    new->source = wcsdup(source);
    ptr = wcsrchr(dest, '\\') + 1;
    filename = wcsrchr(new->source, '\\') + 1;
 
    new->sourcename = filename;
 
    if (*ptr)
        new->destname = ptr;
    else
        new->destname = new->sourcename;
 
    size = (ptr - dest) + lstrlenW(filename) + 1;
    new->dest = malloc(size * sizeof(WCHAR));
    if (!new->dest)
    {
        free_file_entry(new);
        return FALSE;
    }
 
    lstrcpynW(new->dest, dest, ptr - dest + 1);
    lstrcatW(new->dest, filename);
 
    if (list_empty(&files->entry))
    {
        list_add_head(&files->entry, &new->entry);
        return TRUE;
    }
 
    LIST_FOR_EACH_ENTRY(file, &files->entry, struct file_list, entry)
    {
        if (wcscmp( source, file->source ) < 0)
        {
            list_add_before(&file->entry, &new->entry);
            return TRUE;
        }
    }
 
    list_add_after(&file->entry, &new->entry);
    return TRUE;
}

Referenced by move_files_wildcard().

apply_filepatch()

static BOOL apply_filepatch ( MSIPACKAGE *  package, const WCHAR *  patch, const WCHAR *  old, const WCHAR *  new  )

static

Definition at line 151 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = ApplyPatchToFileW( patch, old, new, 0 );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by patch_file().

calculate_install_state()

static msi_file_state calculate_install_state ( MSIPACKAGE *  package, MSIFILE *  file  )

static

Definition at line 299 of file files.c.

{
    MSICOMPONENT *comp = file->Component;
    VS_FIXEDFILEINFO *file_version;
    WCHAR *font_version;
    msi_file_state state;
    DWORD size;
 
    comp->Action = msi_get_component_action( package, comp );
    if (!comp->Enabled || comp->Action != INSTALLSTATE_LOCAL)
    {
        TRACE("skipping %s (not scheduled for install)\n", debugstr_w(file->File));
        return msifs_skipped;
    }
    if (is_obsoleted_by_patch( package, file ))
    {
        TRACE("skipping %s (obsoleted by patch)\n", debugstr_w(file->File));
        return msifs_skipped;
    }
    if (msi_get_file_attributes( package, file->TargetPath ) == INVALID_FILE_ATTRIBUTES)
    {
        TRACE("installing %s (missing)\n", debugstr_w(file->File));
        return msifs_missing;
    }
    if (file->Version)
    {
        if ((file_version = msi_get_disk_file_version( package, file->TargetPath )))
        {
            if (msi_compare_file_versions( file_version, file->Version ) < 0)
            {
                TRACE("overwriting %s (new version %s old version %u.%u.%u.%u)\n",
                      debugstr_w(file->File), debugstr_w(file->Version),
                      HIWORD(file_version->dwFileVersionMS), LOWORD(file_version->dwFileVersionMS),
                      HIWORD(file_version->dwFileVersionLS), LOWORD(file_version->dwFileVersionLS));
                state = msifs_overwrite;
            }
            else
            {
                TRACE("keeping %s (new version %s old version %u.%u.%u.%u)\n",
                      debugstr_w(file->File), debugstr_w(file->Version),
                      HIWORD(file_version->dwFileVersionMS), LOWORD(file_version->dwFileVersionMS),
                      HIWORD(file_version->dwFileVersionLS), LOWORD(file_version->dwFileVersionLS));
                state = msifs_present;
            }
            free( file_version );
            return state;
        }
        else if ((font_version = msi_get_font_file_version( package, file->TargetPath )))
        {
            if (msi_compare_font_versions( font_version, file->Version ) < 0)
            {
                TRACE("overwriting %s (new version %s old version %s)\n",
                      debugstr_w(file->File), debugstr_w(file->Version), debugstr_w(font_version));
                state = msifs_overwrite;
            }
            else
            {
                TRACE("keeping %s (new version %s old version %s)\n",
                      debugstr_w(file->File), debugstr_w(file->Version), debugstr_w(font_version));
                state = msifs_present;
            }
            free( font_version );
            return state;
        }
    }
    if ((size = msi_get_disk_file_size( package, file->TargetPath )) != file->FileSize)
    {
        TRACE("overwriting %s (old size %lu new size %d)\n", debugstr_w(file->File), size, file->FileSize);
        return msifs_overwrite;
    }
    if (file->hash.dwFileHashInfoSize)
    {
        if (file_hash_matches( package, file ))
        {
            TRACE("keeping %s (hash match)\n", debugstr_w(file->File));
            return msifs_hashmatch;
        }
        else
        {
            TRACE("overwriting %s (hash mismatch)\n", debugstr_w(file->File));
            return msifs_overwrite;
        }
    }
    /* assume present */
    TRACE("keeping %s\n", debugstr_w(file->File));
    return msifs_present;
}

Referenced by schedule_install_files().

copy_file()

static BOOL copy_file ( MSIPACKAGE *  package, const WCHAR *  src, const WCHAR *  dst, BOOL  fail_if_exists  )

static

Definition at line 70 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = CopyFileW( src, dst, fail_if_exists );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by copy_file_attributes(), copy_install_file(), move_file(), and msi_patch_assembly().

copy_file_attributes()

static UINT copy_file_attributes ( MSIPACKAGE *  package, MSIFILE *  file, WCHAR *  source  )

static

Definition at line 404 of file files.c.

{
    BOOL ret;
 
    ret = copy_file( package, source, file->TargetPath, FALSE );
    if (!ret)
        return GetLastError();
 
    msi_set_file_attributes( package, file->TargetPath, FILE_ATTRIBUTE_NORMAL );
    return ERROR_SUCCESS;
}

Referenced by copy_install_file().

copy_install_file()

static UINT copy_install_file ( MSIPACKAGE *  package, MSIFILE *  file, LPWSTR  source  )

static

Definition at line 416 of file files.c.

{
    UINT gle;
 
    TRACE("Copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 
    gle = copy_file_attributes( package, file, source );
    if (gle == ERROR_SUCCESS)
        return gle;
 
    if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
    {
        TRACE("overwriting existing file\n");
        return ERROR_SUCCESS;
    }
    else if (gle == ERROR_ACCESS_DENIED)
    {
        msi_set_file_attributes( package, file->TargetPath, FILE_ATTRIBUTE_NORMAL );
 
        gle = copy_file_attributes( package, file, source );
        TRACE("Overwriting existing file: %d\n", gle);
    }
    if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
    {
        WCHAR *tmpfileW, *pathW, *p;
        DWORD len;
 
        TRACE("file in use, scheduling rename operation\n");
 
        if (!(pathW = wcsdup( file->TargetPath ))) return ERROR_OUTOFMEMORY;
        if ((p = wcsrchr(pathW, '\\'))) *p = 0;
        len = lstrlenW( pathW ) + 16;
        if (!(tmpfileW = malloc(len * sizeof(WCHAR))))
        {
            free( pathW );
            return ERROR_OUTOFMEMORY;
        }
        if (!GetTempFileNameW( pathW, L"msi", 0, tmpfileW )) tmpfileW[0] = 0;
        free( pathW );
 
        if (copy_file( package, source, tmpfileW, FALSE ) &&
            msi_move_file( package, file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT ) &&
            msi_move_file( package, tmpfileW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT ))
        {
            package->need_reboot_at_end = 1;
            gle = ERROR_SUCCESS;
        }
        else
        {
            gle = GetLastError();
            WARN("failed to schedule rename operation: %d)\n", gle);
            DeleteFileW( tmpfileW );
        }
        free(tmpfileW);
    }
 
    return gle;
}

Referenced by ACTION_InstallFiles().

create_directory()

static BOOL create_directory ( MSIPACKAGE *  package, const WCHAR *  path  )

static

Definition at line 88 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = CreateDirectoryW( path, NULL );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by msi_create_full_path().

create_folder()

static UINT create_folder ( MSIPACKAGE *  package, const WCHAR *  dir  )

static

Definition at line 475 of file files.c.

{
    MSIFOLDER *folder;
    const WCHAR *install_path;
 
    install_path = msi_get_target_folder( package, dir );
    if (!install_path) return ERROR_FUNCTION_FAILED;
 
    folder = msi_get_loaded_folder( package, dir );
    if (folder->State == FOLDER_STATE_UNINITIALIZED)
    {
        msi_create_full_path( package, install_path );
        folder->State = FOLDER_STATE_CREATED;
    }
    return ERROR_SUCCESS;
}

Referenced by ACTION_InstallFiles(), and installfiles_cb().

file_hash_matches()

static BOOL file_hash_matches ( MSIPACKAGE *  package, MSIFILE *  file  )

static

Definition at line 286 of file files.c.

{
    UINT r;
    MSIFILEHASHINFO hash;
 
    hash.dwFileHashInfoSize = sizeof(hash);
    r = msi_get_filehash( package, file->TargetPath, &hash );
    if (r != ERROR_SUCCESS)
        return FALSE;
 
    return !memcmp( &hash, &file->hash, sizeof(hash) );
}

Referenced by calculate_install_state().

file_update_ui()

static void file_update_ui ( MSIPACKAGE *  package, MSIFILE *  f, const WCHAR *  action  )

static

Definition at line 251 of file files.c.

{
    MSIRECORD *uirow;
 
    uirow = MSI_CreateRecord( 9 );
    MSI_RecordSetStringW( uirow, 1, f->FileName );
    MSI_RecordSetStringW( uirow, 9, f->Component->Directory );
    MSI_RecordSetInteger( uirow, 6, f->FileSize );
    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
    msiobj_release( &uirow->hdr );
    msi_ui_progress( package, 2, f->FileSize, 0, 0 );
}

Referenced by ACTION_InstallFiles(), and ACTION_RemoveFiles().

find_file()

static MSIFILE * find_file ( MSIPACKAGE *  package, UINT  disk_id, const WCHAR *  filename  )

static

Definition at line 492 of file files.c.

{
    MSIFILE *file;
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        if (file->disk_id == disk_id &&
            file->state != msifs_installed &&
            !wcsicmp( filename, file->File )) return file;
    }
    return NULL;
}

Referenced by installfiles_cb().

find_filepatch()

static MSIFILEPATCH * find_filepatch ( MSIPACKAGE *  package, UINT  disk_id, const WCHAR *  key  )

static

Definition at line 658 of file files.c.

{
    MSIFILEPATCH *patch;
 
    LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
    {
        if (!patch->extracted && patch->disk_id == disk_id && !wcscmp( key, patch->File->File ))
            return patch;
    }
    return NULL;
}

Referenced by patchfiles_cb().

free_file_entry()

static void free_file_entry ( struct file_list *  file )

static

Definition at line 916 of file files.c.

{
    free(file->source);
    free(file->dest);
    free(file);
}

Referenced by add_wildcard(), free_list(), and move_files_wildcard().

free_list()

static void free_list ( struct file_list *  list )

static

Definition at line 923 of file files.c.

{
    while (!list_empty(&list->entry))
    {
        struct file_list *file = LIST_ENTRY(list_head(&list->entry), struct file_list, entry);
 
        list_remove(&file->entry);
        free_file_entry(file);
    }
}

Referenced by move_files_wildcard().

get_duplicate_filename()

static WCHAR * get_duplicate_filename ( MSIPACKAGE *  package, MSIRECORD *  row, const WCHAR *  file_key, const WCHAR *  src  )

static

Definition at line 1202 of file files.c.

{
    DWORD len;
    WCHAR *dst_name, *dst_path, *dst;
 
    if (MSI_RecordIsNull( row, 4 ))
    {
        len = lstrlenW( src ) + 1;
        if (!(dst_name = malloc( len * sizeof(WCHAR)))) return NULL;
        lstrcpyW( dst_name, wcsrchr( src, '\\' ) + 1 );
    }
    else
    {
        MSI_RecordGetStringW( row, 4, NULL, &len );
        if (!(dst_name = malloc( ++len * sizeof(WCHAR) ))) return NULL;
        MSI_RecordGetStringW( row, 4, dst_name, &len );
        msi_reduce_to_long_filename( dst_name );
    }
 
    if (MSI_RecordIsNull( row, 5 ))
    {
        WCHAR *p;
        dst_path = wcsdup( src );
        p = wcsrchr( dst_path, '\\' );
        if (p) *p = 0;
    }
    else
    {
        const WCHAR *dst_key = MSI_RecordGetString( row, 5 );
 
        dst_path = wcsdup( msi_get_target_folder( package, dst_key ) );
        if (!dst_path)
        {
            /* try a property */
            dst_path = msi_dup_property( package->db, dst_key );
            if (!dst_path)
            {
                FIXME("Unable to get destination folder, try AppSearch properties\n");
                free( dst_name );
                return NULL;
            }
        }
    }
 
    dst = msi_build_directory_name( 2, dst_path, dst_name );
    msi_create_full_path( package, dst_path );
 
    free( dst_name );
    free( dst_path );
    return dst;
}

Referenced by ITERATE_DuplicateFiles(), and ITERATE_RemoveDuplicateFiles().

installfiles_cb()

static BOOL installfiles_cb ( MSIPACKAGE *  package, LPCWSTR  filename, DWORD  action, LPWSTR *  path, DWORD *  attrs, PVOID  user  )

static

Definition at line 505 of file files.c.

{
    MSIFILE *file = *(MSIFILE **)user;
 
    if (action == MSICABEXTRACT_BEGINEXTRACT)
    {
        if (!(file = find_file( package, file->disk_id, filename )))
        {
            TRACE("unknown file in cabinet (%s)\n", debugstr_w(filename));
            return FALSE;
        }
        if (file->state != msifs_missing && file->state != msifs_overwrite)
            return FALSE;
 
        if (!msi_is_global_assembly( file->Component ))
        {
            create_folder( package, file->Component->Directory );
        }
        *path = wcsdup( file->TargetPath );
        *attrs = file->Attributes;
        *(MSIFILE **)user = file;
    }
    else if (action == MSICABEXTRACT_FILEEXTRACTED)
    {
        if (!msi_is_global_assembly( file->Component )) file->state = msifs_installed;
    }
 
    return TRUE;
}

Referenced by ACTION_InstallFiles().

is_obsoleted_by_patch()

static BOOL is_obsoleted_by_patch ( MSIPACKAGE *  package, MSIFILE *  file  )

static

Definition at line 275 of file files.c.

{
    if (!list_empty( &package->patches ) && file->disk_id < MSI_INITIAL_MEDIA_TRANSFORM_DISKID)
    {
        if (!msi_get_property_int( package->db, L"Installed", 0 )) return FALSE;
        return TRUE;
    }
    if (is_registered_patch_media( package, file->disk_id )) return TRUE;
    return FALSE;
}

Referenced by calculate_install_state().

is_registered_patch_media()

static BOOL is_registered_patch_media ( MSIPACKAGE *  package, UINT  disk_id  )

static

Definition at line 264 of file files.c.

{
    MSIPATCHINFO *patch;
 
    LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
    {
        if (patch->disk_id == disk_id && patch->registered) return TRUE;
    }
    return FALSE;
}

Referenced by is_obsoleted_by_patch(), and patchfiles_cb().

ITERATE_DuplicateFiles()

static UINT ITERATE_DuplicateFiles ( MSIRECORD *  row, LPVOID  param  )

static

Definition at line 1254 of file files.c.

{
    MSIPACKAGE *package = param;
    LPWSTR dest;
    LPCWSTR file_key, component;
    MSICOMPONENT *comp;
    MSIRECORD *uirow;
    MSIFILE *file;
 
    component = MSI_RecordGetString(row,2);
    comp = msi_get_loaded_component(package, component);
    if (!comp)
        return ERROR_SUCCESS;
 
    comp->Action = msi_get_component_action( package, comp );
    if (comp->Action != INSTALLSTATE_LOCAL)
    {
        TRACE("component not scheduled for installation %s\n", debugstr_w(component));
        return ERROR_SUCCESS;
    }
 
    file_key = MSI_RecordGetString(row,3);
    if (!file_key)
    {
        ERR("Unable to get file key\n");
        return ERROR_FUNCTION_FAILED;
    }
 
    file = msi_get_loaded_file( package, file_key );
    if (!file)
    {
        ERR("Original file unknown %s\n", debugstr_w(file_key));
        return ERROR_SUCCESS;
    }
 
    dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
    if (!dest)
    {
        WARN("Unable to get duplicate filename\n");
        return ERROR_SUCCESS;
    }
 
    TRACE("Duplicating file %s to %s\n", debugstr_w(file->TargetPath), debugstr_w(dest));
    if (!copy_file( package, file->TargetPath, dest, TRUE ))
    {
        WARN( "failed to copy file %s -> %s (%lu)\n",
              debugstr_w(file->TargetPath), debugstr_w(dest), GetLastError() );
    }
    FIXME("We should track these duplicate files as well\n");
 
    uirow = MSI_CreateRecord( 9 );
    MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
    MSI_RecordSetInteger( uirow, 6, file->FileSize );
    MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
    msiobj_release( &uirow->hdr );
 
    free(dest);
    return ERROR_SUCCESS;
}

Referenced by ACTION_DuplicateFiles().

ITERATE_MoveFiles()

static UINT ITERATE_MoveFiles ( MSIRECORD *  rec, LPVOID  param  )

static

Definition at line 1059 of file files.c.

{
    MSIPACKAGE *package = param;
    MSIRECORD *uirow;
    MSICOMPONENT *comp;
    LPCWSTR sourcename, component;
    LPWSTR sourcedir, destname = NULL, destdir = NULL, source = NULL, dest = NULL;
    int options;
    DWORD size;
    BOOL wildcards;
 
    component = MSI_RecordGetString(rec, 2);
    comp = msi_get_loaded_component(package, component);
    if (!comp)
        return ERROR_SUCCESS;
 
    comp->Action = msi_get_component_action( package, comp );
    if (comp->Action != INSTALLSTATE_LOCAL)
    {
        TRACE("component not scheduled for installation %s\n", debugstr_w(component));
        return ERROR_SUCCESS;
    }
 
    sourcename = MSI_RecordGetString(rec, 3);
    options = MSI_RecordGetInteger(rec, 7);
 
    sourcedir = msi_dup_property(package->db, MSI_RecordGetString(rec, 5));
    if (!sourcedir)
        goto done;
 
    destdir = msi_dup_property(package->db, MSI_RecordGetString(rec, 6));
    if (!destdir)
        goto done;
 
    if (!sourcename)
    {
        if (msi_get_file_attributes( package, sourcedir ) == INVALID_FILE_ATTRIBUTES)
            goto done;
 
        source = wcsdup(sourcedir);
        if (!source)
            goto done;
    }
    else
    {
        size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
        source = malloc(size * sizeof(WCHAR));
        if (!source)
            goto done;
 
        lstrcpyW(source, sourcedir);
        if (source[lstrlenW(source) - 1] != '\\')
            lstrcatW(source, L"\\");
        lstrcatW(source, sourcename);
    }
 
    wildcards = wcschr(source, '*') || wcschr(source, '?');
 
    if (MSI_RecordIsNull(rec, 4))
    {
        if (!wildcards)
        {
            WCHAR *p;
            if (sourcename)
                destname = wcsdup(sourcename);
            else if ((p = wcsrchr(sourcedir, '\\')))
                destname = wcsdup(p + 1);
            else
                destname = wcsdup(sourcedir);
            if (!destname)
                goto done;
        }
    }
    else
    {
        destname = wcsdup(MSI_RecordGetString(rec, 4));
        if (destname) msi_reduce_to_long_filename(destname);
    }
 
    size = 0;
    if (destname)
        size = lstrlenW(destname);
 
    size += lstrlenW(destdir) + 2;
    dest = malloc(size * sizeof(WCHAR));
    if (!dest)
        goto done;
 
    lstrcpyW(dest, destdir);
    if (dest[lstrlenW(dest) - 1] != '\\')
        lstrcatW(dest, L"\\");
 
    if (destname)
        lstrcatW(dest, destname);
 
    if (msi_get_file_attributes( package, destdir ) == INVALID_FILE_ATTRIBUTES)
    {
        if (!msi_create_full_path( package, destdir ))
        {
            WARN( "failed to create directory %lu\n", GetLastError() );
            goto done;
        }
    }
 
    if (!wildcards)
        move_file( package, source, dest, options );
    else
        move_files_wildcard( package, source, dest, options );
 
done:
    uirow = MSI_CreateRecord( 9 );
    MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(rec, 1) );
    MSI_RecordSetInteger( uirow, 6, 1 ); /* FIXME */
    MSI_RecordSetStringW( uirow, 9, destdir );
    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
    msiobj_release( &uirow->hdr );
 
    free(sourcedir);
    free(destdir);
    free(destname);
    free(source);
    free(dest);
 
    return ERROR_SUCCESS;
}

Referenced by ACTION_MoveFiles().

ITERATE_RemoveDuplicateFiles()

static UINT ITERATE_RemoveDuplicateFiles ( MSIRECORD *  row, LPVOID  param  )

static

Definition at line 1332 of file files.c.

{
    MSIPACKAGE *package = param;
    LPWSTR dest;
    LPCWSTR file_key, component;
    MSICOMPONENT *comp;
    MSIRECORD *uirow;
    MSIFILE *file;
 
    component = MSI_RecordGetString( row, 2 );
    comp = msi_get_loaded_component( package, component );
    if (!comp)
        return ERROR_SUCCESS;
 
    comp->Action = msi_get_component_action( package, comp );
    if (comp->Action != INSTALLSTATE_ABSENT)
    {
        TRACE("component not scheduled for removal %s\n", debugstr_w(component));
        return ERROR_SUCCESS;
    }
 
    file_key = MSI_RecordGetString( row, 3 );
    if (!file_key)
    {
        ERR("Unable to get file key\n");
        return ERROR_FUNCTION_FAILED;
    }
 
    file = msi_get_loaded_file( package, file_key );
    if (!file)
    {
        ERR("Original file unknown %s\n", debugstr_w(file_key));
        return ERROR_SUCCESS;
    }
 
    dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
    if (!dest)
    {
        WARN("Unable to get duplicate filename\n");
        return ERROR_SUCCESS;
    }
 
    TRACE("Removing duplicate %s of %s\n", debugstr_w(dest), debugstr_w(file->TargetPath));
    if (!msi_delete_file( package, dest ))
    {
        WARN( "failed to delete duplicate file %s (%lu)\n", debugstr_w(dest), GetLastError() );
    }
 
    uirow = MSI_CreateRecord( 9 );
    MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
    MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
    msiobj_release( &uirow->hdr );
 
    free(dest);
    return ERROR_SUCCESS;
}

Referenced by ACTION_RemoveDuplicateFiles().

ITERATE_RemoveFiles()

static UINT ITERATE_RemoveFiles ( MSIRECORD *  row, LPVOID  param  )

static

Definition at line 1431 of file files.c.

{
    MSIPACKAGE *package = param;
    MSICOMPONENT *comp;
    MSIRECORD *uirow;
    LPCWSTR component, dirprop;
    UINT install_mode;
    LPWSTR dir = NULL, path = NULL, filename = NULL;
    DWORD size;
    UINT ret = ERROR_SUCCESS;
 
    component = MSI_RecordGetString(row, 2);
    dirprop = MSI_RecordGetString(row, 4);
    install_mode = MSI_RecordGetInteger(row, 5);
 
    comp = msi_get_loaded_component(package, component);
    if (!comp)
        return ERROR_SUCCESS;
 
    comp->Action = msi_get_component_action( package, comp );
    if (!verify_comp_for_removal(comp, install_mode))
    {
        TRACE("Skipping removal due to install mode\n");
        return ERROR_SUCCESS;
    }
    if (comp->assembly && !comp->assembly->application)
    {
        return ERROR_SUCCESS;
    }
    if (comp->Attributes & msidbComponentAttributesPermanent)
    {
        TRACE("permanent component, not removing file\n");
        return ERROR_SUCCESS;
    }
 
    dir = msi_dup_property(package->db, dirprop);
    if (!dir)
    {
        WARN("directory property has no value\n");
        return ERROR_SUCCESS;
    }
    size = 0;
    if ((filename = wcsdup( MSI_RecordGetString(row, 3) )))
    {
        msi_reduce_to_long_filename( filename );
        size = lstrlenW( filename );
    }
    size += lstrlenW(dir) + 2;
    path = malloc(size * sizeof(WCHAR));
    if (!path)
    {
        ret = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    if (filename)
    {
        lstrcpyW(path, dir);
        PathAddBackslashW(path);
        lstrcatW(path, filename);
 
        TRACE("Deleting misc file: %s\n", debugstr_w(path));
        msi_delete_file( package, path );
    }
    else
    {
        TRACE("Removing misc directory: %s\n", debugstr_w(dir));
        msi_remove_directory( package, dir );
    }
 
done:
    uirow = MSI_CreateRecord( 9 );
    MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(row, 1) );
    MSI_RecordSetStringW( uirow, 9, dir );
    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
    msiobj_release( &uirow->hdr );
 
    free(filename);
    free(path);
    free(dir);
    return ret;
}

Referenced by ACTION_RemoveFiles().

move_file()

static BOOL move_file ( MSIPACKAGE *  package, const WCHAR *  source, const WCHAR *  dest, int  options  )

static

Definition at line 863 of file files.c.

{
    BOOL ret;
 
    if (msi_get_file_attributes( package, source ) == FILE_ATTRIBUTE_DIRECTORY ||
        msi_get_file_attributes( package, dest ) == FILE_ATTRIBUTE_DIRECTORY)
    {
        WARN("Source or dest is directory, not moving\n");
        return FALSE;
    }
 
    if (options == msidbMoveFileOptionsMove)
    {
        TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
        ret = msi_move_file( package, source, dest, MOVEFILE_REPLACE_EXISTING );
        if (!ret)
        {
            WARN( "msi_move_file failed: %lu\n", GetLastError() );
            return FALSE;
        }
    }
    else
    {
        TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
        ret = copy_file( package, source, dest, FALSE );
        if (!ret)
        {
            WARN( "copy_file failed: %lu\n", GetLastError() );
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by ITERATE_MoveFiles(), and move_files_wildcard().

move_files_wildcard()

static BOOL move_files_wildcard ( MSIPACKAGE *  package, const WCHAR *  source, WCHAR *  dest, int  options  )

static

Definition at line 985 of file files.c.

{
    WIN32_FIND_DATAW wfd;
    HANDLE hfile;
    LPWSTR path;
    BOOL res;
    struct file_list files, *file;
    DWORD size;
 
    hfile = msi_find_first_file( package, source, &wfd );
    if (hfile == INVALID_HANDLE_VALUE) return FALSE;
 
    list_init(&files.entry);
 
    for (res = TRUE; res; res = msi_find_next_file( package, hfile, &wfd ))
    {
        if (is_dot_dir(wfd.cFileName)) continue;
 
        path = wildcard_to_file( source, wfd.cFileName );
        if (!path)
        {
            res = FALSE;
            goto done;
        }
 
        add_wildcard(&files, path, dest);
        free(path);
    }
 
    /* no files match the wildcard */
    if (list_empty(&files.entry))
        goto done;
 
    /* only the first wildcard match gets renamed to dest */
    file = LIST_ENTRY(list_head(&files.entry), struct file_list, entry);
    size = (wcsrchr(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
    file->dest = realloc(file->dest, size * sizeof(WCHAR));
    if (!file->dest)
    {
        res = FALSE;
        goto done;
    }
 
    /* file->dest may be shorter after the reallocation, so add a NULL
     * terminator.  This is needed for the call to wcsrchr, as there will no
     * longer be a NULL terminator within the bounds of the allocation in this case.
     */
    file->dest[size - 1] = '\0';
    lstrcpyW(wcsrchr(file->dest, '\\') + 1, file->destname);
 
    while (!list_empty(&files.entry))
    {
        file = LIST_ENTRY(list_head(&files.entry), struct file_list, entry);
 
        move_file( package, file->source, file->dest, options );
 
        list_remove(&file->entry);
        free_file_entry(file);
    }
 
    res = TRUE;
 
done:
    free_list(&files);
    FindClose(hfile);
    return res;
}

Referenced by ITERATE_MoveFiles().

msi_create_file()

HANDLE msi_create_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation,
		DWORD	flags
	)

Definition at line 60 of file files.c.

{
    HANDLE handle;
    msi_disable_fs_redirection( package );
    handle = CreateFileW( filename, access, sharing, NULL, creation, flags, NULL );
    msi_revert_fs_redirection( package );
    return handle;
}

Referenced by cabinet_copy_file(), HANDLE_CustomType21_22(), ITERATE_PublishIcon(), load_ttf_name_id(), msi_get_disk_file_size(), and msi_get_filehash().

msi_create_full_path()

BOOL msi_create_full_path	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 211 of file files.c.

{
    BOOL ret = TRUE;
    WCHAR *new_path;
    int len;
 
    if (!(new_path = malloc( (wcslen( path ) + 1) * sizeof(WCHAR) ))) return FALSE;
    lstrcpyW( new_path, path );
 
    while ((len = lstrlenW( new_path )) && new_path[len - 1] == '\\')
    new_path[len - 1] = 0;
 
    while (!create_directory( package, new_path ))
    {
        WCHAR *slash;
        DWORD last_error = GetLastError();
        if (last_error == ERROR_ALREADY_EXISTS) break;
        if (last_error != ERROR_PATH_NOT_FOUND)
        {
            ret = FALSE;
            break;
        }
        if (!(slash = wcsrchr( new_path, '\\' )))
        {
            ret = FALSE;
            break;
        }
        len = slash - new_path;
        new_path[len] = 0;
        if (!msi_create_full_path( package, new_path ))
        {
            ret = FALSE;
            break;
        }
        new_path[len] = '\\';
    }
    free( new_path );
    return ret;
}

Referenced by create_folder(), get_duplicate_filename(), get_link_file(), ITERATE_CreateFolders(), ITERATE_MoveFiles(), msi_build_icon_path(), and msi_create_full_path().

msi_delete_file()

BOOL msi_delete_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 79 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = DeleteFileW( filename );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_RemoveFiles(), cabinet_copy_file(), ITERATE_PublishIcon(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveFiles(), ITERATE_RemoveShortcuts(), ITERATE_UnpublishIcon(), and patch_file().

msi_find_first_file()

HANDLE msi_find_first_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		WIN32_FIND_DATAW *	data
	)

Definition at line 124 of file files.c.

{
    HANDLE handle;
    msi_disable_fs_redirection( package );
    handle = FindFirstFileW( filename, data );
    msi_revert_fs_redirection( package );
    return handle;
}

Referenced by move_files_wildcard(), and recurse_search_directory().

msi_find_next_file()

BOOL msi_find_next_file	(	MSIPACKAGE *	package,
		HANDLE	handle,
		WIN32_FIND_DATAW *	data
	)

Definition at line 133 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = FindNextFileW( handle, data );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by move_files_wildcard(), and recurse_search_directory().

msi_get_disk_file_size()

DWORD msi_get_disk_file_size	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 199 of file files.c.

{
    DWORD size;
    HANDLE file;
    file = msi_create_file( package, filename, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, 0 );
    if (file == INVALID_HANDLE_VALUE) return INVALID_FILE_SIZE;
    size = GetFileSize( file, NULL );
    CloseHandle( file );
    return size;
}

Referenced by calculate_file_cost(), and calculate_install_state().

msi_get_disk_file_version()

VS_FIXEDFILEINFO * msi_get_disk_file_version	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 170 of file files.c.

{
    VS_FIXEDFILEINFO *ptr, *ret;
    DWORD version_size;
    UINT size;
    void *version;
 
    if (!(version_size = msi_get_file_version_info( package, filename, 0, NULL ))) return NULL;
    if (!(version = malloc( version_size ))) return NULL;
 
    msi_get_file_version_info( package, filename, version_size, version );
 
    if (!VerQueryValueW( version, L"\\", (void **)&ptr, &size ))
    {
        free( version );
        return NULL;
    }
 
    if (!(ret = malloc( size )))
    {
        free( version );
        return NULL;
    }
 
    memcpy( ret, ptr, size );
    free( version );
    return ret;
}

Referenced by ACTION_RemoveFiles(), calculate_file_cost(), and calculate_install_state().

msi_get_file_attributes()

DWORD msi_get_file_attributes	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 115 of file files.c.

{
    DWORD attrs;
    msi_disable_fs_redirection( package );
    attrs = GetFileAttributesW( path );
    msi_revert_fs_redirection( package );
    return attrs;
}

Referenced by cabinet_copy_file(), calculate_file_cost(), calculate_install_state(), check_directory(), ITERATE_MoveFiles(), move_file(), msi_resolve_file_source(), MSI_SetTargetPathW(), search_components(), search_directory(), search_dr(), and search_file().

msi_get_file_version_info()

DWORD msi_get_file_version_info	(	MSIPACKAGE *	package,
		const WCHAR *	path,
		DWORD	buflen,
		BYTE *	buffer
	)

Definition at line 160 of file files.c.

{
    DWORD size, handle;
    msi_disable_fs_redirection( package );
    if (buffer) size = GetFileVersionInfoW( path, 0, buflen, buffer );
    else size = GetFileVersionInfoSizeW( path, &handle );
    msi_revert_fs_redirection( package );
    return size;
}

Referenced by file_version_matches(), msi_get_disk_file_version(), and search_file().

msi_get_temp_file_name()

BOOL msi_get_temp_file_name	(	MSIPACKAGE *	package,
		const WCHAR *	tmp_path,
		const WCHAR *	prefix,
		WCHAR *	tmp_filename
	)

Definition at line 51 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = GetTempFileNameW( tmp_path, prefix, 0, tmp_filename );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by cabinet_copy_file().

msi_move_file()

BOOL msi_move_file	(	MSIPACKAGE *	package,
		const WCHAR *	from,
		const WCHAR *	to,
		DWORD	flags
	)

Definition at line 142 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = MoveFileExW( from, to, flags );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by cabinet_copy_file(), copy_install_file(), move_file(), and patch_file().

msi_patch_assembly()

UINT msi_patch_assembly	(	MSIPACKAGE *	package,
		MSIASSEMBLY *	assembly,
		MSIFILEPATCH *	patch
	)

Definition at line 726 of file files.c.

{
    UINT r = ERROR_FUNCTION_FAILED;
    IAssemblyName *name;
    IAssemblyEnum *iter;
 
    if (!(iter = msi_create_assembly_enum( package, assembly->display_name )))
        return ERROR_FUNCTION_FAILED;
 
    while ((IAssemblyEnum_GetNextAssembly( iter, NULL, &name, 0 ) == S_OK))
    {
        WCHAR *displayname, *path;
        DWORD len = 0;
        HRESULT hr;
 
        hr = IAssemblyName_GetDisplayName( name, NULL, &len, 0 );
        if (hr != E_NOT_SUFFICIENT_BUFFER || !(displayname = malloc( len * sizeof(WCHAR) )))
            break;
 
        hr = IAssemblyName_GetDisplayName( name, displayname, &len, 0 );
        if (FAILED( hr ))
        {
            free( displayname );
            break;
        }
 
        if ((path = msi_get_assembly_path( package, displayname )))
        {
            if (!copy_file( package, path, patch->File->TargetPath, FALSE ))
            {
                ERR( "failed to copy file %s -> %s (%lu)\n", debugstr_w(path),
                     debugstr_w(patch->File->TargetPath), GetLastError() );
                free( path );
                free( displayname );
                IAssemblyName_Release( name );
                break;
            }
            r = patch_file( package, patch );
            free( path );
        }
 
        free( displayname );
        IAssemblyName_Release( name );
        if (r == ERROR_SUCCESS) break;
    }
 
    IAssemblyEnum_Release( iter );
    return r;
}

Referenced by ACTION_InstallFinalize().

msi_reduce_to_long_filename()

void msi_reduce_to_long_filename

(

WCHAR *

filename

)

Definition at line 1053 of file files.c.

{
    WCHAR *p = wcschr( filename, '|' );
    if (p) memmove( filename, p + 1, (lstrlenW( p + 1 ) + 1) * sizeof(WCHAR) );
}

Referenced by get_duplicate_filename(), get_link_file(), ITERATE_MoveFiles(), ITERATE_RemoveFiles(), load_class(), and load_file().

msi_remove_directory()

BOOL msi_remove_directory	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 97 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = RemoveDirectoryW( path );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ITERATE_RemoveFiles(), and ITERATE_UnpublishIcon().

msi_resolve_file_source()

WCHAR * msi_resolve_file_source	(	MSIPACKAGE *	package,
		MSIFILE *	file
	)

Definition at line 536 of file files.c.

{
    WCHAR *p, *path;
 
    TRACE("Working to resolve source of file %s\n", debugstr_w(file->File));
 
    if (file->IsCompressed) return NULL;
 
    p = msi_resolve_source_folder( package, file->Component->Directory, NULL );
    path = msi_build_directory_name( 2, p, file->ShortName );
 
    if (file->LongName && msi_get_file_attributes( package, path ) == INVALID_FILE_ATTRIBUTES)
    {
        free( path );
        path = msi_build_directory_name( 2, p, file->LongName );
    }
    free( p );
    TRACE("file %s source resolves to %s\n", debugstr_w(file->File), debugstr_w(path));
    return path;
}

Referenced by ACTION_InstallFiles(), and ACTION_ProcessComponents().

msi_set_file_attributes()

BOOL msi_set_file_attributes	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		DWORD	attrs
	)

Definition at line 106 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = SetFileAttributesW( filename, attrs );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_RemoveFiles(), cabinet_copy_file(), copy_file_attributes(), and copy_install_file().

patch_file()

static UINT patch_file ( MSIPACKAGE *  package, MSIFILEPATCH *  patch  )

static

Definition at line 704 of file files.c.

{
    UINT r = ERROR_SUCCESS;
    WCHAR *tmpfile = msi_create_temp_file( package->db );
 
    if (!tmpfile) return ERROR_INSTALL_FAILURE;
    if (apply_filepatch( package, patch->path, patch->File->TargetPath, tmpfile ))
    {
        msi_delete_file( package, patch->File->TargetPath );
        msi_move_file( package, tmpfile, patch->File->TargetPath, 0 );
    }
    else
    {
        WARN( "failed to patch %s: %#lx\n", debugstr_w(patch->File->TargetPath), GetLastError() );
        r = ERROR_INSTALL_FAILURE;
    }
    DeleteFileW( patch->path );
    DeleteFileW( tmpfile );
    free( tmpfile );
    return r;
}

Referenced by ACTION_PatchFiles(), ApplyPatchToFileA(), ApplyPatchToFileByHandles(), ApplyPatchToFileW(), msi_apply_registered_patch(), msi_patch_assembly(), TestApplyPatchToFileA(), TestApplyPatchToFileByHandles(), and TestApplyPatchToFileW().

patchfiles_cb()

static BOOL patchfiles_cb ( MSIPACKAGE *  package, LPCWSTR  file, DWORD  action, LPWSTR *  path, DWORD *  attrs, PVOID  user  )

static

Definition at line 670 of file files.c.

{
    MSIFILEPATCH *patch = *(MSIFILEPATCH **)user;
 
    if (action == MSICABEXTRACT_BEGINEXTRACT)
    {
        MSICOMPONENT *comp;
 
        if (is_registered_patch_media( package, patch->disk_id ) ||
            !(patch = find_filepatch( package, patch->disk_id, file ))) return FALSE;
 
        comp = patch->File->Component;
        comp->Action = msi_get_component_action( package, comp );
        if (!comp->Enabled || comp->Action != INSTALLSTATE_LOCAL)
        {
            TRACE("file %s component %s not installed or disabled\n",
                  debugstr_w(patch->File->File), debugstr_w(comp->Component));
            return FALSE;
        }
 
        patch->path = msi_create_temp_file( package->db );
        *path = wcsdup( patch->path );
        *attrs = patch->File->Attributes;
        *(MSIFILEPATCH **)user = patch;
    }
    else if (action == MSICABEXTRACT_FILEEXTRACTED)
    {
        patch->extracted = TRUE;
    }
 
    return TRUE;
}

Referenced by ACTION_PatchFiles().

remove_folder()

static void remove_folder ( MSIFOLDER *  folder )

static

Definition at line 1514 of file files.c.

{
    FolderList *fl;
 
    LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
    {
        remove_folder( fl->folder );
    }
    if (!folder->persistent && folder->State != FOLDER_STATE_REMOVED)
    {
        if (RemoveDirectoryW( folder->ResolvedTarget )) folder->State = FOLDER_STATE_REMOVED;
    }
}

Referenced by ACTION_RemoveFiles(), and remove_folder().

schedule_install_files()

static void schedule_install_files ( MSIPACKAGE *  package )

static

Definition at line 387 of file files.c.

{
    MSIFILE *file;
 
    LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
    {
        MSICOMPONENT *comp = file->Component;
 
        file->state = calculate_install_state( package, file );
        if (file->state == msifs_overwrite && (comp->Attributes & msidbComponentAttributesNeverOverwrite))
        {
            TRACE("not overwriting %s\n", debugstr_w(file->TargetPath));
            file->state = msifs_skipped;
        }
    }
}

Referenced by ACTION_InstallFiles().

verify_comp_for_removal()

static BOOL verify_comp_for_removal ( MSICOMPONENT *  comp, UINT  install_mode  )

static

Definition at line 1407 of file files.c.

{
    /* special case */
    if (comp->Action != INSTALLSTATE_SOURCE &&
        comp->Attributes & msidbComponentAttributesSourceOnly &&
        (install_mode == msidbRemoveFileInstallModeOnRemove ||
         install_mode == msidbRemoveFileInstallModeOnBoth)) return TRUE;
 
    switch (comp->Action)
    {
    case INSTALLSTATE_LOCAL:
    case INSTALLSTATE_SOURCE:
        if (install_mode == msidbRemoveFileInstallModeOnInstall ||
            install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
        break;
    case INSTALLSTATE_ABSENT:
        if (install_mode == msidbRemoveFileInstallModeOnRemove ||
            install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
        break;
    default: break;
    }
    return FALSE;
}

Referenced by ITERATE_RemoveFiles().

wildcard_to_file()

static WCHAR * wildcard_to_file ( const WCHAR *  wildcard, const WCHAR *  filename  )

static

Definition at line 898 of file files.c.

{
    const WCHAR *ptr;
    WCHAR *path;
    DWORD dirlen, pathlen;
 
    ptr = wcsrchr(wildcard, '\\');
    dirlen = ptr - wildcard + 1;
 
    pathlen = dirlen + lstrlenW(filename) + 1;
    if (!(path = malloc(pathlen * sizeof(WCHAR)))) return NULL;
 
    lstrcpynW(path, wildcard, dirlen + 1);
    lstrcatW(path, filename);
 
    return path;
}

Referenced by move_files_wildcard().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msi

)