Line data    Source code

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