reg.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winnls.h"
#include "winerror.h"
#include "winuser.h"
#include "winternl.h"
#include "advpub.h"
#include "wine/debug.h"

Include dependency graph for reg.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advpack)
static BOOL	get_temp_ini_path (LPWSTR name)
static BOOL	create_tmp_ini_file (HMODULE hm, WCHAR *ini_file)
static void	strentry_atow (const STRENTRYA *aentry, STRENTRYW *wentry)
static STRTABLEW *	strtable_atow (const STRTABLEA *atable)
static void	free_strtable (STRTABLEW *wtable)
HRESULT WINAPI	RegInstallA (HMODULE hm, LPCSTR pszSection, const STRTABLEA *pstTable)
static HRESULT	write_predefined_strings (HMODULE hm, LPCWSTR ini_path)
HRESULT WINAPI	RegInstallW (HMODULE hm, LPCWSTR pszSection, const STRTABLEW *pstTable)
HRESULT WINAPI	RegRestoreAllA (HWND hWnd, LPSTR pszTitleString, HKEY hkBackupKey)
HRESULT WINAPI	RegRestoreAllW (HWND hWnd, LPWSTR pszTitleString, HKEY hkBackupKey)
HRESULT WINAPI	RegSaveRestoreA (HWND hWnd, LPCSTR pszTitleString, HKEY hkBackupKey, LPCSTR pcszRootKey, LPCSTR pcszSubKey, LPCSTR pcszValueName, DWORD dwFlags)
HRESULT WINAPI	RegSaveRestoreW (HWND hWnd, LPCWSTR pszTitleString, HKEY hkBackupKey, LPCWSTR pcszRootKey, LPCWSTR pcszSubKey, LPCWSTR pcszValueName, DWORD dwFlags)
HRESULT WINAPI	RegSaveRestoreOnINFA (HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF, LPCSTR pszSection, HKEY hHKLMBackKey, HKEY hHKCUBackKey, DWORD dwFlags)
HRESULT WINAPI	RegSaveRestoreOnINFW (HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF, LPCWSTR pszSection, HKEY hHKLMBackKey, HKEY hHKCUBackKey, DWORD dwFlags)

Variables
static const WCHAR	REGINST [] = {'R','E','G','I','N','S','T',0}
static const WCHAR	Strings [] = {'S','t','r','i','n','g','s',0}
static const WCHAR	MOD_PATH [] = {'_','M','O','D','_','P','A','T','H',0}
static const WCHAR	SYS_MOD_PATH [] = {'_','S','Y','S','_','M','O','D','_','P','A','T','H',0}
static const WCHAR	SystemRoot [] = {'S','y','s','t','e','m','R','o','o','t',0}
static const WCHAR	escaped_SystemRoot [] = {'%','S','y','s','t','e','m','R','o','o','t','%',0}
static const WCHAR	quote [] = {'\"',0}

Function Documentation

create_tmp_ini_file()

static BOOL create_tmp_ini_file ( HMODULE  hm, WCHAR *  ini_file  )

static

Definition at line 55 of file reg.c.

