registry.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef __REGISTRY_HPP
#define __REGISTRY_HPP

 
// Unix systems use a file in the user directory (usually $HOME/.idapro/ida.reg)
#if !defined(LOCAL_REGISTRY) && !defined(__NT__)
#  define LOCAL_REGISTRY
#endif
//#define LOCAL_REGISTRY // for testing local registry on windows, uncomment
 
//---------------------------------------------------------------------------
// Each application has its own registry file
#ifdef LOCAL_REGISTRY
#  define IDA_REGISTRY_NAME "ida"
#else
#  define IDA_REGISTRY_NAME "IDA"
#endif
#define HVUI_REGISTRY_NAME "hvui"
 
// note: root_name[] in register.cpp
#define ROOT_KEY_NAME           "Software\\Hex-Rays\\IDA"

// Low level functions. DO NOT USE THEM. See the wrappers below.
// 'mode' is:
//  - 0: data is a raw buffer, and its datalen must be able to hold the entire binary contents
//  - 1: data is a raw buffer, and its datalen doesn't need to be able to hold the entire binary contents
//  - 2: data is a ::bytevec_t*, datalen is ignored.
idaman THREAD_SAFE bool ida_export reg_bin_op(
        const char *name,
        bool save,
        void *data,
        size_t datalen,
        const char *subkey,
        int mode = 0);
idaman THREAD_SAFE bool ida_export reg_str_get(qstring *buf, const char *name, const char *subkey);
idaman THREAD_SAFE void ida_export reg_str_set(const char *name, const char *subkey, const char *buf);
idaman THREAD_SAFE int ida_export reg_int_op(
        const char *name,
        bool save,
        int value,
        const char *subkey = nullptr);

enum regval_type_t
{
  reg_unknown = 0, 
  reg_sz      = 1, 
  reg_binary  = 3, 
  reg_dword   = 4  
};
 

idaman THREAD_SAFE bool ida_export reg_delete_subkey(const char *name);

idaman THREAD_SAFE bool ida_export reg_delete_tree(const char *name);

 
idaman THREAD_SAFE bool ida_export reg_delete(const char *name, const char *subkey = nullptr);
 

 
idaman THREAD_SAFE bool ida_export reg_subkey_exists(const char *name);
 

 
idaman THREAD_SAFE bool ida_export reg_exists(const char *name, const char *subkey = nullptr);
 

 
idaman THREAD_SAFE bool ida_export reg_subkey_children(qstrvec_t *out, const char *name, bool subkeys);
 

 
idaman THREAD_SAFE bool ida_export reg_data_type(regval_type_t *out, const char *name, const char *subkey = nullptr);
 

 
idaman THREAD_SAFE void ida_export reg_read_strlist(qstrvec_t *list, const char *subkey);
 

 
idaman THREAD_SAFE void ida_export reg_write_strlist(const qstrvec_t &in, const char *subkey);
 

 
idaman THREAD_SAFE void ida_export reg_update_strlist(
        const char *subkey,
        const char *add,
        size_t maxrecs,
        const char *rem = nullptr,
        bool ignorecase = false);
 

 
inline THREAD_SAFE void reg_write_binary(
        const char *name,
        const void *data,
        size_t datalen,
        const char *subkey = nullptr)
{
  reg_bin_op(name, true, CONST_CAST(void *)(data), datalen, subkey);
}
 

