reg.h File Reference

#include <stdlib.h>
#include <windows.h>
#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.

Classes
struct	reg_type_rels

Macros
#define	MAX_SUBKEY_LEN   257

Functions
void	output_writeconsole (const WCHAR *str, DWORD wlen)
void WINAPIV	output_message (unsigned int id,...)
void WINAPIV	output_string (const WCHAR *fmt,...)
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)
WCHAR *	get_long_key (HKEY root, WCHAR *path)
BOOL	parse_registry_key (const WCHAR *key, HKEY *root, WCHAR **path)
BOOL	is_char (const WCHAR s, const WCHAR c)
BOOL	is_switch (const WCHAR *s, const WCHAR c)
int	reg_add (int argc, WCHAR *argvW[])
int	reg_copy (int argc, WCHAR *argvW[])
int	reg_delete (int argc, WCHAR *argvW[])
int	reg_export (int argc, WCHAR *argvW[])
int	reg_import (int argc, WCHAR *argvW[])
int	reg_query (int argc, WCHAR *argvW[])

Variables
const struct reg_type_rels	type_rels [8]

Macro Definition Documentation

MAX_SUBKEY_LEN

#define MAX_SUBKEY_LEN   257

Definition at line 26 of file reg.h.

Function Documentation

ask_confirm()

BOOL ask_confirm	(	unsigned int	msgid,
		WCHAR *	reg_info
	)

Definition at line 127 of file reg.c.

{
    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] = towupper(answer[0]);
        if (answer[0] == Ybuffer[0])
            return TRUE;
        if (answer[0] == Nbuffer[0])
            return FALSE;
    }
}

Referenced by get_file_handle(), run_add(), and run_delete().

build_subkey_path()

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

Definition at line 198 of file reg.c.

{
    WCHAR *subkey_path;
 
    subkey_path = malloc((path_len + subkey_len + 2) * sizeof(WCHAR));
    swprintf(subkey_path, L"%s\\%s", path, subkey_name);
 
    return subkey_path;
}

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

get_long_key()

WCHAR * get_long_key	(	HKEY	root,
		WCHAR *	path
	)

Definition at line 208 of file reg.c.

{
    int i, len;
    WCHAR *long_key;
 
    for (i = 0; i < ARRAY_SIZE(root_rels); i++)
    {
        if (root == root_rels[i].key)
            break;
    }
 
    len = lstrlenW(root_rels[i].long_name);
 
    if (!path)
    {
        long_key = malloc((len + 1) * sizeof(WCHAR));
        lstrcpyW(long_key, root_rels[i].long_name);
        return long_key;
    }
 
    len += lstrlenW(path) + 1; /* add one for the concatenating backslash */
    long_key = malloc((len + 1) * sizeof(WCHAR));
    swprintf(long_key, L"%s\\%s", root_rels[i].long_name, path);
    return long_key;
}

Referenced by reg_delete(), reg_export(), and reg_query().

is_char()

BOOL is_char	(	const WCHAR	s,
		const WCHAR	c
	)

Definition at line 267 of file reg.c.

{
    return (s == c || s == towupper(c));
}

Referenced by is_switch(), and reg_export().

is_switch()

BOOL is_switch	(	const WCHAR *	s,
		const WCHAR	c
	)

Definition at line 272 of file reg.c.

{
    if (lstrlenW(s) > 2)
        return FALSE;
 
    return ((s[0] == '/' || s[0] == '-') && is_char(s[1], c));
}

Referenced by is_help_switch().

output_message()

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

Definition at line 92 of file reg.c.

{
    WCHAR *fmt = NULL;
    int len;
    va_list va_args;
 
    if (!(len = LoadStringW(GetModuleHandleW(NULL), id, (WCHAR *)&fmt, 0)))
    {
        WINE_FIXME("LoadString failed with %d\n", GetLastError());
        return;
    }
 
    len++;
    fmt = malloc(len * sizeof(WCHAR));
    if (!fmt) return;
 
    LoadStringW(GetModuleHandleW(NULL), id, fmt, len);
 
    va_start(va_args, id);
    output_formatstring(fmt, va_args);
    va_end(va_args);
 
    free(fmt);
}