{
    HRSRC hrsrc;
    HGLOBAL hmem = NULL;
    DWORD rsrc_size, bytes_written;
    VOID *rsrc_data;
    HANDLE hf = INVALID_HANDLE_VALUE;
 
    if(!get_temp_ini_path(ini_file)) {
        ERR("Can't get temp ini file path\n");
        goto error;
    }
 
    if(!(hrsrc = FindResourceW(hm, REGINST, REGINST))) {
        ERR("Can't find REGINST resource\n");
        goto error;
    }
 
    rsrc_size = SizeofResource(hm, hrsrc);
    hmem = LoadResource(hm, hrsrc);
    rsrc_data = LockResource(hmem);
 
    if(!rsrc_data || !rsrc_size) {
        ERR("Can't load REGINST resource\n");
        goto error;
    }       
 
    if((hf = CreateFileW(ini_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                         FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
        ERR("Unable to create temp ini file\n");
        goto error;
    }
    if(!WriteFile(hf, rsrc_data, rsrc_size, &bytes_written, NULL) || rsrc_size != bytes_written) {
        ERR("Write failed\n");
        goto error;
    }
    FreeResource(hmem);
    CloseHandle(hf);
    return TRUE;
error:
    if(hmem) FreeResource(hmem);
    if(hf != INVALID_HANDLE_VALUE) CloseHandle(hf);
    return FALSE;
}

Referenced by RegInstallW().

free_strtable()

static void free_strtable ( STRTABLEW *  wtable )

static

Definition at line 129 of file reg.c.

{
    DWORD j;
 
    for (j = 0; j < wtable->cEntries; j++)
    {
        HeapFree(GetProcessHeap(), 0, wtable->pse[j].pszName);
        HeapFree(GetProcessHeap(), 0, wtable->pse[j].pszValue);
    }
 
    HeapFree(GetProcessHeap(), 0, wtable->pse);
    HeapFree(GetProcessHeap(), 0, wtable);
}

Referenced by RegInstallA().

get_temp_ini_path()

static BOOL get_temp_ini_path ( LPWSTR  name )

static

Definition at line 42 of file reg.c.

{
    static const WCHAR prefix[] = {'a','v','p',0};
    WCHAR tmp_dir[MAX_PATH];
 
    if(!GetTempPathW(ARRAY_SIZE(tmp_dir), tmp_dir))
       return FALSE;
 
    if(!GetTempFileNameW(tmp_dir, prefix, 0, name))
        return FALSE;
    return TRUE;
}

Referenced by create_tmp_ini_file().

RegInstallA()

HRESULT WINAPI RegInstallA	(	HMODULE	hm,
		LPCSTR	pszSection,
		const STRTABLEA *	pstTable
	)

Definition at line 148 of file reg.c.

{
    UNICODE_STRING section;
    STRTABLEW *wtable;
    HRESULT hr;
 
    TRACE("(%p, %s, %p)\n", hm, debugstr_a(pszSection), pstTable);
 
    if (pstTable)
        wtable = strtable_atow(pstTable);
    else
        wtable = NULL;
 
    RtlCreateUnicodeStringFromAsciiz(&section, pszSection);
 
    hr = RegInstallW(hm, section.Buffer, wtable);
 
    if (pstTable)
        free_strtable(wtable);
 
    RtlFreeUnicodeString(&section);
 
    return hr;
}

Referenced by register_iexplore().

RegInstallW()

HRESULT WINAPI RegInstallW	(	HMODULE	hm,
		LPCWSTR	pszSection,
		const STRTABLEW *	pstTable
	)

Definition at line 221 of file reg.c.

{
    unsigned int i;
    CABINFOW cabinfo;
    WCHAR tmp_ini_path[MAX_PATH];
    HRESULT hr = E_FAIL;
 
    TRACE("(%p, %s, %p)\n", hm, debugstr_w(pszSection), pstTable);
 
    if(!create_tmp_ini_file(hm, tmp_ini_path))
        return E_FAIL;
 
    if (write_predefined_strings(hm, tmp_ini_path) != S_OK)
        goto done;
 
    /* Write the additional string table */
    if (pstTable)
    {
        for(i = 0; i < pstTable->cEntries; i++)
        {
            WCHAR tmp_value[MAX_PATH + 2];
    
            tmp_value[0] = '\"';
            lstrcpyW(tmp_value + 1, pstTable->pse[i].pszValue);
            lstrcatW(tmp_value, quote);
    
            WritePrivateProfileStringW(Strings, pstTable->pse[i].pszName, tmp_value, tmp_ini_path);
        }
    }
 
    /* flush cache */
    WritePrivateProfileStringW(NULL, NULL, NULL, tmp_ini_path);
 
    /* FIXME: read AdvOptions val for dwFlags */
    ZeroMemory(&cabinfo, sizeof(CABINFOW));
    cabinfo.pszInf = tmp_ini_path;
    cabinfo.pszSection = (LPWSTR)pszSection;
    cabinfo.dwFlags = 0;
 
    hr = ExecuteCabW(NULL, &cabinfo, NULL);
 
done:
 
    DeleteFileW(tmp_ini_path);
 
    return hr;
}

Referenced by RegInstallA().

RegRestoreAllA()

HRESULT WINAPI RegRestoreAllA	(	HWND	hWnd,
		LPSTR	pszTitleString,
		HKEY	hkBackupKey
	)

Definition at line 274 of file reg.c.

{
    UNICODE_STRING title;
    HRESULT hr;
 
    TRACE("(%p, %s, %p)\n", hWnd, debugstr_a(pszTitleString), hkBackupKey);
 
    RtlCreateUnicodeStringFromAsciiz(&title, pszTitleString);
 
    hr = RegRestoreAllW(hWnd, title.Buffer, hkBackupKey);
 
    RtlFreeUnicodeString(&title);
 
    return hr;
}

RegRestoreAllW()

HRESULT WINAPI RegRestoreAllW	(	HWND	hWnd,
		LPWSTR	pszTitleString,
		HKEY	hkBackupKey
	)

Definition at line 307 of file reg.c.

{
    FIXME("(%p, %s, %p) stub\n", hWnd, debugstr_w(pszTitleString), hkBackupKey);
    
    return E_FAIL;   
}

Referenced by RegRestoreAllA().

RegSaveRestoreA()

HRESULT WINAPI RegSaveRestoreA	(	HWND	hWnd,
		LPCSTR	pszTitleString,
		HKEY	hkBackupKey,
		LPCSTR	pcszRootKey,
		LPCSTR	pcszSubKey,
		LPCSTR	pcszValueName,
		DWORD	dwFlags
	)

Definition at line 319 of file reg.c.

{
    UNICODE_STRING title, root, subkey, value;
    HRESULT hr;
 
    TRACE("(%p, %s, %p, %s, %s, %s, %d)\n", hWnd, debugstr_a(pszTitleString),
          hkBackupKey, debugstr_a(pcszRootKey), debugstr_a(pcszSubKey),
          debugstr_a(pcszValueName), dwFlags);
 
    RtlCreateUnicodeStringFromAsciiz(&title, pszTitleString);
    RtlCreateUnicodeStringFromAsciiz(&root, pcszRootKey);
    RtlCreateUnicodeStringFromAsciiz(&subkey, pcszSubKey);
    RtlCreateUnicodeStringFromAsciiz(&value, pcszValueName);
 
    hr = RegSaveRestoreW(hWnd, title.Buffer, hkBackupKey, root.Buffer,
                         subkey.Buffer, value.Buffer, dwFlags);
 
    RtlFreeUnicodeString(&title);
    RtlFreeUnicodeString(&root);
    RtlFreeUnicodeString(&subkey);
    RtlFreeUnicodeString(&value);
 
    return hr;
}

RegSaveRestoreOnINFA()

HRESULT WINAPI RegSaveRestoreOnINFA	(	HWND	hWnd,
		LPCSTR	pszTitle,
		LPCSTR	pszINF,
		LPCSTR	pszSection,
		HKEY	hHKLMBackKey,
		HKEY	hHKCUBackKey,
		DWORD	dwFlags
	)

Definition at line 383 of file reg.c.

{
    UNICODE_STRING title, inf, section;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %p, %p, %d)\n", hWnd, debugstr_a(pszTitle),
          debugstr_a(pszINF), debugstr_a(pszSection),
          hHKLMBackKey, hHKCUBackKey, dwFlags);
 
    RtlCreateUnicodeStringFromAsciiz(&title, pszTitle);
    RtlCreateUnicodeStringFromAsciiz(&inf, pszINF);
    RtlCreateUnicodeStringFromAsciiz(&section, pszSection);
 
    hr = RegSaveRestoreOnINFW(hWnd, title.Buffer, inf.Buffer, section.Buffer,
                              hHKLMBackKey, hHKCUBackKey, dwFlags);
 
    RtlFreeUnicodeString(&title);
    RtlFreeUnicodeString(&inf);
    RtlFreeUnicodeString(&section);
 
    return hr;
}

