Line data    Source code

       1              : //! LIEF's logging API
       2              : //!
       3              : //! This module contains function to tweak or use LIEF's logging mechanisms
       4              : //!
       5              : //!
       6              : //! ```
       7              : //! use lief::logging;
       8              : //!
       9              : //! logging::set_level(logging::Level::DEBUG);
      10              : //! logging::log(logging::Level::DEBUG, "Hi!");
      11              : //! ```
      12              : 
      13              : use lief_ffi as ffi;
      14              : 
      15              : use std::path::Path;
      16              : use std::convert::{From, Into};
      17              : 
      18              : #[allow(non_camel_case_types)]
      19            0 : #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
      20              : /// The different levels of log
      21              : pub enum Level {
      22              :     OFF,
      23              :     TRACE,
      24              :     DEBUG,
      25              :     INFO,
      26              :     WARN,
      27              :     ERR,
      28              :     CRITICAL,
      29              :     UNKNOWN(u32),
      30              : }
      31              : 
      32              : impl From<u32> for Level {
      33            0 :     fn from(value: u32) -> Self {
      34            0 :         match value {
      35            0 :             0x00000000 => Level::OFF,
      36            0 :             0x00000001 => Level::TRACE,
      37            0 :             0x00000002 => Level::DEBUG,
      38            0 :             0x00000003 => Level::INFO,
      39            0 :             0x00000004 => Level::WARN,
      40            0 :             0x00000005 => Level::ERR,
      41            0 :             0x00000006 => Level::CRITICAL,
      42            0 :             _ => Level::UNKNOWN(value),
      43              :         }
      44            0 :     }
      45              : }
      46              : 
      47              : impl Into<u32> for Level {
      48           16 :     fn into(self) -> u32 {
      49           16 :         match self {
      50            0 :             Level::OFF => 0x00000000,
      51            0 :             Level::TRACE => 0x00000001,
      52            8 :             Level::DEBUG => 0x00000002,
      53            8 :             Level::INFO => 0x00000003,
      54            0 :             Level::WARN => 0x00000004,
      55            0 :             Level::ERR => 0x00000005,
      56            0 :             Level::CRITICAL => 0x00000006,
      57            0 :             Level::UNKNOWN(_) => 0x00000003, // INFO
      58              :         }
      59           16 :     }
      60              : }
      61              : 
      62              : /// Reset the current logger
      63            8 : pub fn reset() {
      64            8 :     ffi::LIEF_Logging::reset()
      65            8 : }
      66              : 
      67              : /// Prevent any log message from being printed
      68            8 : pub fn disable() {
      69            8 :     ffi::LIEF_Logging::disable()
      70            8 : }
      71              : 
      72              : /// Enable the logger
      73            8 : pub fn enable() {
      74            8 :     ffi::LIEF_Logging::enable()
      75            8 : }
      76              : 
      77              : /// Change the logging level
      78              : ///
      79              : /// ```
      80              : /// set_level(Level::INFO)
      81              : /// ```
      82            8 : pub fn set_level(level: Level) {
      83            8 :     ffi::LIEF_Logging::set_level(level.into())
      84            8 : }
      85              : /// Switch to a file-based logger (instead of stderr-based)
      86              : ///
      87              : /// ```
      88              : /// let mut tmp = env::temp_dir();
      89              : /// tmp.push("lief_log.log");
      90              : /// logging::set_path(dir.as_path());
      91              : /// ```
      92           32 : pub fn set_path(path: &Path) {
      93           32 :     ffi::LIEF_Logging::set_path(path.to_str().expect("Can't convert into string"))
      94           32 : }
      95              : 
      96              : /// Log a message with the logger
      97            8 : pub fn log(level: Level, message: &str) {
      98            8 :     ffi::LIEF_Logging::log(level.into(), message)
      99            8 : }