loader.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _LOADER_HPP
#define _LOADER_HPP
#include <ida.hpp>

 
//----------------------------------------------------------------------
//              DEFINITION OF LDR MODULES
//----------------------------------------------------------------------
 
class linput_t;         // loader input source. see diskio.hpp for the functions
struct extlang_t;       // check expr.hpp
struct plugmod_t;       // idp.hpp

struct loader_t
{
  uint32 version;        
  uint32 flags;          
#define LDRF_RELOAD   0x0001 
#define LDRF_REQ_PROC 0x0002 

  int (idaapi *accept_file)(
        qstring *fileformatname,
        qstring *processor,
        linput_t *li,
        const char *filename);

#define ACCEPT_ARCHIVE 0x2000
#define ACCEPT_CONTINUE 0x4000
#define ACCEPT_FIRST    0x8000

  void (idaapi *load_file)(
        linput_t *li,
        ushort neflags,
        const char *fileformatname);
#define NEF_SEGS        0x0001            
#define NEF_RSCS        0x0002            
#define NEF_NAME        0x0004            
#define NEF_MAN         0x0008            
#define NEF_FILL        0x0010            
#define NEF_IMPS        0x0020            
#define NEF_FIRST       0x0080            
#define NEF_CODE        0x0100            
#define NEF_RELOAD      0x0200            
#define NEF_FLAT        0x0400            
#define NEF_MINI        0x0800            
#define NEF_LOPT        0x1000            
#define NEF_LALL        0x2000            

  int (idaapi *save_file)(FILE *fp, const char *fileformatname);

  int (idaapi *move_segm)(
          ea_t from,
          ea_t to,
          asize_t size,
          const char *fileformatname);

  int (idaapi *process_archive)(
          qstring *temp_file,
          linput_t *li,
          qstring *module_name,
          ushort *neflags,
          const char *fileformatname,
          const char *defmember,
          qstring *errbuf);
};
 

 
idaman AS_PRINTF(1, 0) NORETURN void ida_export vloader_failure(const char *format, va_list va);
 

 
AS_PRINTF(1, 2) NORETURN inline void loader_failure(const char *format=nullptr, ...)
{
  va_list va;
  va_start(va, format);
  vloader_failure(format, va);
}
 
//-------------------------------------------------------------------------
#if defined(__NT__)
#  define DLLEXT "dll"
#elif defined(__LINUX__)
#  define DLLEXT "so"
#elif defined(__MAC__)
#  define DLLEXT "dylib"
#else
#  error Unknown loader ext
#endif
 
//----------------------------------------------------------------------
#ifdef __EA64__
#  define LOADER_DLL "*." DLLEXT
#else
#  define LOADER_DLL "*32." DLLEXT
#endif
 
//----------------------------------------------------------------------
//      Functions for the UI to load files
//----------------------------------------------------------------------
struct load_info_t
{
  load_info_t *next;
  qstring dllname;
  qstring ftypename;
  qstring processor;    
  filetype_t ftype;
  uint32 loader_flags;  
  uint32 lflags;        
  int pri;              

#define LIF_ARCHLDR   0x0001    
 
  bool is_archldr(void) { return (lflags & LIF_ARCHLDR) != 0; }
};
DECLARE_TYPE_AS_MOVABLE(load_info_t);

 
idaman load_info_t *ida_export build_loaders_list(linput_t *li, const char *filename);
 

 
idaman void ida_export free_loaders_list(load_info_t *list);
 

 
idaman char *ida_export get_loader_name_from_dll(char *dllname);
 

 
idaman ssize_t ida_export get_loader_name(char *buf, size_t bufsize);
 

 
idaman bool ida_export load_binary_file(
        const char *filename,
        linput_t *li,
        ushort _neflags,
        qoff64_t fileoff,
        ea_t basepara,
        ea_t binoff,
        uint64 nbytes);
 

 
idaman bool ida_export load_nonbinary_file(
        const char *filename,
        linput_t *li,
        const char *sysdlldir,
        ushort _neflags,
        load_info_t *loader);
 

 
idaman int ida_export process_archive(
        qstring *temp_file,
        linput_t *li,
        qstring *module_name,
        ushort *neflags,
        const char *defmember,
        const load_info_t *loader,
        qstring *errbuf=nullptr);
 
