registry.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winnls.h"
#include "shlwapi.h"
#include "wine/debug.h"
#include "msi.h"
#include "msipriv.h"
#include "wincrypt.h"
#include "winver.h"
#include "winuser.h"
#include "sddl.h"

Include dependency graph for registry.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)
BOOL	unsquash_guid (LPCWSTR in, LPWSTR out)
BOOL	squash_guid (LPCWSTR in, LPWSTR out)
BOOL	decode_base85_guid (LPCWSTR str, GUID *guid)
BOOL	encode_base85_guid (GUID *guid, LPWSTR str)
DWORD	msi_version_str_to_dword (LPCWSTR p)
LONG	msi_reg_set_val_str (HKEY hkey, LPCWSTR name, LPCWSTR value)
LONG	msi_reg_set_val_multi_str (HKEY hkey, LPCWSTR name, LPCWSTR value)
LONG	msi_reg_set_val_dword (HKEY hkey, LPCWSTR name, DWORD val)
LONG	msi_reg_set_subkey_val (HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val)
LPWSTR	msi_reg_get_val_str (HKEY hkey, LPCWSTR name)
BOOL	msi_reg_get_val_dword (HKEY hkey, LPCWSTR name, DWORD *val)
static WCHAR *	get_user_sid (void)
UINT	MSIREG_OpenUninstallKey (const WCHAR *product, enum platform platform, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUninstallKey (const WCHAR *product, enum platform platform)
UINT	MSIREG_OpenProductKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUserProductKey (LPCWSTR szProduct)
UINT	MSIREG_OpenUserPatchesKey (LPCWSTR szPatch, HKEY *key, BOOL create)
UINT	MSIREG_OpenFeaturesKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUserFeaturesKey (LPCWSTR szProduct)
static UINT	MSIREG_OpenInstallerFeaturesKey (LPCWSTR szProduct, HKEY *key, BOOL create)
UINT	MSIREG_OpenUserDataFeaturesKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
UINT	MSIREG_OpenUserComponentsKey (LPCWSTR szComponent, HKEY *key, BOOL create)
UINT	MSIREG_OpenUserDataComponentKey (LPCWSTR szComponent, LPCWSTR szUserSid, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUserDataComponentKey (LPCWSTR szComponent, LPCWSTR szUserSid)
UINT	MSIREG_OpenUserDataProductKey (LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
UINT	MSIREG_OpenUserDataPatchKey (LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUserDataPatchKey (LPCWSTR patch, MSIINSTALLCONTEXT context)
UINT	MSIREG_OpenUserDataProductPatchesKey (LPCWSTR product, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
UINT	MSIREG_OpenInstallProps (LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUserDataProductKey (LPCWSTR szProduct, MSIINSTALLCONTEXT context)
UINT	MSIREG_DeleteProductKey (LPCWSTR szProduct)
UINT	MSIREG_OpenPatchesKey (LPCWSTR szPatch, HKEY *key, BOOL create)
UINT	MSIREG_OpenUpgradeCodesKey (LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
UINT	MSIREG_OpenUserUpgradeCodesKey (LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
UINT	MSIREG_DeleteUpgradeCodesKey (const WCHAR *code)
UINT	MSIREG_DeleteUserUpgradeCodesKey (LPCWSTR szUpgradeCode)
UINT	MSIREG_DeleteLocalClassesProductKey (LPCWSTR szProductCode)
UINT	MSIREG_DeleteLocalClassesFeaturesKey (LPCWSTR szProductCode)
UINT	MSIREG_OpenClassesUpgradeCodesKey (LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
UINT	MSIREG_DeleteClassesUpgradeCodesKey (LPCWSTR szUpgradeCode)
UINT WINAPI	MsiDecomposeDescriptorW (LPCWSTR szDescriptor, LPWSTR szProduct, LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed)
UINT WINAPI	MsiDecomposeDescriptorA (LPCSTR szDescriptor, LPSTR szProduct, LPSTR szFeature, LPSTR szComponent, LPDWORD pUsed)
UINT WINAPI	MsiEnumProductsA (DWORD index, char *lpguid)
UINT WINAPI	MsiEnumProductsW (DWORD index, WCHAR *lpguid)
UINT WINAPI	MsiEnumFeaturesA (const char *szProduct, DWORD index, char *szFeature, char *szParent)
UINT WINAPI	MsiEnumFeaturesW (const WCHAR *szProduct, DWORD index, WCHAR *szFeature, WCHAR *szParent)
UINT WINAPI	MsiEnumComponentsA (DWORD index, char *lpguid)
UINT WINAPI	MsiEnumComponentsW (DWORD index, WCHAR *lpguid)
UINT WINAPI	MsiEnumComponentsExA (const char *user_sid, DWORD ctx, DWORD index, CHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, char *sid, DWORD *sid_len)
static UINT	fetch_machine_component (DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len)
static UINT	fetch_user_component (const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len)
static UINT	enum_components (const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len)
UINT WINAPI	MsiEnumComponentsExW (const WCHAR *user_sid, DWORD ctx, DWORD index, WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)
UINT WINAPI	MsiEnumClientsA (const char *szComponent, DWORD index, char *szProduct)
UINT WINAPI	MsiEnumClientsW (const WCHAR *szComponent, DWORD index, WCHAR *szProduct)
UINT WINAPI	MsiEnumClientsExA (const char *component, const char *usersid, DWORD ctx, DWORD index, char installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, char *sid, DWORD *sid_len)
UINT WINAPI	MsiEnumClientsExW (const WCHAR *component, const WCHAR *usersid, DWORD ctx, DWORD index, WCHAR installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)
static UINT	MSI_EnumComponentQualifiers (const WCHAR *szComponent, DWORD iIndex, awstring *lpQualBuf, DWORD *pcchQual, awstring *lpAppBuf, DWORD *pcchAppBuf)
UINT WINAPI	MsiEnumComponentQualifiersA (const char *szComponent, DWORD iIndex, char *lpQualifierBuf, DWORD *pcchQualifierBuf, char *lpApplicationDataBuf, DWORD *pcchApplicationDataBuf)
UINT WINAPI	MsiEnumComponentQualifiersW (const WCHAR *szComponent, DWORD iIndex, WCHAR *lpQualifierBuf, DWORD *pcchQualifierBuf, WCHAR *lpApplicationDataBuf, DWORD *pcchApplicationDataBuf)
UINT WINAPI	MsiEnumRelatedProductsW (const WCHAR *szUpgradeCode, DWORD dwReserved, DWORD iProductIndex, WCHAR *lpProductBuf)
UINT WINAPI	MsiEnumRelatedProductsA (const char *szUpgradeCode, DWORD dwReserved, DWORD iProductIndex, char *lpProductBuf)
UINT WINAPI	MsiEnumPatchesExA (const char *szProductCode, const char *szUserSid, DWORD dwContext, DWORD dwFilter, DWORD dwIndex, char *szPatchCode, char *szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext, char *szTargetUserSid, DWORD *pcchTargetUserSid)
static UINT	msi_get_patch_state (LPCWSTR prodcode, LPCWSTR usersid, MSIINSTALLCONTEXT context, LPWSTR patch, MSIPATCHSTATE *state)
static UINT	msi_check_product_patches (LPCWSTR prodcode, LPCWSTR usersid, MSIINSTALLCONTEXT context, DWORD filter, DWORD index, DWORD *idx, LPWSTR patch, LPWSTR targetprod, MSIINSTALLCONTEXT *targetctx, LPWSTR targetsid, DWORD *sidsize, LPWSTR *transforms)
static UINT	msi_enum_patches (LPCWSTR szProductCode, LPCWSTR szUserSid, DWORD dwContext, DWORD dwFilter, DWORD dwIndex, DWORD *idx, LPWSTR szPatchCode, LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext, LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid, LPWSTR *szTransforms)
UINT WINAPI	MsiEnumPatchesExW (const WCHAR *szProductCode, const WCHAR *szUserSid, DWORD dwContext, DWORD dwFilter, DWORD dwIndex, WCHAR *szPatchCode, WCHAR *szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext, WCHAR *szTargetUserSid, DWORD *pcchTargetUserSid)
UINT WINAPI	MsiEnumPatchesA (const char *szProduct, DWORD iPatchIndex, char *lpPatchBuf, char *lpTransformsBuf, DWORD *pcchTransformsBuf)
UINT WINAPI	MsiEnumPatchesW (const WCHAR *szProduct, DWORD iPatchIndex, WCHAR *lpPatchBuf, WCHAR *lpTransformsBuf, DWORD *pcchTransformsBuf)
UINT WINAPI	MsiEnumProductsExA (const char *product, const char *usersid, DWORD ctx, DWORD index, char installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, char *sid, DWORD *sid_len)
static UINT	fetch_machine_product (const WCHAR *match, DWORD index, DWORD *idx, WCHAR installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)
static UINT	fetch_user_product (const WCHAR *match, const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)
static UINT	enum_products (const WCHAR *product, const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)
UINT WINAPI	MsiEnumProductsExW (const WCHAR *product, const WCHAR *usersid, DWORD ctx, DWORD index, WCHAR installed_product[GUID_SIZE], MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len)

Variables
static const unsigned char	table_dec85 [0x80]
static const char	table_enc85 []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file registry.c.

Function Documentation

decode_base85_guid()

BOOL decode_base85_guid	(	LPCWSTR	str,
		GUID *	guid
	)

Definition at line 132 of file registry.c.

{
    DWORD i, val = 0, base = 1, *p;
 
    if (!str)
        return FALSE;
 
    p = (DWORD*) guid;
    for( i=0; i<20; i++ )
    {
        if( (i%5) == 0 )
        {
            val = 0;
            base = 1;
        }
        val += table_dec85[str[i]] * base;
        if( str[i] >= 0x80 )
            return FALSE;
        if( table_dec85[str[i]] == 0xff )
            return FALSE;
        if( (i%5) == 4 )
            p[i/5] = val;
        base *= 85;
    }
    return TRUE;
}

Referenced by MSI_ProvideQualifiedComponentEx(), MsiDecomposeDescriptorW(), and query_feature_state().

encode_base85_guid()

BOOL encode_base85_guid	(	GUID *	guid,
		LPWSTR	str
	)

Definition at line 165 of file registry.c.

{
    unsigned int x, *p, i;
 
    p = (unsigned int*) guid;
    for( i=0; i<4; i++ )
    {
        x = p[i];
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
    }
    *str = 0;
 
    return TRUE;
}

Referenced by ACTION_MsiPublishAssemblies(), ACTION_PublishFeatures(), and msi_create_component_advertise_string().

enum_components()

static UINT enum_components ( const WCHAR *  usersid, DWORD  ctx, DWORD  index, DWORD *  idx, WCHAR  guid[39], MSIINSTALLCONTEXT *  installed_ctx, LPWSTR  sid, LPDWORD  sid_len  )

static

Definition at line 1266 of file registry.c.

{
    UINT r = ERROR_NO_MORE_ITEMS;
    WCHAR *user = NULL;
 
    if (!usersid)
    {
        usersid = user = get_user_sid();
        if (!user) return ERROR_FUNCTION_FAILED;
    }
    if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
    {
        r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERMANAGED, index, idx, guid,
                                  installed_ctx, sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
    if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index, idx, guid,
                                  installed_ctx, sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
    if (ctx & MSIINSTALLCONTEXT_MACHINE)
    {
        r = fetch_machine_component( MSIINSTALLCONTEXT_MACHINE, index, idx, guid, installed_ctx,
                                     sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
 
done:
    LocalFree( user );
    return r;
}

Referenced by ciffile_EnumComponents(), group_EnumComponents(), InstallEngine_EnumDownloadIDs(), and MsiEnumComponentsExW().

enum_products()

static UINT enum_products ( const WCHAR *  product, const WCHAR *  usersid, DWORD  ctx, DWORD  index, DWORD *  idx, WCHAR  installed_product[GUID_SIZE], MSIINSTALLCONTEXT *  installed_ctx, WCHAR *  sid, DWORD *  sid_len  )

static

Definition at line 2290 of file registry.c.

{
    UINT r = ERROR_NO_MORE_ITEMS;
    WCHAR *user = NULL;
 
    if (!usersid)
    {
        usersid = user = get_user_sid();
        if (!user) return ERROR_FUNCTION_FAILED;
    }
    if (ctx & MSIINSTALLCONTEXT_MACHINE)
    {
        r = fetch_machine_product( product, index, idx, installed_product, installed_ctx,
                                   sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
    if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index,
                                idx, installed_product, installed_ctx, sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
    if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
    {
        r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERMANAGED, index,
                                idx, installed_product, installed_ctx, sid, sid_len );
        if (r != ERROR_NO_MORE_ITEMS) goto done;
    }
 
done:
    LocalFree( user );
    return r;
}

Referenced by MsiEnumProductsExW().

fetch_machine_component()

static UINT fetch_machine_component ( DWORD  ctx, DWORD  index, DWORD *  idx, WCHAR  guid[39], MSIINSTALLCONTEXT *  installed_ctx, LPWSTR  sid, LPDWORD  sid_len  )

static

Definition at line 1151 of file registry.c.

{
    UINT r = ERROR_SUCCESS;
    WCHAR component[SQUASHED_GUID_SIZE];
    DWORD i = 0, len_component;
    REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
    HKEY key_components;
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE,
                       L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\S-1-5-18\\Components",
                       0, access, &key_components ))
        return ERROR_NO_MORE_ITEMS;
 
    len_component = ARRAY_SIZE( component );
    while (!RegEnumKeyExW( key_components, i, component, &len_component, NULL, NULL, NULL, NULL ))
    {
        if (*idx == index) goto found;
        (*idx)++;
        len_component = ARRAY_SIZE( component );
        i++;
    }
    RegCloseKey( key_components );
    return ERROR_NO_MORE_ITEMS;
 
found:
    if (sid_len)
    {
        if (*sid_len < 1)
        {
            *sid_len = 1;
            r = ERROR_MORE_DATA;
        }
        else if (sid)
        {
            *sid_len = 0;
            sid[0] = 0;
        }
    }
    if (guid) unsquash_guid( component, guid );
    if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
    RegCloseKey( key_components );
    return r;
}

Referenced by enum_components().

fetch_machine_product()

static UINT fetch_machine_product ( const WCHAR *  match, DWORD  index, DWORD *  idx, WCHAR  installed_product[GUID_SIZE], MSIINSTALLCONTEXT *  installed_ctx, WCHAR *  sid, DWORD *  sid_len  )

static

Definition at line 2154 of file registry.c.

{
    UINT r;
    WCHAR product[SQUASHED_GUID_SIZE];
    DWORD i = 0, len;
    REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
    HKEY key;
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\Products", 0, access, &key ))
        return ERROR_NO_MORE_ITEMS;
 
    len = ARRAY_SIZE( product );
    while (!RegEnumKeyExW( key, i, product, &len, NULL, NULL, NULL, NULL ))
    {
        if (match && wcscmp( match, product ))
        {
            i++;
            len = ARRAY_SIZE( product );
            continue;
        }
        if (*idx == index) goto found;
        (*idx)++;
        len = ARRAY_SIZE( product );
        i++;
    }
    RegCloseKey( key );
    return ERROR_NO_MORE_ITEMS;
 
found:
    if (sid_len && *sid_len < 1)
    {
        *sid_len = 1;
        r = ERROR_MORE_DATA;
    }
    else
    {
        if (installed_product) unsquash_guid( product, installed_product );
        if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
        if (sid)
        {
            sid[0] = 0;
            *sid_len = 0;
        }
        r = ERROR_SUCCESS;
    }
    RegCloseKey( key );
    return r;
}

Referenced by enum_products().

fetch_user_component()

static UINT fetch_user_component ( const WCHAR *  usersid, DWORD  ctx, DWORD  index, DWORD *  idx, WCHAR  guid[39], MSIINSTALLCONTEXT *  installed_ctx, LPWSTR  sid, LPDWORD  sid_len  )

static

Definition at line 1196 of file registry.c.

{
    UINT r = ERROR_SUCCESS;
    WCHAR path[MAX_PATH], component[SQUASHED_GUID_SIZE], user[128];
    DWORD i = 0, j = 0, len_component, len_user;
    REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
    HKEY key_users, key_components;
 
    if (ctx == MSIINSTALLCONTEXT_USERMANAGED) /* FIXME: where to find these? */
        return ERROR_NO_MORE_ITEMS;
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData",
                       0, access, &key_users )) return ERROR_NO_MORE_ITEMS;
 
    len_user = ARRAY_SIZE( user );
    while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
    {
        if ((wcscmp( usersid, L"S-1-1-0" ) && wcscmp( usersid, user )) ||
            !wcscmp( L"S-1-5-18", user ))
        {
            i++;
            len_user = ARRAY_SIZE( user );
            continue;
        }
        lstrcpyW( path, user );
        lstrcatW( path, L"\\Components" );
        if (RegOpenKeyExW( key_users, path, 0, access, &key_components ))
        {
            i++;
            len_user = ARRAY_SIZE( user );
            continue;
        }
        len_component = ARRAY_SIZE( component );
        while (!RegEnumKeyExW( key_components, j, component, &len_component, NULL, NULL, NULL, NULL ))
        {
            if (*idx == index) goto found;
            (*idx)++;
            len_component = ARRAY_SIZE( component );
            j++;
        }
        RegCloseKey( key_components );
        len_user = ARRAY_SIZE( user );
        i++;
    }
    RegCloseKey( key_users );
    return ERROR_NO_MORE_ITEMS;
 
found:
    if (sid_len)
    {
        if (*sid_len < len_user + 1)
        {
            *sid_len = len_user + 1;
            r = ERROR_MORE_DATA;
        }
        else if (sid)
        {
            *sid_len = len_user;
            lstrcpyW( sid, user );
        }
    }
    if (guid) unsquash_guid( component, guid );
    if (installed_ctx) *installed_ctx = ctx;
    RegCloseKey( key_components );
    RegCloseKey( key_users );
    return r;
}

Referenced by enum_components().

fetch_user_product()

static UINT fetch_user_product ( const WCHAR *  match, const WCHAR *  usersid, DWORD  ctx, DWORD  index, DWORD *  idx, WCHAR  installed_product[GUID_SIZE], MSIINSTALLCONTEXT *  installed_ctx, WCHAR *  sid, DWORD *  sid_len  )

static

Definition at line 2205 of file registry.c.

{
    UINT r;
    const WCHAR *subkey;
    WCHAR path[MAX_PATH], product[SQUASHED_GUID_SIZE], user[128];
    DWORD i = 0, j = 0, len_product, len_user;
    REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
    HKEY key_users, key_products;
 
    if (ctx == MSIINSTALLCONTEXT_USERMANAGED)
    {
        subkey = L"\\Installer\\Products";
        if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Managed",
                           0, access, &key_users )) return ERROR_NO_MORE_ITEMS;
    }
    else if (ctx == MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        subkey = L"\\Software\\Microsoft\\Installer\\Products";
        if (RegOpenKeyExW( HKEY_USERS, NULL, 0, access, &key_users ))
            return ERROR_NO_MORE_ITEMS;
    }
    else return ERROR_INVALID_PARAMETER;
 
    len_user = ARRAY_SIZE( user );
    while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
    {
        if (wcscmp( usersid, user ) && wcscmp( usersid, L"S-1-1-0" ))
        {
            i++;
            len_user = ARRAY_SIZE( user );
            continue;
        }
        lstrcpyW( path, user );
        lstrcatW( path, subkey );
        if (RegOpenKeyExW( key_users, path, 0, access, &key_products ))
        {
            i++;
            len_user = ARRAY_SIZE( user );
            continue;
        }
        len_product = ARRAY_SIZE( product );
        while (!RegEnumKeyExW( key_products, j, product, &len_product, NULL, NULL, NULL, NULL ))
        {
            if (match && wcscmp( match, product ))
            {
                j++;
                len_product = ARRAY_SIZE( product );
                continue;
            }
            if (*idx == index) goto found;
            (*idx)++;
            len_product = ARRAY_SIZE( product );
            j++;
        }
        RegCloseKey( key_products );
        len_user = ARRAY_SIZE( user );
        i++;
    }
    RegCloseKey( key_users );
    return ERROR_NO_MORE_ITEMS;
 
found:
    if (sid_len && *sid_len <= len_user)
    {
        *sid_len = len_user;
        r = ERROR_MORE_DATA;
    }
    else
    {
        if (installed_product) unsquash_guid( product, installed_product );
        if (installed_ctx) *installed_ctx = ctx;
        if (sid)
        {
            lstrcpyW( sid, user );
            *sid_len = len_user;
        }
        r = ERROR_SUCCESS;
    }
    RegCloseKey( key_products );
    RegCloseKey( key_users );
    return r;
}

Referenced by enum_products().

get_user_sid()

static WCHAR * get_user_sid ( void  )

static

Definition at line 269 of file registry.c.

{
    HANDLE token;
    DWORD size = 256;
    TOKEN_USER *user;
    WCHAR *ret;
 
    if (!OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token )) return NULL;
    if (!(user = msi_alloc( size )))
    {
        CloseHandle( token );
        return NULL;
    }
    if (!GetTokenInformation( token, TokenUser, user, size, &size ))
    {
        msi_free( user );
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER || !(user = msi_alloc( size )))
        {
            CloseHandle( token );
            return NULL;
        }
        GetTokenInformation( token, TokenUser, user, size, &size );
    }
    CloseHandle( token );
    if (!ConvertSidToStringSidW( user->User.Sid, &ret ))
    {
        msi_free( user );
        return NULL;
    }
    msi_free( user );
    return ret;
}

Referenced by enum_components(), enum_products(), msi_enum_patches(), MSIREG_DeleteUserDataComponentKey(), MSIREG_DeleteUserDataPatchKey(), MSIREG_DeleteUserDataProductKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenProductKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), and MSIREG_OpenUserDataProductPatchesKey().

msi_check_product_patches()

static UINT msi_check_product_patches ( LPCWSTR  prodcode, LPCWSTR  usersid, MSIINSTALLCONTEXT  context, DWORD  filter, DWORD  index, DWORD *  idx, LPWSTR  patch, LPWSTR  targetprod, MSIINSTALLCONTEXT *  targetctx, LPWSTR  targetsid, DWORD *  sidsize, LPWSTR *  transforms  )

static

Definition at line 1735 of file registry.c.

{
    MSIPATCHSTATE state = MSIPATCHSTATE_INVALID;
    LPWSTR ptr, patches = NULL;
    HKEY prod, patchkey = 0;
    HKEY localprod = 0, localpatch = 0;
    DWORD type, size;
    LONG res;
    UINT temp, r = ERROR_NO_MORE_ITEMS;
 
    if (MSIREG_OpenProductKey(prodcode, usersid, context,
                              &prod, FALSE) != ERROR_SUCCESS)
        return ERROR_NO_MORE_ITEMS;
 
    size = 0;
    res = RegGetValueW(prod, L"Patches", L"Patches", RRF_RT_ANY, &type, NULL,
                       &size);
    if (res != ERROR_SUCCESS)
        goto done;
 
    if (type != REG_MULTI_SZ)
    {
        r = ERROR_BAD_CONFIGURATION;
        goto done;
    }
 
    patches = msi_alloc(size);
    if (!patches)
    {
        r = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    res = RegGetValueW(prod, L"Patches", L"Patches", RRF_RT_ANY, &type,
                       patches, &size);
    if (res != ERROR_SUCCESS)
        goto done;
 
    for (ptr = patches; *ptr && r == ERROR_NO_MORE_ITEMS; ptr += lstrlenW(ptr) + 1)
    {
        if (!unsquash_guid(ptr, patch))
        {
            r = ERROR_BAD_CONFIGURATION;
            goto done;
        }
 
        size = 0;
        res = RegGetValueW(prod, L"Patches", ptr, RRF_RT_REG_SZ,
                           &type, NULL, &size);
        if (res != ERROR_SUCCESS)
            continue;
 
        if (transforms)
        {
            *transforms = msi_alloc(size);
            if (!*transforms)
            {
                r = ERROR_OUTOFMEMORY;
                goto done;
            }
 
            res = RegGetValueW(prod, L"Patches", ptr, RRF_RT_REG_SZ,
                               &type, *transforms, &size);
            if (res != ERROR_SUCCESS)
                continue;
        }
 
        if (context == MSIINSTALLCONTEXT_USERMANAGED)
        {
            if (!(filter & MSIPATCHSTATE_APPLIED))
            {
                temp = msi_get_patch_state(prodcode, usersid, context,
                                           ptr, &state);
                if (temp == ERROR_BAD_CONFIGURATION)
                {
                    r = ERROR_BAD_CONFIGURATION;
                    goto done;
                }
 
                if (temp != ERROR_SUCCESS || !(filter & state))
                    continue;
            }
        }
        else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
        {
            if (!(filter & MSIPATCHSTATE_APPLIED))
            {
                temp = msi_get_patch_state(prodcode, usersid, context,
                                           ptr, &state);
                if (temp == ERROR_BAD_CONFIGURATION)
                {
                    r = ERROR_BAD_CONFIGURATION;
                    goto done;
                }
 
                if (temp != ERROR_SUCCESS || !(filter & state))
                    continue;
            }
            else
            {
                temp = MSIREG_OpenUserDataPatchKey(patch, context,
                                                   &patchkey, FALSE);
                RegCloseKey(patchkey);
                if (temp != ERROR_SUCCESS)
                    continue;
            }
        }
        else if (context == MSIINSTALLCONTEXT_MACHINE)
        {
            usersid = L"";
 
            if (MSIREG_OpenUserDataProductKey(prodcode, context, NULL, &localprod, FALSE) == ERROR_SUCCESS &&
                RegOpenKeyExW(localprod, L"Patches", 0, KEY_READ, &localpatch) == ERROR_SUCCESS &&
                RegOpenKeyExW(localpatch, ptr, 0, KEY_READ, &patchkey) == ERROR_SUCCESS)
            {
                res = RegGetValueW(patchkey, NULL, L"State", RRF_RT_REG_DWORD,
                                   &type, &state, &size);
 
                if (!(filter & state))
                    res = ERROR_NO_MORE_ITEMS;
 
                RegCloseKey(patchkey);
            }
 
            RegCloseKey(localpatch);
            RegCloseKey(localprod);
 
            if (res != ERROR_SUCCESS)
                continue;
        }
 
        if (*idx < index)
        {
            (*idx)++;
            continue;
        }
 
        r = ERROR_SUCCESS;
        if (targetprod)
            lstrcpyW(targetprod, prodcode);
 
        if (targetctx)
            *targetctx = context;
 
        if (targetsid)
        {
            lstrcpynW(targetsid, usersid, *sidsize);
            if (lstrlenW(usersid) >= *sidsize)
                r = ERROR_MORE_DATA;
        }
 
        if (sidsize)
        {
            *sidsize = lstrlenW(usersid);
            if (!targetsid)
                *sidsize *= sizeof(WCHAR);
        }
    }
 
done:
    RegCloseKey(prod);
    msi_free(patches);
 
    return r;
}

Referenced by msi_enum_patches().

msi_enum_patches()

static UINT msi_enum_patches ( LPCWSTR  szProductCode, LPCWSTR  szUserSid, DWORD  dwContext, DWORD  dwFilter, DWORD  dwIndex, DWORD *  idx, LPWSTR  szPatchCode, LPWSTR  szTargetProductCode, MSIINSTALLCONTEXT *  pdwTargetProductContext, LPWSTR  szTargetUserSid, LPDWORD  pcchTargetUserSid, LPWSTR *  szTransforms  )

static

Definition at line 1904 of file registry.c.

{
    LPWSTR usersid = NULL;
    UINT r = ERROR_INVALID_PARAMETER;
 
    if (!szUserSid)
    {
        szUserSid = usersid = get_user_sid();
        if (!usersid) return ERROR_FUNCTION_FAILED;
    }
 
    if (dwContext & MSIINSTALLCONTEXT_USERMANAGED)
    {
        r = msi_check_product_patches(szProductCode, szUserSid,
                                      MSIINSTALLCONTEXT_USERMANAGED, dwFilter,
                                      dwIndex, idx, szPatchCode,
                                      szTargetProductCode,
                                      pdwTargetProductContext, szTargetUserSid,
                                      pcchTargetUserSid, szTransforms);
        if (r != ERROR_NO_MORE_ITEMS)
            goto done;
    }
 
    if (dwContext & MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        r = msi_check_product_patches(szProductCode, szUserSid,
                                      MSIINSTALLCONTEXT_USERUNMANAGED, dwFilter,
                                      dwIndex, idx, szPatchCode,
                                      szTargetProductCode,
                                      pdwTargetProductContext, szTargetUserSid,
                                      pcchTargetUserSid, szTransforms);
        if (r != ERROR_NO_MORE_ITEMS)
            goto done;
    }
 
    if (dwContext & MSIINSTALLCONTEXT_MACHINE)
    {
        r = msi_check_product_patches(szProductCode, szUserSid,
                                      MSIINSTALLCONTEXT_MACHINE, dwFilter,
                                      dwIndex, idx, szPatchCode,
                                      szTargetProductCode,
                                      pdwTargetProductContext, szTargetUserSid,
                                      pcchTargetUserSid, szTransforms);
        if (r != ERROR_NO_MORE_ITEMS)
            goto done;
    }
 
done:
    LocalFree(usersid);
    return r;
}

Referenced by MsiEnumPatchesExW(), and MsiEnumPatchesW().

MSI_EnumComponentQualifiers()

static UINT MSI_EnumComponentQualifiers ( const WCHAR *  szComponent, DWORD  iIndex, awstring *  lpQualBuf, DWORD *  pcchQual, awstring *  lpAppBuf, DWORD *  pcchAppBuf  )

static

Definition at line 1412 of file registry.c.

{
    DWORD name_sz, val_sz, name_max, val_max, type, ofs;
    WCHAR *name = NULL, *val = NULL;
    UINT r, r2;
    HKEY key;
 
    TRACE( "%s, %lu, %p, %p, %p, %p\n", debugstr_w(szComponent), iIndex, lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf );
 
    if (!szComponent)
        return ERROR_INVALID_PARAMETER;
 
    r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
    if (r != ERROR_SUCCESS)
        return ERROR_UNKNOWN_COMPONENT;
 
    /* figure out how big the name is we want to return */
    name_max = 0x10;
    r = ERROR_OUTOFMEMORY;
    name = msi_alloc( name_max * sizeof(WCHAR) );
    if (!name)
        goto end;
 
    val_max = 0x10;
    r = ERROR_OUTOFMEMORY;
    val = msi_alloc( val_max );
    if (!val)
        goto end;
 
    /* loop until we allocate enough memory */
    while (1)
    {
        name_sz = name_max;
        val_sz = val_max;
        r = RegEnumValueW( key, iIndex, name, &name_sz, NULL, &type, (BYTE *)val, &val_sz );
        if (r == ERROR_SUCCESS)
            break;
        if (r != ERROR_MORE_DATA)
            goto end;
 
        if (type != REG_MULTI_SZ)
        {
            ERR( "component data has wrong type (%lu)\n", type );
            goto end;
        }
 
        r = ERROR_OUTOFMEMORY;
        if (name_sz + 1 >= name_max)
        {
            name_max *= 2;
            msi_free( name );
            name = msi_alloc( name_max * sizeof (WCHAR) );
            if (!name)
                goto end;
            continue;
        }
        if (val_sz > val_max)
        {
            val_max = val_sz + sizeof (WCHAR);
            msi_free( val );
            val = msi_alloc( val_max * sizeof (WCHAR) );
            if (!val)
                goto end;
            continue;
        }
        ERR( "should be enough data, but isn't %lu %lu\n", name_sz, val_sz );
        goto end;
    }
 
    ofs = 0;
    r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
    if (r != ERROR_SUCCESS)
        goto end;
 
    TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
 
    r = msi_strcpy_to_awstring( name, -1, lpQualBuf, pcchQual );
    r2 = msi_strcpy_to_awstring( val+ofs, -1, lpAppBuf, pcchAppBuf );
 
    if (r2 != ERROR_SUCCESS)
        r = r2;
 
end:
    msi_free(val);
    msi_free(name);
    RegCloseKey(key);
    return r;
}

Referenced by MsiEnumComponentQualifiersA(), and MsiEnumComponentQualifiersW().

msi_get_patch_state()

static UINT msi_get_patch_state ( LPCWSTR  prodcode, LPCWSTR  usersid, MSIINSTALLCONTEXT  context, LPWSTR  patch, MSIPATCHSTATE *  state  )

static

Definition at line 1690 of file registry.c.

{
    DWORD type, val, size;
    HKEY prod, hkey = 0;
    HKEY udpatch = 0;
    LONG res;
    UINT r = ERROR_NO_MORE_ITEMS;
 
    *state = MSIPATCHSTATE_INVALID;
 
    r = MSIREG_OpenUserDataProductKey(prodcode, context,
                                      usersid, &prod, FALSE);
    if (r != ERROR_SUCCESS)
        return ERROR_NO_MORE_ITEMS;
 
    res = RegOpenKeyExW(prod, L"Patches", 0, KEY_READ, &hkey);
    if (res != ERROR_SUCCESS)
        goto done;
 
    res = RegOpenKeyExW(hkey, patch, 0, KEY_READ, &udpatch);
    if (res != ERROR_SUCCESS)
        goto done;
 
    size = sizeof(DWORD);
    res = RegGetValueW(udpatch, NULL, L"State", RRF_RT_DWORD, &type, &val, &size);
    if (res != ERROR_SUCCESS ||
        val < MSIPATCHSTATE_APPLIED || val > MSIPATCHSTATE_REGISTERED)
    {
        r = ERROR_BAD_CONFIGURATION;
        goto done;
    }
 
    *state = val;
    r = ERROR_SUCCESS;
 
done:
    RegCloseKey(udpatch);
    RegCloseKey(hkey);
    RegCloseKey(prod);
 
    return r;
}

Referenced by msi_check_product_patches().

msi_reg_get_val_dword()

BOOL msi_reg_get_val_dword	(	HKEY	hkey,
		LPCWSTR	name,
		DWORD *	val
	)

Definition at line 262 of file registry.c.

{
    DWORD type, len = sizeof (DWORD);
    LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
    return r == ERROR_SUCCESS && type == REG_DWORD;
}

Referenced by MSI_GetComponentPath(), MsiQueryProductStateW(), and reg_get_value().

msi_reg_get_val_str()

LPWSTR msi_reg_get_val_str	(	HKEY	hkey,
		LPCWSTR	name
	)

Definition at line 243 of file registry.c.

{
    DWORD len = 0;
    LPWSTR val;
    LONG r;
 
    r = RegQueryValueExW(hkey, name, NULL, NULL, NULL, &len);
    if (r != ERROR_SUCCESS)
        return NULL;
 
    len += sizeof (WCHAR);
    val = msi_alloc( len );
    if (!val)
        return NULL;
    val[0] = 0;
    RegQueryValueExW(hkey, name, NULL, NULL, (LPBYTE) val, &len);
    return val;
}

Referenced by ACTION_PublishProduct(), get_install_location(), get_registered_local_package(), ITERATE_PublishComponent(), MSI_GetComponentPath(), MSI_GetUserInfo(), MSI_OpenProductW(), open_package(), query_feature_state(), reg_get_value(), and set_installer_properties().

msi_reg_set_subkey_val()

LONG msi_reg_set_subkey_val	(	HKEY	hkey,
		LPCWSTR	path,
		LPCWSTR	name,
		LPCWSTR	val
	)

Definition at line 230 of file registry.c.

{
    HKEY hsubkey = 0;
    LONG r;
 
    r = RegCreateKeyW( hkey, path, &hsubkey );
    if (r != ERROR_SUCCESS)
        return r;
    r = msi_reg_set_val_str( hsubkey, name, val );
    RegCloseKey( hsubkey );
    return r;
}

Referenced by ACTION_RegisterClassInfo(), ACTION_RegisterMIMEInfo(), register_progid(), and register_verb().

msi_reg_set_val_dword()

LONG msi_reg_set_val_dword	(	HKEY	hkey,
		LPCWSTR	name,
		DWORD	val
	)

Definition at line 225 of file registry.c.

{
    return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
}

Referenced by msi_publish_install_properties(), msi_publish_product_properties(), and write_shared_dlls_count().

msi_reg_set_val_multi_str()

LONG msi_reg_set_val_multi_str	(	HKEY	hkey,
		LPCWSTR	name,
		LPCWSTR	value
	)

Definition at line 217 of file registry.c.

{
    LPCWSTR p = value;
    while (*p) p += lstrlenW(p) + 1;
    return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
                           (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
}

Referenced by ITERATE_PublishComponent(), msi_publish_product_properties(), and register_verb().

msi_reg_set_val_str()

LONG msi_reg_set_val_str	(	HKEY	hkey,
		LPCWSTR	name,
		LPCWSTR	value
	)

Definition at line 209 of file registry.c.

{
    DWORD len;
    if (!value) value = L"";
    len = (lstrlenW(value) + 1) * sizeof (WCHAR);
    return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
}

Referenced by ACTION_ForceReboot(), ACTION_ProcessComponents(), ACTION_PublishFeatures(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterProduct(), ACTION_RegisterUser(), ITERATE_RegisterFonts(), msi_publish_install_properties(), msi_publish_product_properties(), msi_publish_upgrade_code(), msi_reg_set_subkey_val(), MsiSourceListSetInfoW(), register_appid(), register_progid(), and register_verb().

msi_version_str_to_dword()

DWORD msi_version_str_to_dword

(

LPCWSTR

p

)

Definition at line 188 of file registry.c.

{
    DWORD major, minor = 0, build = 0, version = 0;
 
    if (!p)
        return version;
 
    major = wcstol(p, NULL, 10);
 
    p = wcschr(p, '.');
    if (p)
    {
        minor = wcstol(p+1, NULL, 10);
        p = wcschr(p+1, '.');
        if (p)
            build = wcstol(p+1, NULL, 10);
    }
 
    return MAKELONG(build, MAKEWORD(minor, major));
}

Referenced by ITERATE_FindRelatedProducts(), msi_publish_install_properties(), and msi_publish_product_properties().

MsiDecomposeDescriptorA()

UINT WINAPI MsiDecomposeDescriptorA	(	LPCSTR	szDescriptor,
		LPSTR	szProduct,
		LPSTR	szFeature,
		LPSTR	szComponent,
		LPDWORD	pUsed
	)

Definition at line 984 of file registry.c.

{
    WCHAR product[MAX_FEATURE_CHARS+1];
    WCHAR feature[MAX_FEATURE_CHARS+1];
    WCHAR component[MAX_FEATURE_CHARS+1];
    LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
    UINT r;
 
    TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
          szFeature, szComponent, pUsed);
 
    str = strdupAtoW( szDescriptor );
    if( szDescriptor && !str )
        return ERROR_OUTOFMEMORY;
 
    if (szProduct)
        p = product;
    if (szFeature)
        f = feature;
    if (szComponent)
        c = component;
 
    r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
 
    if (r == ERROR_SUCCESS)
    {
        WideCharToMultiByte( CP_ACP, 0, p, -1,
                             szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, f, -1,
                             szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, c, -1,
                             szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
    }
 
    msi_free( str );
 
    return r;
}

MsiDecomposeDescriptorW()

UINT WINAPI MsiDecomposeDescriptorW	(	LPCWSTR	szDescriptor,
		LPWSTR	szProduct,
		LPWSTR	szFeature,
		LPWSTR	szComponent,
		LPDWORD	pUsed
	)

Definition at line 927 of file registry.c.

{
    UINT len;
    const WCHAR *p;
    GUID product, component;
 
    TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
          szFeature, szComponent, pUsed);
 
    if (!decode_base85_guid( szDescriptor, &product ))
        return ERROR_INVALID_PARAMETER;
 
    TRACE("product %s\n", debugstr_guid( &product ));
 
    if (!(p = wcschr( &szDescriptor[20], '>' )))
        p = wcschr( &szDescriptor[20], '<' );
    if (!p)
        return ERROR_INVALID_PARAMETER;
 
    len = (p - &szDescriptor[20]);
    if( len > MAX_FEATURE_CHARS )
        return ERROR_INVALID_PARAMETER;
 
    TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
 
    if (*p == '>')
    {
        if (!decode_base85_guid( p+1, &component ))
            return ERROR_INVALID_PARAMETER;
        TRACE( "component %s\n", debugstr_guid(&component) );
    }
 
    if (szProduct)
        StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
    if (szComponent)
    {
        if (*p == '>')
            StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
        else
            szComponent[0] = 0;
    }
    if (szFeature)
    {
        memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
        szFeature[len] = 0;
    }
 
    len = p - szDescriptor + 1;
    if (*p == '>') len += 20;
 
    TRACE("length = %d\n", len);
    if (pUsed) *pUsed = len;
 
    return ERROR_SUCCESS;
}

Referenced by MSI_EnumComponentQualifiers(), MSI_ProvideQualifiedComponentEx(), MsiDecomposeDescriptorA(), and MsiGetShortcutTargetW().

MsiEnumClientsA()

UINT WINAPI MsiEnumClientsA	(	const char *	szComponent,
		DWORD	index,
		char *	szProduct
	)

Definition at line 1328 of file registry.c.

{
    DWORD r;
    WCHAR szwProduct[GUID_SIZE];
    WCHAR *szwComponent = NULL;
 
    TRACE( "%s, %lu, %p\n", debugstr_a(szComponent), index, szProduct );
 
    if ( !szProduct )
        return ERROR_INVALID_PARAMETER;
 
    if( szComponent )
    {
        szwComponent = strdupAtoW( szComponent );
        if( !szwComponent )
            return ERROR_OUTOFMEMORY;
    }
 
    r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
    if( r == ERROR_SUCCESS )
        WideCharToMultiByte(CP_ACP, 0, szwProduct, -1, szProduct, GUID_SIZE, NULL, NULL);
 
    msi_free( szwComponent);
 
    return r;
}

Referenced by test_MsiEnumClients().

MsiEnumClientsExA()

UINT WINAPI MsiEnumClientsExA	(	const char *	component,
		const char *	usersid,
		DWORD	ctx,
		DWORD	index,
		char	installed_product[GUID_SIZE],
		MSIINSTALLCONTEXT *	installed_ctx,
		char *	sid,
		DWORD *	sid_len
	)

Definition at line 1394 of file registry.c.

{
    FIXME( "%s, %s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_a(component), debugstr_a(usersid), ctx, index,
           installed_product, installed_ctx, sid, sid_len );
    return ERROR_ACCESS_DENIED;
}

MsiEnumClientsExW()

UINT WINAPI MsiEnumClientsExW	(	const WCHAR *	component,
		const WCHAR *	usersid,
		DWORD	ctx,
		DWORD	index,
		WCHAR	installed_product[GUID_SIZE],
		MSIINSTALLCONTEXT *	installed_ctx,
		WCHAR *	sid,
		DWORD *	sid_len
	)

Definition at line 1403 of file registry.c.

{
    FIXME( "%s, %s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_w(component), debugstr_w(usersid), ctx, index,
           installed_product, installed_ctx, sid, sid_len );
    return ERROR_ACCESS_DENIED;
}

MsiEnumClientsW()

UINT WINAPI MsiEnumClientsW	(	const WCHAR *	szComponent,
		DWORD	index,
		WCHAR *	szProduct
	)

Definition at line 1355 of file registry.c.

{
    HKEY hkeyComp = 0;
    DWORD r, sz;
    WCHAR szValName[SQUASHED_GUID_SIZE];
 
    TRACE( "%s, %lu, %p\n", debugstr_w(szComponent), index, szProduct );
 
    if (!szComponent || !*szComponent || !szProduct)
        return ERROR_INVALID_PARAMETER;
 
    if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkeyComp, FALSE) != ERROR_SUCCESS &&
        MSIREG_OpenUserDataComponentKey(szComponent, L"S-1-5-18", &hkeyComp, FALSE) != ERROR_SUCCESS)
        return ERROR_UNKNOWN_COMPONENT;
 
    /* see if there are any products at all */
    sz = SQUASHED_GUID_SIZE;
    r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
    if (r != ERROR_SUCCESS)
    {
        RegCloseKey(hkeyComp);
 
        if (index != 0)
            return ERROR_INVALID_PARAMETER;
 
        return ERROR_UNKNOWN_COMPONENT;
    }
 
    sz = SQUASHED_GUID_SIZE;
    r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
    if( r == ERROR_SUCCESS )
    {
        unsquash_guid(szValName, szProduct);
        TRACE("-> %s\n", debugstr_w(szProduct));
    }
    RegCloseKey(hkeyComp);
    return r;
}

Referenced by MsiEnumClientsA().

MsiEnumComponentQualifiersA()

UINT WINAPI MsiEnumComponentQualifiersA	(	const char *	szComponent,
		DWORD	iIndex,
		char *	lpQualifierBuf,
		DWORD *	pcchQualifierBuf,
		char *	lpApplicationDataBuf,
		DWORD *	pcchApplicationDataBuf
	)

Definition at line 1505 of file registry.c.

{
    awstring qual, appdata;
    WCHAR *comp;
    UINT r;
 
    TRACE( "%s, %lu, %p, %p, %p, %p\n", debugstr_a(szComponent), iIndex, lpQualifierBuf, pcchQualifierBuf,
           lpApplicationDataBuf, pcchApplicationDataBuf );
 
    comp = strdupAtoW( szComponent );
    if (szComponent && !comp)
        return ERROR_OUTOFMEMORY;
 
    qual.unicode = FALSE;
    qual.str.a = lpQualifierBuf;
 
    appdata.unicode = FALSE;
    appdata.str.a = lpApplicationDataBuf;
 
    r = MSI_EnumComponentQualifiers( comp, iIndex,
              &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
    msi_free( comp );
    return r;
}

MsiEnumComponentQualifiersW()

UINT WINAPI MsiEnumComponentQualifiersW	(	const WCHAR *	szComponent,
		DWORD	iIndex,
		WCHAR *	lpQualifierBuf,
		DWORD *	pcchQualifierBuf,
		WCHAR *	lpApplicationDataBuf,
		DWORD *	pcchApplicationDataBuf
	)

Definition at line 1535 of file registry.c.

{
    awstring qual, appdata;
 
    TRACE( "%s, %lu, %p, %p, %p, %p\n", debugstr_w(szComponent), iIndex, lpQualifierBuf, pcchQualifierBuf,
           lpApplicationDataBuf, pcchApplicationDataBuf );
 
    qual.unicode = TRUE;
    qual.str.w = lpQualifierBuf;
 
    appdata.unicode = TRUE;
    appdata.str.w = lpApplicationDataBuf;
 
    return MSI_EnumComponentQualifiers( szComponent, iIndex, &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
}

MsiEnumComponentsA()

UINT WINAPI MsiEnumComponentsA	(	DWORD	index,
		char *	lpguid
	)

Definition at line 1099 of file registry.c.

{
    DWORD r;
    WCHAR szwGuid[GUID_SIZE];
 
    TRACE( "%lu, %p\n", index, lpguid );
 
    if (!lpguid) return ERROR_INVALID_PARAMETER;
 
    r = MsiEnumComponentsW(index, szwGuid);
    if( r == ERROR_SUCCESS )
        WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 
    return r;
}

Referenced by test_MsiEnumComponents().

MsiEnumComponentsExA()

UINT WINAPI MsiEnumComponentsExA	(	const char *	user_sid,
		DWORD	ctx,
		DWORD	index,
		CHAR	guid[39],
		MSIINSTALLCONTEXT *	installed_ctx,
		char *	sid,
		DWORD *	sid_len
	)

Definition at line 1124 of file registry.c.

{
    UINT r;
    WCHAR *user_sidW = NULL, *sidW = NULL, guidW[GUID_SIZE];
 
    TRACE( "%s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_a(user_sid), ctx, index, guid, installed_ctx,
           sid, sid_len );
 
    if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
    if (user_sid && !(user_sidW = strdupAtoW( user_sid ))) return ERROR_OUTOFMEMORY;
    if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
    {
        msi_free( user_sidW );
        return ERROR_OUTOFMEMORY;
    }
    r = MsiEnumComponentsExW( user_sidW, ctx, index, guidW, installed_ctx, sidW, sid_len );
    if (r == ERROR_SUCCESS)
    {
        if (guid) WideCharToMultiByte( CP_ACP, 0, guidW, GUID_SIZE, guid, GUID_SIZE, NULL, NULL );
        if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
    }
    msi_free( user_sidW );
    msi_free( sidW );
    return r;
}

Referenced by init_functionpointers().

MsiEnumComponentsExW()

UINT WINAPI MsiEnumComponentsExW	(	const WCHAR *	user_sid,
		DWORD	ctx,
		DWORD	index,
		WCHAR	guid[39],
		MSIINSTALLCONTEXT *	installed_ctx,
		WCHAR *	sid,
		DWORD *	sid_len
	)

Definition at line 1301 of file registry.c.

{
    UINT r;
    DWORD idx = 0;
    static DWORD last_index;
 
    TRACE( "%s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_w(user_sid), ctx, index, guid, installed_ctx,
          sid, sid_len );
 
    if ((sid && !sid_len) || !ctx || (user_sid && ctx == MSIINSTALLCONTEXT_MACHINE))
        return ERROR_INVALID_PARAMETER;
 
    if (index && index - last_index != 1)
        return ERROR_INVALID_PARAMETER;
 
    if (!index) last_index = 0;
 
    r = enum_components( user_sid, ctx, index, &idx, guid, installed_ctx, sid, sid_len );
    if (r == ERROR_SUCCESS)
        last_index = index;
    else
        last_index = 0;
 
    return r;
}

Referenced by MsiEnumComponentsExA(), and MsiEnumComponentsW().

MsiEnumComponentsW()

UINT WINAPI MsiEnumComponentsW	(	DWORD	index,
		WCHAR *	lpguid
	)

Definition at line 1115 of file registry.c.

{
    TRACE( "%lu, %p\n", index, lpguid );
 
    if (!lpguid) return ERROR_INVALID_PARAMETER;
 
    return MsiEnumComponentsExW( L"S-1-1-0", MSIINSTALLCONTEXT_ALL, index, lpguid, NULL, NULL, NULL );
}

Referenced by MsiEnumComponentsA().

MsiEnumFeaturesA()

UINT WINAPI MsiEnumFeaturesA	(	const char *	szProduct,
		DWORD	index,
		char *	szFeature,
		char *	szParent
	)

Definition at line 1051 of file registry.c.

{
    DWORD r;
    WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
    WCHAR *szwProduct = NULL;
 
    TRACE( "%s, %lu, %p, %p\n", debugstr_a(szProduct), index, szFeature, szParent );
 
    if( szProduct )
    {
        szwProduct = strdupAtoW( szProduct );
        if( !szwProduct )
            return ERROR_OUTOFMEMORY;
    }
 
    r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
    if( r == ERROR_SUCCESS )
    {
        WideCharToMultiByte(CP_ACP, 0, szwFeature, -1, szFeature, GUID_SIZE, NULL, NULL);
        WideCharToMultiByte(CP_ACP, 0, szwParent, -1, szParent, GUID_SIZE, NULL, NULL);
    }
 
    msi_free( szwProduct);
 
    return r;
}

MsiEnumFeaturesW()

UINT WINAPI MsiEnumFeaturesW	(	const WCHAR *	szProduct,
		DWORD	index,
		WCHAR *	szFeature,
		WCHAR *	szParent
	)

Definition at line 1078 of file registry.c.

{
    HKEY hkeyProduct = 0;
    DWORD r, sz;
 
    TRACE( "%s, %lu, %p, %p\n", debugstr_w(szProduct), index, szFeature, szParent );
 
    if( !szProduct )
        return ERROR_INVALID_PARAMETER;
 
    r = MSIREG_OpenInstallerFeaturesKey(szProduct,&hkeyProduct,FALSE);
    if( r != ERROR_SUCCESS )
        return ERROR_NO_MORE_ITEMS;
 
    sz = GUID_SIZE;
    r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
    RegCloseKey(hkeyProduct);
 
    return r;
}

Referenced by MsiEnumFeaturesA(), and test_null().

MsiEnumPatchesA()

UINT WINAPI MsiEnumPatchesA	(	const char *	szProduct,
		DWORD	iPatchIndex,
		char *	lpPatchBuf,
		char *	lpTransformsBuf,
		DWORD *	pcchTransformsBuf
	)

Definition at line 2016 of file registry.c.

{
    WCHAR *product, *transforms, patch[GUID_SIZE];
    DWORD len;
    UINT r;
 
    TRACE( "%s, %lu, %p, %p, %p\n", debugstr_a(szProduct), iPatchIndex, lpPatchBuf, lpTransformsBuf,
           pcchTransformsBuf );
 
    if (!szProduct || !lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
        return ERROR_INVALID_PARAMETER;
 
    product = strdupAtoW(szProduct);
    if (!product)
        return ERROR_OUTOFMEMORY;
 
    len = *pcchTransformsBuf;
    transforms = msi_alloc( len * sizeof(WCHAR) );
    if (!transforms)
    {
        r = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    r = MsiEnumPatchesW(product, iPatchIndex, patch, transforms, &len);
    if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
        goto done;
 
    WideCharToMultiByte(CP_ACP, 0, patch, -1, lpPatchBuf,
                        GUID_SIZE, NULL, NULL);
 
    if (!WideCharToMultiByte(CP_ACP, 0, transforms, -1, lpTransformsBuf,
                             *pcchTransformsBuf, NULL, NULL))
        r = ERROR_MORE_DATA;
 
    if (r == ERROR_MORE_DATA)
    {
        lpTransformsBuf[*pcchTransformsBuf - 1] = '\0';
        *pcchTransformsBuf = len * 2;
    }
    else
        *pcchTransformsBuf = strlen( lpTransformsBuf );
 
done:
    msi_free(transforms);
    msi_free(product);
 
    return r;
}

Referenced by test_MsiEnumPatches().

MsiEnumPatchesExA()

UINT WINAPI MsiEnumPatchesExA	(	const char *	szProductCode,
		const char *	szUserSid,
		DWORD	dwContext,
		DWORD	dwFilter,
		DWORD	dwIndex,
		char *	szPatchCode,
		char *	szTargetProductCode,
		MSIINSTALLCONTEXT *	pdwTargetProductContext,
		char *	szTargetUserSid,
		DWORD *	pcchTargetUserSid
	)

Definition at line 1618 of file registry.c.

{
    WCHAR *prodcode = NULL, *usersid = NULL, *targsid = NULL;
    WCHAR patch[GUID_SIZE], targprod[GUID_SIZE];
    DWORD len;
    UINT r;
 
    TRACE( "%s, %s, %#lx, %lu, %lu, %p, %p, %p, %p, %p\n", debugstr_a(szProductCode), debugstr_a(szUserSid),
           dwContext, dwFilter, dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext, szTargetUserSid,
           pcchTargetUserSid );
 
    if (szTargetUserSid && !pcchTargetUserSid)
        return ERROR_INVALID_PARAMETER;
 
    if (szProductCode) prodcode = strdupAtoW(szProductCode);
    if (szUserSid) usersid = strdupAtoW(szUserSid);
 
    r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
                          patch, targprod, pdwTargetProductContext,
                          NULL, &len);
    if (r != ERROR_SUCCESS)
        goto done;
 
    WideCharToMultiByte(CP_ACP, 0, patch, -1, szPatchCode,
                        GUID_SIZE, NULL, NULL);
    WideCharToMultiByte(CP_ACP, 0, targprod, -1, szTargetProductCode,
                        GUID_SIZE, NULL, NULL);
 
    if (!szTargetUserSid)
    {
        if (pcchTargetUserSid)
            *pcchTargetUserSid = len;
 
        goto done;
    }
 
    targsid = msi_alloc(++len * sizeof(WCHAR));
    if (!targsid)
    {
        r = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
                          patch, targprod, pdwTargetProductContext,
                          targsid, &len);
    if (r != ERROR_SUCCESS || !szTargetUserSid)
        goto done;
 
    WideCharToMultiByte(CP_ACP, 0, targsid, -1, szTargetUserSid,
                        *pcchTargetUserSid, NULL, NULL);
 
    len = lstrlenW(targsid);
    if (*pcchTargetUserSid < len + 1)
    {
        r = ERROR_MORE_DATA;
        *pcchTargetUserSid = len * sizeof(WCHAR);
    }
    else
        *pcchTargetUserSid = len;
 
done:
    msi_free(prodcode);
    msi_free(usersid);
    msi_free(targsid);
 
    return r;
}

Referenced by init_function_pointers(), and init_functionpointers().

MsiEnumPatchesExW()

UINT WINAPI MsiEnumPatchesExW	(	const WCHAR *	szProductCode,
		const WCHAR *	szUserSid,
		DWORD	dwContext,
		DWORD	dwFilter,
		DWORD	dwIndex,
		WCHAR *	szPatchCode,
		WCHAR *	szTargetProductCode,
		MSIINSTALLCONTEXT *	pdwTargetProductContext,
		WCHAR *	szTargetUserSid,
		DWORD *	pcchTargetUserSid
	)

Definition at line 1963 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    DWORD idx = 0;
    UINT r;
 
    static DWORD last_index;
 
    TRACE( "%s, %s, %#lx, %lu, %lu, %p, %p, %p, %p, %p)\n", debugstr_w(szProductCode), debugstr_w(szUserSid),
           dwContext, dwFilter, dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext, szTargetUserSid,
           pcchTargetUserSid );
 
    if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
        return ERROR_INVALID_PARAMETER;
 
    if (szUserSid && !wcscmp( szUserSid, L"S-1-5-18" ))
        return ERROR_INVALID_PARAMETER;
 
    if (dwContext & MSIINSTALLCONTEXT_MACHINE && szUserSid)
        return ERROR_INVALID_PARAMETER;
 
    if (dwContext <= MSIINSTALLCONTEXT_NONE ||
        dwContext > MSIINSTALLCONTEXT_ALL)
        return ERROR_INVALID_PARAMETER;
 
    if (dwFilter <= MSIPATCHSTATE_INVALID || dwFilter > MSIPATCHSTATE_ALL)
        return ERROR_INVALID_PARAMETER;
 
    if (dwIndex && dwIndex - last_index != 1)
        return ERROR_INVALID_PARAMETER;
 
    if (dwIndex == 0)
        last_index = 0;
 
    r = msi_enum_patches(szProductCode, szUserSid, dwContext, dwFilter,
                         dwIndex, &idx, szPatchCode, szTargetProductCode,
                         pdwTargetProductContext, szTargetUserSid,
                         pcchTargetUserSid, NULL);
 
    if (r == ERROR_SUCCESS)
        last_index = dwIndex;
    else
        last_index = 0;
 
    return r;
}

Referenced by MSI_OpenPackageW(), and MsiEnumPatchesExA().

MsiEnumPatchesW()

UINT WINAPI MsiEnumPatchesW	(	const WCHAR *	szProduct,
		DWORD	iPatchIndex,
		WCHAR *	lpPatchBuf,
		WCHAR *	lpTransformsBuf,
		DWORD *	pcchTransformsBuf
	)

Definition at line 2070 of file registry.c.

{
    WCHAR *transforms = NULL, squashed_pc[SQUASHED_GUID_SIZE];
    HKEY prod;
    DWORD idx = 0;
    UINT r;
 
    TRACE( "%s, %lu, %p, %p, %p)\n", debugstr_w(szProduct), iPatchIndex, lpPatchBuf, lpTransformsBuf,
           pcchTransformsBuf );
 
    if (!szProduct || !squash_guid( szProduct, squashed_pc ))
        return ERROR_INVALID_PARAMETER;
 
    if (!lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
        return ERROR_INVALID_PARAMETER;
 
    if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
                              &prod, FALSE) != ERROR_SUCCESS &&
        MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
                              &prod, FALSE) != ERROR_SUCCESS &&
        MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
                              &prod, FALSE) != ERROR_SUCCESS)
        return ERROR_UNKNOWN_PRODUCT;
 
    RegCloseKey(prod);
 
    r = msi_enum_patches(szProduct, NULL, MSIINSTALLCONTEXT_ALL,
                         MSIPATCHSTATE_ALL, iPatchIndex, &idx, lpPatchBuf,
                         NULL, NULL, NULL, NULL, &transforms);
    if (r != ERROR_SUCCESS)
        goto done;
 
    lstrcpynW(lpTransformsBuf, transforms, *pcchTransformsBuf);
    if (*pcchTransformsBuf <= lstrlenW(transforms))
    {
        r = ERROR_MORE_DATA;
        *pcchTransformsBuf = lstrlenW(transforms);
    }
    else
        *pcchTransformsBuf = lstrlenW(transforms);
 
done:
    msi_free(transforms);
    return r;
}

Referenced by MsiEnumPatchesA(), and test_MsiEnumPatches().

MsiEnumProductsA()

UINT WINAPI MsiEnumProductsA	(	DWORD	index,
		char *	lpguid
	)

Definition at line 1024 of file registry.c.

{
    DWORD r;
    WCHAR szwGuid[GUID_SIZE];
 
    TRACE( "%lu, %p\n", index, lpguid );
 
    if (NULL == lpguid)
        return ERROR_INVALID_PARAMETER;
    r = MsiEnumProductsW(index, szwGuid);
    if( r == ERROR_SUCCESS )
        WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 
    return r;
}

Referenced by test_MsiEnumProducts().

MsiEnumProductsExA()

UINT WINAPI MsiEnumProductsExA	(	const char *	product,
		const char *	usersid,
		DWORD	ctx,
		DWORD	index,
		char	installed_product[GUID_SIZE],
		MSIINSTALLCONTEXT *	installed_ctx,
		char *	sid,
		DWORD *	sid_len
	)

Definition at line 2117 of file registry.c.

{
    UINT r;
    WCHAR installed_productW[GUID_SIZE], *productW = NULL, *usersidW = NULL, *sidW = NULL;
 
    TRACE( "%s, %s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_a(product), debugstr_a(usersid), ctx, index,
           installed_product, installed_ctx, sid, sid_len );
 
    if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
    if (product && !(productW = strdupAtoW( product ))) return ERROR_OUTOFMEMORY;
    if (usersid && !(usersidW = strdupAtoW( usersid )))
    {
        msi_free( productW );
        return ERROR_OUTOFMEMORY;
    }
    if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
    {
        msi_free( usersidW );
        msi_free( productW );
        return ERROR_OUTOFMEMORY;
    }
    r = MsiEnumProductsExW( productW, usersidW, ctx, index, installed_productW,
                            installed_ctx, sidW, sid_len );
    if (r == ERROR_SUCCESS)
    {
        if (installed_product) WideCharToMultiByte( CP_ACP, 0, installed_productW, GUID_SIZE,
                                                    installed_product, GUID_SIZE, NULL, NULL );
        if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
    }
    msi_free( productW );
    msi_free( usersidW );
    msi_free( sidW );
    return r;
}

Referenced by init_functionpointers().

MsiEnumProductsExW()

UINT WINAPI MsiEnumProductsExW	(	const WCHAR *	product,
		const WCHAR *	usersid,
		DWORD	ctx,
		DWORD	index,
		WCHAR	installed_product[GUID_SIZE],
		MSIINSTALLCONTEXT *	installed_ctx,
		WCHAR *	sid,
		DWORD *	sid_len
	)

Definition at line 2326 of file registry.c.

{
    UINT r;
    DWORD idx = 0;
    static DWORD last_index;
 
    TRACE( "%s, %s, %#lx, %lu, %p, %p, %p, %p\n", debugstr_w(product), debugstr_w(usersid), ctx, index,
           installed_product, installed_ctx, sid, sid_len );
 
    if ((sid && !sid_len) || !ctx || (usersid && ctx == MSIINSTALLCONTEXT_MACHINE))
        return ERROR_INVALID_PARAMETER;
 
    if (index && index - last_index != 1)
        return ERROR_INVALID_PARAMETER;
 
    if (!index) last_index = 0;
 
    r = enum_products( product, usersid, ctx, index, &idx, installed_product, installed_ctx,
                       sid, sid_len );
    if (r == ERROR_SUCCESS)
        last_index = index;
    else
        last_index = 0;
 
    return r;
}

Referenced by MsiEnumProductsExA(), and MsiEnumProductsW().

MsiEnumProductsW()

UINT WINAPI MsiEnumProductsW	(	DWORD	index,
		WCHAR *	lpguid
	)

Definition at line 1040 of file registry.c.

{
    TRACE("%lu, %p\n", index, lpguid );
 
    if (NULL == lpguid)
        return ERROR_INVALID_PARAMETER;
 
    return MsiEnumProductsExW( NULL, L"S-1-1-0", MSIINSTALLCONTEXT_ALL, index, lpguid,
                               NULL, NULL, NULL );
}

Referenced by create_list(), get_products_count(), MsiEnumProductsA(), and MsiGetPatchInfoW().

MsiEnumRelatedProductsA()

UINT WINAPI MsiEnumRelatedProductsA	(	const char *	szUpgradeCode,
		DWORD	dwReserved,
		DWORD	iProductIndex,
		char *	lpProductBuf
	)

Definition at line 1588 of file registry.c.

{
    WCHAR *szwUpgradeCode = NULL;
    WCHAR productW[GUID_SIZE];
    UINT r;
 
    TRACE( "%s, %#lx, %lu, %p\n", debugstr_a(szUpgradeCode), dwReserved, iProductIndex, lpProductBuf );
 
    if (szUpgradeCode)
    {
        szwUpgradeCode = strdupAtoW( szUpgradeCode );
        if( !szwUpgradeCode )
            return ERROR_OUTOFMEMORY;
    }
 
    r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
                                 iProductIndex, productW );
    if (r == ERROR_SUCCESS)
    {
        WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
                             lpProductBuf, GUID_SIZE, NULL, NULL );
    }
    msi_free( szwUpgradeCode);
    return r;
}

MsiEnumRelatedProductsW()

UINT WINAPI MsiEnumRelatedProductsW	(	const WCHAR *	szUpgradeCode,
		DWORD	dwReserved,
		DWORD	iProductIndex,
		WCHAR *	lpProductBuf
	)

Definition at line 1557 of file registry.c.

{
    UINT r;
    HKEY hkey;
    WCHAR szKeyName[SQUASHED_GUID_SIZE];
    DWORD dwSize = ARRAY_SIZE(szKeyName);
 
    TRACE( "%s, %#lx, %lu, %p\n", debugstr_w(szUpgradeCode), dwReserved, iProductIndex, lpProductBuf );
 
    if (NULL == szUpgradeCode)
        return ERROR_INVALID_PARAMETER;
    if (NULL == lpProductBuf)
        return ERROR_INVALID_PARAMETER;
 
    r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
    if (r != ERROR_SUCCESS)
        return ERROR_NO_MORE_ITEMS;
 
    r = RegEnumValueW(hkey, iProductIndex, szKeyName, &dwSize, NULL, NULL, NULL, NULL);
    if( r == ERROR_SUCCESS )
        unsquash_guid(szKeyName, lpProductBuf);
    RegCloseKey(hkey);
 
    return r;
}

Referenced by create_list(), get_products_count(), and MsiEnumRelatedProductsA().

MSIREG_DeleteClassesUpgradeCodesKey()

UINT MSIREG_DeleteClassesUpgradeCodesKey

(

LPCWSTR

szUpgradeCode

)

Definition at line 890 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\UpgradeCodes", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_uc );
    RegCloseKey(hkey);
    return r;
}

