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)

Function Documentation

create_tmp_ini_file()

static BOOL create_tmp_ini_file ( HMODULE  hm, WCHAR *  ini_file  )

static

Definition at line 46 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, L"REGINST", L"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 120 of file reg.c.

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

Referenced by RegInstallA().

get_temp_ini_path()

static BOOL get_temp_ini_path ( LPWSTR  name )

static

Definition at line 34 of file reg.c.

{
    WCHAR tmp_dir[MAX_PATH];
 
    if(!GetTempPathW(ARRAY_SIZE(tmp_dir), tmp_dir))
       return FALSE;
 
    if (!GetTempFileNameW(tmp_dir, L"avp", 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 139 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 212 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, L"\"");
 
            WritePrivateProfileStringW(L"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 265 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 298 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 310 of file reg.c.

{
    UNICODE_STRING title, root, subkey, value;
    HRESULT hr;
 
    TRACE("(%p, %s, %p, %s, %s, %s, %ld)\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 374 of file reg.c.

{
    UNICODE_STRING title, inf, section;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %p, %p, %ld)\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 420 of file reg.c.

{
    FIXME("(%p, %s, %s, %s, %p, %p, %ld): 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 358 of file reg.c.

{
    FIXME("(%p, %s, %p, %s, %s, %s, %ld): 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 91 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 = malloc(name_len * sizeof(WCHAR));
    wentry->pszValue = malloc(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 105 of file reg.c.

{
    STRTABLEW *wtable;
    DWORD j;
 
    wtable = malloc(sizeof(STRTABLEW));
    wtable->pse = malloc(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 164 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, L"\"");
    WritePrivateProfileStringW(L"Strings", L"_MOD_PATH", mod_path, ini_path);
 
    *sys_root = '\0';
    GetEnvironmentVariableW(L"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, L"%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(L"Strings", L"_SYS_MOD_PATH", sys_mod_path, ini_path);
 
    return S_OK;
}

Referenced by RegInstallW().