output_string()

void WINAPIV output_string	(	const WCHAR *	fmt,
			...
	)

Definition at line 117 of file reg.c.

{
    va_list va_args;
 
    va_start(va_args, fmt);
    output_formatstring(fmt, va_args);
    va_end(va_args);
}

Referenced by output_value(), query_all(), query_value(), and run_query().

output_writeconsole()

void output_writeconsole	(	const WCHAR *	str,
		DWORD	wlen
	)

Definition at line 53 of file reg.c.

{
    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 = malloc(len);
 
        WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL);
        WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
        free(msgA);
    }
}

Referenced by get_file_handle(), and output_formatstring().

parse_registry_key()

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

Definition at line 234 of file reg.c.

{
    WCHAR *p;
 
    if (!sane_path(key))
        return FALSE;
 
    *root = path_get_rootkey(key);
    if (!*root)
    {
        output_message(STRING_INVALID_SYSTEM_KEY);
        return FALSE;
    }
 
    *path = wcschr(key, '\\');
 
    if (!*path)
        return TRUE;
 
    (*path)++;
 
    if (!**path)
    {
        output_message(STRING_INVALID_SYSTEM_KEY);
        return FALSE;
    }
 
    p = *path + lstrlenW(*path) - 1;
    if (*p == '\\') *p = 0;
 
    return TRUE;
}

Referenced by reg_add(), reg_copy(), reg_delete(), reg_export(), and reg_query().

path_get_rootkey()

HKEY path_get_rootkey

(

const WCHAR *

path

)

Definition at line 165 of file reg.c.

{
    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;
}

Referenced by parse_key_name(), and parse_registry_key().

reg_add()

int reg_add	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 227 of file add.c.

