diskio.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _DISKIO_HPP
#define _DISKIO_HPP
 
#include <stdio.h>
#include <functional>
#include <pro.h>

 
//-------------------------------------------------------------------------
#define VAULT_CACHE_SUBDIR ".vault"         
#define VAULT_CACHE_FNAME  ".vault_cache"   
 
//-------------------------------------------------------------------------
//      S E A R C H   F O R   F I L E S
//-------------------------------------------------------------------------
 

 
idaman THREAD_SAFE const char *ida_export idadir(const char *subdir);
 

 
idaman THREAD_SAFE char *ida_export getsysfile(
        char *buf,
        size_t bufsize,
        const char *filename,
        const char *subdir);

#define CFG_SUBDIR "cfg"
#define IDC_SUBDIR "idc"
#define IDS_SUBDIR "ids"
#define IDP_SUBDIR "procs"
#define LDR_SUBDIR "loaders"
#define SIG_SUBDIR "sig"
#define TIL_SUBDIR "til"
#define PLG_SUBDIR "plugins"
#define THM_SUBDIR "themes"

 
idaman THREAD_SAFE const char *ida_export get_user_idadir(void);
 

 
idaman THREAD_SAFE int ida_export get_ida_subdirs(qstrvec_t *dirs, const char *subdir, int flags=0);

#define IDA_SUBDIR_IDP           0x0001  
#define IDA_SUBDIR_IDADIR_FIRST  0x0002  
#define IDA_SUBDIR_ONLY_EXISTING 0x0004  
 

 
idaman THREAD_SAFE bool ida_export get_special_folder(char *buf, size_t bufsize, int csidl);

#ifndef CSIDL_APPDATA
#define CSIDL_APPDATA                 0x001a
#endif
#ifndef CSIDL_LOCAL_APPDATA
#define CSIDL_LOCAL_APPDATA           0x001c
#endif
#ifndef CSIDL_PROGRAM_FILES
#define CSIDL_PROGRAM_FILES           0x0026
#endif
#ifndef CSIDL_PROGRAM_FILES_COMMON
#define CSIDL_PROGRAM_FILES_COMMON    0x002b
#endif
#ifndef CSIDL_PROGRAM_FILESX86
#define CSIDL_PROGRAM_FILESX86        0x002a
#endif

 
struct file_enumerator_t
{
  virtual int visit_file(const char *file) = 0;
  virtual ~file_enumerator_t() {}
};
 
idaman THREAD_SAFE int ida_export enumerate_files(
        char *answer,
        size_t answer_size,
        const char *path,
        const char *fname,
        file_enumerator_t &fv);
 
 
 
