dscu.h

Go to the documentation of this file.

#pragma once
 
#include <string_view>
 
#include <pro.h>
#include <range.hpp>
#include <loader.hpp>

 
 
//-------------------------------------------------------------------------
struct dscu_svc_t;
struct dscu_ctx_t;
 
//-------------------------------------------------------------------------
class dscu_req_t
{
  friend dscu_ctx_t;
 
protected:
  enum code_t
  {
    drc_unknown = 10,
    drc_create_layout,
    drc_get_dscu_svc,
 
#ifdef TESTABLE_BUILD
    drc_load_cancellation_req = 100,
#endif
  };
 
private:
  code_t code = drc_unknown;
 
protected:
  dscu_req_t(code_t _code)
    : code(_code) {}
 
  bool _perform()
  {
    return load_and_run_plugin("dscu", size_t(this));
  }
};
 
//-------------------------------------------------------------------------
class dscu_create_layout_req_t : public dscu_req_t
{
  friend dscu_ctx_t;
 
  bytevec_t uuid;
  qstring path;
  int image_index = -1;
 
public:
  dscu_create_layout_req_t(
          const bytevec_t &_uuid,
          const qstring &_path,
          int _image_index)
    : dscu_req_t(drc_create_layout)
  {
    uuid = _uuid;
    path = _path;
    image_index = _image_index;
  }
 
  bool perform()
  {
    return _perform();
  }
};
 
//-------------------------------------------------------------------------
class dscu_svc_req_t : public dscu_req_t
{
  friend dscu_ctx_t;
 
  dscu_svc_t *ds = nullptr;
 
public:
  dscu_svc_req_t()
    : dscu_req_t(drc_get_dscu_svc) {}
 
  dscu_svc_t *perform()
  {
    _perform();
    return ds;
  }
};
 
//-------------------------------------------------------------------------
inline dscu_svc_t *get_dscu_svc()
{
  return dscu_svc_req_t().perform();
};
 
//-------------------------------------------------------------------------
enum region_type_t : uint32
{
  rt_invalid = (uint32)-1, 
  rt_image_entity = 0,   
  rt_island = 1,         
  rt_header = 2,         
  rt_mapping = 3,        
  rt_unknown = 4,        
  rt_got = 5,            
  rt_cache_data = 6,     
};
 
//-------------------------------------------------------------------------
struct mapping_coords_t
{
  int16 file_index;    
  int16 mapping_index; 
 
  bool operator==(const mapping_coords_t &r) const
  {
    return file_index == r.file_index
        && mapping_index == r.mapping_index;
  }
  bool operator!=(const mapping_coords_t &r) const
  {
    return !(*this == r);
  }
 
  inline bool valid() const { return file_index >= 0 && mapping_index >= 0; }
 
  static mapping_coords_t make_invalid()
  {
    mapping_coords_t c;
    c.file_index = int16(-1);
    c.mapping_index = int16(-1);
    return c;
  }
};
CASSERT(sizeof(mapping_coords_t) == sizeof(int));
DECLARE_TYPE_AS_MOVABLE(mapping_coords_t);
typedef qvector<mapping_coords_t> mapping_coords_vec_t;
 
//-----------------------------------------------------------------------------
struct region_info_t
{
  ea_t start = BADADDR;            
  asize_t size = 0;                
 
  region_type_t type = rt_invalid; 

  union
  {
    int image_index = -1;          
    int branch_island_number;      
  };
 
  char name[40] = { 0 };           
 
 
  void swap(region_info_t &r)
  {
    qswap(start, r.start);
    qswap(size, r.size);
    qswap(type, r.type);
    qswap(image_index, r.image_index);
    qswap(name, r.name);
  }
 
  range_t get_range() const { return range_t(start, start+size); }
 
  bool operator==(const region_info_t &r) const
  {
    return start == r.start
        && size == r.size
        && type == r.type
        && image_index == r.image_index
        && streq(name, r.name);
  }
  bool operator!=(const region_info_t &r) const { return !(*this == r); }
};
CASSERT(sizeof(region_info_t) == 64);
DECLARE_TYPE_AS_MOVABLE(region_info_t);
typedef qvector<region_info_t> region_info_vec_t;
 