RegSaveRestoreOnINFW()

HRESULT WINAPI RegSaveRestoreOnINFW	(	HWND	hWnd,
		LPCWSTR	pszTitle,
		LPCWSTR	pszINF,
		LPCWSTR	pszSection,
		HKEY	hHKLMBackKey,
		HKEY	hHKCUBackKey,
		DWORD	dwFlags
	)

Definition at line 429 of file reg.c.

{
    FIXME("(%p, %s, %s, %s, %p, %p, %d): stub\n", hWnd, debugstr_w(pszTitle),
          debugstr_w(pszINF), debugstr_w(pszSection),
          hHKLMBackKey, hHKCUBackKey, dwFlags);
 
    return E_FAIL;   
}

Referenced by RegSaveRestoreOnINFA().

RegSaveRestoreW()

HRESULT WINAPI RegSaveRestoreW	(	HWND	hWnd,
		LPCWSTR	pszTitleString,
		HKEY	hkBackupKey,
		LPCWSTR	pcszRootKey,
		LPCWSTR	pcszSubKey,
		LPCWSTR	pcszValueName,
		DWORD	dwFlags
	)

Definition at line 367 of file reg.c.

{
    FIXME("(%p, %s, %p, %s, %s, %s, %d): stub\n", hWnd, debugstr_w(pszTitleString),
          hkBackupKey, debugstr_w(pcszRootKey), debugstr_w(pcszSubKey),
          debugstr_w(pcszValueName), dwFlags);
 
    return E_FAIL;   
}

