regproc.c File Reference

#include <errno.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>
#include <commctrl.h>
#include "main.h"

Include dependency graph for regproc.c:

Go to the source code of this file.

Classes
struct	parser

Macros
#define	REG_VAL_BUF_SIZE   4096
#define	MAX_HEX_CHARS   77
#define	MAX_SUBKEY_LEN   257

Typedefs
typedef WCHAR *(*	parser_state_func) (struct parser *parser, WCHAR *pos)

Enumerations
enum	parser_state {   HEADER , PARSE_WIN31_LINE , LINE_START , KEY_NAME ,   DELETE_KEY , DEFAULT_VALUE_NAME , QUOTED_VALUE_NAME , DATA_START ,   DELETE_VALUE , DATA_TYPE , STRING_DATA , DWORD_DATA ,   HEX_DATA , EOL_BACKSLASH , HEX_MULTILINE , UNKNOWN_DATA ,   SET_VALUE , NB_PARSER_STATES , HEADER , PARSE_WIN31_LINE ,   LINE_START , KEY_NAME , DELETE_KEY , DEFAULT_VALUE_NAME ,   QUOTED_VALUE_NAME , DATA_START , DELETE_VALUE , DATA_TYPE ,   STRING_DATA , DWORD_DATA , HEX_DATA , EOL_BACKSLASH ,   HEX_MULTILINE , UNKNOWN_DATA , SET_VALUE , NB_PARSER_STATES ,   LINE_START , SECTION_NAME , KEY_NAME , VALUE_NAME ,   EOL_BACKSLASH , QUOTES , LEADING_SPACES , TRAILING_SPACES ,   COMMENT , NB_PARSER_STATES , LINE_START , SECTION_NAME ,   KEY_NAME , VALUE_NAME , EOL_BACKSLASH , QUOTES ,   LEADING_SPACES , TRAILING_SPACES , COMMENT , NB_PARSER_STATES ,   LINE_START , SECTION_NAME , KEY_NAME , VALUE_NAME ,   EOL_BACKSLASH , QUOTES , LEADING_SPACES , TRAILING_SPACES ,   COMMENT , NB_PARSER_STATES }
enum	reg_versions {   REG_VERSION_31 , REG_VERSION_40 , REG_VERSION_50 , REG_VERSION_FUZZY ,   REG_VERSION_INVALID , REG_VERSION_31 , REG_VERSION_40 , REG_VERSION_50 ,   REG_VERSION_FUZZY , REG_VERSION_INVALID }

