Line data    Source code

       1              : use lief_ffi as ffi;
       2              : use std::collections::HashMap;
       3              : use std::marker::PhantomData;
       4              : 
       5              : use crate::common::FromFFI;
       6              : use crate::elf::note::NoteBase;
       7              : 
       8              : #[allow(non_camel_case_types)]
       9          832 : #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
      10              : /// Auxiliary vector types
      11              : pub enum Type {
      12              :     END,
      13              :     IGNORE_TY,
      14              :     EXECFD,
      15              :     PHDR,
      16              :     PHENT,
      17              :     PHNUM,
      18              :     PAGESZ,
      19              :     BASE,
      20              :     FLAGS,
      21              :     ENTRY,
      22              :     NOTELF,
      23              :     UID,
      24              :     EUID,
      25              :     GID,
      26              :     EGID,
      27              :     TGT_PLATFORM,
      28              :     HWCAP,
      29              :     CLKTCK,
      30              :     FPUCW,
      31              :     DCACHEBSIZE,
      32              :     ICACHEBSIZE,
      33              :     UCACHEBSIZE,
      34              :     IGNOREPPC,
      35              :     SECURE,
      36              :     BASE_PLATFORM,
      37              :     RANDOM,
      38              :     HWCAP2,
      39              :     EXECFN,
      40              :     SYSINFO,
      41              :     SYSINFO_EHDR,
      42              :     UNKNOWN(u64),
      43              : }
      44              : 
      45              : impl From<u64> for Type {
      46          468 :     fn from(value: u64) -> Self {
      47          468 :         match value {
      48            0 :             0 => Type::END,
      49            0 :             1 => Type::IGNORE_TY,
      50            0 :             2 => Type::EXECFD,
      51           26 :             3 => Type::PHDR,
      52           26 :             4 => Type::PHENT,
      53           26 :             5 => Type::PHNUM,
      54           26 :             6 => Type::PAGESZ,
      55           26 :             7 => Type::BASE,
      56           26 :             8 => Type::FLAGS,
      57           26 :             9 => Type::ENTRY,
      58            0 :             10 => Type::NOTELF,
      59           26 :             11 => Type::UID,
      60           26 :             12 => Type::EUID,
      61           26 :             13 => Type::GID,
      62           26 :             14 => Type::EGID,
      63           26 :             15 => Type::TGT_PLATFORM,
      64           26 :             16 => Type::HWCAP,
      65           26 :             17 => Type::CLKTCK,
      66            0 :             18 => Type::FPUCW,
      67            0 :             19 => Type::DCACHEBSIZE,
      68            0 :             20 => Type::ICACHEBSIZE,
      69            0 :             21 => Type::UCACHEBSIZE,
      70            0 :             22 => Type::IGNOREPPC,
      71           26 :             23 => Type::SECURE,
      72            0 :             24 => Type::BASE_PLATFORM,
      73           26 :             25 => Type::RANDOM,
      74           13 :             26 => Type::HWCAP2,
      75           26 :             31 => Type::EXECFN,
      76            0 :             32 => Type::SYSINFO,
      77           13 :             33 => Type::SYSINFO_EHDR,
      78            0 :             _ => Type::UNKNOWN(value),
      79              :         }
      80          468 :     }
      81              : }
      82              : 
      83              : /// Note representing core auxiliary vector (`NT_AUXV`)
      84              : pub struct Auxv<'a> {
      85              :     ptr: cxx::UniquePtr<ffi::ELF_CoreAuxv>,
      86              :     _owner: PhantomData<&'a ffi::ELF_Binary>,
      87              : }
      88              : 
      89              : impl Auxv<'_> {
      90              :     /// Return the auxiliary values as a map of (Type, value)
      91           26 :     pub fn values(&self) -> HashMap<Type, u64> {
      92           26 :         self.ptr
      93           26 :             .values()
      94           26 :             .as_slice()
      95           26 :             .chunks_exact(2)
      96          468 :             .map(|c| (Type::from(c[0]), c[1]))
      97           26 :             .collect()
      98           26 :     }
      99              : }
     100              : 
     101              : impl NoteBase for Auxv<'_> {
     102          299 :     fn get_base(&self) -> &ffi::ELF_Note {
     103          299 :         self.ptr.as_ref().unwrap().as_ref()
     104          299 :     }
     105              : }
     106              : 
     107              : impl FromFFI<ffi::ELF_CoreAuxv> for Auxv<'_> {
     108          104 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_CoreAuxv>) -> Self {
     109          104 :         Self {
     110          104 :             ptr,
     111          104 :             _owner: PhantomData,
     112          104 :         }
     113          104 :     }
     114              : }
     115              : 
     116              : impl std::fmt::Debug for Auxv<'_> {
     117           78 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     118           78 :         let base = self as &dyn NoteBase;
     119           78 :         f.debug_struct("CoreAuxv").field("base", &base).finish()
     120           78 :     }
     121              : }