patch.c File Reference

#include <stdio.h>
#include <windows.h>
#include <msiquery.h>
#include <msidefs.h>
#include <msi.h>
#include <wtypes.h>
#include "wine/test.h"

Include dependency graph for patch.c:

Go to the source code of this file.

Classes
struct	msi_table
struct	table_data

Macros
#define	_WIN32_MSI   300
#define	COBJMACROS
#define	ADD_TABLE(x)   { #x".idt", x##_dat, sizeof(x##_dat) }
#define	GET_PROC(mod, func)
#define	create_file(name, size)   create_file_data( name, name, size )

Functions
static	UINT (WINAPI *pMsiApplyPatchA)(LPCSTR
static void	init_function_pointers (void)
static BOOL	is_process_limited (void)
static BOOL	get_program_files_dir (char *buf, char *buf2)
static void	create_file_data (const char *filename, const char *data, DWORD size)
static BOOL	delete_pf (const char *rel_path, BOOL is_file)
static DWORD	get_pf_file_size (const char *filename)
static void	write_file (const char *filename, const char *data, DWORD data_size)
static void	set_suminfo (const WCHAR *filename)
static void	create_database (const char *filename, const struct msi_table *tables, UINT num_tables)
static void	write_tables (IStorage *stg, const struct table_data *tables, UINT num_tables)
static void	create_patch (const char *filename)
static void	test_simple_patch (void)
static void	test_MsiOpenDatabase (void)
static UINT	find_entry (MSIHANDLE hdb, const char *table, const char *entry)
static UINT	find_entryW (MSIHANDLE hdb, const WCHAR *table, const WCHAR *entry)
static INT	get_integer (MSIHANDLE hdb, UINT field, const char *query)
static char *	get_string (MSIHANDLE hdb, UINT field, const char *query)
static void	test_system_tables (void)
static void	test_patch_registration (void)
	START_TEST (patch)

Variables
static	LPCSTR
static	INSTALLTYPE
static	MSIINSTALLCONTEXT
static	LPSTR
static DWORD *static	DWORD
static DWORD *static MSIINSTALLCONTEXT	LPDWORD
static const char *	msifile = "winetest-patch.msi"
static const char *	mspfile = "winetest-patch.msp"
static const WCHAR	msifileW [] = L"winetest-patch.msi"
static const WCHAR	mspfileW [] = L"winetest-patch.msp"
static char	CURR_DIR [MAX_PATH]
static char	PROG_FILES_DIR [MAX_PATH]
static char	COMMON_FILES_DIR [MAX_PATH]
static const char	property_dat []
static const char	media_dat []
static const char	file_dat []
static const char	directory_dat []
static const char	component_dat []
static const char	feature_dat []
static const char	feature_comp_dat []
static const char	install_exec_seq_dat []
static const char	condition_dat []
static const struct msi_table	tables []
static const WCHAR	p_name0 [] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }
static const WCHAR	p_name1 [] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }
static const WCHAR	p_name2 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }
static const WCHAR	p_name3 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }
static const WCHAR	p_name4 [] = { 0x3a8c, 0x47cb, 0x45b0, 0x45ec, 0x45a8, 0x4837, 0}
static const WCHAR	p_name5 [] = { 0x4840, 0x4596, 0x3e6c, 0x45e4, 0x42e6, 0x421c, 0x4634, 0x4468, 0x4226, 0 }
static const WCHAR	p_name6 []
static const WCHAR	p_name7 []
static const WCHAR	p_name8 []
static const WCHAR	p_data0 []
static const WCHAR	p_data1 []
static const char	p_data2 []
static const WCHAR	p_data3 []
static const char	p_data4 []
static const WCHAR	p_data5 []
static const char	p_data6 []
static const struct table_data	table_patch_data []
static const WCHAR	t1_name0 [] = { 0x4840, 0x430f, 0x422f, 0 }
static const WCHAR	t1_name1 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }
static const WCHAR	t1_name2 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }
static const WCHAR	t1_name3 []
static const WCHAR	t1_data0 []
static const char	t1_data1 []
static const WCHAR	t1_data2 []
static const char	t1_data3 []
static const struct table_data	table_transform1_data []
static const WCHAR	t2_name0 [] = { 0x4840, 0x430f, 0x422f, 0 }
static const WCHAR	t2_name1 [] = { 0x4840, 0x4216, 0x4327, 0x4824, 0 }
static const WCHAR	t2_name2 [] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }
static const WCHAR	t2_name3 [] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }
static const WCHAR	t2_name4 [] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }
static const WCHAR	t2_name5 [] = { 0x4840, 0x4119, 0x41b7, 0x3e6b, 0x41a4, 0x412e, 0x422a, 0 }
static const WCHAR	t2_name6 []
static const WCHAR	t2_name7 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }
static const WCHAR	t2_name8 [] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }
static const WCHAR	t2_name9 []
static const WCHAR	t2_name10 []
static const WCHAR	t2_name11 [] = { 0x4840, 0x448c, 0x44f0, 0x4472, 0x4468, 0x4837, 0 }
static const WCHAR	t2_name12 [] = { 0x4840, 0x420f, 0x45e4, 0x4578, 0x4828, 0 }
static const WCHAR	t2_data0 []
static const WCHAR	t2_data1 []
static const WCHAR	t2_data2 []
static const WCHAR	t2_data3 []
static const WCHAR	t2_data4 []
static const WCHAR	t2_data5 []
static const WCHAR	t2_data6 []
static const char	t2_data7 []
static const WCHAR	t2_data8 []
static const char	t2_data9 []
static const WCHAR	t2_data10 []
static const WCHAR	t2_data11 []
static const WCHAR	t2_data12 []
static const struct table_data	table_transform2_data []

Macro Definition Documentation

_WIN32_MSI

#define _WIN32_MSI   300

Definition at line 21 of file patch.c.

ADD_TABLE

#define ADD_TABLE

(

x

)

{ #x".idt", x##_dat, sizeof(x##_dat) }

Definition at line 139 of file patch.c.

COBJMACROS

#define COBJMACROS

Definition at line 22 of file patch.c.

create_file

#define create_file	(		name,
			size
	)		create_file_data( name, name, size )

Definition at line 230 of file patch.c.

GET_PROC

#define GET_PROC	(		mod,
			func
	)