Functions
static WCHAR *	GetWideString (const char *strA)
static WCHAR *	GetWideStringN (const char *strA, int chars, DWORD *len)
char *	GetMultiByteString (const WCHAR *strW)
static char *	GetMultiByteStringN (const WCHAR *strW, int chars, DWORD *len)
static WCHAR *	header_state (struct parser *parser, WCHAR *pos)
static WCHAR *	parse_win31_line_state (struct parser *parser, WCHAR *pos)
static WCHAR *	line_start_state (struct parser *parser, WCHAR *pos)
static WCHAR *	key_name_state (struct parser *parser, WCHAR *pos)
static WCHAR *	delete_key_state (struct parser *parser, WCHAR *pos)
static WCHAR *	default_value_name_state (struct parser *parser, WCHAR *pos)
static WCHAR *	quoted_value_name_state (struct parser *parser, WCHAR *pos)
static WCHAR *	data_start_state (struct parser *parser, WCHAR *pos)
static WCHAR *	delete_value_state (struct parser *parser, WCHAR *pos)
static WCHAR *	data_type_state (struct parser *parser, WCHAR *pos)
static WCHAR *	string_data_state (struct parser *parser, WCHAR *pos)
static WCHAR *	dword_data_state (struct parser *parser, WCHAR *pos)
static WCHAR *	hex_data_state (struct parser *parser, WCHAR *pos)
static WCHAR *	eol_backslash_state (struct parser *parser, WCHAR *pos)
static WCHAR *	hex_multiline_state (struct parser *parser, WCHAR *pos)
static WCHAR *	unknown_data_state (struct parser *parser, WCHAR *pos)
static WCHAR *	set_value_state (struct parser *parser, WCHAR *pos)
static enum parser_state	set_state (struct parser *parser, enum parser_state state)
static BOOL	convert_hex_to_dword (WCHAR *str, DWORD *dw)
static BOOL	convert_hex_csv_to_hex (struct parser *parser, WCHAR **str)
static BOOL	parse_data_type (struct parser *parser, WCHAR **line)
static BOOL	REGPROC_unescape_string (WCHAR *str, WCHAR **unparsed)
static HKEY	parse_key_name (WCHAR *key_name, WCHAR **key_path)
static void	close_key (struct parser *parser)
static LONG	open_key (struct parser *parser, WCHAR *path)
static void	free_parser_data (struct parser *parser)
static void	prepare_hex_string_data (struct parser *parser)
static enum reg_versions	parse_file_header (const WCHAR *s)
static WCHAR *	get_lineA (FILE *fp)
static WCHAR *	get_lineW (FILE *fp)
BOOL	import_registry_file (FILE *reg_file)
void	delete_registry_key (WCHAR *reg_key_name)
static void	REGPROC_write_line (FILE *fp, const WCHAR *str, BOOL unicode)
static WCHAR *	REGPROC_escape_string (WCHAR *str, size_t str_len, size_t *line_len)
static size_t	export_value_name (FILE *fp, WCHAR *name, size_t len, BOOL unicode)
static void	export_string_data (WCHAR **buf, WCHAR *data, size_t size)
static void	export_dword_data (WCHAR **buf, DWORD *data)
static size_t	export_hex_data_type (FILE *fp, DWORD type, BOOL unicode)
static void	export_hex_data (FILE *fp, WCHAR **buf, DWORD type, DWORD line_len, void *data, DWORD size, BOOL unicode)
static void	export_newline (FILE *fp, BOOL unicode)
static void	export_data (FILE *fp, WCHAR *value_name, DWORD value_len, DWORD type, void *data, size_t size, BOOL unicode)
static WCHAR *	build_subkey_path (WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
static void	export_key_name (FILE *fp, WCHAR *name, BOOL unicode)
static void	export_registry_data (FILE *fp, HKEY key, WCHAR *path, BOOL unicode)
static FILE *	REGPROC_open_export_file (WCHAR *file_name, BOOL unicode)
static HKEY	open_export_key (HKEY key_class, WCHAR *subkey, WCHAR *path)
static BOOL	export_key (WCHAR *file_name, WCHAR *path, BOOL unicode)
static BOOL	export_all (WCHAR *file_name, WCHAR *path, BOOL unicode)
BOOL	export_registry_key (WCHAR *file_name, WCHAR *path, DWORD format)

Variables
static HKEY	reg_class_keys []
static WCHAR *(*	get_line )(FILE *)
static const parser_state_func	parser_funcs [NB_PARSER_STATES]

Macro Definition Documentation

MAX_HEX_CHARS

#define MAX_HEX_CHARS   77

Definition at line 1294 of file regproc.c.

MAX_SUBKEY_LEN

#define MAX_SUBKEY_LEN   257

Definition at line 1403 of file regproc.c.

REG_VAL_BUF_SIZE

#define REG_VAL_BUF_SIZE   4096

Definition at line 25 of file regproc.c.

Typedef Documentation

parser_state_func

typedef WCHAR *(* parser_state_func) (struct parser *parser, WCHAR *pos)

Definition at line 151 of file regproc.c.

Enumeration Type Documentation

parser_state

enum parser_state

Enumerator
HEADER
PARSE_WIN31_LINE
LINE_START
KEY_NAME
DELETE_KEY
DEFAULT_VALUE_NAME
QUOTED_VALUE_NAME
DATA_START
DELETE_VALUE
DATA_TYPE
STRING_DATA
DWORD_DATA
HEX_DATA
EOL_BACKSLASH
HEX_MULTILINE
UNKNOWN_DATA
SET_VALUE
NB_PARSER_STATES
HEADER
PARSE_WIN31_LINE
LINE_START
KEY_NAME
DELETE_KEY
DEFAULT_VALUE_NAME
QUOTED_VALUE_NAME
DATA_START
DELETE_VALUE
DATA_TYPE
STRING_DATA
DWORD_DATA
HEX_DATA
EOL_BACKSLASH
HEX_MULTILINE
UNKNOWN_DATA
SET_VALUE
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES

Definition at line 109 of file regproc.c.

{
    HEADER,              /* parsing the registry file version header */
    PARSE_WIN31_LINE,    /* parsing a Windows 3.1 registry line */
    LINE_START,          /* at the beginning of a registry line */
    KEY_NAME,            /* parsing a key name */
    DELETE_KEY,          /* deleting a registry key */
    DEFAULT_VALUE_NAME,  /* parsing a default value name */
    QUOTED_VALUE_NAME,   /* parsing a double-quoted value name */
    DATA_START,          /* preparing for data parsing operations */
    DELETE_VALUE,        /* deleting a registry value */
    DATA_TYPE,           /* parsing the registry data type */
    STRING_DATA,         /* parsing REG_SZ data */
    DWORD_DATA,          /* parsing DWORD data */
    HEX_DATA,            /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
    EOL_BACKSLASH,       /* preparing to parse multiple lines of hex data */
    HEX_MULTILINE,       /* parsing multiple lines of hex data */
    UNKNOWN_DATA,        /* parsing an unhandled or invalid data type */
    SET_VALUE,           /* adding a value to the registry */
    NB_PARSER_STATES
};

reg_versions

enum reg_versions

Enumerator
REG_VERSION_31
REG_VERSION_40
REG_VERSION_50
REG_VERSION_FUZZY
REG_VERSION_INVALID
REG_VERSION_31
REG_VERSION_40
REG_VERSION_50
REG_VERSION_FUZZY
REG_VERSION_INVALID

Definition at line 529 of file regproc.c.

                  {
    REG_VERSION_31,
    REG_VERSION_40,
    REG_VERSION_50,
    REG_VERSION_FUZZY,
    REG_VERSION_INVALID
};

Function Documentation

build_subkey_path()

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

static

Definition at line 1375 of file regproc.c.

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

Referenced by export_registry_data().

close_key()

static void close_key ( struct parser *  parser )

static

Definition at line 441 of file regproc.c.

{
    if (parser->hkey)
    {
        free(parser->key_name);
        parser->key_name = NULL;
 
        RegCloseKey(parser->hkey);
        parser->hkey = NULL;
    }
}

convert_hex_csv_to_hex()

static BOOL convert_hex_csv_to_hex ( struct parser *  parser, WCHAR **  str  )

static

Definition at line 238 of file regproc.c.

{
    size_t size;
    BYTE *d;
    WCHAR *s;
 
    parser->backslash = FALSE;
 
    /* The worst case is 1 digit + 1 comma per byte */
    size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
    parser->data = realloc(parser->data, size);
 
    s = *str;
    d = (BYTE *)parser->data + parser->data_size;
 
    while (*s)
    {
        WCHAR *end;
        unsigned long wc;
 
        wc = wcstoul(s, &end, 16);
        if (wc > 0xff) return FALSE;
 
        if (s == end && wc == 0)
        {
            while (*end == ' ' || *end == '\t') end++;
            if (*end == '\\')
            {
                parser->backslash = TRUE;
                *str = end + 1;
                return TRUE;
            }
            else if (*end == ';')
                return TRUE;
            return FALSE;
        }
 
        *d++ = wc;
        parser->data_size++;
 
        if (*end && *end != ',')
        {
            while (*end == ' ' || *end == '\t') end++;
            if (*end && *end != ';') return FALSE;
            return TRUE;
        }
 
        if (*end) end++;
        s = end;
    }
 
    return TRUE;
}

Referenced by hex_data_state().

convert_hex_to_dword()

static BOOL convert_hex_to_dword ( WCHAR *  str, DWORD *  dw  )

static

Definition at line 204 of file regproc.c.

{
    WCHAR *p, *end;
    int count = 0;
 
    while (*str == ' ' || *str == '\t') str++;
    if (!*str) goto error;
 
    p = str;
    while (iswxdigit(*p))
    {
        count++;
        p++;
    }
    if (count > 8) goto error;
 
    end = p;
    while (*p == ' ' || *p == '\t') p++;
    if (*p && *p != ';') goto error;
 
    *end = 0;
    *dw = wcstoul(str, &end, 16);
    return TRUE;
 
error:
    return FALSE;
}

Referenced by dword_data_state().

data_start_state()

static WCHAR * data_start_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 741 of file regproc.c.

{
    WCHAR *p = pos;
    unsigned int len;
 
    while (*p == ' ' || *p == '\t') p++;
    if (*p != '=') goto done;
    p++;
    while (*p == ' ' || *p == '\t') p++;
 
    /* trim trailing whitespace */
    len = lstrlenW(p);
    while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
    p[len] = 0;
 
    if (*p == '-')
        set_state(parser, DELETE_VALUE);
    else
        set_state(parser, DATA_TYPE);
    return p;
 
done:
    set_state(parser, LINE_START);
    return p;
}

data_type_state()

static WCHAR * data_type_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 783 of file regproc.c.

{
    WCHAR *line = pos;
 
    if (!parse_data_type(parser, &line))
    {
        set_state(parser, LINE_START);
        return line;
    }
 
    switch (parser->parse_type)
    {
    case REG_SZ:
        set_state(parser, STRING_DATA);
        break;
    case REG_DWORD:
        set_state(parser, DWORD_DATA);
        break;
    case REG_BINARY: /* all hex data types, including undefined */
        set_state(parser, HEX_DATA);
        break;
    default:
        set_state(parser, UNKNOWN_DATA);
    }
 
    return line;
}

default_value_name_state()

static WCHAR * default_value_name_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 708 of file regproc.c.

{
    free(parser->value_name);
    parser->value_name = NULL;
 
    set_state(parser, DATA_START);
    return pos + 1;
}

delete_key_state()

static WCHAR * delete_key_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 694 of file regproc.c.

{
    WCHAR *p = pos;
 
    close_key(parser);
 
    if (*p == 'H' || *p == 'h')
        delete_registry_key(p);
 
    set_state(parser, LINE_START);
    return p;
}

delete_registry_key()

void delete_registry_key

(

WCHAR *

reg_key_name

)

Definition at line 1114 of file regproc.c.

{
    WCHAR *key_name = NULL;
    HKEY key_class;
 
    if (!reg_key_name || !reg_key_name[0])
        return;
 
    if (!(key_class = parse_key_name(reg_key_name, &key_name)))
    {
        if (key_name) *(key_name - 1) = 0;
#ifdef __REACTOS__
        output_message(STRING_INVALID_SYSTEM_KEY, reg_key_name);
        return;
#else
        error_exit(STRING_INVALID_SYSTEM_KEY, reg_key_name);
#endif
    }
 
    if (!key_name || !*key_name)
#ifdef __REACTOS__
    {
        output_message(STRING_DELETE_FAILED, reg_key_name);
        return;
    }
#else
        error_exit(STRING_DELETE_FAILED, reg_key_name);
#endif
 
#ifdef __REACTOS__
    SHDeleteKey(key_class, key_name);
#else
    RegDeleteTreeW(key_class, key_name);
#endif
}

Referenced by delete_key_state(), and PerformRegAction().

delete_value_state()

static WCHAR * delete_value_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 768 of file regproc.c.

{
    WCHAR *p = pos + 1;
 
    while (*p == ' ' || *p == '\t') p++;
    if (*p && *p != ';') goto done;
 
    RegDeleteValueW(parser->hkey, parser->value_name);
 
done:
    set_state(parser, LINE_START);
    return p;
}

dword_data_state()

static WCHAR * dword_data_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 836 of file regproc.c.

{
    WCHAR *line = pos;
 
    parser->data = malloc(sizeof(DWORD));
 
    if (!convert_hex_to_dword(line, parser->data))
        goto invalid;
 
    parser->data_size = sizeof(DWORD);
 
    set_state(parser, SET_VALUE);
    return line;
 
invalid:
    free_parser_data(parser);
    set_state(parser, LINE_START);
    return line;
}

eol_backslash_state()

static WCHAR * eol_backslash_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 886 of file regproc.c.

{
    WCHAR *p = pos;
 
    while (*p == ' ' || *p == '\t') p++;
    if (*p && *p != ';') goto invalid;
 
    set_state(parser, HEX_MULTILINE);
    return pos;
 
invalid:
    free_parser_data(parser);
    set_state(parser, LINE_START);
    return p;
}

export_all()

static BOOL export_all ( WCHAR *  file_name, WCHAR *  path, BOOL  unicode  )

static

Definition at line 1555 of file regproc.c.

{
    FILE *fp;
    int i;
    HKEY classes[] = {HKEY_LOCAL_MACHINE, HKEY_USERS}, key;
    WCHAR *class_name;
 
    fp = REGPROC_open_export_file(file_name, unicode);
#ifdef __REACTOS__
    if (!fp)
        return TRUE; /* Error message is already displayed */
#endif
 
    for (i = 0; i < ARRAY_SIZE(classes); i++)
    {
        if (!(key = open_export_key(classes[i], NULL, path)))
        {
            fclose(fp);
            return FALSE;
        }
 
        class_name = malloc((lstrlenW(reg_class_namesW[i]) + 1) * sizeof(WCHAR));
        lstrcpyW(class_name, reg_class_namesW[i]);
 
        export_registry_data(fp, classes[i], class_name, unicode);
 
        free(class_name);
        RegCloseKey(key);
    }
 
    export_newline(fp, unicode);
    fclose(fp);
 
    return TRUE;
}

Referenced by export_registry_key().

export_data()

static void export_data ( FILE *  fp, WCHAR *  value_name, DWORD  value_len, DWORD  type, void *  data, size_t  size, BOOL  unicode  )

static

Definition at line 1339 of file regproc.c.

{
    WCHAR *buf = NULL;
    size_t line_len = export_value_name(fp, value_name, value_len, unicode);
 
    switch (type)
    {
    case REG_SZ:
        export_string_data(&buf, data, size);
        break;
    case REG_DWORD:
        if (size)
        {
            export_dword_data(&buf, data);
            break;
        }
        /* fall through */
    case REG_NONE:
    case REG_EXPAND_SZ:
    case REG_BINARY:
    case REG_MULTI_SZ:
    default:
        export_hex_data(fp, &buf, type, line_len, data, size, unicode);
        break;
    }
 
    if (size || type == REG_SZ)
    {
        REGPROC_write_line(fp, buf, unicode);
        free(buf);
    }
 
    export_newline(fp, unicode);
}

Referenced by export_registry_data().

export_dword_data()

static void export_dword_data ( WCHAR **  buf, DWORD *  data  )

static

Definition at line 1258 of file regproc.c.

{
    *buf = malloc(15 * sizeof(WCHAR));
#ifdef __REACTOS__
    StringCchPrintfW(*buf, 15, L"dword:%08x", *data);
#else
    swprintf(*buf, 15, L"dword:%08x", *data);
#endif
}

Referenced by export_data().

export_hex_data()

static void export_hex_data ( FILE *  fp, WCHAR **  buf, DWORD  type, DWORD  line_len, void *  data, DWORD  size, BOOL  unicode  )

static

Definition at line 1296 of file regproc.c.

{
    size_t num_commas, i, pos;
 
    line_len += export_hex_data_type(fp, type, unicode);
 
    if (!size) return;
 
    if (!unicode && (type == REG_EXPAND_SZ || type == REG_MULTI_SZ))
        data = GetMultiByteStringN(data, size / sizeof(WCHAR), &size);
 
    num_commas = size - 1;
    *buf = malloc(size * 3 * sizeof(WCHAR));
 
    for (i = 0, pos = 0; i < size; i++)
    {
#ifdef __REACTOS__
        StringCchPrintfW(*buf + pos, 3, L"%02x", ((BYTE *)data)[i]);
        pos += wcslen(*buf + pos);
#else
        pos += swprintf(*buf + pos, 3, L"%02x", ((BYTE *)data)[i]);
#endif
        if (i == num_commas) break;
        (*buf)[pos++] = ',';
        (*buf)[pos] = 0;
        line_len += 3;
 
        if (line_len >= MAX_HEX_CHARS)
        {
            REGPROC_write_line(fp, *buf, unicode);
            REGPROC_write_line(fp, L"\\\r\n  ", unicode);
            line_len = 2;
            pos = 0;
        }
    }
}

Referenced by export_data().

export_hex_data_type()

static size_t export_hex_data_type ( FILE *  fp, DWORD  type, BOOL  unicode  )

static

Definition at line 1268 of file regproc.c.

{
    static const WCHAR hex[] = L"hex:";
    size_t line_len;
 
    if (type == REG_BINARY)
    {
        line_len = lstrlenW(hex);
        REGPROC_write_line(fp, hex, unicode);
    }
    else
    {
        WCHAR *buf = malloc(15 * sizeof(WCHAR));
#ifdef __REACTOS__
        StringCchPrintfW(buf, 15, L"hex(%x):", type);
        line_len = wcslen(buf);
#else
        line_len = swprintf(buf, 15, L"hex(%x):", type);
#endif
        REGPROC_write_line(fp, buf, unicode);
        free(buf);
    }
 
    return line_len;
}

Referenced by export_hex_data().

export_key()

static BOOL export_key ( WCHAR *  file_name, WCHAR *  path, BOOL  unicode  )

static

Definition at line 1526 of file regproc.c.

{
    HKEY key_class, key;
    WCHAR *subkey;
    FILE *fp;
 
    if (!(key_class = parse_key_name(path, &subkey)))
    {
        if (subkey) *(subkey - 1) = 0;
        output_message(STRING_INVALID_SYSTEM_KEY, path);
        return FALSE;
    }
 
    if (!(key = open_export_key(key_class, subkey, path)))
        return FALSE;
 
    fp = REGPROC_open_export_file(file_name, unicode);
#ifdef __REACTOS__
    if (!fp)
        return TRUE; /* Error message is already displayed */
#endif
    export_registry_data(fp, key, path, unicode);
    export_newline(fp, unicode);
    fclose(fp);
 
    RegCloseKey(key);
    return TRUE;
}

Referenced by export_registry_key().

export_key_name()

static void export_key_name ( FILE *  fp, WCHAR *  name, BOOL  unicode  )

static

Definition at line 1389 of file regproc.c.

{
    WCHAR *buf;
 
    buf = malloc((lstrlenW(name) + 7) * sizeof(WCHAR));
#ifdef __REACTOS__
    StringCchPrintfW(buf, lstrlenW(name) + 7, L"\r\n[%s]\r\n", name);
#else
    swprintf(buf, lstrlenW(name) + 7, L"\r\n[%s]\r\n", name);
#endif
    REGPROC_write_line(fp, buf, unicode);
    free(buf);
}

Referenced by export_registry_data().

export_newline()

static void export_newline ( FILE *  fp, BOOL  unicode  )

static

Definition at line 1334 of file regproc.c.

{
    REGPROC_write_line(fp, L"\r\n", unicode);
}

Referenced by export_all(), export_data(), and export_key().

export_registry_data()

static void export_registry_data ( FILE *  fp, HKEY  key, WCHAR *  path, BOOL  unicode  )

static

Definition at line 1405 of file regproc.c.

{
    LONG rc;
    DWORD max_value_len = 256, value_len;
    DWORD max_data_bytes = 2048, data_size;
    DWORD subkey_len;
    DWORD i, type, path_len;
    WCHAR *value_name, *subkey_name, *subkey_path;
    BYTE *data;
    HKEY subkey;
 
    export_key_name(fp, path, unicode);
 
    value_name = malloc(max_value_len * sizeof(WCHAR));
    data = malloc(max_data_bytes);
 
    i = 0;
    for (;;)
    {
        value_len = max_value_len;
        data_size = max_data_bytes;
        rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
        if (rc == ERROR_SUCCESS)
        {
            export_data(fp, value_name, value_len, type, data, data_size, unicode);
            i++;
        }
        else if (rc == ERROR_MORE_DATA)
        {
            if (data_size > max_data_bytes)
            {
                max_data_bytes = data_size;
                data = realloc(data, max_data_bytes);
            }
            else
            {
                max_value_len *= 2;
                value_name = realloc(value_name, max_value_len * sizeof(WCHAR));
            }
        }
        else break;
    }
 
    free(data);
    free(value_name);
 
    subkey_name = malloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
 
    path_len = lstrlenW(path);
 
    i = 0;
    for (;;)
    {
        subkey_len = MAX_SUBKEY_LEN;
        rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
        if (rc == ERROR_SUCCESS)
        {
            subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
            if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
            {
                export_registry_data(fp, subkey, subkey_path, unicode);
                RegCloseKey(subkey);
            }
            free(subkey_path);
            i++;
        }
        else break;
    }
 
    free(subkey_name);
}

Referenced by export_all(), export_key(), and export_registry_data().

export_registry_key()

BOOL export_registry_key	(	WCHAR *	file_name,
		WCHAR *	path,
		DWORD	format
	)

Definition at line 1591 of file regproc.c.

{
    BOOL unicode = (format == REG_FORMAT_5);
 
    if (path && *path)
        return export_key(file_name, path, unicode);
    else
        return export_all(file_name, path, unicode);
}

Referenced by ExportRegistryFile(), and PerformRegAction().

export_string_data()

static void export_string_data ( WCHAR **  buf, WCHAR *  data, size_t  size  )

static

Definition at line 1241 of file regproc.c.

{
    size_t len = 0, line_len;
    WCHAR *str;
 
    if (size)
        len = size / sizeof(WCHAR) - 1;
    str = REGPROC_escape_string(data, len, &line_len);
    *buf = malloc((line_len + 3) * sizeof(WCHAR));
#ifdef __REACTOS__
    StringCchPrintfW(*buf, line_len + 3, L"\"%s\"", str);
#else
    swprintf(*buf, line_len + 3, L"\"%s\"", str);
#endif
    free(str);
}

Referenced by export_data().

export_value_name()

static size_t export_value_name ( FILE *  fp, WCHAR *  name, size_t  len, BOOL  unicode  )

static

Definition at line 1213 of file regproc.c.

{
    static const WCHAR default_name[] = L"@=";
    size_t line_len;
 
    if (name && *name)
    {
        WCHAR *str = REGPROC_escape_string(name, len, &line_len);
        WCHAR *buf = malloc((line_len + 4) * sizeof(WCHAR));
#ifdef __REACTOS__
        StringCchPrintfW(buf, line_len + 4, L"\"%s\"=", str);
        line_len = wcslen(buf);
#else
        line_len = swprintf(buf, line_len + 4, L"\"%s\"=", str);
#endif
        REGPROC_write_line(fp, buf, unicode);
        free(buf);
        free(str);
    }
    else
    {
        line_len = lstrlenW(default_name);
        REGPROC_write_line(fp, default_name, unicode);
    }
 
    return line_len;
}

Referenced by export_data().

free_parser_data()

static void free_parser_data ( struct parser *  parser )

static

Definition at line 483 of file regproc.c.

{
    if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
        free(parser->data);
 
    parser->data = NULL;
    parser->data_size = 0;
}

Referenced by dword_data_state(), eol_backslash_state(), hex_data_state(), hex_multiline_state(), set_value_state(), and string_data_state().

get_lineA()

static WCHAR * get_lineA ( FILE *  fp )

static

Definition at line 953 of file regproc.c.

{
    static WCHAR *lineW;
    static size_t size;
    static char *buf, *next;
    char *line;
 
    free(lineW);
 
    if (!fp) goto cleanup;
 
    if (!size)
    {
        size = REG_VAL_BUF_SIZE;
        buf = malloc(size);
        *buf = 0;
        next = buf;
    }
    line = next;
 
    while (next)
    {
        char *p = strpbrk(line, "\r\n");
        if (!p)
        {
            size_t len, count;
            len = strlen(next);
            memmove(buf, next, len + 1);
            if (size - len < 3)
            {
                size *= 2;
                buf = realloc(buf, size);
            }
            if (!(count = fread(buf + len, 1, size - len - 1, fp)))
            {
                next = NULL;
                lineW = GetWideString(buf);
                return lineW;
            }
            buf[len + count] = 0;
            next = buf;
            line = buf;
            continue;
        }
        next = p + 1;
        if (*p == '\r' && *(p + 1) == '\n') next++;
        *p = 0;
        lineW = GetWideString(line);
        return lineW;
    }
 
cleanup:
    lineW = NULL;
    if (size) free(buf);
    size = 0;
    return NULL;
}

Referenced by import_registry_file().

get_lineW()

static WCHAR * get_lineW ( FILE *  fp )

static

Definition at line 1011 of file regproc.c.

{
    static size_t size;
    static WCHAR *buf, *next;
    WCHAR *line;
 
    if (!fp) goto cleanup;
 
    if (!size)
    {
        size = REG_VAL_BUF_SIZE;
        buf = malloc(size * sizeof(WCHAR));
        *buf = 0;
        next = buf;
    }
    line = next;
 
    while (next)
    {
        WCHAR *p = wcspbrk(line, L"\r\n");
        if (!p)
        {
            size_t len, count;
            len = lstrlenW(next);
            memmove(buf, next, (len + 1) * sizeof(WCHAR));
            if (size - len < 3)
            {
                size *= 2;
                buf = realloc(buf, size * sizeof(WCHAR));
            }
            if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
            {
                next = NULL;
                return buf;
            }
            buf[len + count] = 0;
            next = buf;
            line = buf;
            continue;
        }
        next = p + 1;
        if (*p == '\r' && *(p + 1) == '\n') next++;
        *p = 0;
        return line;
    }
 
cleanup:
    if (size) free(buf);
    size = 0;
    return NULL;
}

Referenced by import_registry_file().

GetMultiByteString()

char * GetMultiByteString

(

const WCHAR *

strW

)

Definition at line 73 of file regproc.c.

{
    if(strW)
    {
        char* strA;
        int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
 
        strA = malloc(len);
        WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
        return strA;
    }
    return NULL;
}

Referenced by REGPROC_write_line().

GetMultiByteStringN()

static char * GetMultiByteStringN ( const WCHAR *  strW, int  chars, DWORD *  len  )

static

Definition at line 91 of file regproc.c.

{
    if(strW)
    {
        char* strA;
        *len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
 
        strA = malloc(*len);
        WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
        return strA;
    }
    *len = 0;
    return NULL;
}

Referenced by export_hex_data().

GetWideString()

static WCHAR * GetWideString ( const char *  strA )

static

Definition at line 36 of file regproc.c.

{
    if(strA)
    {
        WCHAR* strW;
        int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
 
        strW = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
        return strW;
    }
    return NULL;
}

Referenced by get_lineA().

GetWideStringN()

static WCHAR * GetWideStringN ( const char *  strA, int  chars, DWORD *  len  )

static

Definition at line 54 of file regproc.c.

{
    if(strA)
    {
        WCHAR* strW;
        *len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
 
        strW = malloc(*len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
        return strW;
    }
    *len = 0;
    return NULL;
}

Referenced by prepare_hex_string_data().

header_state()

static WCHAR * header_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 564 of file regproc.c.

{
    WCHAR *line, *header;
 
    if (!(line = get_line(parser->file)))
        return NULL;
 
    if (!parser->is_unicode)
    {
        header = malloc((lstrlenW(line) + 3) * sizeof(WCHAR));
        header[0] = parser->two_wchars[0];
        header[1] = parser->two_wchars[1];
        lstrcpyW(header + 2, line);
        parser->reg_version = parse_file_header(header);
        free(header);
    }
    else parser->reg_version = parse_file_header(line);
 
    switch (parser->reg_version)
    {
    case REG_VERSION_31:
        set_state(parser, PARSE_WIN31_LINE);
        break;
    case REG_VERSION_40:
    case REG_VERSION_50:
        set_state(parser, LINE_START);
        break;
    default:
        get_line(NULL); /* Reset static variables */
        return NULL;
    }
 
    return line;
}

hex_data_state()

static WCHAR * hex_data_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 857 of file regproc.c.

{
    WCHAR *line = pos;
 
    if (!*line)
        goto set_value;
 
    if (!convert_hex_csv_to_hex(parser, &line))
        goto invalid;
 
    if (parser->backslash)
    {
        set_state(parser, EOL_BACKSLASH);
        return line;
    }
 
    prepare_hex_string_data(parser);
 
set_value:
    set_state(parser, SET_VALUE);
    return line;
 
invalid:
    free_parser_data(parser);
    set_state(parser, LINE_START);
    return line;
}

hex_multiline_state()

static WCHAR * hex_multiline_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 903 of file regproc.c.

{
    WCHAR *line;
 
    if (!(line = get_line(parser->file)))
    {
        prepare_hex_string_data(parser);
        set_state(parser, SET_VALUE);
        return pos;
    }
 
    while (*line == ' ' || *line == '\t') line++;
    if (!*line || *line == ';') return line;
 
    if (!iswxdigit(*line)) goto invalid;
 
    set_state(parser, HEX_DATA);
    return line;
 
invalid:
    free_parser_data(parser);
    set_state(parser, LINE_START);
    return line;
}

import_registry_file()

BOOL import_registry_file

(

FILE *

reg_file

)

Definition at line 1066 of file regproc.c.

{
    BYTE s[2];
    struct parser parser;
    WCHAR *pos;
 
    if (!reg_file || (fread(s, 2, 1, reg_file) != 1))
        return FALSE;
 
    parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
    get_line = parser.is_unicode ? get_lineW : get_lineA;
 
    parser.file          = reg_file;
    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_FUZZY || parser.reg_version == REG_VERSION_INVALID)
        return parser.reg_version == REG_VERSION_FUZZY;
 
    free(parser.value_name);
    close_key(&parser);
 
    return TRUE;
}

Referenced by ImportRegistryFile(), and PerformRegAction().

key_name_state()

static WCHAR * key_name_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 671 of file regproc.c.

{
    WCHAR *p = pos, *key_end;
 
    if (*p == ' ' || *p == '\t' || !(key_end = wcsrchr(p, ']')))
        goto done;
 
    *key_end = 0;
 
    if (*p == '-')
    {
        set_state(parser, DELETE_KEY);
        return p + 1;
    }
    else if (open_key(parser, p) != ERROR_SUCCESS)
        output_message(STRING_OPEN_KEY_FAILED, p);
 
done:
    set_state(parser, LINE_START);
    return p;
}

line_start_state()

static WCHAR * line_start_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 639 of file regproc.c.

{
    WCHAR *line, *p;
 
    if (!(line = get_line(parser->file)))
        return NULL;
 
    for (p = line; *p; p++)
    {
        switch (*p)
        {
        case '[':
            set_state(parser, KEY_NAME);
            return p + 1;
        case '@':
            set_state(parser, DEFAULT_VALUE_NAME);
            return p;
        case '"':
            set_state(parser, QUOTED_VALUE_NAME);
            return p + 1;
        case ' ':
        case '\t':
            break;
        default:
            return p;
        }
    }
 
    return p;
}

open_export_key()

static HKEY open_export_key ( HKEY  key_class, WCHAR *  subkey, WCHAR *  path  )

static

Definition at line 1515 of file regproc.c.

{
    HKEY key;
 
    if (!RegOpenKeyExW(key_class, subkey, 0, KEY_READ, &key))
        return key;
 
    output_message(STRING_OPEN_KEY_FAILED, path);
    return NULL;
}

Referenced by export_all(), and export_key().

open_key()

static LONG open_key ( struct parser *  parser, WCHAR *  path  )

static

Definition at line 457 of file regproc.c.

{
    HKEY key_class;
    WCHAR *key_path;
    LONG res;
 
    close_key(parser);
 
    /* Get the registry class */
    if (!path || !(key_class = parse_key_name(path, &key_path)))
        return ERROR_INVALID_PARAMETER;
 
    res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
                          KEY_ALL_ACCESS, NULL, &parser->hkey, NULL);
 
    if (res == ERROR_SUCCESS)
    {
        parser->key_name = malloc((lstrlenW(path) + 1) * sizeof(WCHAR));
        lstrcpyW(parser->key_name, path);
    }
    else
        parser->hkey = NULL;
 
    return res;
}

