rings-node 0.20.0

Rings is a structured peer-to-peer network implementation using WebRTC, Chord algorithm, and full WebAssembly (WASM) support.
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

use rings_core::ecc::PublicKey;

use super::*;
use crate::onion::circuit::OnionBackwardPath;

struct ClientReturnPath {
    runtime: Arc<OnionTcpRuntime>,
    scope: Scope,
    path: OnionCircuitPath,
    client_return: OnionClientReturn,
}

#[async_trait::async_trait]
impl pump::TcpDuplexEffects for ClientReturnPath {
    async fn send(&mut self, payload: OnionTcpPayload) -> Result<()> {
        send_client_payload(
            &self.runtime.link_sender,
            &self.scope,
            &self.path,
            self.client_return,
            payload,
        )
        .await
    }

    fn remote_failed(&mut self, failure: &OnionExitFailure) {
        tracing::warn!("onion TCP client stream failed: {failure}");
    }
}

pub(super) fn spawn_client_stream<S>(
    runtime: Arc<OnionTcpRuntime>,
    scope: Scope,
    key: TcpStreamKey,
    stream: S,
    path: OnionCircuitPath,
    client_return: OnionClientReturn,
    rx: mpsc::Receiver<TcpInbound>,
) where
    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
{
    tokio::spawn(async move {
        let mut return_path = ClientReturnPath {
            runtime: runtime.clone(),
            scope,
            path,
            client_return,
        };
        pump::pump_tcp_duplex(stream, rx, &mut return_path).await;
        runtime.remove_client_stream(key);
    });
}

async fn send_client_payload(
    link_sender: &OnionLinkSender,
    scope: &Scope,
    path: &OnionCircuitPath,
    client_return: OnionClientReturn,
    payload: OnionTcpPayload,
) -> Result<()> {
    let payload = encode_tcp_payload(path.service_name(), payload)?;
    let (first_link, payload) = path.encode_forward(client_return, payload)?;
    link_sender
        .send_sealed(scope.clone(), first_link, payload)
        .await
}

pub(super) struct TcpBackwardRoute<'route> {
    pub(super) link_sender: &'route OnionLinkSender,
    pub(super) scope: &'route Scope,
    pub(super) signer: &'route SessionSk,
    pub(super) service: &'route OnionServiceName,
    pub(super) circuit_id: OnionCircuitId,
    pub(super) return_peer: Did,
    pub(super) return_session_public_key: PublicKey<33>,
    pub(super) client: OnionClientReturn,
}

impl TcpBackwardRoute<'_> {
    pub(super) async fn send(
        self,
        sequence: OnionBackwardSequence,
        payload: OnionTcpPayload,
    ) -> Result<()> {
        send_backward(
            self.link_sender,
            self.scope,
            self.signer,
            OnionBackwardPath::new(
                self.circuit_id,
                self.return_peer,
                self.return_session_public_key,
                self.client,
            ),
            sequence,
            encode_tcp_payload(self.service, payload)?,
        )
        .await
    }
}