Referenced by RegSaveRestoreA().

strentry_atow()

static void strentry_atow ( const STRENTRYA *  aentry, STRENTRYW *  wentry  )

static

Definition at line 100 of file reg.c.

{
    DWORD name_len, val_len;
 
    name_len = MultiByteToWideChar(CP_ACP, 0, aentry->pszName, -1, NULL, 0);
    val_len = MultiByteToWideChar(CP_ACP, 0, aentry->pszValue, -1, NULL, 0);
 
    wentry->pszName = HeapAlloc(GetProcessHeap(), 0, name_len * sizeof(WCHAR));
    wentry->pszValue = HeapAlloc(GetProcessHeap(), 0, val_len * sizeof(WCHAR));
 
    MultiByteToWideChar(CP_ACP, 0, aentry->pszName, -1, wentry->pszName, name_len);
    MultiByteToWideChar(CP_ACP, 0, aentry->pszValue, -1, wentry->pszValue, val_len);
}

Referenced by strtable_atow().

strtable_atow()

static STRTABLEW * strtable_atow ( const STRTABLEA *  atable )

static

Definition at line 114 of file reg.c.

{
    STRTABLEW *wtable;
    DWORD j;
 
    wtable = HeapAlloc(GetProcessHeap(), 0, sizeof(STRTABLEW));
    wtable->pse = HeapAlloc(GetProcessHeap(), 0, atable->cEntries * sizeof(STRENTRYW));
    wtable->cEntries = atable->cEntries;
 
    for (j = 0; j < wtable->cEntries; j++)
        strentry_atow(&atable->pse[j], &wtable->pse[j]);
 
    return wtable;
}

Referenced by RegInstallA().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advpack

)

write_predefined_strings()

static HRESULT write_predefined_strings ( HMODULE  hm, LPCWSTR  ini_path  )

static