parse_data_type()

static BOOL parse_data_type ( struct parser *  parser, WCHAR **  line  )

static

Definition at line 298 of file regproc.c.

{
    struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
 
    static const struct data_type data_types[] = {
    /*    tag       len  type         parse type    */
        { L"\"",     1,  REG_SZ,      REG_SZ },
        { L"hex:",   4,  REG_BINARY,  REG_BINARY },
        { L"dword:", 6,  REG_DWORD,   REG_DWORD },
        { L"hex(",   4,  -1,          REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
        { NULL,      0,  0,           0 }
    };
 
    const struct data_type *ptr;
 
#ifdef __REACTOS__
    DWORD len = wcslen(*line);
 
    parser->unicode_in_asc = FALSE;
 
    if (!parser->is_unicode && len >= 15)
    {
        WCHAR Buffer[16] = { 0 };
        WCHAR* ret;
 
        memcpy(Buffer, *line, 30);
        Buffer[_countof(Buffer) - 1] = UNICODE_NULL;
 
        ret = wcsstr(Buffer, L"00,"); // Any UNICODE characters?
        parser->unicode_in_asc = (ret != NULL);
    }
 
#endif
    for (ptr = data_types; ptr->tag; ptr++)
    {
        if (wcsncmp(ptr->tag, *line, ptr->len))
            continue;
 
        parser->parse_type = ptr->parse_type;
        parser->data_type = ptr->parse_type;
        *line += ptr->len;
 
        if (ptr->type == -1)
        {
            WCHAR *end;
            DWORD val;
 
            if (!**line || towlower((*line)[1]) == 'x')
                return FALSE;
 
            /* "hex(xx):" is special */
            val = wcstoul(*line, &end, 16);
#ifdef __REACTOS__
            /* Up to 8 hex digits, "hex(000000002)" is invalid */
            if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE) || end - *line > 8)
#else
            if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
#endif
                return FALSE;
 
            parser->data_type = val;
            *line = end + 2;
        }
        return TRUE;
    }
    return FALSE;
}

