reg.h File Reference

#include "resource.h"

Include dependency graph for reg.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MAX_SUBKEY_LEN   257

Functions
void *	heap_xalloc (size_t size)
void *	heap_xrealloc (void *buf, size_t size)
void	output_writeconsole (const WCHAR *str, DWORD wlen)
void WINAPIV	output_message (unsigned int id,...)
BOOL	ask_confirm (unsigned int msgid, WCHAR *reg_info)
HKEY	path_get_rootkey (const WCHAR *path)
WCHAR *	build_subkey_path (WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
BOOL	parse_registry_key (const WCHAR *key, HKEY *root, WCHAR **path, WCHAR **long_key)
int	reg_import (const WCHAR *filename)
int	reg_export (int argc, WCHAR *argv[])

Macro Definition Documentation

MAX_SUBKEY_LEN

#define MAX_SUBKEY_LEN   257

Definition at line 24 of file reg.h.

Referenced by export_registry_data(), query_all(), and query_value().

Function Documentation

ask_confirm()

BOOL ask_confirm	(	unsigned int	msgid,
		WCHAR *	reg_info
	)

Definition at line 172 of file reg.c.

Referenced by get_file_handle(), reg_add(), and reg_delete().

{
    HMODULE hmod;
    WCHAR Ybuffer[4];
    WCHAR Nbuffer[4];
    WCHAR defval[32];
    WCHAR answer[MAX_PATH];
    WCHAR *str;
    DWORD count;

    hmod = GetModuleHandleW(NULL);
    LoadStringW(hmod, STRING_YES, Ybuffer, ARRAY_SIZE(Ybuffer));
    LoadStringW(hmod, STRING_NO,  Nbuffer, ARRAY_SIZE(Nbuffer));
    LoadStringW(hmod, STRING_DEFAULT_VALUE, defval, ARRAY_SIZE(defval));

    str = (reg_info && *reg_info) ? reg_info : defval;

    while (1)
    {
        output_message(msgid, str);
        output_message(STRING_YESNO);
        ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE), answer, ARRAY_SIZE(answer), &count, NULL);
        answer[0] = toupperW(answer[0]);
        if (answer[0] == Ybuffer[0])
            return TRUE;
        if (answer[0] == Nbuffer[0])
            return FALSE;
    }
}

build_subkey_path()

WCHAR* build_subkey_path	(	WCHAR *	path,
		DWORD	path_len,
		WCHAR *	subkey_name,
		DWORD	subkey_len
	)

Definition at line 632 of file reg.c.

Referenced by export_registry_data(), query_all(), and query_value().

{
    WCHAR *subkey_path;
    static const WCHAR fmt[] = {'%','s','\\','%','s',0};

    subkey_path = heap_xalloc((path_len + subkey_len + 2) * sizeof(WCHAR));
    sprintfW(subkey_path, fmt, path, subkey_name);

    return subkey_path;
}

heap_xalloc()

void* heap_xalloc

(

size_t

size

)

Definition at line 83 of file reg.c.

Referenced by build_subkey_path(), dword_data_state(), escape_string(), export_dword_data(), export_hex_data(), export_hex_data_type(), export_key_name(), export_registry_data(), export_string_data(), export_value_name(), get_lineA(), get_lineW(), get_long_key(), get_regdata(), GetWideString(), GetWideStringN(), header_state(), open_key(), output_writeconsole(), query_all(), query_value(), quoted_value_name_state(), reg_data_to_wchar(), and reg_delete().

{
    void *buf = heap_alloc(size);
    if (!buf)
    {
        ERR("Out of memory!\n");
        exit(1);
    }
    return buf;
}

heap_xrealloc()

void* heap_xrealloc	(	void *	buf,
		size_t	size
	)

Definition at line 94 of file reg.c.

Referenced by convert_hex_csv_to_hex(), export_registry_data(), get_lineA(), get_lineW(), query_all(), query_value(), and reg_delete().

{
    void *new_buf = heap_realloc(buf, size);

    if (!new_buf)
    {
        ERR("Out of memory!\n");
        exit(1);
    }

    return new_buf;
}

output_message()

void WINAPIV output_message	(	unsigned int	id,
			...
	)

Definition at line 147 of file reg.c.

Referenced by ask_confirm(), get_file_handle(), get_regdata(), key_name_state(), parse_registry_key(), parse_win31_line_state(), query_value(), reg_add(), reg_delete(), reg_export(), reg_import(), reg_query(), sane_path(), unescape_string(), and wmain().