Value:

    p ## func = (void *)GetProcAddress( mod, #func ); \
    if (!p ## func) \
        trace( "GetProcAddress(%s) failed\n", #func );

Function Documentation

create_database()

static void create_database ( const char *  filename, const struct msi_table *  tables, UINT  num_tables  )

static

Definition at line 316 of file patch.c.

{
    MSIHANDLE hdb;
    UINT r, i;
    WCHAR *filenameW;
    int len;
 
    len = MultiByteToWideChar( CP_ACP, 0, filename, -1, NULL, 0 );
    if (!(filenameW = malloc( len * sizeof(WCHAR) ))) return;
    MultiByteToWideChar( CP_ACP, 0, filename, -1, filenameW, len );
 
    r = MsiOpenDatabaseW( filenameW, MSIDBOPEN_CREATE, &hdb );
    ok(r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r);
 
    /* import the tables into the database */
    for (i = 0; i < num_tables; i++)
    {
        const struct msi_table *table = &tables[i];
 
        write_file( table->filename, table->data, (table->size - 1) * sizeof(char) );
 
        r = MsiDatabaseImportA( hdb, CURR_DIR, table->filename );
        ok(r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r);
 
        DeleteFileA( table->filename );
    }
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r);
 
    MsiCloseHandle( hdb );
    set_suminfo( filenameW );
    free( filenameW );
}

create_file_data()

static void create_file_data ( const char *  filename, const char *  data, DWORD  size  )

static

Definition at line 212 of file patch.c.

{
    HANDLE file;
    DWORD written;
 
    file = CreateFileA( filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
    if (file == INVALID_HANDLE_VALUE)
        return;
 
    WriteFile( file, data, strlen( data ), &written, NULL );
    if (size)
    {
        SetFilePointer( file, size, NULL, FILE_BEGIN );
        SetEndOfFile( file );
    }
    CloseHandle( file );
}

create_patch()

static void create_patch ( const char *  filename )

static

Definition at line 695 of file patch.c.

{
    IStorage *stg = NULL, *stg1 = NULL, *stg2 = NULL;
    WCHAR *filenameW;
    HRESULT r;
    int len;
    const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
 
    const CLSID CLSID_MsiPatch = {0xc1086, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46}};
    const CLSID CLSID_MsiTransform = {0xc1082, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46}};
 
    len = MultiByteToWideChar( CP_ACP, 0, filename, -1, NULL, 0 );
    filenameW = malloc( len * sizeof(WCHAR) );
    MultiByteToWideChar( CP_ACP, 0, filename, -1, filenameW, len );
 
    r = StgCreateDocfile( filenameW, mode, 0, &stg );
    free( filenameW );
    ok( r == S_OK, "failed to create storage %#lx\n", r );
    if (!stg)
        return;
 
    r = IStorage_SetClass( stg, &CLSID_MsiPatch );
    ok( r == S_OK, "failed to set storage type %#lx\n", r );
 
    write_tables( stg, table_patch_data, ARRAY_SIZE( table_patch_data ));
 
    r = IStorage_CreateStorage( stg, p_name7, mode, 0, 0, &stg1 );
    ok( r == S_OK, "failed to create substorage %#lx\n", r );
 
    r = IStorage_SetClass( stg1, &CLSID_MsiTransform );
    ok( r == S_OK, "failed to set storage type %#lx\n", r );
 
    write_tables( stg1, table_transform1_data, ARRAY_SIZE( table_transform1_data ));
    IStorage_Release( stg1 );
 
    r = IStorage_CreateStorage( stg, p_name8, mode, 0, 0, &stg2 );
    ok( r == S_OK, "failed to create substorage %#lx\n", r );
 
    r = IStorage_SetClass( stg2, &CLSID_MsiTransform );
    ok( r == S_OK, "failed to set storage type %#lx\n", r );
 
    write_tables( stg2, table_transform2_data, ARRAY_SIZE( table_transform2_data ));
    IStorage_Release( stg2 );
    IStorage_Release( stg );
}

Referenced by test_MsiOpenDatabase(), test_patch_registration(), test_simple_patch(), and test_system_tables().

delete_pf()

static BOOL delete_pf ( const char *  rel_path, BOOL  is_file  )

static

Definition at line 232 of file patch.c.

{
    char path[MAX_PATH];
 
    strcpy( path, PROG_FILES_DIR );
    strcat( path, "\\" );
    strcat( path, rel_path );
 
    if (is_file)
        return DeleteFileA( path );
    else
        return RemoveDirectoryA( path );
}

Referenced by test_simple_patch().

find_entry()

static UINT find_entry ( MSIHANDLE  hdb, const char *  table, const char *  entry  )

static

Definition at line 979 of file patch.c.

{
    static const char fmt[] = "SELECT * FROM `%s` WHERE `Name` = '%s'";
    char query[0x100];
    UINT r;
    MSIHANDLE hview, hrec;
 
    sprintf( query, fmt, table, entry );
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    MsiCloseHandle( hrec );
    return r;
}

Referenced by test_system_tables().

find_entryW()

static UINT find_entryW ( MSIHANDLE  hdb, const WCHAR *  table, const WCHAR *  entry  )

static

Definition at line 1000 of file patch.c.

{
    WCHAR query[0x100];
    MSIHANDLE hview, hrec;
    UINT r;
 
    wsprintfW( query, L"SELECT * FROM `%s` WHERE `Name` = '%s'", table, entry );
    r = MsiDatabaseOpenViewW( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    MsiCloseHandle( hrec );
    return r;
}

Referenced by test_system_tables().

get_integer()

static INT get_integer ( MSIHANDLE  hdb, UINT  field, const char *  query  )

static

Definition at line 1020 of file patch.c.

{
    UINT r;
    INT ret = -1;
    MSIHANDLE hview, hrec;
 
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    if (r == ERROR_SUCCESS)
    {
        UINT r_tmp;
        ret = MsiRecordGetInteger( hrec, field );
        MsiCloseHandle( hrec );
 
        r_tmp = MsiViewFetch( hview, &hrec );
        ok( r_tmp == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r);
    }
 
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    return ret;
}

Referenced by test_system_tables().

get_pf_file_size()

static DWORD get_pf_file_size ( const char *  filename )

static

Definition at line 246 of file patch.c.

{
    char path[MAX_PATH];
    HANDLE file;
    DWORD size;
 
    strcpy( path, PROG_FILES_DIR );
    strcat( path, "\\");
    strcat( path, filename );
 
    file = CreateFileA( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
    if (file == INVALID_HANDLE_VALUE)
        return INVALID_FILE_SIZE;
 
    size = GetFileSize( file, NULL );
    CloseHandle( file );
    return size;
}

Referenced by test_simple_patch().

get_program_files_dir()

static BOOL get_program_files_dir ( char *  buf, char *  buf2  )

static

Definition at line 187 of file patch.c.

{
    HKEY hkey;
    DWORD type, size;
 
    if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion", &hkey ))
        return FALSE;
 
    size = MAX_PATH;
    if (RegQueryValueExA( hkey, "ProgramFilesDir (x86)", 0, &type, (LPBYTE)buf, &size ) &&
        RegQueryValueExA( hkey, "ProgramFilesDir", 0, &type, (LPBYTE)buf, &size ))
    {
        RegCloseKey( hkey );
        return FALSE;
    }
    size = MAX_PATH;
    if (RegQueryValueExA( hkey, "CommonFilesDir", 0, &type, (LPBYTE)buf2, &size ))
    {
        RegCloseKey( hkey );
        return FALSE;
    }
    RegCloseKey( hkey );
    return TRUE;
}

Referenced by START_TEST().

get_string()

static char * get_string ( MSIHANDLE  hdb, UINT  field, const char *  query  )

static

Definition at line 1049 of file patch.c.

{
    UINT r;
    static char ret[MAX_PATH];
    MSIHANDLE hview, hrec;
 
    ret[0] = '\0';
 
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    if (r == ERROR_SUCCESS)
    {
        DWORD size = MAX_PATH;
        r = MsiRecordGetStringA( hrec, field, ret, &size );
        ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r);
        MsiCloseHandle( hrec );
 
        r = MsiViewFetch( hview, &hrec );
        ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r);
    }
 
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    return ret;
}

Referenced by test_system_tables().

init_function_pointers()

static void init_function_pointers ( void  )

static

