ftnet 0.1.0

FTNet: FifthTry Network
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

pub async fn run(ep: iroh::Endpoint, _fastn_port: u16) -> eyre::Result<()> {
    loop {
        println!("waiting for incoming connection");
        let conn = match ep.accept().await {
            Some(conn) => conn,
            None => {
                println!("no connection");
                break;
            }
        };
        println!("got connection");
        tokio::spawn(async move {
            let start = std::time::Instant::now();
            if let Err(e) = handle_connection(conn).await {
                eprintln!("connection error: {:?}", e);
            }
            println!("connection handled in {:?}", start.elapsed());
        });
    }

    ep.close().await;
    Ok(())
}

async fn handle_connection(conn: iroh::endpoint::Incoming) -> eyre::Result<()> {
    let conn = conn.await?;
    let remote_node_id = match conn.remote_node_id() {
        Ok(id) => id,
        Err(e) => {
            eprintln!("could not read remote node id: {e}, closing connection");
            // TODO: is this how we close the connection in error cases or do we send some error
            //       and wait for other side to close the connection?
            let e2 = conn.closed().await;
            println!("connection closed: {e2}");
            // TODO: send another error_code to indicate bad remote node id?
            conn.close(0u8.into(), &[]);
            return Err(eyre::anyhow!("could not read remote node id: {e}"));
        }
    };
    println!("new client: {remote_node_id:?}");
    loop {
        let (mut send_stream, mut recv_stream) = conn.accept_bi().await?;
        let msg = recv_stream.read_to_end(1024).await?;
        match ftnet::Protocol::parse(&msg) {
            Ok((ftnet::Protocol::Quit, rest)) => {
                if !rest.is_empty() {
                    send_stream
                        .write_all(b"error: quit message should not have payload\n")
                        .await?;
                } else {
                    send_stream.write_all(b"see you later!\n").await?;
                }
                send_stream.finish()?;
                break;
            }
            Ok((ftnet::Protocol::Ping, rest)) => {
                if !rest.is_empty() {
                    send_stream
                        .write_all(b"error: ping message should not have payload\n")
                        .await?;
                    break;
                }
                send_stream.write_all(ftnet::client::PONG).await?;
            }
            Ok((ftnet::Protocol::WhatTimeIsIt, rest)) => {
                if !rest.is_empty() {
                    send_stream
                        .write_all(b"error: quit message should not have payload\n")
                        .await?;
                } else {
                    let d = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)?;

                    send_stream
                        .write_all(format!("{}\n", d.as_nanos()).as_bytes())
                        .await?;
                }
                send_stream.finish()?;
                break;
            }
            Ok((ftnet::Protocol::Identity, _)) => todo!(),
            Ok((ftnet::Protocol::Http { .. }, _)) => todo!(),
            Ok((ftnet::Protocol::Socks5 { .. }, _)) => todo!(),
            Ok((ftnet::Protocol::Tcp { id }, _)) => {
                if let Err(e) =
                    ftnet::server::tcp(&remote_node_id, &id, &mut send_stream, recv_stream).await
                {
                    eprintln!("tcp error: {e}");
                    send_stream.finish()?;
                }
            }
            Err(e) => {
                eprintln!("error parsing protocol: {e}");
                send_stream.write_all(b"error: invalid protocol\n").await?;
                send_stream.finish()?;
                break;
            }
        };
        send_stream.finish()?;
    }

    let e = conn.closed().await;
    println!("connection closed by peer: {e}");
    conn.close(0u8.into(), &[]);
    Ok(())
}