hostab 0.0.2

Your dev tool to manage /etc/hosts like a pro — written in Rust
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::cli::Cli;
use crate::store::file::Store;
use tabled::{settings::Style, Table, Tabled};

#[derive(Tabled)]
struct ResolveRow {
    #[tabled(rename = "NAME")]
    name: String,
    #[tabled(rename = "ADDR")]
    addr: String,
}

pub fn handle(cli: &Cli, hosts: &[String], local: bool) {
    if local {
        resolve_local(cli, hosts);
    } else {
        resolve_dns(hosts);
    }
}

fn resolve_dns(hosts: &[String]) {
    let (config, _opts) = match hickory_resolver::system_conf::read_system_conf() {
        Ok(c) => c,
        Err(e) => {
            eprintln!("DNS init error: {}", e);
            std::process::exit(1);
        }
    };
    let resolver = match hickory_resolver::TokioResolver::builder_with_config(
        config,
        hickory_resolver::net::runtime::TokioRuntimeProvider::default(),
    )
    .build()
    {
        Ok(r) => r,
        Err(e) => {
            eprintln!("DNS init error: {}", e);
            std::process::exit(1);
        }
    };
    let rt = tokio::runtime::Runtime::new().unwrap();
    let _guard = rt.enter();

    let mut rows = Vec::new();
    for host in hosts {
        let host_stripped = host.trim_end_matches('.');
        if host_stripped.parse::<std::net::IpAddr>().is_ok() {
            match rt.block_on(
                resolver.reverse_lookup(host_stripped.parse::<std::net::IpAddr>().unwrap()),
            ) {
                Ok(names) => {
                    for name in names.answers() {
                        rows.push(ResolveRow {
                            name: name.to_string().trim_end_matches('.').to_string(),
                            addr: host.to_string(),
                        });
                    }
                }
                Err(e) => {
                    eprintln!("{}: {}", host, e);
                }
            }
        } else {
            match rt.block_on(resolver.lookup_ip(host_stripped)) {
                Ok(addrs) => {
                    for addr in addrs.iter() {
                        rows.push(ResolveRow {
                            name: host.to_string(),
                            addr: addr.to_string(),
                        });
                    }
                }
                Err(e) => {
                    eprintln!("{}: {}", host, e);
                }
            }
        }
    }

    if rows.is_empty() {
        return;
    }
    let mut table = Table::new(&rows);
    table.with(Style::rounded());
    println!("{}", table);
}

fn resolve_local(cli: &Cli, hosts: &[String]) {
    let store = Store::new(&cli.hosts_file);
    let entries = match store.load() {
        Ok(e) => e,
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        }
    };

    let mut rows = Vec::new();
    for host in hosts {
        let host_stripped = host.trim_end_matches('.');
        if host_stripped.parse::<std::net::IpAddr>().is_ok() {
            // IP → find hostnames pointing to this IP
            for entry in &entries {
                if entry.ip == host_stripped && !entry.disabled {
                    for h in &entry.hostnames {
                        rows.push(ResolveRow {
                            name: h.clone(),
                            addr: entry.ip.clone(),
                        });
                    }
                }
            }
        } else {
            // hostname → find IPs
            for entry in &entries {
                if entry.hostnames.contains(&host_stripped.to_string()) && !entry.disabled {
                    rows.push(ResolveRow {
                        name: host.to_string(),
                        addr: entry.ip.clone(),
                    });
                }
            }
        }
    }

    if rows.is_empty() {
        println!("No local match found.");
        return;
    }
    let mut table = Table::new(&rows);
    table.with(Style::rounded());
    println!("{}", table);
}