//-------------------------------------------------------------------------
struct address_info_t
{
  region_info_t region;                                            
  mapping_coords_t mapping = mapping_coords_t::make_invalid();     
  uint64 file_offset = 0;                                          
 
  bool valid() const { return mapping.valid(); }
};
DECLARE_TYPE_AS_MOVABLE(address_info_t);
 
//-------------------------------------------------------------------------
typedef std::set<int> dyldlib_set_t;
 
//-------------------------------------------------------------------------
struct dscu_load_request_t
{
  intvec_t images;                
  intvec_t islands;               
  eavec_t mappings;               
  eavec_t gots;                   
  eavec_t unknown_regions;        
  eavec_t cache_data;             
 
#define DLRF_UNDO_ON_FAILURE   0x1                          
#define DLRF_CREATE_UNDO_POINT (0x2 | DLRF_UNDO_ON_FAILURE) 
#define DLRF_SILENT            0x4                          
#define DLRF_ASK_CONFIRMATION  0x8                          
#define DLRF_DEFAULT           (DLRF_CREATE_UNDO_POINT)     
 
  uint32 flags = 0;
 
  dscu_load_request_t(uint32 _flags=DLRF_DEFAULT) : flags(_flags) {}
 
  void add_region(const region_info_t &ri)
  {
    switch ( ri.type )
    {
      case rt_image_entity:
        // Regions belonging to images, need to cause a full image load
        images.add_unique(ri.image_index);
        break;
 
      case rt_island:
        islands.add_unique(ri.branch_island_number);
        break;
 
      case rt_mapping:
        mappings.add_unique(ri.start);
        break;
 
      case rt_header:
        // ?
        break;
 
      case rt_got:
        gots.add_unique(ri.start);
        break;
 
      case rt_unknown:
        unknown_regions.add_unique(ri.start);
        break;
 
      case rt_cache_data:
        cache_data.add_unique(ri.start);
        break;
 
      default:
        TB_INTERR_OR_RETURN(0);
    }
  }
 
  void add_regions(const region_info_vec_t &ris)
  {
    for ( const auto &ri : ris )
      add_region(ri);
  }
 
  void clear()
  {
    images.clear();
    islands.clear();
    mappings.clear();
    gots.clear();
    unknown_regions.clear();
    cache_data.clear();
    flags = DLRF_DEFAULT;
  }
 
  bool empty() const
  {
    return images.empty()
        && islands.empty()
        && mappings.empty()
        && gots.empty()
        && unknown_regions.empty()
        && cache_data.empty();
  }
};
 
//-------------------------------------------------------------------------
struct symbol_match_t
{
  std::string_view symbol;  
  ea_t ea = BADADDR;        
  int image_index = -1;     
 
