integrate dbus

Author: NunuM

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
     "libnss",
-    "doh"
-]
+    "doh",
+    "doh-daemon",
+    "doh-common"]

doh-common/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "doh-common"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "doh_common"
+
+[dependencies]
+libnss = { path = "../libnss" }
+log = "0.4.17"
+serde_json = "1.0"
+sqlite = "0.37.0"
+zbus = "5.9.0"
+
+zvariant = "5.6.0"
+serde = { version = "1", features = ["derive"] }
+reqwest = { version =  "0.12.23", features = ["gzip","json", "brotli"] }
+url = "2.5.4"

doh-common/src/error.rs

@@ -0,0 +1,89 @@
+use std::error::Error as Err;
+use std::fmt::{Display, Formatter};
+use std::time::SystemTimeError;
+
+use log::error;
+use url::ParseError;
+
+use libnss::host::Host;
+use libnss::interop::Response;
+
+#[derive(Debug)]
+pub enum Error {
+    DNSErrorReply,
+    EmptyDNSReply,
+    UpstreamError,
+    DatabaseError,
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::UpstreamError => write!(f, "UpstreamError"),
+            Error::DNSErrorReply => write!(f, "DNSErrorReply"),
+            Error::EmptyDNSReply => write!(f, "EmptyDNSReply"),
+            Error::DatabaseError => write!(f, "DatabaseError")
+        }
+    }
+}
+
+impl Err for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(error: std::io::Error) -> Self {
+        error!("reading response body error: {:?}", error);
+        Error::UpstreamError
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(error: serde_json::Error) -> Self {
+        error!("error deserialization JSON: {} {:?}", error, error);
+        Error::UpstreamError
+    }
+}
+
+impl From<sqlite::Error> for Error {
+    fn from(err: sqlite::Error) -> Self {
+        error!("database error: {}", err);
+        Error::DatabaseError
+    }
+}
+
+impl From<SystemTimeError> for Error {
+    fn from(error: SystemTimeError) -> Self {
+        error!("error getting system time: {}", error);
+        Error::DatabaseError
+    }
+}
+
+impl Into<Response<Host>> for Error {
+    fn into(self) -> Response<Host> {
+        match self {
+            Error::EmptyDNSReply => Response::NotFound,
+            Error::UpstreamError => Response::TryAgain,
+            _ => Response::Unavail
+        }
+    }
+}
+
+impl From<crate::error::Error> for zbus::fdo::Error {
+    fn from(value: Error) -> Self {
+        zbus::fdo::Error::Failed(value.to_string())
+    }
+}
+
+
+impl From<url::ParseError> for Error {
+    fn from(error: ParseError) -> Self {
+        error!("error parsing url: {} {:?}", error, error);
+        Error::UpstreamError
+    }
+}
+
+impl From<reqwest::Error> for Error {
+    fn from(error: reqwest::Error) -> Self {
+        error!("error while making upstream request: {} {:?}", error, error);
+        Error::UpstreamError
+    }
+}

doh-common/src/lib.rs

@@ -0,0 +1,31 @@
+pub mod error;
+pub mod loggger;
+
+use serde::{Serialize};
+use zvariant::Type;
+
+
+#[derive(Serialize, Type)]
+pub struct AuditDnsQueryPage {
+    current_page: u64,
+    results: Vec<AuditDnsQuery>,
+}
+
+impl AuditDnsQueryPage {
+    pub fn new(current_page: u64, results: Vec<AuditDnsQuery>) -> Self {
+        Self { current_page, results }
+    }
+}
+
+#[derive(Serialize, Type)]
+pub struct AuditDnsQuery {
+    process_name: String,
+    host: String,
+    create: u64,
+}
+
+impl AuditDnsQuery {
+    pub fn new(process_name: String, host: String, create: u64) -> Self {
+        Self { process_name, host, create }
+    }
+}

doh-common/src/loggger.rs

@@ -0,0 +1,9 @@
+use log::info;
+
+// use syslog::{Facility, Formatter3164};
+
+pub fn log<M: AsRef<str>>(message: M) {
+    // Log to syslog of it is in debug mode
+    // if let Ok(_) = std::env::var(format!("{}_DEBUG", LIB_NAME.to_uppercase())) {
+    info!("{}", message.as_ref())
+}