Definition at line 154 of file patch.c.

{
    HMODULE hmsi = GetModuleHandleA( "msi.dll" );
 
#define GET_PROC( mod, func ) \
    p ## func = (void *)GetProcAddress( mod, #func ); \
    if (!p ## func) \
        trace( "GetProcAddress(%s) failed\n", #func );
 
    GET_PROC( hmsi, MsiApplyPatchA );
    GET_PROC( hmsi, MsiGetPatchInfoExA );
    GET_PROC( hmsi, MsiEnumPatchesExA );
 
#undef GET_PROC
}

Referenced by START_TEST().

is_process_limited()

static BOOL is_process_limited ( void  )

static

Definition at line 170 of file patch.c.

{
    HANDLE token;
 
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
    {
        BOOL ret;
        TOKEN_ELEVATION_TYPE type = TokenElevationTypeDefault;
        DWORD size;
 
        ret = GetTokenInformation(token, TokenElevationType, &type, sizeof(type), &size);
        CloseHandle(token);
        return (ret && type == TokenElevationTypeLimited);
    }
    return FALSE;
}

Referenced by test_patch_registration(), test_simple_patch(), and test_system_tables().

set_suminfo()

static void set_suminfo ( const WCHAR *  filename )

static

Definition at line 274 of file patch.c.

{
    UINT r;
    MSIHANDLE hsi, hdb;
 
    r = MsiOpenDatabaseW( filename, MSIDBOPEN_DIRECT, &hdb );
    ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
 
    r = MsiGetSummaryInformationA( hdb, NULL, 7, &hsi );
    ok( r == ERROR_SUCCESS, "failed to open summaryinfo %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 2, VT_LPSTR, 0, NULL, "Installation Database" );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 3, VT_LPSTR, 0, NULL, "Installation Database" );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 4, VT_LPSTR, 0, NULL, "WineHQ" );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 7, VT_LPSTR, 0, NULL, ";1033" );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 9, VT_LPSTR, 0, NULL, "{E528DDD6-4801-4BEC-BBB6-C5EE0FD097E9}" );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 14, VT_I4, 100, NULL, NULL );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, 15, VT_I4, 0, NULL, NULL );
    ok( r == ERROR_SUCCESS, "failed to set summary info %u\n", r );
 
    r = MsiSummaryInfoPersist( hsi );
    ok( r == ERROR_SUCCESS, "failed to persist suminfo %u\n", r );
 
    r = MsiCloseHandle( hsi );
    ok( r == ERROR_SUCCESS, "failed to close suminfo %u\n", r );
 
    r = MsiCloseHandle( hdb );
    ok( r == ERROR_SUCCESS, "failed to close database %u\n", r );
}

Referenced by create_database().

START_TEST()

START_TEST

(

patch

)

Definition at line 1376 of file patch.c.

{
    DWORD len;
    char temp_path[MAX_PATH], prev_path[MAX_PATH];
 
    init_function_pointers();
 
    GetCurrentDirectoryA( MAX_PATH, prev_path );
    GetTempPathA( MAX_PATH, temp_path );
    SetCurrentDirectoryA( temp_path );
 
    strcpy( CURR_DIR, temp_path );
    len = strlen( CURR_DIR );
 
    if (len && (CURR_DIR[len - 1] == '\\'))
        CURR_DIR[len - 1] = 0;
 
    get_program_files_dir( PROG_FILES_DIR, COMMON_FILES_DIR );
 
    test_simple_patch();
    test_MsiOpenDatabase();
    test_system_tables();
    test_patch_registration();
 
    SetCurrentDirectoryA( prev_path );
}

test_MsiOpenDatabase()

static void test_MsiOpenDatabase ( void  )

static

Definition at line 937 of file patch.c.

{
    UINT r;
    MSIHANDLE hdb;
 
    r = MsiOpenDatabaseW( mspfileW, MSIDBOPEN_CREATE, &hdb );
    ok(r == ERROR_SUCCESS, "failed to open database %u\n", r);
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS, "failed to commit database %u\n", r);
    MsiCloseHandle( hdb );
 
    r = MsiOpenDatabaseW( mspfileW, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &hdb );
    ok(r == ERROR_OPEN_FAILED, "expected ERROR_OPEN_FAILED, got %u\n", r);
    DeleteFileA( mspfile );
 
    r = MsiOpenDatabaseW( mspfileW, MSIDBOPEN_CREATE + MSIDBOPEN_PATCHFILE, &hdb );
    ok(r == ERROR_SUCCESS , "failed to open database %u\n", r);
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS, "failed to commit database %u\n", r);
    MsiCloseHandle( hdb );
 
    r = MsiOpenDatabaseW( mspfileW, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &hdb );
    ok(r == ERROR_SUCCESS, "failed to open database %u\n", r);
    MsiCloseHandle( hdb );
    DeleteFileA( mspfile );
 
    create_database( msifile, tables, ARRAY_SIZE(tables) );
    create_patch( mspfile );
 
    r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &hdb );
    ok(r == ERROR_OPEN_FAILED, "failed to open database %u\n", r );
 
    r = MsiOpenDatabaseW( mspfileW, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &hdb );
    ok(r == ERROR_SUCCESS, "failed to open database %u\n", r );
    MsiCloseHandle( hdb );
 
    DeleteFileA( msifile );
    DeleteFileA( mspfile );
}

Referenced by START_TEST().

test_patch_registration()

static void test_patch_registration ( void  )

static

Definition at line 1273 of file patch.c.

{
    UINT r;
    DWORD size;
    char buffer[MAX_PATH], patch_code[39];
 
    if (!pMsiApplyPatchA || !pMsiGetPatchInfoExA || !pMsiEnumPatchesExA)
    {
        win_skip("required functions not available\n");
        return;
    }
    if (is_process_limited())
    {
        skip("process is limited\n");
        return;
    }
 
    CreateDirectoryA( "msitest", NULL );
    create_file( "msitest\\patch.txt", 1000 );
 
    create_database( msifile, tables, ARRAY_SIZE(tables) );
    create_patch( mspfile );
 
    MsiSetInternalUI( INSTALLUILEVEL_NONE, NULL );
 
    r = MsiInstallProductA( msifile, "DISABLE_FEATURE=1" );
    if (r != ERROR_SUCCESS)
    {
        skip("Product installation failed with error code %d\n", r);
        goto cleanup;
    }
 
    r = MsiApplyPatchA( mspfile, NULL, INSTALLTYPE_DEFAULT, NULL );
    ok( r == ERROR_SUCCESS || broken( r == ERROR_PATCH_PACKAGE_INVALID ), /* version 2.0 */
        "expected ERROR_SUCCESS, got %u\n", r );
 
    if (r == ERROR_PATCH_PACKAGE_INVALID)
    {
        win_skip("Windows Installer < 3.0 detected\n");
        goto uninstall;
    }
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = pMsiGetPatchInfoExA( "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}",
                             "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                              NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
                              INSTALLPROPERTY_LOCALPACKAGEA, buffer, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( buffer[0], "buffer empty\n" );
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = pMsiGetPatchInfoExA( "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}",
                             "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                             NULL, MSIINSTALLCONTEXT_MACHINE,
                             INSTALLPROPERTY_LOCALPACKAGEA, buffer, &size );
    ok( r == ERROR_UNKNOWN_PRODUCT, "expected ERROR_UNKNOWN_PRODUCT, got %u\n", r );
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = pMsiGetPatchInfoExA( "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}",
                             "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                             NULL, MSIINSTALLCONTEXT_USERMANAGED,
                             INSTALLPROPERTY_LOCALPACKAGEA, buffer, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( !buffer[0], "got %s\n", buffer );
 
    r = pMsiEnumPatchesExA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                           NULL, MSIINSTALLCONTEXT_USERUNMANAGED, MSIPATCHSTATE_APPLIED,
                           0, patch_code, NULL, NULL, NULL, NULL );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( !strcmp( patch_code, "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}" ), "wrong patch code\n" );
 
    r = pMsiEnumPatchesExA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                           NULL, MSIINSTALLCONTEXT_MACHINE, MSIPATCHSTATE_APPLIED,
                           0, patch_code, NULL, NULL, NULL, NULL );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
    r = pMsiEnumPatchesExA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                           NULL, MSIINSTALLCONTEXT_USERMANAGED, MSIPATCHSTATE_APPLIED,
                           0, patch_code, NULL, NULL, NULL, NULL );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
