shadowsocks-service 1.25.0

shadowsocks is a fast tunnel proxy that helps you bypass firewalls.
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

//! DNS request processor

use std::io;

use hickory_resolver::proto::{
    op::{Message, MessageType, OpCode, ResponseCode, UpdateMessage},
    rr::{
        DNSClass, RData, Record, RecordType,
        rdata::{A, AAAA},
    },
};
use log::{debug, trace, warn};

use super::manager::FakeDnsManager;

pub async fn handle_dns_request(req_message: &Message, manager: &FakeDnsManager) -> io::Result<Message> {
    let mut rsp_message = Message::response(req_message.id(), req_message.op_code);

    if req_message.op_code != OpCode::Query || req_message.message_type != MessageType::Query {
        rsp_message.metadata.response_code = ResponseCode::NotImp;
    } else {
        for query in req_message.queries.iter() {
            // Copy all the queries into response.
            rsp_message.add_query(query.clone());

            if query.query_class() != DNSClass::IN {
                // let record = Record::<RData>::from_rdata(query.name().clone(), 0, query.query_type());
                // rsp_message.add_answer(record);
                warn!(
                    "Query class: {:?} is not supported. Full {:?}",
                    query.query_class(),
                    req_message
                );
                continue;
            }

            match query.query_type() {
                RecordType::A => {
                    let (ip_addr, expire_duration) = manager.map_domain_ipv4(query.name()).await?;

                    let mut record = Record::<RData>::from_rdata(
                        query.name().clone(),
                        expire_duration.as_secs() as u32,
                        RData::A(A(ip_addr)),
                    );
                    record.dns_class = query.query_class();
                    rsp_message.add_answer(record);
                }
                RecordType::AAAA => {
                    let (ip_addr, expire_duration) = manager.map_domain_ipv6(query.name()).await?;

                    let mut record = Record::<RData>::from_rdata(
                        query.name().clone(),
                        expire_duration.as_secs() as u32,
                        RData::AAAA(AAAA(ip_addr)),
                    );
                    record.dns_class = query.query_class();
                    rsp_message.add_answer(record);
                }
                _ => {
                    debug!("fakedns {} not supported. {:?}", query.query_type(), query);
                }
            }
        }
    }

    trace!("QUERY {:?} ANSWER {:?}", req_message, rsp_message);

    Ok(rsp_message)
}