libdnscheck 0.5.1

Checks DNS allow- and deny-lists
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use dbus::blocking::Connection;
use dbus::{Error as DBusError, MethodErr};

use generate_dbus_resolve1::OrgFreedesktopResolve1Manager;

use crate::{format_ip, DnsCheckError, DnsListMembership, Query};
use log::*;
use std::time::Duration;

impl From<MethodErr> for DnsCheckError {
    fn from(e: MethodErr) -> Self {
        if e.errorname()
            .starts_with("org.freedesktop.resolve1.DnsError.NXDOMAIN")
        {
            DnsCheckError::NxDomain(e.description().to_string())
        } else {
            DnsCheckError::DBus(e.errorname().to_string(), e.description().to_string())
        }
    }
}

impl From<DBusError> for DnsCheckError {
    fn from(error: DBusError) -> Self {
        MethodErr::from(error).into()
    }
}

pub fn lookup_dbus(
    source: &str,
    query: &Query,
    output: &Output,
) -> Result<DnsListMembership, DnsCheckError> {
    info!("Source: {:?}, Query: {:?}", source, query);

    let conn = Connection::new_system().map_err(|e| DnsCheckError::NoResolved(e.into()))?;
    let proxy = conn.with_proxy(
        "org.freedesktop.resolve1",
        "/org/freedesktop/resolve1",
        Duration::from_secs(30),
    );

    let queryhost = match query {
        Query::Domain(d) => format!("{}.", d),
        Query::Address(ip) => format_ip(ip),
    };

    let hostname = format!("{}{}.", queryhost, source);

    debug!("Querying: {}", hostname);

    type DBusDnsResponse = (Vec<(i32, i32, Vec<u8>)>, String, u64);
    let result: Result<DBusDnsResponse, DnsCheckError> = proxy
        .resolve_hostname(0, &hostname, libc::AF_INET, 0)
        .map_err(From::from);

    debug!("Result: {:?}", result);

    result.map_or_else(
        |error| match error {
            DnsCheckError::NxDomain(_) => Ok(DnsListMembership {
                name: format!("{}", query),
                list: source.to_string(),
                found: false,
            }),
            e => Err(e),
        },
        |r| {
            Ok(DnsListMembership {
                name: format!("{}", query),
                list: source.to_string(),
                found: !r.0.is_empty(),
            })
        },
    )
}