doh-daemon/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "doh-daemon"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+log = "0.4.17"
+env_logger = "0.11.8"
+zbus = { version = "5.9.0", features = ["tokio"] }
+zvariant = "5.6.0"
+zvariant_derive = "5.6.0"
+tokio = { version = "1", features = ["full"] }
+serde_json = "1.0"
+serde = { version = "1", features = ["derive"] }
+libnss = { path = "../libnss" }
+doh-common = {path = "../doh-common"}
+punycode = "0.4.1"
+sqlite = "0.37.0"
+reqwest = { version =  "0.12.23", features = ["gzip","json", "brotli"] }
+configparser = "3.1.0"

doh-daemon/config.ini

@@ -0,0 +1,6 @@
+[sqlite]
+connection=test.db
+
+[resolver]
+provider=google
+ttl=500

doh-daemon/src/client/mod.rs

@@ -0,0 +1,115 @@
+use std::net::{IpAddr, SocketAddr};
+use log::{debug, trace};
+use reqwest::Url;
+use serde::de::DeserializeOwned;
+
+
+
+pub async fn request<'de, B>(
+                                server_address: IpAddr,
+                             port: u16,
+                             url: &str,
+                             headers: &Vec<(&str, &str)>,
+                             query_params: &Vec<(&str, &str)>) -> Result<B, doh_common::error::Error>
+where B: DeserializeOwned {
+
+    let address = SocketAddr::new(server_address, port);
+
+    let url = Url::parse(url)?;
+
+    let client = reqwest::ClientBuilder::new()
+        .resolve(url.domain().unwrap(), address)
+        .user_agent("???")
+        .brotli(true)
+        .gzip(true)
+        .build()?;
+
+    let mut request_builder = client.get(url);
+
+    for (key, value) in headers {
+        request_builder = request_builder.header(key.to_string(), value.to_string());
+    }
+
+    request_builder = request_builder.query(query_params);
+
+    let request = request_builder.build()?;
+
+    let response = client.execute(request).await?;
+
+    let status = response.status();
+
+    if status.is_success() {
+
+        //debug!("Response body: {}", body.clone());
+
+        let body = response.bytes().await?;
+
+        debug!("response body: {}", String::from_utf8_lossy(&body.to_vec()));
+
+        let obj : B = serde_json::from_slice(&body)?;
+
+        Ok(obj)
+    } else {
+
+        let body = response.bytes().await?;
+
+        debug!("response status {:?}: {:?}", status, String::from_utf8_lossy(&body.to_vec()));
+
+        Err(doh_common::error::Error::UpstreamError)
+
+    }
+}
+
+
+// pub fn request<'de, B>(server_address: IpAddr,
+//                        port: u16,
+//                        url: &str,
+//                        headers: &Vec<(&str, &str)>,
+//                        query_params: &Vec<(&str, &str)>) -> Result<B, doh_common::error::Error>
+//     where B: DeserializeOwned {
+//
+//     let address = SocketAddr::new(server_address, port);
+//
+//     let agent =  ureq::AgentBuilder::new()
+//         .user_agent("??????????????????????????")
+//         .resolver(move |addr: &str| match addr {
+//            _ => Ok(vec![address])
+//         })
+//         .build();
+//
+//     let mut request = agent.get(&url);
+//
+//     for (key, value) in headers {
+//         request = request.set(key, value);
+//     }
+//
+//     for (key, value) in query_params {
+//         request = request.query(key, value)
+//     }
+//
+//     let response = request.call()?;
+//     let status = response.status();
+//
+//     if status > 199 && status < 300 {
+//
+//         let body = response.into_string()?;
+//
+//         debug!("Response body: {}", body.clone());
+//
+//         let obj: B = serde_json::from_str::<B>(&body)
+//             .inspect_err(|er| {
+//
+//                 error!("Error deserializing: {}", er);
+//
+//             })?;
+//
+//         Ok(obj)
+//     } else {
+//
+//         let body = response.into_string()?;
+//
+//         debug!("Response status {}: {}", status, body.clone());
+//
+//         Err(doh_common::error::Error::UpstreamError)
+//     }
+// }