vinezombie 0.3.1

A modular IRCv3 framework
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

use super::{Handler, SelfMadeHandler};
use crate::client::ClientState;
use crate::names::cmd::{PING, PONG};
use crate::{
    client::{
        channel::{ChannelSpec, Sender, SenderRef},
        queue::QueueEditGuard,
    },
    ircmsg::{ClientMsg, ServerMsg},
    string::Arg,
};
use std::time::Instant;

/// [`Handler`] that pings the server and yields the duration it took.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub struct Ping(pub std::time::Instant);

impl Default for Ping {
    fn default() -> Self {
        Ping(std::time::Instant::now())
    }
}

impl Handler for Ping {
    type Value = (Option<crate::ircmsg::Source<'static>>, std::time::Duration);

    fn handle(
        &mut self,
        msg: &ServerMsg<'_>,
        _: &mut ClientState,
        _: QueueEditGuard<'_>,
        mut channel: SenderRef<'_, Self::Value>,
    ) -> std::ops::ControlFlow<()> {
        if msg.kind == PONG {
            if let Some(last) = msg.args.split_last().1 {
                let hash = crate::util::mangle(&self.0);
                let mut value: u32 = 0;
                for byte in last.as_bytes().iter().cloned() {
                    if !(b'0'..=b'7').contains(&byte) {
                        return std::ops::ControlFlow::Continue(());
                    }
                    value <<= 3;
                    value |= (byte - b'0') as u32;
                }
                if hash == value {
                    let duration = Instant::now().saturating_duration_since(self.0);
                    let source = msg.source.clone().map(crate::ircmsg::SharedSource::owning_merged);
                    channel.send((source, duration));
                    return std::ops::ControlFlow::Break(());
                }
            }
        }
        std::ops::ControlFlow::Continue(())
    }
}

impl SelfMadeHandler for Ping {
    type Receiver<Spec: ChannelSpec> = Spec::Oneshot<Self::Value>;

    fn queue_msgs(&self, _: &ClientState, mut queue: QueueEditGuard<'_>) {
        let mut msg = ClientMsg::new(PING);
        let hash = crate::util::mangle(&self.0);
        let hash: Arg<'static> = format!("{hash:o}").try_into().unwrap();
        msg.args.edit().add_word(hash);
        queue.push(msg);
    }

    fn make_channel<Spec: ChannelSpec>(
        spec: &Spec,
    ) -> (Box<dyn Sender<Value = Self::Value> + Send>, Self::Receiver<Spec>) {
        spec.new_oneshot()
    }
}

pub(crate) fn pong(
    msg: &ServerMsg<'_>,
    mut queue: impl crate::client::ClientMsgSink<'static>,
) -> bool {
    let retval = msg.kind == PING;
    if retval {
        let mut reply = ClientMsg::new(PONG);
        if let Some(last) = msg.args.split_last().1 {
            reply.args.edit().add(last.clone().owning());
        }
        queue.send(reply);
    }
    retval
}

/// Auto-replier to PING messages.
///
/// This is generally necessary on every connection to avoid being disconnected by the server.
/// Note that the included registration handler automatically responds to pings on its own,
/// as some IRCds require this to successfully register.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Default)]
pub struct AutoPong;

impl Handler for AutoPong {
    type Value = ();

    fn handle(
        &mut self,
        msg: &ServerMsg<'_>,
        _: &mut ClientState,
        mut queue: QueueEditGuard<'_>,
        _: SenderRef<'_, Self::Value>,
    ) -> std::ops::ControlFlow<()> {
        pong(msg, &mut queue);
        std::ops::ControlFlow::Continue(())
    }
}

impl SelfMadeHandler for AutoPong {
    type Receiver<Spec: ChannelSpec> = ();

    fn queue_msgs(&self, _: &ClientState, _: QueueEditGuard<'_>) {}

    fn make_channel<Spec: ChannelSpec>(
        _: &Spec,
    ) -> (Box<dyn Sender<Value = Self::Value> + Send>, Self::Receiver<Spec>) {
        (Box::<crate::client::channel::ClosedSender<_>>::default(), ())
    }
}