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           20 :     pub fn nbucket(&self) -> u32 {
      15           20 :         self.ptr.nbucket()
      16           20 :     }
      17              : 
      18              :     /// Number of chains used for this hash table
      19           20 :     pub fn nchain(&self) -> u32 {
      20           20 :         self.ptr.nchain()
      21           20 :     }
      22              : 
      23              :     /// Bucket's values
      24           20 :     pub fn buckets(&self) -> Vec<u32> {
      25           20 :         Vec::from(self.ptr.buckets().as_slice())
      26           20 :     }
      27              : 
      28              :     /// Chain's values
      29           20 :     pub fn chains(&self) -> Vec<u32> {
      30           20 :         Vec::from(self.ptr.chains().as_slice())
      31           20 :     }
      32              : }
      33              : 
      34              : impl fmt::Debug for Sysv<'_> {
      35           20 :     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
      36           20 :         f.debug_struct("Sysv")
      37           20 :             .field("nbucket", &self.nbucket())
      38           20 :             .field("nchain", &self.nchain())
      39           20 :             .field("buckets", &self.buckets())
      40           20 :             .field("chains", &self.chains())
      41           20 :             .finish()
      42           20 :     }
      43              : }
      44              : 
      45              : impl FromFFI<ffi::ELF_SysvHash> for Sysv<'_> {
      46           20 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_SysvHash>) -> Self {
      47           20 :         Self {
      48           20 :             ptr,
      49           20 :             _owner: PhantomData
      50           20 :         }
      51           20 :     }
      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           40 :     pub fn nb_buckets(&self) -> u32 {
      64           40 :         self.ptr.nb_buckets()
      65           40 :     }
      66              : 
      67              :     /// Index of the first symbol in the dynamic symbols table which accessible with the hash table
      68           40 :     pub fn symbol_index(&self) -> u32 {
      69           40 :         self.ptr.symbol_index()
      70           40 :     }
      71              : 
      72              :     /// Shift count used in the bloom filter
      73           40 :     pub fn shift2(&self) -> u32 {
      74           40 :         self.ptr.shift2()
      75           40 :     }
      76              : 
      77              :     /// Number of bloom filters used. It must be a power of 2.
      78           40 :     pub fn maskwords(&self) -> u32 {
      79           40 :         self.ptr.maskwords()
      80           40 :     }
      81              : 
      82              :     /// Bloom filters
      83           40 :     pub fn bloom_filters(&self) -> Vec<u64> {
      84           40 :         Vec::from(self.ptr.bloom_filters().as_slice())
      85           40 :     }
      86              : 
      87              :     /// Hash bucket values
      88           40 :     pub fn buckets(&self) -> Vec<u32> {
      89           40 :         Vec::from(self.ptr.buckets().as_slice())
      90           40 :     }
      91              : 
      92              :     /// Hash values
      93           40 :     pub fn hash_values(&self) -> Vec<u32> {
      94           40 :         Vec::from(self.ptr.hash_values().as_slice())
      95           40 :     }
      96              : }
      97              : 
      98              : impl fmt::Debug for Gnu<'_> {
      99           40 :     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     100           40 :         f.debug_struct("GnuHash")
     101           40 :             .field("nb_buckets", &self.nb_buckets())
     102           40 :             .field("symbol_index", &self.symbol_index())
     103           40 :             .field("shift2", &self.shift2())
     104           40 :             .field("maskwords", &self.maskwords())
     105           40 :             .field("bloom_filters", &self.bloom_filters())
     106           40 :             .field("buckets", &self.buckets())
     107           40 :             .field("hash_values", &self.hash_values())
     108           40 :             .finish()
     109           40 :     }
     110              : }
     111              : 
     112              : impl FromFFI<ffi::ELF_GnuHash> for Gnu<'_> {
     113           40 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_GnuHash>) -> Self {
     114           40 :         Self {
     115           40 :             ptr,
     116           40 :             _owner: PhantomData
     117           40 :         }
     118           40 :     }
     119              : }