//--------------------------------------------------------------------------
enum ofile_type_t
{
  OFILE_MAP  = 0,        
  OFILE_EXE  = 1,        
  OFILE_IDC  = 2,        
  OFILE_LST  = 3,        
  OFILE_ASM  = 4,        
  OFILE_DIF  = 5,        
};
 
//------------------------------------------------------------------
 
idaman int ida_export gen_file(ofile_type_t otype, FILE *fp, ea_t ea1, ea_t ea2, int flags);

#define GENFLG_MAPSEG  0x0001          
#define GENFLG_MAPNAME 0x0002          
#define GENFLG_MAPDMNG 0x0004          
#define GENFLG_MAPLOC  0x0008          
#define GENFLG_IDCTYPE 0x0008          
#define GENFLG_ASMTYPE 0x0010          
#define GENFLG_GENHTML 0x0020          
#define GENFLG_ASMINC  0x0040          
 
//----------------------------------------------------------------------
//      Helper functions for the loaders & ui
//----------------------------------------------------------------------

 
idaman int ida_export file2base(
        linput_t *li,
        qoff64_t pos,
        ea_t ea1,
        ea_t ea2,
        int patchable);
 
#define FILEREG_PATCHABLE       1       
#define FILEREG_NOTPATCHABLE    0       
 

 
idaman int ida_export mem2base(const void *memptr, ea_t ea1, ea_t ea2, qoff64_t fpos);
 

 
idaman int ida_export base2file(FILE *fp, qoff64_t pos, ea_t ea1, ea_t ea2);
 

 
idaman bool ida_export extract_module_from_archive(
        char *filename,
        size_t bufsize,
        char **temp_file_ptr,
        bool is_remote);
 

 
idaman void ida_export create_filename_cmt(void);
 

 
idaman filetype_t ida_export get_basic_file_type(linput_t *li);
 

 
idaman size_t ida_export get_file_type_name(char *buf, size_t bufsize);
 
 
//----------------------------------------------------------------------
//      Work with IDS files: read and use information from them
//

struct impinfo_t
{
  const char *dllname;
  void (idaapi*func)(uval_t num, const char *name, uval_t node);
  uval_t node;
};
 

 
typedef int idaapi importer_t(linput_t *li, impinfo_t *ii);
 

 
idaman void ida_export import_module(
        const char *module,
        const char *windir,
        uval_t modnode,
        importer_t *importer,
        const char *ostype);
 

 
idaman void ida_export set_import_ordinal(
        uval_t modnode,
        ea_t ea,
        uval_t ord);
 

 
idaman void ida_export set_import_name(
        uval_t modnode,
        ea_t ea,
        const char *name);
 

 
idaman int ida_export load_ids_module(char *fname);
 
 
//----------------------------------------------------------------------
//              DEFINITION OF PLUGIN MODULES
//----------------------------------------------------------------------
class plugin_t
{
public:
  int version;                  
  int flags;                    
#define PLUGIN_MOD  0x0001      
#define PLUGIN_DRAW 0x0002      
#define PLUGIN_SEG  0x0004      
#define PLUGIN_UNL  0x0008      
#define PLUGIN_HIDE 0x0010      
#define PLUGIN_DBG  0x0020      
#define PLUGIN_PROC 0x0040      
#define PLUGIN_FIX  0x0080      
#define PLUGIN_MULTI    0x0100  
#define PLUGIN_SCRIPTED 0x8000  
 
  plugmod_t *(idaapi *init)(void);  
#if !defined(NO_OBSOLETE_FUNCS) || defined(__DEFINE_PLUGIN_RETURN_CODES__)
#define PLUGIN_SKIP  nullptr          
#define PLUGIN_OK    ((plugmod_t *)1) 
#define PLUGIN_KEEP  ((plugmod_t *)2) 
#endif
 
  void (idaapi *term)(void);      
  bool (idaapi *run)(size_t arg); 
  const char *comment;            
  const char *help;               
  const char *wanted_name;        
  const char *wanted_hotkey;      
};
 
#ifndef __X86__
  CASSERT(sizeof(plugin_t) == 64);
#else
  CASSERT(sizeof(plugin_t) == 36);
#endif
 
