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
use futures::channel::mpsc::UnboundedSender;
use futures::future::Future;
use log::debug;
use rand;
use crate::error::*;
use crate::op::{Message, MessageType, OpCode, Query};
use crate::xfer::{DnsRequest, DnsRequestOptions, DnsResponse, SerialMessage};
const MAX_PAYLOAD_LEN: u16 = 1500 - 40 - 8;
pub struct StreamHandle {
sender: UnboundedSender<Vec<u8>>,
}
impl StreamHandle {
pub fn new(sender: UnboundedSender<Vec<u8>>) -> Self {
StreamHandle { sender }
}
}
pub trait DnsStreamHandle: 'static + Send {
fn send(&mut self, buffer: SerialMessage) -> Result<(), ProtoError>;
}
impl DnsStreamHandle for StreamHandle {
fn send(&mut self, buffer: SerialMessage) -> Result<(), ProtoError> {
UnboundedSender::unbounded_send(&self.sender, buffer.unwrap().0)
.map_err(|e| ProtoError::from(format!("mpsc::SendError {}", e)))
}
}
pub trait DnsHandle: 'static + Clone + Send + Sync + Unpin {
type Response: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin;
fn is_verifying_dnssec(&self) -> bool {
false
}
fn send<R: Into<DnsRequest> + Unpin + Send + 'static>(&mut self, request: R) -> Self::Response;
fn lookup(&mut self, query: Query, options: DnsRequestOptions) -> Self::Response {
debug!("querying: {} {:?}", query.name(), query.query_type());
let mut message: Message = Message::new();
let id: u16 = rand::random();
message.add_query(query);
message
.set_id(id)
.set_message_type(MessageType::Query)
.set_op_code(OpCode::Query)
.set_recursion_desired(true);
{
let edns = message.edns_mut();
edns.set_max_payload(MAX_PAYLOAD_LEN);
edns.set_version(0);
}
self.send(DnsRequest::new(message, options))
}
}