Add a logger

OpenSMTPD plans to gather all logs from filters. Therefore, a default
logger that implements the smtpd (future) log interface has to be
available.

opensmtpd/src/errors.rs

@@ -26,6 +26,12 @@ impl From<std::io::Error> for Error {
     }
 }
 
+impl From<log::SetLoggerError> for Error {
+    fn from(error: log::SetLoggerError) -> Self {
+        Error::new(&format!("Logger error: {}", error))
+    }
+}
+
 impl From<nom::Err<&str>> for Error {
     fn from(error: nom::Err<&str>) -> Self {
         let msg = match error {

opensmtpd/src/lib.rs

@@ -1,6 +1,7 @@
 mod entry;
 mod errors;
 mod event_handlers;
+mod logger;
 
 use log::{debug, error, warn};
 use std::collections::HashMap;
@@ -12,6 +13,7 @@ use std::thread;
 pub use crate::entry::{Entry, Event};
 pub use crate::errors::Error;
 pub use crate::event_handlers::{Callback, EventHandler, MatchEvent};
+pub use crate::logger::SmtpdLogger;
 pub use opensmtpd_derive::event;
 
 #[macro_export]

opensmtpd/src/logger.rs

@@ -0,0 +1,48 @@
+use crate::errors::Error;
+use log::{Level, Metadata, Record};
+use std::io::{self, Write};
+
+#[derive(Clone)]
+pub struct SmtpdLogger {
+    level: Level,
+}
+
+impl SmtpdLogger {
+    pub fn new() -> Self {
+        SmtpdLogger::default()
+    }
+
+    pub fn set_level(&mut self, level: Level) -> Self {
+        self.level = level;
+        self.clone()
+    }
+
+    pub fn init(self) -> Result<(), Error> {
+        let level = self.level.to_level_filter();
+        log::set_boxed_logger(Box::new(self))?;
+        log::set_max_level(level);
+        Ok(())
+    }
+}
+
+impl Default for SmtpdLogger {
+    fn default() -> Self {
+        SmtpdLogger { level: Level::Warn }
+    }
+}
+
+impl log::Log for SmtpdLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= self.level
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            let stderr = io::stderr();
+            let mut handle = stderr.lock();
+            writeln!(handle, "{}: {}", record.level(), record.args()).unwrap();
+        }
+    }
+
+    fn flush(&self) {}
+}