dominion-chat 0.1.0

DNS chat server for fun and profit
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

#![forbid(unsafe_code)]
#![warn(rust_2018_idioms, missing_debug_implementations)]

use argh::FromArgs;
use dominion::{DnsPacket, Name, QType, Server, ServerService};
use owo_colors::OwoColorize;
use std::net::{IpAddr, SocketAddr};

mod a;

#[derive(Clone, Debug, FromArgs)]
/// Receive DNS messages from the world
struct ChatArgs {
    /// number of threads in the thread pool
    #[argh(option, short = 't', default = "num_cpus::get()")]
    threads: usize,
    /// UDP port to listen to
    #[argh(option, short = 'p', default = "54")]
    port: u16,
    /// ip to listen to
    #[argh(option, short = 'i', default = "any_ip()")]
    ip: IpAddr,
    /// domain name to use as a filter
    #[argh(option, short = 'd')]
    domain: Option<String>,
}

fn main() {
    let args: ChatArgs = argh::from_env();

    let name = match args.domain {
        Some(domain) => domain,
        None => "".to_string(),
    };

    let name = match Name::try_from(name.as_ref()) {
        Ok(name) => name,
        Err(_) => {
            eprintln!(
                "{}: could not parse the domain name because some label is too big.",
                "ERROR".red()
            );
            std::process::exit(1)
        }
    };

    let chat = Chat::new(name);

    Server::default()
        .threads(args.threads)
        .bind((args.ip, args.port).into())
        .unwrap()
        .serve(chat)
}

struct Chat<'a>(Name<'a>);

impl<'a> Chat<'a> {
    fn new(name: Name<'a>) -> Self {
        Chat(name)
    }
}

impl ServerService for Chat<'_> {
    fn run<'b>(&self, client: SocketAddr, question: DnsPacket<'b>) -> DnsPacket<'b> {
        if question.header.questions > 0 {
            match question.questions[0].qtype {
                QType::A => a::response(client, question, &self.0),
                _ => todo!("Implement missing Question Types"),
            }
        } else {
            todo!("Implement case without questions")
        }
    }
}

fn any_ip() -> IpAddr {
    "0.0.0.0".parse().unwrap()
}