domain 0.12.0

A DNS library for 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

//! Provide server-side of datagram protocols
use std::boxed::Box;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::sync::Mutex as SyncMutex;
use std::task::{Context, Poll, Waker};
use std::vec::Vec;

use tokio::io::ReadBuf;

use crate::base::message_builder::AdditionalBuilder;
use crate::base::Message;
use crate::net::client::protocol::{
    AsyncConnect, AsyncDgramRecv, AsyncDgramSend,
};

use super::client::CurrStepValue;
use super::parse_stelline::Stelline;
use super::server::do_server;

#[derive(Clone, Debug)]
pub struct Dgram {
    stelline: Stelline,
    step_value: Arc<CurrStepValue>,
}

impl Dgram {
    pub fn new(stelline: Stelline, step_value: Arc<CurrStepValue>) -> Self {
        Self {
            stelline,
            step_value,
        }
    }
}

impl AsyncConnect for Dgram {
    type Connection = DgramConnection;
    type Fut = Pin<
        Box<
            dyn Future<Output = Result<Self::Connection, std::io::Error>>
                + Send
                + Sync,
        >,
    >;
    fn connect(&self) -> Self::Fut {
        let stelline = self.stelline.clone();
        let step_value = self.step_value.clone();
        Box::pin(
            async move { Ok(DgramConnection::new(stelline, step_value)) },
        )
    }
}

pub struct DgramConnection {
    stelline: Stelline,
    step_value: Arc<CurrStepValue>,

    reply: SyncMutex<Option<AdditionalBuilder<Vec<u8>>>>,
    waker: SyncMutex<Option<Waker>>,
}

impl DgramConnection {
    fn new(stelline: Stelline, step_value: Arc<CurrStepValue>) -> Self {
        Self {
            stelline,
            step_value,
            reply: SyncMutex::new(None),
            waker: SyncMutex::new(None),
        }
    }
}
impl AsyncDgramRecv for DgramConnection {
    fn poll_recv(
        &self,
        cx: &mut Context<'_>,
        buf: &mut ReadBuf<'_>,
    ) -> Poll<Result<(), std::io::Error>> {
        let mut reply = self.reply.lock().unwrap();
        if (*reply).is_some() {
            let slice = (*reply).as_ref().unwrap().as_slice();
            buf.put_slice(slice);
            *reply = None;
            return Poll::Ready(Ok(()));
        }
        *reply = None;
        let mut waker = self.waker.lock().unwrap();
        *waker = Some(cx.waker().clone());
        Poll::Pending
    }
}

impl AsyncDgramSend for DgramConnection {
    fn poll_send(
        &self,
        _: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<Result<usize, std::io::Error>> {
        let msg = Message::from_octets(buf).unwrap();
        let opt_reply = do_server(&msg, &self.stelline, &self.step_value);
        let len = buf.len();
        if opt_reply.is_some() {
            // Do we need to support more than one reply?
            let mut reply = self.reply.lock().unwrap();
            *reply = opt_reply;
            drop(reply);
            let mut waker = self.waker.lock().unwrap();
            let opt_waker = (*waker).take();
            drop(waker);
            if let Some(waker) = opt_waker {
                waker.wake();
            }
        }
        Poll::Ready(Ok(len))
    }
}