  bool operator==(const symbol_match_t &r) const
  {
    return ea == r.ea && image_index == r.image_index && symbol == r.symbol;
  }
  bool operator!=(const symbol_match_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(symbol_match_t);
typedef qvector<symbol_match_t> symbol_match_vec_t;
 
//-------------------------------------------------------------------------
struct string_match_t
{
  ea_t ea = BADADDR;        
  int image_index = -1;     
  size_t file_index = 0;    
  uint64 file_offset = 0;   
  qstring context;          
 
  bool operator==(const string_match_t &r) const
  {
    return ea == r.ea
        && image_index == r.image_index
        && file_index == r.file_index
        && file_offset == r.file_offset
        && context == r.context;
  }
  bool operator!=(const string_match_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(string_match_t);
typedef qvector<string_match_t> string_match_vec_t;
 
//-------------------------------------------------------------------------
class shared_cache_toplevel_file_t;
 
//-------------------------------------------------------------------------
struct dependency_match_entry_t
{
  qstring image_name;                    
  int image_index = -1;                  
  uint32 load_command_type = uint32(-1); 
 
  bool operator==(const dependency_match_entry_t &r) const
  {
    return image_name == r.image_name
        && image_index == r.image_index
        && load_command_type == r.load_command_type;
  }
  bool operator!=(const dependency_match_entry_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(dependency_match_entry_t);
typedef qvector<dependency_match_entry_t> dependency_match_entry_vec_t;
 
//-------------------------------------------------------------------------
struct dependency_match_result_t : public dependency_match_entry_vec_t
{
};
 
//-------------------------------------------------------------------------
struct dscu_svc_t
{
  virtual ~dscu_svc_t() {}

  virtual std::shared_ptr<shared_cache_toplevel_file_t> get_toplevel() const = 0;

  virtual bool get_input_file_path(qstring *out) const = 0;

  virtual adiff_t get_dyld_slide() const = 0;

  virtual void update_dyld_slide(adiff_t delta) = 0;



  virtual void get_files_names(qstrvec_t *out) const = 0;

  virtual bool get_file_name(qstring *out, size_t file_index) const = 0;

  virtual size_t get_file_index(const char *file_name) const = 0;

  virtual bool get_file_mappings(mapping_coords_vec_t *out, const char *file_name) const = 0;




  virtual bool get_mapping_range(range_t *out, mapping_coords_t mapping) const = 0;

  virtual address_info_t locate_address(ea_t ea) const = 0;




  virtual bool get_region(region_info_t *ri, size_t region_index, bool full=true) const = 0;

  virtual bool get_region_by_ea(
        region_info_t *ri,
        ea_t ea,
        size_t *out_region_index=nullptr,
        bool full=true) const = 0;

  virtual void get_regions(
        region_info_vec_t *vout,
        const sizevec_t *region_indexes=nullptr,
        bool full=true) const = 0;




  virtual int get_images_count() const = 0;

  virtual void get_images_names(qstrvec_t *out) const = 0;

  virtual int get_image_index(const char *image_name) const = 0;

  virtual bool get_image_name(qstring *out, int image_index) const = 0;

  bool get_image_filename(qstring *out, int image_index) const
  {
    bool ok = get_image_name(out, image_index);
    if ( ok )
    {
      const size_t pos = out->rfind('/');
      ok = pos != qstring::npos;
      if ( ok )
      {
        qstring tmp(out->c_str() + pos + 1, out->length() - pos - 1);
        out->swap(tmp);
      }
    }
    return ok;
  }

  virtual mapping_coords_t get_image_mapping(int image_index) const = 0;
  inline mapping_coords_t get_image_mapping(const char *image_name) const { return get_image_mapping(get_image_index(image_name)); }

  virtual bool is_image_loaded(int image_index) const = 0;
  inline bool is_image_loaded(const char *image_name) const { return is_image_loaded(get_image_index(image_name)); }

  virtual bool get_image_file_name(qstring *out, int image_index) const = 0;
  inline bool get_image_file_name(qstring *out, const char *image_name) const { return get_image_file_name(out, get_image_index(image_name)); }

  virtual bool get_image_regions(region_info_vec_t *out, int image_index, bool full=true) const = 0;
  inline bool get_image_regions(region_info_vec_t *out, const char *image_name, bool full=true) const { return get_image_regions(out, get_image_index(image_name), full); }

  virtual bool get_image_regions_indexes(sizevec_t *out, int image_index) const = 0;
  inline bool get_image_regions_indexes(sizevec_t *out, const char *image_name) const { return get_image_regions_indexes(out, get_image_index(image_name)); }

  virtual bool get_image_dependencies(intvec_t *out, int image_index, int depth=1) const = 0;
  inline bool get_image_dependencies(intvec_t *out, const char *image_name, int depth=1) const { return get_image_dependencies(out, get_image_index(image_name), depth); }

  virtual ea_t get_image_address(int image_index) const = 0;

  virtual uint64 get_image_total_size(int image_index) const = 0;
  inline uint64 get_image_total_size(const char *image_name) const { return get_image_total_size(get_image_index(image_name)); }

  virtual size_t get_image_file_index(int image_index) const = 0;
  inline size_t get_image_file_index(const char *image_name) const { return get_image_file_index(get_image_index(image_name)); }

  virtual bool get_images_dependencies(intvec_t *out, const intvec_t &images_indexes, int depth=1) const = 0;




  virtual bool is_island_loaded(int island_index) const = 0;




  virtual bool load_image(int image_index, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool load_island(int island_index, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool load_branch_mapping(ea_t ea, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool is_mapping_loaded(ea_t mapping_addr) const = 0;

  virtual bool load_got(ea_t ea, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool is_got_loaded(ea_t got_addr) const = 0;

  virtual bool load_unknown_region(ea_t ea, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool is_unknown_region_loaded(ea_t ea) const = 0;

  virtual bool load_cache_data(ea_t ea, uint32 flags=DLRF_DEFAULT) = 0;

  virtual bool is_cache_data_loaded(ea_t cache_data_addr) const = 0;

  virtual bool load_regions(const dscu_load_request_t &regions) = 0;

  virtual int get_load_regions_requests_count() const = 0;




  virtual region_type_t get_region_type(size_t region_index) const = 0;

  virtual bool query_symbols(
        symbol_match_vec_t *out,
        const range_t &range) const = 0;

  virtual std::string_view query_symbol(ea_t ea) const = 0;

  virtual std::string_view query_exported_symbol(ea_t ea) const = 0;

#define FSF_LOADED_IMAGES_ONLY 0x1 
#define FSF_CASE_INSENSITIVE   0x2 

  virtual bool find_symbol(
        symbol_match_vec_t *out,
        const char *needle,
        uint32 flags=0,
        size_t max_count=size_t(-1)) const = 0;

#define FSSF_SCOPE_IMAGES               0x00 
#define FSSF_SCOPE_FILES                0x01 
#define FSSF_SCOPE_MASK                 0x01 
 
#define FSSF_IMAGES_SCOPE_DATA_SECTIONS 0x00 
#define FSSF_IMAGES_SCOPE_ALL           0x02 
#define FSSF_IMAGES_SCOPE_MASK          0x02 
 
#define FSSF_FILES_INCLUDE_SYMBOLS      0x04 
#define FSSF_FILES_INCLUDE_BRANCH_MAPPINGS 0x08 
#define FSSF_FILES_INCLUDE_OTHER        0x10 
 
#define FSSF_CASE_INSENSITIVE           0x20 

  virtual bool find_string(
        string_match_vec_t *out,
        const char *needle,
        uint32 flags=0,
        size_t max_count=size_t(-1)) const = 0;

  virtual bool has_local_symbols() const = 0;
 
  enum depmatch_code_t
  {
    dmc_ok = 0,            
    dmc_bad_file,          
    dmc_cpu_mismatch,      
    dmc_platform_mismatch, 
    dmc_failed,            
  };

#define MDF_ALLOW_CPU_MISMATCH      0x1 
#define MDF_ALLOW_PLATFORM_MISMATCH 0x2 

  virtual depmatch_code_t match_dependencies(
        dependency_match_result_t *out,
        const char *path,
        uint32 flags=0) const = 0;

#define DLF_VALIDATE             (1 << 0)                    
#define DLF_VALIDATE_HARD        (DLF_VALIDATE | (1 << 1))   
#define DLF_TOPLEVEL_INPUT_PATH  (1 << 2)                    
#define DLF_TOPLEVEL_DETAILS     (1 << 3)                    
#define DLF_TOPLEVEL             (DLF_TOPLEVEL_INPUT_PATH | DLF_TOPLEVEL_DETAILS) 
#define DLF_FILES                (1 << 4)                    
#define DLF_MAPPINGS             (1 << 5)                    
#define DLF_IMAGES               (1 << 6)                    
#define DLF_IMAGES_DEPENDENCIES  (DLF_IMAGES | (1 << 7))     
#define DLF_IMAGES_REGIONS       (DLF_IMAGES | (1 << 8))     
#define DLF_ISLANDS              (1 << 9)                    
#define DLF_ISLANDS_REGIONS      (DLF_ISLANDS | (1 << 10))   
#define DLF_GOTS                 (1 << 11)                   
#define DLF_UNKNOWN_REGIONS      (1 << 12)                   
#define DLF_CACHE_DATA           (1 << 13)                   
 
#define DLF_ALL 0xFFFFFFFF

  virtual void dump_layout(uint32 flags=DLF_ALL) const = 0;
 
};