Referenced by remove_product_upgrade_code().

MSIREG_DeleteLocalClassesFeaturesKey()

UINT MSIREG_DeleteLocalClassesFeaturesKey

(

LPCWSTR

szProductCode

)

Definition at line 858 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\Features", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteLocalClassesProductKey()

UINT MSIREG_DeleteLocalClassesProductKey

(

LPCWSTR

szProductCode

)

Definition at line 841 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\Products", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteProductKey()

UINT MSIREG_DeleteProductKey

(

LPCWSTR

szProduct

)

Definition at line 751 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Products",
                      0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteUninstallKey()

UINT MSIREG_DeleteUninstallKey	(	const WCHAR *	product,
		enum platform platform
	)

Definition at line 319 of file registry.c.

{
    REGSAM access = KEY_ALL_ACCESS;
    HKEY parent;
    LONG r;
 
    TRACE("%s\n", debugstr_w(product));
 
    if (platform == PLATFORM_INTEL)
        access |= KEY_WOW64_32KEY;
    else
        access |= KEY_WOW64_64KEY;
    if ((r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\",
                           0, access, &parent))) return r;
    r = RegDeleteTreeW(parent, product);
    RegCloseKey(parent);
    return r;
}

MSIREG_DeleteUpgradeCodesKey()

UINT MSIREG_DeleteUpgradeCodesKey