{
    WCHAR fmt[1024];
    __ms_va_list va_args;

    if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
    {
        WINE_FIXME("LoadString failed with %d\n", GetLastError());
        return;
    }
    __ms_va_start(va_args, id);
    output_formatstring(fmt, va_args);
    __ms_va_end(va_args);
}

output_writeconsole()

void output_writeconsole	(	const WCHAR *	str,
		DWORD	wlen
	)

Definition at line 107 of file reg.c.

Referenced by get_file_handle(), and output_formatstring().

{
    DWORD count, ret;

    ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, wlen, &count, NULL);
    if (!ret)
    {
        DWORD len;
        char  *msgA;

        /* On Windows WriteConsoleW() fails if the output is redirected. So fall
         * back to WriteFile(), assuming the console encoding is still the right
         * one in that case.
         */
        len = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, NULL, 0, NULL, NULL);
        msgA = heap_xalloc(len);

        WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL);
        WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
        heap_free(msgA);
    }
}

parse_registry_key()

BOOL parse_registry_key	(	const WCHAR *	key,
		HKEY *	root,
		WCHAR **	path,
		WCHAR **	long_key
	)

Definition at line 863 of file reg.c.

Referenced by reg_export(), and wmain().

{
    if (!sane_path(key))
        return FALSE;

    *path = strchrW(key, '\\');
    if (*path) (*path)++;

    *root = path_get_rootkey(key);
    if (!*root)
    {
        if (*path) *(*path - 1) = 0;
        output_message(STRING_INVALID_SYSTEM_KEY, key);
        return FALSE;
    }

    *long_key = get_long_key(*root, *path);

    return TRUE;
}

path_get_rootkey()

HKEY path_get_rootkey

(

const WCHAR *

path

)

Definition at line 210 of file reg.c.

Referenced by parse_key_name(), and parse_registry_key().

{
    DWORD i;

    for (i = 0; i < ARRAY_SIZE(root_rels); i++)
    {
        if (path_rootname_cmp(path, root_rels[i].short_name) ||
            path_rootname_cmp(path, root_rels[i].long_name))
            return root_rels[i].key;
    }

    return NULL;
}

reg_export()

int reg_export	(	int	argc,
		WCHAR *	argv[]
	)

Definition at line 373 of file export.c.

Referenced by wmain().

{
    HKEY root, hkey;
    WCHAR *path, *long_key;
    BOOL overwrite_file = FALSE;
    HANDLE hFile;
    int ret;

    if (argc == 3 || argc > 5)
        goto error;

    if (!parse_registry_key(argv[2], &root, &path, &long_key))
        return 1;

    if (argc == 5 && !(overwrite_file = is_overwrite_switch(argv[4])))
        goto error;

    if (RegOpenKeyExW(root, path, 0, KEY_READ, &hkey))
    {
        output_message(STRING_INVALID_KEY);
        return 1;
    }

    hFile = get_file_handle(argv[3], overwrite_file);
    export_file_header(hFile);
    ret = export_registry_data(hFile, hkey, long_key);
    export_newline(hFile);
    CloseHandle(hFile);

    RegCloseKey(hkey);

    return ret;

error:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, struprW(argv[1]));
    return 1;
}

reg_import()

int reg_import

(

const WCHAR *

filename

)

Definition at line 995 of file import.c.

Referenced by wmain().

{
    FILE *fp;
    static const WCHAR rb_mode[] = {'r','b',0};
    BYTE s[2];
    struct parser parser;
    WCHAR *pos;

    fp = _wfopen(filename, rb_mode);
    if (!fp)
    {
        output_message(STRING_FILE_NOT_FOUND, filename);
        return 1;
    }

    if (fread(s, sizeof(WCHAR), 1, fp) != 1)
        goto error;

    parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
    get_line = parser.is_unicode ? get_lineW : get_lineA;

    parser.file          = fp;
    parser.two_wchars[0] = s[0];
    parser.two_wchars[1] = s[1];
    parser.reg_version   = -1;
    parser.hkey          = NULL;
    parser.key_name      = NULL;
    parser.value_name    = NULL;
    parser.parse_type    = 0;
    parser.data_type     = 0;
    parser.data          = NULL;
    parser.data_size     = 0;
    parser.backslash     = FALSE;
    parser.state         = HEADER;

    pos = parser.two_wchars;

    /* parser main loop */
    while (pos)
        pos = (parser_funcs[parser.state])(&parser, pos);

    if (parser.reg_version == REG_VERSION_INVALID)
        goto error;

    heap_free(parser.value_name);
    close_key(&parser);

    fclose(fp);
    return 0;

error:
    fclose(fp);
    return 1;
}