uninstall:
    r = MsiInstallProductA( msifile, "REMOVE=ALL" );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = pMsiGetPatchInfoExA( "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}",
                             "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                              NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
                              INSTALLPROPERTY_LOCALPACKAGEA, buffer, &size );
    ok( r == ERROR_UNKNOWN_PRODUCT, "expected ERROR_UNKNOWN_PRODUCT, got %u\n", r );
 
cleanup:
    DeleteFileA( msifile );
    DeleteFileA( mspfile );
    DeleteFileA( "msitest\\patch.txt" );
    RemoveDirectoryA( "msitest" );
}

Referenced by START_TEST().

test_simple_patch()

static void test_simple_patch ( void  )

static

Definition at line 741 of file patch.c.

{
    UINT r;
    DWORD size;
    char path[MAX_PATH], install_source[MAX_PATH], buffer[32];
    const char *query;
    WCHAR pathW[MAX_PATH];
    MSIHANDLE hpackage, hdb, hview, hrec;
 
    if (!pMsiApplyPatchA)
    {
        win_skip("MsiApplyPatchA is not available\n");
        return;
    }
    if (is_process_limited())
    {
        skip("process is limited\n");
        return;
    }
 
    CreateDirectoryA( "msitest", NULL );
    create_file( "msitest\\patch.txt", 1000 );
 
    create_database( msifile, tables, ARRAY_SIZE(tables) );
    create_patch( mspfile );
 
    MsiSetInternalUI( INSTALLUILEVEL_NONE, NULL );
 
    r = MsiInstallProductA( msifile, "DISABLE_FEATURE=1" );
    if (r != ERROR_SUCCESS)
    {
        skip("Product installation failed with error code %u\n", r);
        goto cleanup;
    }
 
    size = get_pf_file_size( "msitest\\patch.txt" );
    ok( size == 1000, "expected 1000, got %lu\n", size );
 
    size = sizeof(install_source);
    r = MsiGetProductInfoA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                            "InstallSource", install_source, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    strcpy( path, CURR_DIR );
    strcat( path, "\\" );
    strcat( path, msifile );
 
    r = MsiOpenPackageA( path, &hpackage );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    hdb = MsiGetActiveDatabase( hpackage );
    ok( hdb, "failed to get database handle\n" );
 
    query = "SELECT * FROM `Property` where `Property` = 'PATCHNEWPACKAGECODE'";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
 
    query = "SELECT * FROM `Property` WHERE `Property` = 'PATCHNEWSUMMARYSUBJECT' "
            "AND `Value` = 'Installer Database'";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = MsiGetPropertyA( hpackage, "PATCHNEWSUMMARYSUBJECT", buffer, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( !strcmp( buffer, "Installer Database" ), "expected \'Installer Database\', got \'%s\'\n", buffer );
 
    MsiCloseHandle( hdb );
    MsiCloseHandle( hpackage );
 
    r = MsiApplyPatchA( mspfile, NULL, INSTALLTYPE_DEFAULT, NULL );
    ok( r == ERROR_SUCCESS || broken( r == ERROR_PATCH_PACKAGE_INVALID ), /* version 2.0 */
        "expected ERROR_SUCCESS, got %u\n", r );
 
    if (r == ERROR_PATCH_PACKAGE_INVALID)
    {
        win_skip("Windows Installer < 3.0 detected\n");
        goto uninstall;
    }
 
    size = get_pf_file_size( "msitest\\patch.txt" );
    ok( size == 1002, "expected 1002, got %lu\n", size );
    size = get_pf_file_size( "msitest\\file.txt" );
    ok( size == 1000, "expected 1000, got %lu\n", size );
 
    /* show that MsiOpenPackage applies registered patches */
    r = MsiOpenPackageA( path, &hpackage );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    hdb = MsiGetActiveDatabase( hpackage );
    ok( hdb, "failed to get database handle\n" );
 
    query = "SELECT * FROM `Property` where `Property` = 'PATCHNEWPACKAGECODE'";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
 
    query = "SELECT * FROM `Property` WHERE `Property` = 'PATCHNEWSUMMARYSUBJECT' "
            "AND `Value` = 'Installation Database'";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
 
    buffer[0] = 0;
    size = sizeof(buffer);
    r = MsiGetPropertyA( hpackage, "PATCHNEWSUMMARYSUBJECT", buffer, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( !strcmp( buffer, "Installation Database" ), "expected \'Installation Database\', got \'%s\'\n", buffer );
 
    MsiCloseHandle( hdb );
    MsiCloseHandle( hpackage );
 
    /* show that patches are not committed to the local package database */
    size = sizeof(path);
    r = MsiGetProductInfoA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                            "LocalPackage", path, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    MultiByteToWideChar( CP_ACP, 0, path, -1, pathW, MAX_PATH );
    r = MsiOpenDatabaseW( pathW, MSIDBOPEN_READONLY, &hdb );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    MsiCloseHandle( hdb );
 
uninstall:
    size = sizeof(path);
    r = MsiGetProductInfoA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}",
                            "InstallSource", path, &size );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
    ok( !strcasecmp( path, install_source ), "wrong path %s\n", path );
 
    r = MsiInstallProductA( msifile, "REMOVE=ALL" );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    ok( !delete_pf( "msitest\\patch.txt", TRUE ), "file not removed\n" );
    ok( !delete_pf( "msitest\\file.txt", TRUE ), "file not removed\n" );
    ok( !delete_pf( "msitest", FALSE ), "directory not removed\n" );
 
cleanup:
    DeleteFileA( msifile );
    DeleteFileA( mspfile );
    DeleteFileA( "msitest\\patch.txt" );
    RemoveDirectoryA( "msitest" );
}

Referenced by START_TEST().

test_system_tables()

static void test_system_tables ( void  )

static

Definition at line 1081 of file patch.c.