(

const WCHAR *

code

)

Definition at line 812 of file registry.c.

{
    WCHAR squashed_code[SQUASHED_GUID_SIZE];
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    HKEY hkey;
    LONG ret;
 
    if (!squash_guid( code, squashed_code )) return ERROR_FUNCTION_FAILED;
    TRACE( "%s squashed %s\n", debugstr_w(code), debugstr_w(squashed_code) );
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UpgradeCodes\\",
                       0, access, &hkey )) return ERROR_SUCCESS;
    ret = RegDeleteTreeW( hkey, squashed_code );
    RegCloseKey( hkey );
    return ret;
}

Referenced by remove_product_upgrade_code().

MSIREG_DeleteUserDataComponentKey()

UINT MSIREG_DeleteUserDataComponentKey	(	LPCWSTR	szComponent,
		LPCWSTR	szUserSid
	)

Definition at line 552 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Components";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
 
    if (!szUserSid)
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
    else swprintf(keypath, ARRAY_SIZE(keypath), fmtW, szUserSid);
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_comp );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_ProcessComponents().

MSIREG_DeleteUserDataPatchKey()

UINT MSIREG_DeleteUserDataPatchKey	(	LPCWSTR	patch,
		MSIINSTALLCONTEXT	context
	)

Definition at line 636 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Patches";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( patch, squashed_patch )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(patch), debugstr_w(squashed_patch));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18");
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_patch );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteUserDataProductKey()