Referenced by data_type_state().

parse_file_header()

static enum reg_versions parse_file_header ( const WCHAR *  s )

static

Definition at line 537 of file regproc.c.

{
    static const WCHAR header_31[] = L"REGEDIT";
 
    while (*s == ' ' || *s == '\t') s++;
 
    if (!lstrcmpW(s, header_31))
        return REG_VERSION_31;
 
    if (!lstrcmpW(s, L"REGEDIT4"))
        return REG_VERSION_40;
 
    if (!lstrcmpW(s, L"Windows Registry Editor Version 5.00"))
        return REG_VERSION_50;
 
    /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
     * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
     * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
     * In all such cases, however, the contents of the registry file are not imported.
     */
    if (!wcsncmp(s, header_31, 7)) /* "REGEDIT" without NUL */
        return REG_VERSION_FUZZY;
 
    return REG_VERSION_INVALID;
}

Referenced by header_state().

parse_key_name()

static HKEY parse_key_name ( WCHAR *  key_name, WCHAR **  key_path  )

static

Definition at line 415 of file regproc.c.

{
    unsigned int i;
 
    if (!key_name) return 0;
 
    *key_path = wcschr(key_name, '\\');
    if (*key_path) (*key_path)++;
 
    for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++)
    {
        int len = lstrlenW(reg_class_namesW[i]);
#ifdef __REACTOS__
        if (!_wcsnicmp(key_name, reg_class_namesW[i], len) &&
#else
        if (!wcsnicmp(key_name, reg_class_namesW[i], len) &&
#endif
           (key_name[len] == 0 || key_name[len] == '\\'))
        {
            return reg_class_keys[i];
        }
    }
 
    return 0;
}