#if !defined(__KERNEL__) && !defined(PLUGIN_SUBMODULE)
idaman ida_module_data plugin_t PLUGIN; // (declaration for plugins)
#endif

 
idaman const char *ida_export get_plugin_options(const char *plugin);
 
 
//--------------------------------------------------------------------------
#ifdef __EA64__
#  define PLUGIN_DLL "*." DLLEXT
#else
#  define PLUGIN_DLL "*32." DLLEXT
#endif
 
 
// LOW LEVEL DLL LOADING FUNCTIONS
// Only the kernel should use these functions!
#define LNE_MAXSEG      10      // Max number of segments
 
#if 0
extern char dlldata[4096];      // Reserved place for DLL data
#define DLLDATASTART    0xA0    // Absolute offset of dlldata
extern char ldrdata[64];        // Reserved place for LOADER data
#define LDRDATASTART    (DLLDATASTART+sizeof(dlldata)) // Absolute offset of ldrdata
#endif
 
struct idadll_t
{
  void *dllinfo[LNE_MAXSEG] = {};
  void *entry = nullptr;          // first entry point of DLL
  bool is_loaded(void) const { return dllinfo[0] != nullptr; }
};
 
#define MODULE_ENTRY_LOADER "LDSC"   
#define MODULE_ENTRY_PLUGIN "PLUGIN" 
#define MODULE_ENTRY_IDP "LPH"       
 
int _load_core_module(
        idadll_t *dllmem,
        const char *file,
        const char *entry);
                                // dllmem - allocated segments
                                //          dos: segment 1 (data) isn't allocated
                                // Returns 0 - ok, else:
#define RE_NOFILE       1       /* No such file */
#define RE_NOTIDP       2       /* Not IDP file */
#define RE_NOPAGE       3       /* Can't load: bad segments */
#define RE_NOLINK       4       /* No linkage info */
#define RE_BADRTP       5       /* Bad relocation type */
#define RE_BADORD       6       /* Bad imported ordinal */
#define RE_BADATP       7       /* Bad relocation atype */
#define RE_BADMAP       8       /* DLLDATA offset is invalid */
 
void load_core_module_or_die(
        idadll_t *dllmem,
        const char *file,
        const char *entry);
idaman bool ida_export load_core_module(
        idadll_t *dllmem,
        const char *file,
        const char *entry);
 
idaman void ida_export free_dll(idadll_t *dllmem);

struct idp_name_t
{
  qstring lname;        
  qstring sname;        
  bool    hidden;       
  idp_name_t() : hidden(false) {}
};
DECLARE_TYPE_AS_MOVABLE(idp_name_t);
typedef qvector<idp_name_t> idp_names_t; 

struct idp_desc_t
{
  qstring   path;       
  time_t    mtime;      
  qstring   family;     
  idp_names_t names;    
  bool      is_script;  
  bool      checked;    
  idp_desc_t(): mtime(time_t(-1)), is_script(false), checked(false) {}
};
DECLARE_TYPE_AS_MOVABLE(idp_desc_t);
typedef qvector<idp_desc_t> idp_descs_t; 
 

 
idaman const idp_descs_t *ida_export get_idp_descs(void);
 
 
//--------------------------------------------------------------------------
#ifdef __EA64__
#  define IDP_DLL "*." DLLEXT
#else
#  define IDP_DLL "*32." DLLEXT
#endif
 
 
//--------------------------------------------------------------------------
struct plugin_info_t
{
  plugin_info_t *next = nullptr;  
  char *path = nullptr;           
  char *org_name = nullptr;       
  char *name = nullptr;           
  ushort org_hotkey = 0;          
  ushort hotkey = 0;              
  size_t arg = 0;                 
  plugin_t *entry = nullptr;      
  idadll_t dllmem;
  int flags = 0;                  
  char *comment = nullptr;        
  qstring idaplg_name;            
};
 
 

 
idaman plugin_info_t *ida_export get_plugins(void);
 

 
idaman plugin_t *ida_export find_plugin(const char *name, bool load_if_needed=false);
 
inline plugin_t *load_plugin(const char *name)
{
  return find_plugin(name, true);
}
 

 
idaman bool ida_export run_plugin(const plugin_t *ptr, size_t arg);
 

 
inline bool idaapi load_and_run_plugin(const char *name, size_t arg)
{
  return run_plugin(load_plugin(name), arg);
}
 

 
idaman bool ida_export invoke_plugin(plugin_info_t *ptr);
 

