ts_ffi 0.2.0

c ffi bindings for tailscale-rs
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

use std::ffi;

use crate::TOKIO_RUNTIME;

/// A Tailscale TCP listener handle.
pub struct tcp_listener(tailscale::TcpListener);

/// A Tailscale TCP stream handle.
pub struct tcp_stream(tailscale::TcpStream);

/// Start a TCP listener on the given `addr`.
///
/// Returns null if the listener couldn't be created.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_listen(
    dev: &crate::device,
    addr: &crate::sockaddr,
) -> Option<Box<tcp_listener>> {
    let addr = addr.try_into().ok()?;

    match TOKIO_RUNTIME.block_on(dev.0.tcp_listen(addr)) {
        Ok(sock) => Some(Box::new(tcp_listener(sock))),
        Err(e) => {
            tracing::error!(err = %e, "tcp listen");
            None
        }
    }
}

/// Accept an incoming connection on the given listener.
///
/// Returns null if there was an error.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_accept(listener: &tcp_listener) -> Option<Box<tcp_stream>> {
    match listener.0.accept_blocking() {
        Ok(sock) => Some(Box::new(tcp_stream(sock))),
        Err(e) => {
            tracing::error!(err = %e, "tcp accept");
            None
        }
    }
}

/// Get the local endpoint `listener` is listening on.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_listener_local_addr(listener: &tcp_listener) -> crate::sockaddr {
    listener.0.local_addr().into()
}

/// Close the specified socket.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_close_listener(sock: Box<tcp_listener>) {
    drop(sock)
}

/// Open a TCP connection to the specified `remote`.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_connect(
    dev: &crate::device,
    remote: &crate::sockaddr,
) -> Option<Box<tcp_stream>> {
    let addr = remote.try_into().ok()?;

    match TOKIO_RUNTIME.block_on(dev.0.tcp_connect(addr)) {
        Ok(sock) => Some(Box::new(tcp_stream(sock))),
        Err(e) => {
            tracing::error!(err = %e, "binding sock");
            None
        }
    }
}

/// Send bytes to the specified socket, blocking until at least one byte is sent.
///
/// Returns the number of bytes written, or a negative number if an error occurred. This is
/// guaranteed to be less than or equal to `len`.
///
/// # Safety
///
/// `buf` must be safe to convert into a Rust slice of length `len` (see
/// [`core::slice::from_raw_parts`]).
#[unsafe(no_mangle)]
pub unsafe extern "C" fn ts_tcp_send(
    stream: &tcp_stream,
    buf: *const u8,
    len: usize,
) -> ffi::c_int {
    // SAFETY: ensured by function precondition
    let b = unsafe { core::slice::from_raw_parts(buf, len) };

    match stream.0.send_blocking(b) {
        Err(e) => {
            tracing::error!(err = %e, "tcp accept");
            -1
        }
        Ok(n) => n as _,
    }
}

/// Receive bytes from the specified socket, blocking until at least one byte is received.
///
/// Returns the number of bytes read, or a negative number if an error occurred. This is
/// guaranteed to be less than or equal to `len`.
///
/// # Safety
///
/// `buf` must be safe to convert into a mutable Rust slice of length `len` (see
/// [`core::slice::from_raw_parts_mut`]).
#[unsafe(no_mangle)]
pub unsafe extern "C" fn ts_tcp_recv(stream: &tcp_stream, buf: *mut u8, len: usize) -> ffi::c_int {
    // SAFETY: ensured by function precondition
    let b = unsafe { core::slice::from_raw_parts_mut(buf, len) };

    match stream.0.recv_blocking(b) {
        Err(e) => {
            tracing::error!(err = %e, "tcp accept");
            -1
        }
        Ok(read) => read as _,
    }
}

/// Get the local endpoint for this TCP stream.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_local_addr(stream: &tcp_stream) -> crate::sockaddr {
    stream.0.local_addr().into()
}

/// Get the remote endpoint this TCP stream is connected to.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_remote_addr(stream: &tcp_stream) -> crate::sockaddr {
    stream.0.remote_addr().into()
}

/// Close the specified socket.
#[unsafe(no_mangle)]
pub extern "C" fn ts_tcp_close(sock: Box<tcp_stream>) {
    drop(sock);
}