Line data    Source code

       1              : use lief_ffi as ffi;
       2              : use std::fmt;
       3              : use crate::common::FromFFI;
       4              : use std::marker::PhantomData;
       5              : 
       6              : /// This structure wraps the sysv-hash info
       7              : pub struct Sysv<'a> {
       8              :     ptr: cxx::UniquePtr<ffi::ELF_SysvHash>,
       9              :     _owner: PhantomData<&'a ffi::ELF_Binary>
      10              : }
      11              : 
      12              : impl Sysv<'_> {
      13              :     /// Number of bucket used for this hash table
      14           16 :     pub fn nbucket(&self) -> u32 {
      15           16 :         self.ptr.nbucket()
      16           16 :     }
      17              : 
      18              :     /// Number of chains used for this hash table
      19           16 :     pub fn nchain(&self) -> u32 {
      20           16 :         self.ptr.nchain()
      21           16 :     }
      22              : 
      23              :     /// Bucket's values
      24           16 :     pub fn buckets(&self) -> Vec<u32> {
      25           16 :         Vec::from(self.ptr.buckets().as_slice())
      26           16 :     }
      27              : 
      28              :     /// Chain's values
      29           16 :     pub fn chains(&self) -> Vec<u32> {
      30           16 :         Vec::from(self.ptr.chains().as_slice())
      31           16 :     }
      32              : }
      33              : 
      34              : impl fmt::Debug for Sysv<'_> {
      35           16 :     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
      36           16 :         f.debug_struct("Sysv")
      37           16 :             .field("nbucket", &self.nbucket())
      38           16 :             .field("nchain", &self.nchain())
      39           16 :             .field("buckets", &self.buckets())
      40           16 :             .field("chains", &self.chains())
      41           16 :             .finish()
      42           16 :     }
      43              : }
      44              : 
      45              : impl FromFFI<ffi::ELF_SysvHash> for Sysv<'_> {
      46           16 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_SysvHash>) -> Self {
      47           16 :         Self {
      48           16 :             ptr,
      49           16 :             _owner: PhantomData
      50           16 :         }
      51           16 :     }
      52              : }
      53              : 
      54              : /// Structure that wraps the GNU-hash implementation
      55              : pub struct Gnu<'a> {
      56              :     ptr: cxx::UniquePtr<ffi::ELF_GnuHash>,
      57              :     _owner: PhantomData<&'a ffi::ELF_Binary>
      58              : }
      59              : 
      60              : 
      61              : impl Gnu<'_> {
      62              :     /// Number of buckets used in this hash table
      63           32 :     pub fn nb_buckets(&self) -> u32 {
      64           32 :         self.ptr.nb_buckets()
      65           32 :     }
      66              : 
      67              :     /// Index of the first symbol in the dynamic symbols table which accessible with the hash table
      68           32 :     pub fn symbol_index(&self) -> u32 {
      69           32 :         self.ptr.symbol_index()
      70           32 :     }
      71              : 
      72              :     /// Shift count used in the bloom filter
      73           32 :     pub fn shift2(&self) -> u32 {
      74           32 :         self.ptr.shift2()
      75           32 :     }
      76              : 
      77              :     /// Number of bloom filters used. It must be a power of 2.
      78           32 :     pub fn maskwords(&self) -> u32 {
      79           32 :         self.ptr.maskwords()
      80           32 :     }
      81              : 
      82              :     /// Bloom filters
      83           32 :     pub fn bloom_filters(&self) -> Vec<u64> {
      84           32 :         Vec::from(self.ptr.bloom_filters().as_slice())
      85           32 :     }
      86              : 
      87              :     /// Hash bucket values
      88           32 :     pub fn buckets(&self) -> Vec<u32> {
      89           32 :         Vec::from(self.ptr.buckets().as_slice())
      90           32 :     }
      91              : 
      92              :     /// Hash values
      93           32 :     pub fn hash_values(&self) -> Vec<u32> {
      94           32 :         Vec::from(self.ptr.hash_values().as_slice())
      95           32 :     }
      96              : }
      97              : 
      98              : impl fmt::Debug for Gnu<'_> {
      99           32 :     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     100           32 :         f.debug_struct("GnuHash")
     101           32 :             .field("nb_buckets", &self.nb_buckets())
     102           32 :             .field("symbol_index", &self.symbol_index())
     103           32 :             .field("shift2", &self.shift2())
     104           32 :             .field("maskwords", &self.maskwords())
     105           32 :             .field("bloom_filters", &self.bloom_filters())
     106           32 :             .field("buckets", &self.buckets())
     107           32 :             .field("hash_values", &self.hash_values())
     108           32 :             .finish()
     109           32 :     }
     110              : }
     111              : 
     112              : impl FromFFI<ffi::ELF_GnuHash> for Gnu<'_> {
     113           32 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_GnuHash>) -> Self {
     114           32 :         Self {
     115           32 :             ptr,
     116           32 :             _owner: PhantomData
     117           32 :         }
     118           32 :     }
     119              : }