UINT MSIREG_DeleteUserDataProductKey	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	context
	)

Definition at line 720 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18");
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_RegisterUser(), and ACTION_UnpublishProduct().

MSIREG_DeleteUserFeaturesKey()

UINT MSIREG_DeleteUserFeaturesKey

(

LPCWSTR

szProduct

)

Definition at line 445 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Features\\" );
    lstrcatW( keypath, squashed_pc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteUserProductKey()

UINT MSIREG_DeleteUserProductKey

(

LPCWSTR

szProduct

)

Definition at line 378 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Products\\" );
    lstrcatW( keypath, squashed_pc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by ACTION_UnpublishProduct().

MSIREG_DeleteUserUpgradeCodesKey()

UINT MSIREG_DeleteUserUpgradeCodesKey

(

LPCWSTR

szUpgradeCode

)

Definition at line 829 of file registry.c.

{
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by remove_product_upgrade_code().

MSIREG_OpenClassesUpgradeCodesKey()

UINT MSIREG_OpenClassesUpgradeCodesKey	(	LPCWSTR	szUpgradeCode,
		HKEY *	key,
		BOOL	create
	)

Definition at line 875 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Classes\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ITERATE_MigrateFeatureStates(), msi_publish_upgrade_code(), and remove_product_upgrade_code().

MSIREG_OpenFeaturesKey()

UINT MSIREG_OpenFeaturesKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 404 of file registry.c.

{
    HKEY root = HKEY_LOCAL_MACHINE;
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        lstrcpyW(keypath, L"Software\\Classes\\Installer\\Features\\");
        lstrcatW( keypath, squashed_pc );
    }
    else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        root = HKEY_CURRENT_USER;
        lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\Features\\");
        lstrcatW( keypath, squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath),
                  L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Managed\\%s\\Installer\\Features\\%s",
                  szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(root, keypath, 0, access, key);
}

Referenced by ACTION_PublishFeatures(), msi_unpublish_feature(), and query_feature_state().

MSIREG_OpenInstallerFeaturesKey()

static UINT MSIREG_OpenInstallerFeaturesKey ( LPCWSTR  szProduct, HKEY *  key, BOOL  create  )

static

Definition at line 457 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Features\\");
    lstrcatW( keypath, squashed_pc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by MsiEnumFeaturesW().

MSIREG_OpenInstallProps()

UINT MSIREG_OpenInstallProps	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	dwContext,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 692 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\InstallProperties";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    else if (szUserSid)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_RegisterProduct(), ACTION_RegisterUser(), get_install_location(), get_registered_local_package(), msi_comp_find_package(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), MSI_OpenProductW(), MsiGetPatchInfoExW(), MsiGetProductInfoExW(), MsiQueryProductStateW(), and open_package().

MSIREG_OpenPatchesKey()

UINT MSIREG_OpenPatchesKey	(	LPCWSTR	szPatch,
		HKEY *	key,
		BOOL	create
	)

Definition at line 768 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Patches\\" );
    lstrcatW( keypath, squashed_pc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by OpenSourceKey().

MSIREG_OpenProductKey()

UINT MSIREG_OpenProductKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 338 of file registry.c.

{
    HKEY root = HKEY_LOCAL_MACHINE;
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid = NULL, squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        lstrcpyW(keypath, L"Software\\Classes\\Installer\\Products\\");
        lstrcatW( keypath, squashed_pc );
    }
    else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        root = HKEY_CURRENT_USER;
        lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Products\\" );
        lstrcatW( keypath, squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath),
                  L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Managed\\%s\\Installer\\Products\\%s",
                  szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(root, keypath, 0, access, key);
}

Referenced by ACTION_PublishProduct(), ITERATE_FindRelatedProducts(), msi_check_product_patches(), msi_comp_find_prod_key(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), msi_locate_product(), msi_publish_patches(), MsiEnumPatchesW(), MsiGetPatchInfoExW(), MsiGetProductCodeW(), MsiGetProductInfoExW(), MsiQueryProductStateW(), MsiSourceListAddSourceW(), and OpenSourceKey().

MSIREG_OpenUninstallKey()

UINT MSIREG_OpenUninstallKey	(	const WCHAR *	product,
		enum platform platform	,
		HKEY *	key,
		BOOL	create
	)

Definition at line 302 of file registry.c.

{
    REGSAM access = KEY_ALL_ACCESS;
    WCHAR keypath[0x200];
 
    TRACE("%s\n", debugstr_w(product));
 
    if (platform == PLATFORM_INTEL)
        access |= KEY_WOW64_32KEY;
    else
        access |= KEY_WOW64_64KEY;
    lstrcpyW(keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\");
    lstrcatW(keypath, product);
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

MSIREG_OpenUpgradeCodesKey()

UINT MSIREG_OpenUpgradeCodesKey	(	LPCWSTR	szUpgradeCode,
		HKEY *	key,
		BOOL	create
	)

Definition at line 783 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UpgradeCodes\\" );
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_RegisterProduct(), ITERATE_FindRelatedProducts(), MsiEnumRelatedProductsW(), and remove_product_upgrade_code().

MSIREG_OpenUserComponentsKey()

UINT MSIREG_OpenUserComponentsKey	(	LPCWSTR	szComponent,
		HKEY *	key,
		BOOL	create
	)

Definition at line 505 of file registry.c.

{
    WCHAR squashed_cc[SQUASHED_GUID_SIZE], keypath[0x200];
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    UINT ret;
 
    if (!squash_guid( szComponent, squashed_cc)) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_cc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\Components\\");
    lstrcatW( keypath, squashed_cc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    ret = RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
    if (ret != ERROR_FILE_NOT_FOUND) return ret;
 
    lstrcpyW(keypath, L"Software\\Classes\\Installer\\Components\\");
    lstrcatW( keypath, squashed_cc );
    return RegOpenKeyExW( HKEY_LOCAL_MACHINE, keypath, 0, access, key );
}

Referenced by ITERATE_PublishComponent(), MSI_EnumComponentQualifiers(), and MSI_ProvideQualifiedComponentEx().

MSIREG_OpenUserDataComponentKey()

UINT MSIREG_OpenUserDataComponentKey	(	LPCWSTR	szComponent,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 526 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Components\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
 
    if (!szUserSid)
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_comp );
        LocalFree(usersid);
    }
    else swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_comp );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_ProcessComponents(), get_client_counts(), msi_comp_find_prodcode(), MsiEnumClientsW(), MsiGetProductCodeW(), open_userdata_comp_key(), and query_feature_state().

MSIREG_OpenUserDataFeaturesKey()

UINT MSIREG_OpenUserDataFeaturesKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 472 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\Features";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200], *usersid = NULL;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_PublishFeatures(), MSI_ProvideQualifiedComponentEx(), msi_unpublish_feature(), and query_feature_state().

MSIREG_OpenUserDataPatchKey()

UINT MSIREG_OpenUserDataPatchKey	(	LPCWSTR	szPatch,
		MSIINSTALLCONTEXT	dwContext,
		HKEY *	key,
		BOOL	create
	)

Definition at line 610 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Patches\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_patch )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_patch));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_patch );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_patch );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by msi_check_product_patches(), msi_publish_patches(), and MsiGetPatchInfoExW().