Referenced by delete_registry_key(), export_key(), and open_key().

parse_win31_line_state()

static WCHAR * parse_win31_line_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 600 of file regproc.c.

{
    WCHAR *line, *value;
    static WCHAR hkcr[] = L"HKEY_CLASSES_ROOT";
    unsigned int key_end = 0;
 
    if (!(line = get_line(parser->file)))
        return NULL;
 
    if (wcsncmp(line, hkcr, lstrlenW(hkcr)))
        return line;
 
    /* get key name */
    while (line[key_end] && !iswspace(line[key_end])) key_end++;
 
    value = line + key_end;
    while (*value == ' ' || *value == '\t') value++;
 
    if (*value == '=') value++;
    if (*value == ' ') value++; /* at most one space is skipped */
 
    line[key_end] = 0;
 
    if (open_key(parser, line) != ERROR_SUCCESS)
    {
        output_message(STRING_OPEN_KEY_FAILED, line);
        return line;
    }
 
    parser->value_name = NULL;
    parser->data_type = REG_SZ;
    parser->data = value;
    parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
 
    set_state(parser, SET_VALUE);
    return value;
}

prepare_hex_string_data()

static void prepare_hex_string_data ( struct parser *  parser )

static

Definition at line 492 of file regproc.c.

{
    if (parser->data_type == REG_EXPAND_SZ || parser->data_type == REG_MULTI_SZ ||
        parser->data_type == REG_SZ)
    {
#ifdef __REACTOS__
        if (parser->is_unicode || (!parser->is_unicode && parser->unicode_in_asc))
#else
        if (parser->is_unicode)
#endif
        {
            WCHAR *data = parser->data;
            DWORD len = parser->data_size / sizeof(WCHAR);
 
            if (data[len - 1] != 0)
            {
                data[len] = 0;
                parser->data_size += sizeof(WCHAR);
            }
        }
        else
        {
            BYTE *data = parser->data;
 
            if (data[parser->data_size - 1] != 0)
            {
                data[parser->data_size] = 0;
                parser->data_size++;
            }
 
            parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
            parser->data_size *= sizeof(WCHAR);
            free(data);
        }
    }
}