struct dbg_info_t
{
  plugin_info_t *pi;
  struct debugger_t *dbg;
  dbg_info_t(plugin_info_t *_pi, struct debugger_t *_dbg) : pi(_pi), dbg(_dbg) {}
};
DECLARE_TYPE_AS_MOVABLE(dbg_info_t);
 

 
idaman size_t ida_export get_debugger_plugins(const dbg_info_t **array);
 

 
idaman void ida_export init_plugins(int flag);
 

 
idaman void ida_export term_plugins(int flag);
 
 
//------------------------------------------------------------------------

 
idaman qoff64_t ida_export get_fileregion_offset(ea_t ea);
 

 
idaman ea_t ida_export get_fileregion_ea(qoff64_t offset);
 
 
//------------------------------------------------------------------------
 
idaman int ida_export gen_exe_file(FILE *fp);
 
 
//------------------------------------------------------------------------
 
idaman bool ida_export reload_file(const char *file, bool is_remote);
 
 
//---------------------------------------------------------------------------
//       S N A P S H O T   F U N C T I O N S

#define MAX_DATABASE_DESCRIPTION 128
 
class snapshot_t;
typedef qvector<snapshot_t *> snapshots_t; 

class snapshot_t
{
private:
  snapshot_t &operator=(const snapshot_t &);
  snapshot_t(const snapshot_t &);
 
  int compare(const snapshot_t &r) const
  {
    return ::compare(id, r.id);
  }
 
public:
  qtime64_t id = 0;                      
  uint16 flags = 0;                      
#define SSF_AUTOMATIC         0x0001     
  char desc[MAX_DATABASE_DESCRIPTION];   
  char filename[QMAXPATH];               
  snapshots_t children;                  
  DEFINE_MEMORY_ALLOCATION_FUNCS()
  DECLARE_COMPARISON_OPERATORS(snapshot_t)
  void clear()
  {
    for ( snapshots_t::iterator p=children.begin();
          p != children.end();
          ++p )
    {
      delete *p;
    }
    children.clear();
  }
 
  snapshot_t()
  {
    desc[0] = '\0';
    filename[0] = '\0';
  }
 
  ~snapshot_t()
  {
    clear();
  }
};
DECLARE_TYPE_AS_MOVABLE(snapshot_t);
 
//------------------------------------------------------------------------
 
idaman bool ida_export build_snapshot_tree(snapshot_t *root);
 
 
//------------------------------------------------------------------------
idaman bool ida_export update_snapshot_attributes(
        const char *filename,
        const snapshot_t *root,
        const snapshot_t *attr,
        int uf);

#define SSUF_DESC        0x00000001             
#define SSUF_PATH        0x00000002             
#define SSUF_FLAGS       0x00000004             
 
//------------------------------------------------------------------------
 
idaman int ida_export visit_snapshot_tree(
        snapshot_t *root,
        int (idaapi *callback)(snapshot_t *ss, void *ud),
        void *ud=nullptr);
 

 
idaman int ida_export flush_buffers(void);
 

 
idaman bool ida_export is_trusted_idb(void);
 
//------------------------------------------------------------------------
 
idaman bool ida_export save_database(
        const char *outfile=nullptr,
        uint32 flags=0,
        const snapshot_t *root = nullptr,
        const snapshot_t *attr = nullptr);

#define DBFL_KILL       0x01            
#define DBFL_COMP       0x02            
#define DBFL_BAK        0x04            
#define DBFL_TEMP       0x08            

 
idaman bool ida_export is_database_flag(uint32 dbfl);

 
idaman void ida_export set_database_flag(uint32 dbfl, bool cnd=true);
inline void clr_database_flag(uint32 dbfl) { set_database_flag(dbfl, false); }

inline bool is_temp_database(void) { return is_database_flag(DBFL_TEMP); }
 
 
//------------------------------------------------------------------------
enum path_type_t
{
  PATH_TYPE_CMD,  
  PATH_TYPE_IDB,  
  PATH_TYPE_ID0,  
};


idaman const char *ida_export get_path(path_type_t pt);

idaman void ida_export set_path(path_type_t pt, const char *path);
 

idaman bool ida_export is_database_ext(const char *ext);
 

idaman const char *ida_export get_elf_debug_file_directory();

 
#endif