MSIREG_OpenUserDataProductKey()

UINT MSIREG_OpenUserDataProductKey	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	dwContext,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 582 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    else if (szUserSid)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_PublishProduct(), msi_check_product_patches(), msi_get_patch_state(), MSI_GetComponentPath(), and MsiGetPatchInfoExW().

MSIREG_OpenUserDataProductPatchesKey()

UINT MSIREG_OpenUserDataProductPatchesKey	(	LPCWSTR	product,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 666 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\Patches";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_product[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( product, squashed_product )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(product), debugstr_w(squashed_product));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_product );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_product );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by msi_publish_patches().

MSIREG_OpenUserPatchesKey()

UINT MSIREG_OpenUserPatchesKey	(	LPCWSTR	szPatch,
		HKEY *	key,
		BOOL	create
	)

Definition at line 390 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Patches\\" );
    lstrcatW( keypath, squashed_pc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
}

Referenced by OpenSourceKey().

MSIREG_OpenUserUpgradeCodesKey()

UINT MSIREG_OpenUserUpgradeCodesKey	(	LPCWSTR	szUpgradeCode,
		HKEY *	key,
		BOOL	create
	)

Definition at line 798 of file registry.c.

{
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
}

Referenced by ITERATE_MigrateFeatureStates(), msi_publish_upgrade_code(), and remove_product_upgrade_code().

squash_guid()

BOOL squash_guid	(	LPCWSTR	in,
		LPWSTR	out
	)

Definition at line 74 of file registry.c.

{
    DWORD i,n=1;
    GUID guid;
 
    out[0] = 0;
 
    if (FAILED(CLSIDFromString((LPCOLESTR)in, &guid)))
        return FALSE;
 
    for(i=0; i<8; i++)
        out[7-i] = in[n++];
    n++;
    for(i=0; i<4; i++)
        out[11-i] = in[n++];
    n++;
    for(i=0; i<4; i++)
        out[15-i] = in[n++];
    n++;
    for(i=0; i<2; i++)
    {
        out[17+i*2] = in[n++];
        out[16+i*2] = in[n++];
    }
    n++;
    for( ; i<8; i++)
    {
        out[17+i*2] = in[n++];
        out[16+i*2] = in[n++];
    }
    out[32]=0;
    return TRUE;
}

Referenced by ACTION_ForceReboot(), ACTION_ProcessComponents(), ACTION_PublishProduct(), ACTION_RegisterProduct(), compose_base85_guid(), create_test_guid(), ITERATE_UnpublishComponent(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), msi_publish_patches(), msi_publish_product_properties(), msi_publish_upgrade_code(), MsiEnumPatchesExW(), MsiEnumPatchesW(), MsiGetPatchInfoExW(), MsiGetProductCodeW(), MsiGetProductInfoExW(), MsiOpenProductW(), MsiQueryComponentStateW(), MsiQueryFeatureStateExW(), MsiQueryFeatureStateW(), MSIREG_DeleteClassesUpgradeCodesKey(), MSIREG_DeleteLocalClassesFeaturesKey(), MSIREG_DeleteLocalClassesProductKey(), MSIREG_DeleteProductKey(), MSIREG_DeleteUpgradeCodesKey(), MSIREG_DeleteUserDataComponentKey(), MSIREG_DeleteUserDataPatchKey(), MSIREG_DeleteUserDataProductKey(), MSIREG_DeleteUserFeaturesKey(), MSIREG_DeleteUserProductKey(), MSIREG_DeleteUserUpgradeCodesKey(), MSIREG_OpenClassesUpgradeCodesKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallerFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenPatchesKey(), MSIREG_OpenProductKey(), MSIREG_OpenUpgradeCodesKey(), MSIREG_OpenUserComponentsKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), MSIREG_OpenUserDataProductPatchesKey(), MSIREG_OpenUserPatchesKey(), MSIREG_OpenUserUpgradeCodesKey(), MsiSourceListAddMediaDiskW(), MsiSourceListAddSourceExW(), MsiSourceListAddSourceW(), MsiSourceListEnumMediaDisksW(), MsiSourceListEnumSourcesW(), MsiSourceListGetInfoW(), MsiSourceListSetInfoW(), and remove_product_upgrade_code().