Referenced by hex_data_state(), and hex_multiline_state().

quoted_value_name_state()

static WCHAR * quoted_value_name_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 718 of file regproc.c.

{
    WCHAR *val_name = pos, *p;
 
    free(parser->value_name);
    parser->value_name = NULL;
 
    if (!REGPROC_unescape_string(val_name, &p))
        goto invalid;
 
    /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
    parser->value_name = malloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
    lstrcpyW(parser->value_name, val_name);
 
    set_state(parser, DATA_START);
    return p;
 
invalid:
    set_state(parser, LINE_START);
    return val_name;
}

REGPROC_escape_string()

static WCHAR * REGPROC_escape_string ( WCHAR *  str, size_t  str_len, size_t *  line_len  )

static

Definition at line 1162 of file regproc.c.

{
    size_t i, escape_count, pos;
    WCHAR *buf;
 
    for (i = 0, escape_count = 0; i < str_len; i++)
    {
        WCHAR c = str[i];
 
        if (!c) break;
 
        if (c == '\r' || c == '\n' || c == '\\' || c == '"')
            escape_count++;
    }
 
    buf = malloc((str_len + escape_count + 1) * sizeof(WCHAR));
 
    for (i = 0, pos = 0; i < str_len; i++, pos++)
    {
        WCHAR c = str[i];
 
        if (!c) break;
 
        switch (c)
        {
        case '\r':
            buf[pos++] = '\\';
            buf[pos] = 'r';
            break;
        case '\n':
            buf[pos++] = '\\';
            buf[pos] = 'n';
            break;
        case '\\':
            buf[pos++] = '\\';
            buf[pos] = '\\';
            break;
        case '"':
            buf[pos++] = '\\';
            buf[pos] = '"';
            break;
        default:
            buf[pos] = c;
        }
    }
 
    buf[pos] = 0;
    *line_len = pos;
    return buf;
}