inline THREAD_SAFE void reg_write_binary(
        const char *name,
        const bytevec_t &data,
        const char *subkey = nullptr)
{
  return reg_write_binary(name, data.begin(), data.size(), subkey);
}
 

 
inline THREAD_SAFE bool reg_read_binary(
        const char *name,
        void *data,
        size_t datalen,
        const char *subkey = nullptr)
{
  return reg_bin_op(name, false, data, datalen, subkey);
}
 

 
inline THREAD_SAFE bool reg_read_binary_part(
        const char *name,
        void *data,
        size_t datalen,
        const char *subkey = nullptr)
{
  return reg_bin_op(name, false, data, datalen, subkey, 1);
}
 

 
inline THREAD_SAFE bool reg_read_binary(
        const char *name,
        bytevec_t *data,
        const char *subkey = nullptr)
{
  return reg_bin_op(name, false, data, 0, subkey, 2);
}
 

 
inline THREAD_SAFE void reg_write_string(
        const char *name,
        const char *utf8,
        const char *subkey = nullptr)
{
  reg_str_set(name, subkey, utf8);
}
 

 
inline THREAD_SAFE bool reg_read_string(
        qstring *utf8,
        const char *name,
        const char *subkey = nullptr)
{
  return reg_str_get(utf8, name, subkey);
}
 

 
inline THREAD_SAFE int reg_read_int(const char *name, int defval, const char *subkey = nullptr)
{
  return reg_int_op(name, false, defval, subkey);
}
 

 
inline THREAD_SAFE void reg_write_int(const char *name, int value, const char *subkey = nullptr)
{
  reg_int_op(name, true, value, subkey);
}
 

 
inline THREAD_SAFE bool reg_read_bool(const char *name, bool defval, const char *subkey = nullptr)
{
  return reg_int_op(name, false, int(defval), subkey) != 0;
}
 

 
inline THREAD_SAFE void reg_write_bool(const char *name, int value, const char *subkey = nullptr)
{
  reg_int_op(name, true, value != 0, subkey);
}
 

 
inline THREAD_SAFE bool reg_subkey_subkeys(qstrvec_t *out, const char *name)
{
  return reg_subkey_children(out, name, true);
}
 

 
inline THREAD_SAFE bool reg_subkey_values(qstrvec_t *out, const char *name)
{
  return reg_subkey_children(out, name, false);
}
 

 
inline THREAD_SAFE void reg_update_filestrlist(
        const char *subkey,
        const char *add,
        size_t maxrecs,
        const char *rem = nullptr)
{
  reg_update_strlist(
    subkey, add, maxrecs, rem,
  #ifdef __NT__ // Ignore case in Windows
    true
  #else
    false
  #endif
  );
}
 
//-----------------------------------------------------------------------------
// INTERNALS

#define _RVN_(f) regname_ ## f
 
#ifndef __DEFINE_REG_NAMES__
#define REG_VAL_NAME(n,s)         \
    extern const char _RVN_(n)[]
#else
#define REG_VAL_NAME(n,s)         \
    extern const char _RVN_(n)[]; \
    const char _RVN_(n)[] = s
#endif
 
#define REG_BOOL_FUNC(func, valname)          \
REG_VAL_NAME(func, valname);                  \
inline THREAD_SAFE void regset_ ## func(bool value)       \
  { reg_write_bool(_RVN_(func), value); }     \
inline THREAD_SAFE bool regget_ ## func(bool def)         \
  { return reg_read_bool(_RVN_(func), def); }
 
#define REG_INT_FUNC(func, valname)           \
REG_VAL_NAME(func,valname);                   \
inline THREAD_SAFE void regset_ ## func(int value)        \
{                                             \
  reg_int_op(_RVN_(func), true, value);       \
}                                             \
inline THREAD_SAFE int regget_ ## func(int def=0)         \
{                                             \
  return reg_int_op(_RVN_(func), false, def); \
}

idaman THREAD_SAFE bool ida_export set_registry_name(const char *name);
 
// if using history functions below, you have to define the following two variables
extern const char regkey_history[];
extern int max_history_files;     // max number of files in the file menu
                                  // and in the welcome box
#define MAX_HISTORY_FILES_DEF 10  // default value
 
inline THREAD_SAFE void regget_history(qstrvec_t *list)
{
  reg_read_strlist(list, regkey_history);
}
 
inline THREAD_SAFE void reg_update_history(const char *addfile, const char *removefile = nullptr)
{
  // On Windows avoid duplicate upper/lower-case entries
  // by using reg_update_filestrlist() which takes care of case sensitivity
  reg_update_filestrlist(regkey_history, addfile, max_history_files, removefile);
}
 
inline THREAD_SAFE void reg_history_size_truncate(void)
{
  reg_update_strlist(regkey_history, nullptr, max_history_files, nullptr);
}
 
 
#endif // __REGISTRY_HPP