unsquash_guid()

BOOL unsquash_guid	(	LPCWSTR	in,
		LPWSTR	out
	)

Definition at line 41 of file registry.c.

{
    DWORD i,n=0;
 
    if (lstrlenW(in) != 32)
        return FALSE;
 
    out[n++]='{';
    for(i=0; i<8; i++)
        out[n++] = in[7-i];
    out[n++]='-';
    for(i=0; i<4; i++)
        out[n++] = in[11-i];
    out[n++]='-';
    for(i=0; i<4; i++)
        out[n++] = in[15-i];
    out[n++]='-';
    for(i=0; i<2; i++)
    {
        out[n++] = in[17+i*2];
        out[n++] = in[16+i*2];
    }
    out[n++]='-';
    for( ; i<8; i++)
    {
        out[n++] = in[17+i*2];
        out[n++] = in[16+i*2];
    }
    out[n++]='}';
    out[n]=0;
    return TRUE;
}

Referenced by fetch_machine_component(), fetch_machine_product(), fetch_user_component(), fetch_user_product(), ITERATE_FindRelatedProducts(), msi_check_product_patches(), MSI_GetProductInfo(), MsiEnumClientsW(), MsiEnumRelatedProductsW(), and MsiGetProductCodeW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msi

)

Variable Documentation

table_dec85

const unsigned char table_dec85[0x80]

static

Initial value:

= {
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
}

Definition at line 110 of file registry.c.

Referenced by decode_base85_guid().

table_enc85

const char table_enc85[]

static

Initial value:

=
"!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
"PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
"yz{}~"

Definition at line 121 of file registry.c.

Referenced by encode_base85_guid().