kdeconnect-proto 0.2.0

A pure Rust modular implementation of the KDE Connect protocol
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! TCP connection response implementation.
use core::net::{IpAddr, Ipv6Addr, SocketAddr};

#[cfg(feature = "std")]
use std::sync::Arc;

#[cfg(not(feature = "std"))]
use alloc::sync::Arc;

use crate::{
    device::Device,
    io::{IoImpl, KnownFunctionName, TcpListenerImpl, TcpStreamImpl, TlsStreamImpl, UdpSocketImpl},
    packet::{NetworkPacket, NetworkPacketBody},
};

/// Start a TCP listener on a port in the range 1716-1764.
///
/// As a library user, you should ignore this function as it's only useful to develop other IO
/// backends.
///
/// If a TCP connection is made with this device, it's upgraded to a TLS connection and used to
/// send application packets.
pub async fn setup_tcp<
    Io: IoImpl<UdpSocket, TcpStream, TcpListener, TlsStream> + Unpin + 'static,
    UdpSocket: UdpSocketImpl + Unpin + 'static,
    TcpStream: TcpStreamImpl + Unpin + 'static,
    TcpListener: TcpListenerImpl<TcpStream> + Unpin + 'static,
    TlsStream: TlsStreamImpl + Unpin + 'static,
>(
    device: Arc<Device<Io, UdpSocket, TcpStream, TcpListener, TlsStream>>,
) {
    #[allow(unused_mut)]
    let (mut tcp_listener, tcp_port) = {
        let mut port = crate::config::MIN_TCP_PORT;

        loop {
            if port > crate::config::MAX_TCP_PORT {
                log::error!(
                    "No port available in {}..{}",
                    crate::config::MIN_TCP_PORT,
                    crate::config::MAX_TCP_PORT
                );
                return;
            }

            if let Ok(tcp_listener) = device
                .io_impl
                .listen_tcp(SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port))
                .await
            {
                break (tcp_listener, port);
            }

            port += 1;
        }
    };

    let _ = device.my_tcp_port.set(tcp_port).await;

    // The TCP server is initialized, launch discovery mechanisms
    super::start_discovering(Arc::clone(&device));

    loop {
        let Ok(socket) = tcp_listener.accept().await else {
            #[cfg(feature = "embedded")]
            device.io_impl.sleep(core::time::Duration::from_millis(500)).await;
            continue;
        };

        // A task is spawned per TCP-stream which will be further converted to a TLS stream
        Arc::clone(&device)
            .io_impl
            .spawn(KnownFunctionName::PerTcpStream(socket), Arc::clone(&device));

        #[cfg(feature = "embedded")]
        {
            tcp_listener = device
                .io_impl
                .listen_tcp(SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), tcp_port))
                .await
                .unwrap();
        }
    }
}

// Function which should be called when a new TCP stream is made.
///
/// As a library user, you should ignore this function as it's only useful to develop other IO
/// backends.
///
/// It upgrades the connection to a TLS connection and use it to
/// send application packets.
pub async fn per_tcp_stream<
    Io: IoImpl<UdpSocket, TcpStream, TcpListener, TlsStream> + Unpin + 'static,
    UdpSocket: UdpSocketImpl + Unpin + 'static,
    TcpStream: TcpStreamImpl + Unpin + 'static,
    TcpListener: TcpListenerImpl<TcpStream> + Unpin + 'static,
    TlsStream: TlsStreamImpl + Unpin + 'static,
>(
    mut socket: TcpStream,
    device: Arc<Device<Io, UdpSocket, TcpStream, TcpListener, TlsStream>>,
) {
    let mut i = 0;
    let mut buf = [0; crate::config::TCP_BUFFER_SIZE];

    loop {
        let Ok(bytes_read) = socket.read(&mut buf[i..]).await else {
            log::warn!(
                "TCP packet is too large, consider reading the documentation of config::TCP_BUFFER_SIZE"
            );
            i = 0;
            continue;
        };
        i += bytes_read;

        if let Ok(NetworkPacket {
            body: NetworkPacketBody::Identity(packet),
            ..
        }) = NetworkPacket::try_read_from(&buf[..i])
        {
            if device.links.lock().await.contains_key(&packet.device_id) {
                log::debug!(
                    "Device {} has already established connection, ignore the MDNS request",
                    packet.device_id
                );
                continue;
            }

            log::debug!("TCP Identity packet received, upgrading connection");

            // Upgrade to TLS as SSL client
            super::tls::upgrade_tcp_connection(packet, socket, device, true).await;

            break;
        }

        if bytes_read == 0 {
            log::warn!("tcp: Failed to parse the received JSON");
            break;
        }
    }
}