{
    static const char patchsource[] = "MSPSRC0F96CDC04CDF4304B2837B9264889EF7";
    UINT r;
    char *cr;
    const char *query;
    MSIHANDLE hproduct, hdb, hview, hrec;
 
    if (!pMsiApplyPatchA)
    {
        win_skip("MsiApplyPatchA is not available\n");
        return;
    }
    if (is_process_limited())
    {
        skip("process is limited\n");
        return;
    }
 
    CreateDirectoryA( "msitest", NULL );
    create_file( "msitest\\patch.txt", 1000 );
 
    create_database( msifile, tables, ARRAY_SIZE(tables) );
    create_patch( mspfile );
 
    MsiSetInternalUI( INSTALLUILEVEL_NONE, NULL );
 
    r = MsiInstallProductA( msifile, "DISABLE_FEATURE=1" );
    if (r != ERROR_SUCCESS)
    {
        skip("Product installation failed with error code %d\n", r);
        goto cleanup;
    }
 
    r = MsiOpenProductA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}", &hproduct );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    hdb = MsiGetActiveDatabase( hproduct );
    ok( hdb, "failed to get database handle\n" );
 
    r = find_entry( hdb, "_Streams", "\5SummaryInformation" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    query = "SELECT * FROM `_Storages`";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Directory" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "File" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Component" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Feature" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "FeatureComponents" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Property" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "InstallExecuteSequence" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Media" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = get_integer( hdb, 1, "SELECT * FROM `Media` WHERE `VolumeLabel`=\'DISK1\'");
    ok( r == 1, "Got %u\n", r );
 
    r = find_entry( hdb, "_Tables", "_Property" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    MsiCloseHandle( hdb );
    MsiCloseHandle( hproduct );
 
    r = MsiApplyPatchA( mspfile, NULL, INSTALLTYPE_DEFAULT, NULL );
    ok( r == ERROR_SUCCESS || broken( r == ERROR_PATCH_PACKAGE_INVALID ), /* version 2.0 */
        "expected ERROR_SUCCESS, got %u\n", r );
 
    if (r == ERROR_PATCH_PACKAGE_INVALID)
    {
        win_skip("Windows Installer < 3.0 detected\n");
        goto uninstall;
    }
 
    r = MsiOpenProductA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}", &hproduct );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    hdb = MsiGetActiveDatabase( hproduct );
    ok( hdb, "failed to get database handle\n" );
 
    r = find_entry( hdb, "_Streams", "\5SummaryInformation" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entryW( hdb, L"_Streams", L"\x3a8c\x47cb\x45b0\x45ec\x45a8\x4837" );
    ok( r == ERROR_NO_MORE_ITEMS, "failed to find entry %u\n", r );
 
    query = "SELECT * FROM `_Storages`";
    r = MsiDatabaseOpenViewA( hdb, query, &hview );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewExecute( hview, 0 );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
    r = MsiViewFetch( hview, &hrec );
    ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Directory" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "File" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Component" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Feature" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "FeatureComponents" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Property" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "InstallExecuteSequence" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Media" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "_Property" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "MsiPatchHeaders" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "Patch" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    r = find_entry( hdb, "_Tables", "PatchPackage" );
    ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
 
    cr = get_string( hdb, 6, "SELECT * FROM `Media` WHERE `Source` IS NOT NULL");
    todo_wine ok( !strcmp(cr, patchsource), "Expected \"%s\", got \"%s\"\n", patchsource, cr );
 
    r = get_integer( hdb, 1, "SELECT * FROM `Media` WHERE `Source` IS NOT NULL");
    todo_wine ok( r == 100, "Got %u\n", r );
 
    r = get_integer( hdb, 2, "SELECT * FROM `Media` WHERE `Source` IS NOT NULL");
    todo_wine ok( r == 10001, "Got %u\n", r );
 
    r = get_integer( hdb, 1, "SELECT * FROM `Media` WHERE `VolumeLabel`=\'DISK1\'");
    ok( r == 1, "Got %u\n", r );
 
    cr = get_string( hdb, 4, "SELECT * FROM `Media` WHERE `Source` IS NOT NULL");
    ok( !strcmp(cr, "#CAB_msitest"), "Expected \"#CAB_msitest\", got \"%s\"\n", cr );
 
    r = get_integer( hdb, 8, "SELECT * FROM `File` WHERE `File` = 'patch.txt'");
    ok( r == 10000, "Got %u\n", r );
 
    MsiCloseHandle( hrec );
    MsiViewClose( hview );
    MsiCloseHandle( hview );
    MsiCloseHandle( hdb );
    MsiCloseHandle( hproduct );
 
uninstall:
    r = MsiInstallProductA( msifile, "REMOVE=ALL" );
    ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
 
cleanup:
    DeleteFileA( msifile );
    DeleteFileA( mspfile );
    DeleteFileA( "msitest\\patch.txt" );
    RemoveDirectoryA( "msitest" );
}

Referenced by START_TEST().

UINT()

static UINT ( WINAPI *  pMsiApplyPatchA )

static

write_file()

static void write_file ( const char *  filename, const char *  data, DWORD  data_size  )

static

Definition at line 265 of file patch.c.

{
    DWORD size;
    HANDLE file = CreateFileA( filename, GENERIC_WRITE, 0, NULL,
                               CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
    WriteFile( file, data, data_size, &size, NULL );
    CloseHandle( file );
}

Referenced by create_database().

write_tables()

static void write_tables ( IStorage *  stg, const struct table_data *  tables, UINT  num_tables  )

static

Definition at line 673 of file patch.c.

{
    IStream *stm;
    DWORD i, count;
    HRESULT r;
 
    for (i = 0; i < num_tables; i++)
    {
        r = IStorage_CreateStream( stg, tables[i].name, STGM_WRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
        if (FAILED( r ))
        {
            ok( 0, "failed to create stream %#lx\n", r );
            continue;
        }
 
        r = IStream_Write( stm, tables[i].data, tables[i].size, &count );
        if (FAILED( r ) || count != tables[i].size)
            ok( 0, "failed to write stream\n" );
        IStream_Release( stm );
    }
}

Variable Documentation

COMMON_FILES_DIR

char COMMON_FILES_DIR[MAX_PATH]

static

Definition at line 47 of file patch.c.

Referenced by START_TEST().

component_dat

const char component_dat[]

static

Initial value:

=
    "Component\tComponentId\tDirectory_\tAttributes\tCondition\tKeyPath\n"
    "s72\tS38\ts72\ti2\tS255\tS72\n"
    "Component\tComponent\n"
    "patch\t{4B79D87E-6D28-4FD3-92D6-CD9B26AF64F1}\tMSITESTDIR\t0\t\tpatch.txt\n"
    "disable\t{BDDBA0EE-0031-4591-ADC0-33308175AC19}\tMSITESTDIR\t0\t\tdisable.txt\n"

Definition at line 85 of file patch.c.

condition_dat

const char condition_dat[]

static

Initial value:

=
    "Feature_\tLevel\tCondition\n"
    "s38\ti2\tS255\n"
    "Condition\tFeature_\tLevel\n"
    "disable\t0\tDISABLE_FEATURE\n"

Definition at line 126 of file patch.c.

CURR_DIR

char CURR_DIR[MAX_PATH]

static

Definition at line 45 of file patch.c.

Referenced by create_database(), START_TEST(), and test_simple_patch().

directory_dat

const char directory_dat[]

static

Initial value:

=
    "Directory\tDirectory_Parent\tDefaultDir\n"
    "s72\tS72\tl255\n"
    "Directory\tDirectory\n"
    "MSITESTDIR\tProgramFilesFolder\tmsitest\n"
    "ProgramFilesFolder\tTARGETDIR\t.\n"
    "TARGETDIR\t\tSourceDir"

Definition at line 77 of file patch.c.

DWORD

DWORD *static DWORD

Definition at line 37 of file patch.c.

feature_comp_dat

const char feature_comp_dat[]

static

Initial value:

=
    "Feature_\tComponent_\n"
    "s38\ts72\n"
    "FeatureComponents\tFeature_\tComponent_\n"
    "patch\tpatch\n"
    "disable\tdisable\n"

Definition at line 99 of file patch.c.

feature_dat

const char feature_dat[]

static

Initial value:

=
    "Feature\tFeature_Parent\tTitle\tDescription\tDisplay\tLevel\tDirectory_\tAttributes\n"
    "s38\tS38\tL64\tL255\tI2\ti2\tS72\ti2\n"
    "Feature\tFeature\n"
    "patch\t\t\tpatch feature\t1\t1\tMSITESTDIR\t0\n"
    "disable\t\t\tdisabled feature\t1\t1\tMSITESTDIR\t0\n"

Definition at line 92 of file patch.c.

file_dat

const char file_dat[]

static

Initial value:

=
    "File\tComponent_\tFileName\tFileSize\tVersion\tLanguage\tAttributes\tSequence\n"
    "s72\ts72\tl255\ti4\tS72\tS20\tI2\ti2\n"
    "File\tFile\n"
    "patch.txt\tpatch\tpatch.txt\t1000\t\t\t0\t1\n"
    "disable.txt\tdisable\tdisable.txt\t1000\t\t\t0\t1\n"

Definition at line 70 of file patch.c.

install_exec_seq_dat

const char install_exec_seq_dat[]

static

Initial value:

=
    "Action\tCondition\tSequence\n"
    "s72\tS255\tI2\n"
    "InstallExecuteSequence\tAction\n"
    "LaunchConditions\t\t100\n"
    "CostInitialize\t\t800\n"
    "FileCost\t\t900\n"
    "CostFinalize\t\t1000\n"
    "InstallValidate\t\t1400\n"
    "InstallInitialize\t\t1500\n"
    "ProcessComponents\t\t1600\n"
    "RemoveFiles\t\t1700\n"
    "InstallFiles\t\t2000\n"
    "RegisterUser\t\t3000\n"
    "RegisterProduct\t\t3100\n"
    "PublishFeatures\t\t5100\n"
    "PublishProduct\t\t5200\n"
    "UnpublishFeatures\t\t5300\n"
    "InstallFinalize\t\t6000\n"

Definition at line 106 of file patch.c.

INSTALLTYPE

INSTALLTYPE

Definition at line 34 of file patch.c.

LPCSTR

DWORD *static LPCSTR

Definition at line 34 of file patch.c.

LPDWORD

DWORD *static MSIINSTALLCONTEXT LPDWORD

Definition at line 38 of file patch.c.

LPSTR

DWORD *static MSIINSTALLCONTEXT LPSTR

Definition at line 36 of file patch.c.

media_dat

const char media_dat[]

static

Initial value:

=
    "DiskId\tLastSequence\tDiskPrompt\tCabinet\tVolumeLabel\tSource\n"
    "i2\ti4\tL64\tS255\tS32\tS72\n"
    "Media\tDiskId\n"
    "1\t1\t\t\tDISK1\t\n"

Definition at line 64 of file patch.c.

msifile

const char* msifile = "winetest-patch.msi"

static

Definition at line 40 of file patch.c.

Referenced by test_MsiOpenDatabase(), test_patch_registration(), test_simple_patch(), and test_system_tables().

msifileW

const WCHAR msifileW[] = L"winetest-patch.msi"

static

Definition at line 42 of file patch.c.

Referenced by test_MsiOpenDatabase().

MSIINSTALLCONTEXT

MSIINSTALLCONTEXT

Definition at line 35 of file patch.c.

mspfile

const char* mspfile = "winetest-patch.msp"

static

Definition at line 41 of file patch.c.

Referenced by test_MsiOpenDatabase(), test_patch_registration(), test_simple_patch(), and test_system_tables().

mspfileW

const WCHAR mspfileW[] = L"winetest-patch.msp"

static

Definition at line 43 of file patch.c.

Referenced by test_MsiOpenDatabase().

p_data0

const WCHAR p_data0[]

static

Initial value:

= { 
    0x0001, 0x0001, 0x0001, 0x0001, 0x8001, 0x8002, 0x8003, 0x8004,
    0x0002, 0x0003, 0x0004, 0x0005, 0xad00, 0xbd26, 0x8d00, 0x9502
}

Definition at line 370 of file patch.c.

p_data1

const WCHAR p_data1[]

static

Initial value:

= { 
    0x0001
}

Definition at line 374 of file patch.c.

p_data2

const char p_data2[]

static

Initial value:

= { 
    "MsiPatchSequencePatchFamilyProductCodeSequenceAttributes1.1.19388.37230913B8D18FBB64CACA239C74C11E3FA74"
}

Definition at line 377 of file patch.c.

p_data3

const WCHAR p_data3[]

static

Initial value:

= { 
 
     0,  0,     
    16,  5,     
    11,  1,     
    11,  1,     
     8,  1,     
    10,  1,     
    15,  1,     
    32,  1,     
}

Definition at line 380 of file patch.c.

p_data4

const char p_data4[]

static

Initial value:

= { 
    0x4d, 0x53, 0x43, 0x46, 0x00, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
    0xea, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87,
    0x3c, 0xd4, 0xb8, 0x20, 0x00, 0x70, 0x61, 0x74, 0x63, 0x68, 0x2e,
    0x74, 0x78, 0x74, 0x00, 0xe8, 0x03, 0x00, 0x00, 0xea, 0x03, 0x00,
    0x00, 0x00, 0x00, 0xcb, 0x50, 0x17, 0x7e, 0x20, 0x00, 0x66, 0x69,
    0x6c, 0x65, 0x2e, 0x74, 0x78, 0x74, 0x00, 0xb0, 0xb2, 0xb2, 0x25,
    0x2d, 0x00, 0xd2, 0x07, 0x43, 0x4b, 0xcb, 0x2d, 0xce, 0x2c, 0x49,
    0x2d, 0x2e, 0x89, 0x29, 0x48, 0x2c, 0x49, 0xce, 0x48, 0x4d, 0xd1,
    0x2b, 0xa9, 0x28, 0x51, 0x18, 0x05, 0xa3, 0x60, 0x14, 0x0c, 0x37,
    0x90, 0x8b, 0x9c, 0xd3, 0x41, 0xf9, 0x9c, 0x61, 0x14, 0x8c, 0x82,
    0x51, 0x30, 0xdc, 0x00, 0x00
}

Definition at line 391 of file patch.c.

p_data5

const WCHAR p_data5[]

static

Initial value:

= { 
    0x0007, 0x0000, 0x0006, 0x8000
}

Definition at line 407 of file patch.c.

p_data6

const char p_data6[]

static

Initial value:

= { 
    0xfe, 0xff, 0x00, 0x00, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x85, 0x9f, 0xf2, 0xf9,
    0x4f, 0x68, 0x10, 0xab, 0x91, 0x08, 0x00, 0x2b, 0x27, 0xb3, 0xd9,
    0x30, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
    0x00, 0x09, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x07, 0x00,
    0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x90,
    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00,
    0x0f, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
    0x00, 0x27, 0x00, 0x00, 0x00, 0x7b, 0x30, 0x46, 0x39, 0x36, 0x43,
    0x44, 0x43, 0x30, 0x2d, 0x34, 0x43, 0x44, 0x46, 0x2d, 0x34, 0x33,
    0x30, 0x34, 0x2d, 0x42, 0x32, 0x38, 0x33, 0x2d, 0x37, 0x42, 0x39,
    0x32, 0x36, 0x34, 0x38, 0x38, 0x39, 0x45, 0x46, 0x37, 0x7d, 0x00,
    0x00, 0x1e, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x7b, 0x39,
    0x31, 0x33, 0x42, 0x38, 0x44, 0x31, 0x38, 0x2d, 0x46, 0x42, 0x42,
    0x36, 0x2d, 0x34, 0x43, 0x41, 0x43, 0x2d, 0x41, 0x32, 0x33, 0x39,
    0x2d, 0x43, 0x37, 0x34, 0x43, 0x31, 0x31, 0x45, 0x33, 0x46, 0x41,
    0x37, 0x34, 0x7d, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x25, 0x00,
    0x00, 0x00, 0x3a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x6f,
    0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x3b, 0x3a, 0x23,
    0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x6f, 0x75, 0x70, 0x67,
    0x72, 0x61, 0x64, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00,
    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x50, 0x61, 0x74, 0x63, 0x68,
    0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x00,
    0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
}

Definition at line 410 of file patch.c.

p_name0

const WCHAR p_name0[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }

static

Definition at line 354 of file patch.c.

p_name1

const WCHAR p_name1[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }

static

Definition at line 355 of file patch.c.

p_name2

const WCHAR p_name2[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }

static

Definition at line 356 of file patch.c.

p_name3

const WCHAR p_name3[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }

static

Definition at line 357 of file patch.c.

p_name4

const WCHAR p_name4[] = { 0x3a8c, 0x47cb, 0x45b0, 0x45ec, 0x45a8, 0x4837, 0}

static

Definition at line 358 of file patch.c.

p_name5

const WCHAR p_name5[] = { 0x4840, 0x4596, 0x3e6c, 0x45e4, 0x42e6, 0x421c, 0x4634, 0x4468, 0x4226, 0 }

static

Definition at line 359 of file patch.c.

p_name6

const WCHAR p_name6[]

static

Initial value:

= { 0x0005, 0x0053, 0x0075, 0x006d, 0x006d, 0x0061, 0x0072,
                                 0x0079, 0x0049, 0x006e, 0x0066, 0x006f, 0x0072, 0x006d,
                                 0x0061, 0x0074, 0x0069, 0x006f, 0x006e, 0 }

Definition at line 360 of file patch.c.

p_name7

const WCHAR p_name7[]

static

Initial value:

= { 0x0074, 0x0061, 0x0072, 0x0067, 0x0065, 0x0074, 0x0054, 0x006f, 0x0075, 0x0070,
                                 0x0067, 0x0072, 0x0061, 0x0064, 0x0065, 0x0064, 0 }

Definition at line 364 of file patch.c.

Referenced by create_patch().

p_name8

const WCHAR p_name8[]

static

Initial value:

= { 0x0023, 0x0074, 0x0061, 0x0072, 0x0067, 0x0065, 0x0074, 0x0054, 0x006f, 0x0075,
                                 0x0070, 0x0067, 0x0072, 0x0061, 0x0064, 0x0065, 0x0064, 0 }

Definition at line 366 of file patch.c.

Referenced by create_patch().

PROG_FILES_DIR

char PROG_FILES_DIR[MAX_PATH]

static

Definition at line 46 of file patch.c.

Referenced by delete_pf(), get_pf_file_size(), and START_TEST().

property_dat

const char property_dat[]

static

Initial value:

=
    "Property\tValue\n"
    "s72\tl0\n"
    "Property\tProperty\n"
    "Manufacturer\tWineHQ\n"
    "ProductCode\t{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}\n"
    "UpgradeCode\t{A2E3D643-4E2C-477F-A309-F76F552D5F43}\n"
    "ProductLanguage\t1033\n"
    "ProductName\tmsitest\n"
    "ProductVersion\t1.1.1\n"
    "PATCHNEWSUMMARYSUBJECT\tInstaller Database\n"
    "MSIFASTINSTALL\t1\n"

Definition at line 51 of file patch.c.

t1_data0

const WCHAR t1_data0[]

static

Initial value:

= { 
    0x0008, 0x0001, 0x03ea, 0x8000
}

Definition at line 461 of file patch.c.

t1_data1

const char t1_data1[]

static

Initial value:

= { 
    "patch.txt"
}

Definition at line 464 of file patch.c.

t1_data2

const WCHAR t1_data2[]

static

Initial value:

= { 
 
     0,  0,     
     9,  1,     
}

Definition at line 467 of file patch.c.

t1_data3

const char t1_data3[]

static

Definition at line 472 of file patch.c.

t1_name0

const WCHAR t1_name0[] = { 0x4840, 0x430f, 0x422f, 0 }

static

Definition at line 454 of file patch.c.

t1_name1

const WCHAR t1_name1[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }

static

Definition at line 455 of file patch.c.

t1_name2

const WCHAR t1_name2[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }

static

Definition at line 456 of file patch.c.

t1_name3

const WCHAR t1_name3[]

static

Initial value:

= { 0x0005, 0x0053, 0x0075, 0x006d, 0x006d, 0x0061, 0x0072,
                                  0x0079, 0x0049, 0x006e, 0x0066, 0x006f, 0x0072, 0x006d,
                                  0x0061, 0x0074, 0x0069, 0x006f, 0x006e, 0 }

Definition at line 457 of file patch.c.

t2_data0

const WCHAR t2_data0[]

static

Initial value:

= { 
    0x00c0, 0x0001, 0x9000, 0x83e8, 0x0801, 0x0002, 0x0003, 0x0002,
    0x03e8, 0x8000, 0x0000, 0x0000, 0x9000, 0x83e9
}

Definition at line 543 of file patch.c.

t2_data1

const WCHAR t2_data1[]

static

Initial value:

= { 
    0x0601, 0x8002, 0x03e9, 0x8000, 0x0000, 0x000d, 0x0000, 0x000e
}

Definition at line 547 of file patch.c.

t2_data10

const WCHAR t2_data10[]

static

Initial value:

= { 
    0x0201, 0x0006, 0x0003
}

Definition at line 646 of file patch.c.

t2_data11

const WCHAR t2_data11[]

static

Initial value:

= { 
    0x0601, 0x0003, 0x0004, 0x0005, 0x8000, 0x0000, 0x0002
}

Definition at line 649 of file patch.c.

t2_data12

const WCHAR t2_data12[]

static

Initial value:

= { 
    0x0801, 0x0006, 0x0000, 0x0000, 0x0007, 0x8001, 0x8001, 0x0005,
    0x8000
}

Definition at line 652 of file patch.c.

t2_data2

const WCHAR t2_data2[]

static

Initial value:

= { 
    0x0401, 0x000f, 0x0000, 0x0010, 0xad48, 0x0401, 0x000f, 0x0000, 
    0x0011, 0xa502, 0x0401, 0x000f, 0x0000, 0x0012, 0x8104, 0x0401,
    0x000f, 0x0000, 0x0013, 0x8502, 0x0401, 0x000f, 0x0000, 0x0014,
    0x9900, 0x0401, 0x000f, 0x0000, 0x0015, 0x9d48, 0x0401, 0x0016,
    0x0000, 0x0017, 0xad26, 0x0401, 0x0016, 0x0000, 0x0018, 0x8502,
    0x0401, 0x001a, 0x0000, 0x001b, 0xad26, 0x0401, 0x001a, 0x0000,
    0x0014, 0x8900
}

Definition at line 550 of file patch.c.

t2_data3

const WCHAR t2_data3[]

static

Initial value:

= { 
    0x0101, 0x000f, 0x0101, 0x0016, 0x0101, 0x001a
}

Definition at line 559 of file patch.c.

t2_data4

const WCHAR t2_data4[]

static

Initial value:

= { 
    0x0002, 0x0008, 0x0009, 0x0201, 0x000a, 0x000b
}

Definition at line 562 of file patch.c.

t2_data5

const WCHAR t2_data5[]

static

Initial value:

= { 
    0x0201, 0x0019, 0x8002
}

Definition at line 565 of file patch.c.

t2_data6

const WCHAR t2_data6[]

static

Initial value:

= { 
    0x0301, 0x000c, 0x0000, 0x87d1
}

Definition at line 568 of file patch.c.

t2_data7

const char t2_data7[]

static

Initial value:

= { 
    "patch.txtfile.txtfile{327d9640-674f-4b9f-8b8a-547a0f6f8518}MSITESTDIRnewnew featurePATCHNEWSUMMARYSUBJECT"
    "Installation DatabasePATCHNEWPACKAGECODE{42A14A82-12F8-4E6D-970E-1B4EE7BE28B0}PatchFiles#CAB_msitestprop"
    "PatchFile_SequencePatchSizeAttributesHeaderStreamRef_PatchPackagePatchIdMedia_"
    "{0F96CDC0-4CDF-4304-B283-7B9264889EF7}MsiPatchHeadersStreamRef"
}

Definition at line 571 of file patch.c.

t2_data8

const WCHAR t2_data8[]

static

Definition at line 577 of file patch.c.

t2_data9

const char t2_data9[]

static

Definition at line 608 of file patch.c.

t2_name0

const WCHAR t2_name0[] = { 0x4840, 0x430f, 0x422f, 0 }

static

Definition at line 525 of file patch.c.

t2_name1

const WCHAR t2_name1[] = { 0x4840, 0x4216, 0x4327, 0x4824, 0 }

static

Definition at line 526 of file patch.c.

t2_name10

const WCHAR t2_name10[]

static

Initial value:

= { 0x4840, 0x420f, 0x45e4, 0x4578, 0x3b28, 0x4432, 0x44b3,
                                   0x4231, 0x45f1, 0x4836, 0 }

Definition at line 538 of file patch.c.

t2_name11

const WCHAR t2_name11[] = { 0x4840, 0x448c, 0x44f0, 0x4472, 0x4468, 0x4837, 0 }

static

Definition at line 540 of file patch.c.

t2_name12

const WCHAR t2_name12[] = { 0x4840, 0x420f, 0x45e4, 0x4578, 0x4828, 0 }

static

Definition at line 541 of file patch.c.

t2_name2

const WCHAR t2_name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }

static

Definition at line 527 of file patch.c.

t2_name3

const WCHAR t2_name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }

static

Definition at line 528 of file patch.c.

t2_name4

const WCHAR t2_name4[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }

static

Definition at line 529 of file patch.c.

t2_name5

const WCHAR t2_name5[] = { 0x4840, 0x4119, 0x41b7, 0x3e6b, 0x41a4, 0x412e, 0x422a, 0 }

static

Definition at line 530 of file patch.c.

t2_name6

const WCHAR t2_name6[]

static

Initial value:

= { 0x4840, 0x4452, 0x45f6, 0x43e4, 0x3baf, 0x423b, 0x4626,
                                  0x4237, 0x421c, 0x4634, 0x4468, 0x4226, 0 }

Definition at line 531 of file patch.c.

t2_name7

const WCHAR t2_name7[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }

static

Definition at line 533 of file patch.c.

t2_name8

const WCHAR t2_name8[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }

static

Definition at line 534 of file patch.c.

t2_name9

const WCHAR t2_name9[]

static

Initial value:

= { 0x0005, 0x0053, 0x0075, 0x006d, 0x006d, 0x0061, 0x0072,
                                  0x0079, 0x0049, 0x006e, 0x0066, 0x006f, 0x0072, 0x006d,
                                  0x0061, 0x0074, 0x0069, 0x006f, 0x006e, 0 }

Definition at line 535 of file patch.c.

table_patch_data

const struct table_data table_patch_data[]

static

Initial value:

= {
    { p_name0, p_data0, sizeof p_data0 },
    { p_name1, p_data1, sizeof p_data1 },
    { p_name2, p_data2, sizeof p_data2 - 1 },
    { p_name3, p_data3, sizeof p_data3 },
    { p_name4, p_data4, sizeof p_data4 },
    { p_name5, p_data5, sizeof p_data5 },
    { p_name6, p_data6, sizeof p_data6 }
}

Definition at line 444 of file patch.c.

Referenced by create_patch().

table_transform1_data

const struct table_data table_transform1_data[]

static

Initial value:

= {
    { t1_name0, t1_data0, sizeof t1_data0 },
    { t1_name1, t1_data1, sizeof t1_data1 - 1 },
    { t1_name2, t1_data2, sizeof t1_data2 },
    { t1_name3, t1_data3, sizeof t1_data3 }
}

Definition at line 518 of file patch.c.

Referenced by create_patch().

table_transform2_data

const struct table_data table_transform2_data[]

static

Initial value:

= {
    { t2_name0, t2_data0, sizeof t2_data0 },
    { t2_name1, t2_data1, sizeof t2_data1 },
    { t2_name2, t2_data2, sizeof t2_data2 },
    { t2_name3, t2_data3, sizeof t2_data3 },
    { t2_name4, t2_data4, sizeof t2_data4 },
    { t2_name5, t2_data5, sizeof t2_data5 },
    { t2_name6, t2_data6, sizeof t2_data6 },
    { t2_name7, t2_data7, sizeof t2_data7 - 1 },
    { t2_name8, t2_data8, sizeof t2_data8 },
    { t2_name9, t2_data9, sizeof t2_data9 },
    { t2_name10, t2_data10, sizeof t2_data10 },
    { t2_name11, t2_data11, sizeof t2_data11 },
    { t2_name12, t2_data12, sizeof t2_data12 },
}

Definition at line 657 of file patch.c.

Referenced by create_patch().

tables

const struct msi_table tables[]

static

Initial value:

=
{
    ADD_TABLE( directory ),
    ADD_TABLE( file ),
    ADD_TABLE( component ),
    ADD_TABLE( feature ),
    ADD_TABLE( feature_comp ),
    ADD_TABLE( property ),
    ADD_TABLE( install_exec_seq ),
    ADD_TABLE( media ),
 
}

Definition at line 141 of file patch.c.

Referenced by create_database(), test_MsiOpenDatabase(), test_patch_registration(), test_simple_patch(), test_system_tables(), and write_tables().