Referenced by export_string_data(), and export_value_name().

REGPROC_open_export_file()

static FILE * REGPROC_open_export_file ( WCHAR *  file_name, BOOL  unicode  )

static

Definition at line 1477 of file regproc.c.

{
    FILE *file;
 
    if (!lstrcmpW(file_name, L"-"))
    {
        file = stdout;
        _setmode(_fileno(file), _O_BINARY);
    }
    else
    {
        file = _wfopen(file_name, L"wb");
        if (!file)
        {
            _wperror(L"regedit");
#ifdef __REACTOS__
            output_message(STRING_CANNOT_OPEN_FILE, file_name);
            return NULL;
#else
            error_exit(STRING_CANNOT_OPEN_FILE, file_name);
#endif
        }
    }
 
    if (unicode)
    {
        static const BYTE bom[] = {0xff,0xfe};
        static const WCHAR header[] = L"Windows Registry Editor Version 5.00\r\n";
 
        fwrite(bom, sizeof(BYTE), ARRAY_SIZE(bom), file);
        fwrite(header, sizeof(WCHAR), lstrlenW(header), file);
    }
    else
        fputs("REGEDIT4\r\n", file);
 
    return file;
}

Referenced by export_all(), export_key(), and export_registry_key().

REGPROC_unescape_string()