Definition at line 173 of file reg.c.

{
    WCHAR mod_path[MAX_PATH + 2];
    WCHAR sys_mod_path[MAX_PATH + 2];
    WCHAR sys_root[MAX_PATH];
 
    *mod_path = '\"';
    if (!GetModuleFileNameW(hm, mod_path + 1, ARRAY_SIZE(mod_path) - 2))
        return E_FAIL;
 
    lstrcatW(mod_path, quote);
    WritePrivateProfileStringW(Strings, MOD_PATH, mod_path, ini_path);
 
    *sys_root = '\0';
    GetEnvironmentVariableW(SystemRoot, sys_root, ARRAY_SIZE(sys_root));
 
    if(!_wcsnicmp(sys_root, mod_path + 1, lstrlenW(sys_root)))
    {
        *sys_mod_path = '\"';
        lstrcpyW(sys_mod_path + 1, escaped_SystemRoot);
        lstrcatW(sys_mod_path, mod_path + 1 + lstrlenW(sys_root));
    }
    else
    {
        FIXME("SYS_MOD_PATH needs more work\n");
        lstrcpyW(sys_mod_path, mod_path);
    }
 
    WritePrivateProfileStringW(Strings, SYS_MOD_PATH, sys_mod_path, ini_path);
 
    return S_OK;
}

Referenced by RegInstallW().

Variable Documentation

escaped_SystemRoot

const WCHAR escaped_SystemRoot[] = {'%','S','y','s','t','e','m','R','o','o','t','%',0}

static

Definition at line 39 of file reg.c.

Referenced by write_predefined_strings().

MOD_PATH

const WCHAR MOD_PATH[] = {'_','M','O','D','_','P','A','T','H',0}

static

Definition at line 36 of file reg.c.

Referenced by write_predefined_strings().

quote

const WCHAR quote[] = {'\"',0}

static

Definition at line 40 of file reg.c.

Referenced by AppendToPathList(), msi_dialog_hyperlink_handler(), next_xml_attr(), ExplorerCmd::ParseCmdLine(), PROFILE_CopyEntry(), reader_parse_attvalue(), reader_parse_pub_literal(), reader_parse_sys_literal(), RegInstallW(), and write_predefined_strings().

REGINST

const WCHAR REGINST[] = {'R','E','G','I','N','S','T',0}

static

Definition at line 34 of file reg.c.

Referenced by create_tmp_ini_file().

Strings

const WCHAR Strings[] = {'S','t','r','i','n','g','s',0}

static

Definition at line 35 of file reg.c.

Referenced by append_multi_sz_value(), ElfReportEventA(), ElfReportEventAndSourceW(), ElfReportEventW(), ElfrIntReportEventW(), ElfrReportEventA(), ElfrReportEventAndSourceW(), ElfrReportEventW(), find_and_print_offset(), i8042ParseSMBiosTables(), LoadSMBiosData(), parse_buffer(), ParseSMBiosTables(), print_offset(), RegInstallW(), ReportEventA(), ReportEventW(), rsym_parse(), SetupControls(), UserpLogHardError(), and write_predefined_strings().

SYS_MOD_PATH

const WCHAR SYS_MOD_PATH[] = {'_','S','Y','S','_','M','O','D','_','P','A','T','H',0}

static

Definition at line 37 of file reg.c.

Referenced by write_predefined_strings().

SystemRoot

const WCHAR SystemRoot[] = {'S','y','s','t','e','m','R','o','o','t',0}

static

Definition at line 38 of file reg.c.

Referenced by EnumerateInstallations(), LoadAndBootWindowsCommon(), OslPrepareTarget(), ScmConvertToBootPathName(), SetupLdrInitErrataInf(), TestRelativeNames(), WinLdrInitErrataInf(), WinLdrInitializePhase1(), WinLdrInitSystemHive(), WinLdrScanSystemHive(), and write_predefined_strings().