//-------------------------------------------------------------------------
//      O P E N / R E A D / W R I T E / C L O S E   F I L E S
//-------------------------------------------------------------------------


 
idaman THREAD_SAFE FILE *ida_export fopenWT(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export fopenWB(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export fopenRT(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export fopenRB(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export fopenM(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export fopenA(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export openR(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export openRT(const char *file);
 

 
idaman THREAD_SAFE FILE *ida_export openM(const char *file);
 

 
//-------------------------------------------------------------------------
//      F I L E   S I Z E   /   D I S K   S P A C E
//-------------------------------------------------------------------------

 
idaman THREAD_SAFE void ida_export echsize(FILE *fp, uint64 size);
 

 
idaman THREAD_SAFE uint64 ida_export get_free_disk_space(const char *path);
 
 
//-------------------------------------------------------------------------
//      I / O   P O R T   D E F I N I T I O N S   F I L E
//-------------------------------------------------------------------------
struct ioport_bit_t
{
  qstring name;         
  qstring cmt;          
};
DECLARE_TYPE_AS_MOVABLE(ioport_bit_t);
typedef qvector<ioport_bit_t> ioport_bits_t;

struct ioport_t
{
  ea_t address;         
  qstring name;         
  qstring cmt;          
  ioport_bits_t bits;   
  void *userdata;       
 
  ioport_t()
    : address(0), userdata(nullptr)
  {
  }
};
DECLARE_TYPE_AS_MOVABLE(ioport_t);
typedef qvector<ioport_t> ioports_t;

 
struct ioports_fallback_t
{
  virtual ~ioports_fallback_t() {}
  virtual bool handle(qstring *errbuf, const ioports_t &ports, const char *line) = 0;
};
 
idaman THREAD_SAFE ssize_t ida_export read_ioports(
        ioports_t *ports,
        qstring *device,
        const char *file,
        ioports_fallback_t *callback=nullptr);
 

 
idaman THREAD_SAFE bool ida_export choose_ioport_device(
        qstring *_device,
        const char *file,
        const char *(idaapi *parse_params)(
          qstring *buf,
          const char *line)=nullptr);
 
struct choose_ioport_parser_t
{
  virtual ~choose_ioport_parser_t() {}
  virtual bool parse(qstring *param, const char *line) = 0;
};
 
idaman THREAD_SAFE bool ida_export choose_ioport_device2(
        qstring *_device,
        const char *file,
        choose_ioport_parser_t *parse_params);

#define IOPORT_SKIP_DEVICE ((const char *)(-1))
 

 
idaman THREAD_SAFE const ioport_t *ida_export find_ioport(const ioports_t &ports, ea_t address);
 

 
idaman THREAD_SAFE const ioport_bit_t *ida_export find_ioport_bit(const ioports_t &ports, ea_t address, size_t bit);
 
 
//-------------------------------------------------------------------------
//      S Y S T E M   S P E C I F I C   C A L L S
//-------------------------------------------------------------------------

 
idaman THREAD_SAFE int ida_export call_system(const char *command);
 
 
//-------------------------------------------------------------------------
//       L O A D E R   I N P U T   S O U R C E   F U N C T I O N S
//-------------------------------------------------------------------------

 
class linput_t;         
 

enum linput_type_t
{
  LINPUT_NONE,          
  LINPUT_LOCAL,         
  LINPUT_RFILE,         
  LINPUT_PROCMEM,       
  LINPUT_GENERIC        
};
 

 
idaman void ida_export lread(linput_t *li, void *buf, size_t size);
 
#ifdef TESTABLE_BUILD
#endif
 

 
idaman ssize_t ida_export qlread(linput_t *li, void *buf, size_t size);
 

 
idaman char *ida_export qlgets(char *s, size_t len, linput_t *li);
 

 
idaman int ida_export qlgetc(linput_t *li);
 

 
idaman int ida_export lreadbytes(linput_t *li, void *buf, size_t size, bool mf);

#define DEF_LREADBYTES(read, type, size)                       \
 \
inline int idaapi read(linput_t *li, type *res, bool mf)       \
               { return lreadbytes(li, res, size, mf); }
DEF_LREADBYTES(lread2bytes, int16, 2)
DEF_LREADBYTES(lread2bytes, uint16, 2)
DEF_LREADBYTES(lread4bytes, int32, 4)
DEF_LREADBYTES(lread4bytes, uint32, 4)
DEF_LREADBYTES(lread8bytes, int64, 8)
DEF_LREADBYTES(lread8bytes, uint64, 8)
#undef DEF_LREADBYTES
 

 
idaman char *ida_export qlgetz(
        linput_t *li,
        int64 fpos,
        char *buf,
        size_t bufsize);
 

 
idaman int64 ida_export qlsize(linput_t *li);
 

 
idaman qoff64_t ida_export qlseek(linput_t *li, qoff64_t pos, int whence=SEEK_SET);
 

 
inline qoff64_t idaapi qltell(linput_t *li) { return qlseek(li, 0, SEEK_CUR); }
 

 
idaman linput_t *ida_export open_linput(const char *file, bool remote);
 

 
idaman THREAD_SAFE void ida_export close_linput(linput_t *li);
 

 
idaman THREAD_SAFE FILE *ida_export qlfile(linput_t *li);
 

//lint -sem(make_linput,custodial(1))
 
idaman THREAD_SAFE linput_t *ida_export make_linput(FILE *fp);

 
idaman THREAD_SAFE void ida_export unmake_linput(linput_t *li);
 

struct generic_linput_t
{
  uint64 filesize;      
  uint32 blocksize;     
  virtual ssize_t idaapi read(qoff64_t off, void *buffer, size_t nbytes) = 0;
  virtual ~generic_linput_t() {}
};

 
idaman THREAD_SAFE linput_t *ida_export create_generic_linput(generic_linput_t *gl);

 
idaman THREAD_SAFE linput_t *ida_export create_bytearray_linput(const uchar *start, size_t size);
 

 
idaman linput_t *ida_export create_memory_linput(ea_t start, asize_t size);

 
inline THREAD_SAFE linput_type_t idaapi get_linput_type(linput_t *li)
{
  return li != nullptr ? *(linput_type_t *)li : LINPUT_NONE;
}

typedef janitor_t<linput_t*> linput_janitor_t;
template <> inline linput_janitor_t::~janitor_t()
{
  close_linput(resource);
}
 
//---------------------------------------------------------------------------
class linput_buffer_t
{
public:
  linput_buffer_t(linput_t *linput, int64 size=0): li(linput), lsize(size) {}
  ssize_t read(void *buf, size_t n)
  {
    return qlread(li, buf, n);
  }
  bool eof()
  {
    if ( lsize == 0 )
      lsize = qlsize(li);
    return qltell(li) >= lsize;
  }
protected:
  linput_t *li;
private:
  int64 lsize;
};

 

enum linput_close_code_t
{
  LOC_CLOSE,    
  LOC_UNMAKE,   
  LOC_KEEP,     
};
 
 
#endif // _DISKIO_HPP