{
    HKEY root;
    WCHAR *path, *value_name = NULL, *type = NULL, *data = NULL, separator = '\0';
    BOOL value_empty = FALSE, force = FALSE;
    REGSAM sam = 0;
    int i;
 
    if (!parse_registry_key(argvW[2], &root, &path))
        return 1;
 
    for (i = 3; i < argc; i++)
    {
        WCHAR *str;
 
        if (argvW[i][0] != '/' && argvW[i][0] != '-')
            goto invalid;
 
        str = &argvW[i][1];
 
        if (!lstrcmpiW(str, L"ve"))
        {
            if (value_empty) goto invalid;
            value_empty = TRUE;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:32"))
        {
            if (sam & KEY_WOW64_32KEY) goto invalid;
            sam |= KEY_WOW64_32KEY;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:64"))
        {
            if (sam & KEY_WOW64_64KEY) goto invalid;
            sam |= KEY_WOW64_64KEY;
            continue;
        }
        else if (!str[0] || str[1])
            goto invalid;
 
        switch (towlower(*str))
        {
        case 'v':
            if (value_name || !(value_name = argvW[++i]))
                goto invalid;
            break;
        case 't':
            if (type || !(type = argvW[++i]))
                goto invalid;
            break;
        case 'd':
            if (data || !(data = argvW[++i]))
                goto invalid;
            break;
        case 's':
            str = argvW[++i];
            if (separator || !str || lstrlenW(str) != 1)
                goto invalid;
            separator = str[0];
            break;
        case 'f':
            if (force) goto invalid;
            force = TRUE;
            break;
        default:
            goto invalid;
        }
    }
 
    if (value_name && value_empty)
        goto invalid;
 
    if (sam == (KEY_WOW64_32KEY|KEY_WOW64_64KEY))
        goto invalid;
 
    return run_add(root, path, sam, value_name, value_empty, type, separator, data, force);
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

reg_copy()

int reg_copy	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 193 of file copy.c.

{
    struct key src, dest;
    BOOL recurse = FALSE, force = FALSE;
    REGSAM sam = 0;
    int i;
 
    if (argc == 3)
        goto invalid;
 
    if (!parse_registry_key(argvW[2], &src.root, &src.subkey))
        return 1;
 
    if (!parse_registry_key(argvW[3], &dest.root, &dest.subkey))
        return 1;
 
    for (i = 4; i < argc; i++)
    {
        WCHAR *str;
 
        if (argvW[i][0] != '/' && argvW[i][0] != '-')
            goto invalid;
 
        str = &argvW[i][1];
 
        if (!lstrcmpiW(str, L"reg:32"))
        {
            if (sam & KEY_WOW64_32KEY) goto invalid;
            sam |= KEY_WOW64_32KEY;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:64"))
        {
            if (sam & KEY_WOW64_64KEY) goto invalid;
            sam |= KEY_WOW64_64KEY;
            continue;
        }
        else if (!str[0] || str[1])
            goto invalid;
 
        switch (towlower(*str))
        {
        case 's':
            if (recurse) goto invalid;
            recurse = TRUE;
            break;
        case 'f':
            if (force) goto invalid;
            force = TRUE;
            break;
        default:
            goto invalid;
        }
    }
 
    if (sam == (KEY_WOW64_32KEY|KEY_WOW64_64KEY))
        goto invalid;
 
    if (src.root == dest.root && !lstrcmpiW(src.subkey, dest.subkey))
    {
        output_message(STRING_COPY_SRC_DEST_SAME);
        return 1;
    }
 
    src.path = src.subkey;
 
    return run_copy(&src, &dest, sam, recurse, force);
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

reg_delete()

int reg_delete	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 134 of file delete.c.

{
    HKEY root;
    WCHAR *path, *key_name, *value_name = NULL;
    BOOL value_all = FALSE, value_empty = FALSE, force = FALSE;
    REGSAM sam = 0;
    int i;
 
    if (!parse_registry_key(argvW[2], &root, &path))
        return 1;
 
    for (i = 3; i < argc; i++)
    {
        WCHAR *str;
 
        if (argvW[i][0] != '/' && argvW[i][0] != '-')
            goto invalid;
 
        str = &argvW[i][1];
 
        if (!lstrcmpiW(str, L"va"))
        {
            if (value_all) goto invalid;
            value_all = TRUE;
            continue;
        }
        else if (!lstrcmpiW(str, L"ve"))
        {
            if (value_empty) goto invalid;
            value_empty = TRUE;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:32"))
        {
            if (sam & KEY_WOW64_32KEY) goto invalid;
            sam |= KEY_WOW64_32KEY;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:64"))
        {
            if (sam & KEY_WOW64_64KEY) goto invalid;
            sam |= KEY_WOW64_64KEY;
            continue;
        }
        else if (!str[0] || str[1])
            goto invalid;
 
        switch (towlower(*str))
        {
        case 'v':
            if (value_name || !(value_name = argvW[++i]))
                goto invalid;
            break;
        case 'f':
            if (force) goto invalid;
            force = TRUE;
            break;
        default:
            goto invalid;
        }
    }
 
    if ((value_name && value_empty) || (value_name && value_all) || (value_empty && value_all))
        goto invalid;
 
    if (sam == (KEY_WOW64_32KEY|KEY_WOW64_64KEY))
        goto invalid;
 
    key_name = get_long_key(root, path);
 
    return run_delete(root, path, sam, key_name, value_name, value_empty, value_all, force);
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

reg_export()

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

Definition at line 347 of file export.c.

{
    HKEY root, hkey;
    WCHAR *path, *key_name;
    BOOL overwrite_file = FALSE;
    REGSAM sam = 0;
    HANDLE hFile;
    int i, ret;
 
    if (argc < 4) goto invalid;
 
    if (!parse_registry_key(argvW[2], &root, &path))
        return 1;
 
    for (i = 4; i < argc; i++)
    {
        WCHAR *str;
 
        if (argvW[i][0] != '/' && argvW[i][0] != '-')
            goto invalid;
 
        str = &argvW[i][1];
 
        if (is_char(*str, 'y') && !str[1])
            overwrite_file = TRUE;
        else if (!lstrcmpiW(str, L"reg:32"))
        {
            if (sam & KEY_WOW64_32KEY) goto invalid;
            sam |= KEY_WOW64_32KEY;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:64"))
        {
            if (sam & KEY_WOW64_64KEY) goto invalid;
            sam |= KEY_WOW64_64KEY;
            continue;
        }
        else
            goto invalid;
    }
 
    if (sam == (KEY_WOW64_32KEY|KEY_WOW64_64KEY))
        goto invalid;
 
    if (RegOpenKeyExW(root, path, 0, KEY_READ|sam, &hkey))
    {
        output_message(STRING_KEY_NONEXIST);
        return 1;
    }
 
    key_name = get_long_key(root, path);
 
    hFile = get_file_handle(argvW[3], overwrite_file);
    export_file_header(hFile);
    ret = export_registry_data(hFile, hkey, key_name, sam);
    export_newline(hFile);
    CloseHandle(hFile);
 
    RegCloseKey(hkey);
 
    return ret;
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

reg_import()

int reg_import	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 980 of file import.c.

{
    WCHAR *filename, *pos;
    FILE *fp;
    BYTE s[2];
    struct parser parser;
 
    if (argc > 4) goto invalid;
 
    parser.sam = 0;
 
    if (argc == 4)
    {
        WCHAR *str = argvW[3];
 
        if (*str != '/' && *str != '-')
            goto invalid;
 
        str++;
 
        if (!lstrcmpiW(str, L"reg:32"))
            parser.sam = KEY_WOW64_32KEY;
        else if (!lstrcmpiW(str, L"reg:64"))
            parser.sam = KEY_WOW64_64KEY;
        else
            goto invalid;
    }
 
    filename = argvW[2];
 
    fp = _wfopen(filename, L"rb");
    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;
 
    free(parser.value_name);
    close_key(&parser);
 
    fclose(fp);
    return 0;
 
error:
    fclose(fp);
    return 1;
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

reg_query()

int reg_query	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 339 of file query.c.

{
    HKEY root;
    WCHAR *path, *key_name, *value_name = NULL;
    BOOL value_empty = FALSE, recurse = FALSE;
    int i;
 
    if (!parse_registry_key(argvW[2], &root, &path))
        return 1;
 
    for (i = 3; i < argc; i++)
    {
        WCHAR *str;
 
        if (argvW[i][0] != '/' && argvW[i][0] != '-')
            goto invalid;
 
        str = &argvW[i][1];
 
        if (!lstrcmpiW(str, L"ve"))
        {
            if (value_empty) goto invalid;
            value_empty = TRUE;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:32"))
        {
            if (sam & KEY_WOW64_32KEY) goto invalid;
            sam |= KEY_WOW64_32KEY;
            continue;
        }
        else if (!lstrcmpiW(str, L"reg:64"))
        {
            if (sam & KEY_WOW64_64KEY) goto invalid;
            sam |= KEY_WOW64_64KEY;
            continue;
        }
        else if (!str[0] || str[1])
            goto invalid;
 
        switch (towlower(*str))
        {
        case 'v':
            if (value_name || !(value_name = argvW[++i]))
                goto invalid;
            break;
        case 's':
            if (recurse) goto invalid;
            recurse = TRUE;
            break;
        default:
            goto invalid;
        }
    }
 
    if (value_name && value_empty)
        goto invalid;
 
    if (sam == (KEY_WOW64_32KEY|KEY_WOW64_64KEY))
        goto invalid;
 
    key_name = get_long_key(root, path);
 
    return run_query(root, path, key_name, value_name, value_empty, recurse);
 
invalid:
    output_message(STRING_INVALID_SYNTAX);
    output_message(STRING_FUNC_HELP, _wcsupr(argvW[1]));
    return 1;
}

Referenced by wmain().

Variable Documentation

type_rels

const struct reg_type_rels type_rels[8]

extern

Definition at line 41 of file reg.c.

Referenced by reg_type_to_wchar(), and wchar_get_type().