static BOOL REGPROC_unescape_string ( WCHAR *  str, WCHAR **  unparsed  )

static

Definition at line 373 of file regproc.c.

{
    int str_idx = 0;            /* current character under analysis */
    int val_idx = 0;            /* the last character of the unescaped string */
    int len = lstrlenW(str);
    BOOL ret;
 
    for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
        if (str[str_idx] == '\\') {
            str_idx++;
            switch (str[str_idx]) {
            case 'n':
                str[val_idx] = '\n';
                break;
            case 'r':
                str[val_idx] = '\r';
                break;
            case '0':
                return FALSE;
            case '\\':
            case '"':
                str[val_idx] = str[str_idx];
                break;
            default:
                if (!str[str_idx]) return FALSE;
                output_message(STRING_ESCAPE_SEQUENCE, str[str_idx]);
                str[val_idx] = str[str_idx];
                break;
            }
        } else if (str[str_idx] == '"') {
            break;
        } else {
            str[val_idx] = str[str_idx];
        }
    }
 
    ret = (str[str_idx] == '"');
    *unparsed = str + str_idx + 1;
    str[val_idx] = '\0';
    return ret;
}

Referenced by processSetValue(), quoted_value_name_state(), setValue(), and string_data_state().

REGPROC_write_line()

static void REGPROC_write_line ( FILE *  fp, const WCHAR *  str, BOOL  unicode  )

static

Definition at line 1150 of file regproc.c.

{
    if (unicode)
        fwrite(str, sizeof(WCHAR), lstrlenW(str), fp);
    else
    {
        char *strA = GetMultiByteString(str);
        fputs(strA, fp);
        free(strA);
    }
}

Referenced by export_data(), export_hex_data(), export_hex_data_type(), export_key_name(), export_newline(), and export_value_name().

set_state()

static enum parser_state set_state ( struct parser *  parser, enum parser_state  state  )

inlinestatic

Definition at line 194 of file regproc.c.

{
    enum parser_state ret = parser->state;
    parser->state = state;
    return ret;
}

Referenced by data_start_state(), data_type_state(), default_value_name_state(), delete_key_state(), delete_value_state(), dword_data_state(), eol_backslash_state(), header_state(), hex_data_state(), hex_multiline_state(), key_name_state(), line_start_state(), parse_win31_line_state(), quoted_value_name_state(), set_value_state(), string_data_state(), and unknown_data_state().

set_value_state()

static WCHAR * set_value_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 938 of file regproc.c.

{
    RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
                   parser->data, parser->data_size);
 
    free_parser_data(parser);
 
    if (parser->reg_version == REG_VERSION_31)
        set_state(parser, PARSE_WIN31_LINE);
    else
        set_state(parser, LINE_START);
 
    return pos;
}

string_data_state()

static WCHAR * string_data_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 812 of file regproc.c.

{
    WCHAR *line;
 
    parser->data = pos;
 
    if (!REGPROC_unescape_string(parser->data, &line))
        goto invalid;
 
    while (*line == ' ' || *line == '\t') line++;
    if (*line && *line != ';') goto invalid;
 
    parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
 
    set_state(parser, SET_VALUE);
    return line;
 
invalid:
    free_parser_data(parser);
    set_state(parser, LINE_START);
    return line;
}

unknown_data_state()

static WCHAR * unknown_data_state ( struct parser *  parser, WCHAR *  pos  )

static

Definition at line 929 of file regproc.c.

{
    output_message(STRING_UNKNOWN_DATA_FORMAT, parser->data_type);
 
    set_state(parser, LINE_START);
    return pos;
}

Variable Documentation

get_line

WCHAR *(* get_line) (FILE *) ( FILE *  )

static

Definition at line 106 of file regproc.c.

Referenced by header_state(), hex_multiline_state(), import_registry_file(), line_start_state(), and parse_win31_line_state().

parser_funcs

const parser_state_func parser_funcs[NB_PARSER_STATES]

static

Initial value:

=
{
    header_state,              
    parse_win31_line_state,    
    line_start_state,          
    key_name_state,            
    delete_key_state,          
    default_value_name_state,  
    quoted_value_name_state,   
    data_start_state,          
    delete_value_state,        
    data_type_state,           
    string_data_state,         
    dword_data_state,          
    hex_data_state,            
    eol_backslash_state,       
    hex_multiline_state,       
    unknown_data_state,        
    set_value_state,           
}

Definition at line 172 of file regproc.c.

Referenced by import_registry_file().

reg_class_keys

HKEY reg_class_keys[]

static

Initial value:

= {
            HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
            HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
        }

Definition at line 27 of file regproc.c.

Referenced by export_registry_key(), getRegClass(), and parse_key_name().