code
stringlengths 40
729k
| docstring
stringlengths 22
46.3k
| func_name
stringlengths 1
97
| language
stringclasses 1
value | repo
stringlengths 6
48
| path
stringlengths 8
176
| url
stringlengths 47
228
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
pub fn reset(&mut self) {
self.current_delay = self.start_delay;
} | Resets the exponential backoff so that the next delay is the start delay again. | reset | rust | mullvad/udp-over-tcp | src/exponential_backoff.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/exponential_backoff.rs | Apache-2.0 |
pub fn next_delay(&mut self) -> Duration {
let delay = self.current_delay;
let next_delay = self.current_delay * 2;
self.current_delay = cmp::min(next_delay, self.max_delay);
delay
} | Returns the next delay. This is twice as long as the last returned delay,
up until `max_delay` is reached. | next_delay | rust | mullvad/udp-over-tcp | src/exponential_backoff.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/exponential_backoff.rs | Apache-2.0 |
pub async fn process_udp_over_tcp(
udp_socket: UdpSocket,
tcp_stream: TcpStream,
tcp_recv_timeout: Option<Duration>,
) {
let udp_in = Arc::new(udp_socket);
let udp_out = udp_in.clone();
let (tcp_in, tcp_out) = tcp_stream.into_split();
let tcp2udp = async move {
if let Err(error) = process_tcp2udp(tcp_in, udp_out, tcp_recv_timeout).await {
log::error!("Error: {}", error.display("\nCaused by: "));
}
};
let udp2tcp = async move {
let Err(error) = process_udp2tcp(udp_in, tcp_out).await;
log::error!("Error: {}", error.display("\nCaused by: "));
};
pin_mut!(tcp2udp);
pin_mut!(udp2tcp);
// Wait until the UDP->TCP or TCP->UDP future terminates.
select(tcp2udp, udp2tcp).await;
} | Forward traffic between the given UDP and TCP sockets in both directions.
This async function runs until one of the sockets are closed or there is an error.
Both sockets are closed before returning. | process_udp_over_tcp | rust | mullvad/udp-over-tcp | src/forward_traffic.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/forward_traffic.rs | Apache-2.0 |
async fn process_tcp2udp(
mut tcp_in: TcpReadHalf,
udp_out: Arc<UdpSocket>,
tcp_recv_timeout: Option<Duration>,
) -> Result<(), Box<dyn std::error::Error>> {
let mut buffer = datagram_buffer();
// `buffer` has unprocessed data from the TCP socket up until this index.
let mut unprocessed_i = 0;
loop {
let tcp_read_len =
maybe_timeout(tcp_recv_timeout, tcp_in.read(&mut buffer[unprocessed_i..]))
.await
.context("Timeout while reading from TCP")?
.context("Failed reading from TCP")?;
if tcp_read_len == 0 {
break;
}
unprocessed_i += tcp_read_len;
let processed_i = forward_datagrams_in_buffer(&udp_out, &buffer[..unprocessed_i])
.await
.context("Failed writing to UDP")?;
// If we have read data that was not forwarded, because it was not a complete datagram,
// move it to the start of the buffer and start over
if unprocessed_i > processed_i {
buffer.copy_within(processed_i..unprocessed_i, 0);
}
unprocessed_i -= processed_i;
}
log::debug!("TCP socket closed");
Ok(())
} | Reads from `tcp_in` and extracts UDP datagrams. Writes the datagrams to `udp_out`.
Returns if the TCP socket is closed, or an IO error happens on either socket. | process_tcp2udp | rust | mullvad/udp-over-tcp | src/forward_traffic.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/forward_traffic.rs | Apache-2.0 |
async fn forward_datagrams_in_buffer(udp_out: &UdpSocket, buffer: &[u8]) -> io::Result<usize> {
let mut unprocessed_buffer = buffer;
loop {
let Some((datagram_data, tail)) = split_first_datagram(unprocessed_buffer) else {
// The buffer does not contain the entire datagram
break Ok(buffer.len() - unprocessed_buffer.len());
};
let udp_write_len = udp_out.send(datagram_data).await?;
assert_eq!(
udp_write_len,
datagram_data.len(),
"Did not send entire UDP datagram"
);
log::trace!("Forwarded {} bytes TCP->UDP", datagram_data.len());
unprocessed_buffer = tail;
}
} | Forward all complete datagrams in `buffer` to `udp_out`.
Returns the number of processed bytes. | forward_datagrams_in_buffer | rust | mullvad/udp-over-tcp | src/forward_traffic.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/forward_traffic.rs | Apache-2.0 |
fn split_first_datagram(buffer: &[u8]) -> Option<(&[u8], &[u8])> {
let (header, tail) = buffer.split_first_chunk::<HEADER_LEN>()?;
let datagram_len = usize::from(u16::from_be_bytes(*header));
tail.split_at_checked(datagram_len)
} | Parses the header at the beginning of the `buffer` and if it contains a full
`udp-to-tcp` datagram it splits the buffer and returns the datagram data and
buffer tail as two separate slices: `(datagram_data, tail)` | split_first_datagram | rust | mullvad/udp-over-tcp | src/forward_traffic.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/forward_traffic.rs | Apache-2.0 |
async fn process_udp2tcp(
udp_in: Arc<UdpSocket>,
mut tcp_out: TcpWriteHalf,
) -> Result<Infallible, Box<dyn std::error::Error>> {
// A buffer large enough to hold any possible UDP datagram plus its 16 bit length header.
let mut buffer = datagram_buffer();
loop {
let udp_read_len = udp_in
.recv(&mut buffer[HEADER_LEN..])
.await
.context("Failed reading from UDP")?;
// Set the "header" to the length of the datagram.
let datagram_len =
u16::try_from(udp_read_len).expect("UDP datagram can't be larger than 2^16");
buffer[..HEADER_LEN].copy_from_slice(&datagram_len.to_be_bytes()[..]);
tcp_out
.write_all(&buffer[..HEADER_LEN + udp_read_len])
.await
.context("Failed writing to TCP")?;
log::trace!("Forwarded {} bytes UDP->TCP", udp_read_len);
}
} | Reads datagrams from `udp_in` and writes them (with the 16 bit header containing the length)
to `tcp_out` indefinitely, or until an IO error happens on either socket. | process_udp2tcp | rust | mullvad/udp-over-tcp | src/forward_traffic.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/forward_traffic.rs | Apache-2.0 |
pub fn new(tcp_listen_addrs: Vec<SocketAddr>, udp_forward_addr: SocketAddr) -> Self {
Options {
tcp_listen_addrs,
udp_forward_addr,
udp_bind_ip: None,
tcp_options: Default::default(),
#[cfg(feature = "statsd")]
statsd_host: None,
}
} | Creates a new [`Options`] with all mandatory fields set to the passed arguments.
All optional values are set to their default values. They can later be set, since
they are public.
# Examples
```
# use std::net::{IpAddr, Ipv4Addr, SocketAddrV4, SocketAddr};
let mut options = udp_over_tcp::tcp2udp::Options::new(
// Listen on 127.0.0.1:1234/TCP
vec![SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 1234))],
// Forward to 192.0.2.15:5001/UDP
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 0, 2, 15), 5001)),
);
// Bind the local UDP socket (used to send to 192.0.2.15:5001/UDP) to the loopback interface
options.udp_bind_ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
``` | new | rust | mullvad/udp-over-tcp | src/tcp2udp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp2udp.rs | Apache-2.0 |
pub async fn run(options: Options) -> Result<Infallible, Tcp2UdpError> {
if options.tcp_listen_addrs.is_empty() {
return Err(Tcp2UdpError::NoTcpListenAddrs);
}
let udp_bind_ip = options.udp_bind_ip.unwrap_or_else(|| {
if options.udp_forward_addr.is_ipv4() {
"0.0.0.0".parse().unwrap()
} else {
"::".parse().unwrap()
}
});
#[cfg(not(feature = "statsd"))]
let statsd = Arc::new(statsd::StatsdMetrics::dummy());
#[cfg(feature = "statsd")]
let statsd = Arc::new(match options.statsd_host {
None => statsd::StatsdMetrics::dummy(),
Some(statsd_host) => {
statsd::StatsdMetrics::real(statsd_host).map_err(Tcp2UdpError::CreateStatsdClient)?
}
});
let mut join_handles = Vec::with_capacity(options.tcp_listen_addrs.len());
for tcp_listen_addr in options.tcp_listen_addrs {
let tcp_listener = create_listening_socket(tcp_listen_addr, &options.tcp_options)?;
log::info!("Listening on {}/TCP", tcp_listener.local_addr().unwrap());
let udp_forward_addr = options.udp_forward_addr;
let tcp_recv_timeout = options.tcp_options.recv_timeout;
let tcp_nodelay = options.tcp_options.nodelay;
let statsd = Arc::clone(&statsd);
join_handles.push(tokio::spawn(async move {
process_tcp_listener(
tcp_listener,
udp_bind_ip,
udp_forward_addr,
tcp_recv_timeout,
tcp_nodelay,
statsd,
)
.await;
}));
}
futures::future::join_all(join_handles).await;
unreachable!("Listening TCP sockets never exit");
} | Sets up TCP listening sockets on all addresses in `Options::tcp_listen_addrs`.
If binding a listening socket fails this returns an error. Otherwise the function
will continue indefinitely to accept incoming connections and forward to UDP.
Errors are just logged. | run | rust | mullvad/udp-over-tcp | src/tcp2udp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp2udp.rs | Apache-2.0 |
async fn process_socket(
tcp_stream: TcpStream,
tcp_peer_addr: SocketAddr,
udp_bind_ip: IpAddr,
udp_peer_addr: SocketAddr,
tcp_recv_timeout: Option<Duration>,
) -> Result<(), Box<dyn std::error::Error>> {
let udp_bind_addr = SocketAddr::new(udp_bind_ip, 0);
let udp_socket = UdpSocket::bind(udp_bind_addr)
.await
.with_context(|_| format!("Failed to bind UDP socket to {}", udp_bind_addr))?;
udp_socket
.connect(udp_peer_addr)
.await
.with_context(|_| format!("Failed to connect UDP socket to {}", udp_peer_addr))?;
log::debug!(
"UDP socket bound to {} and connected to {}",
udp_socket
.local_addr()
.ok()
.as_ref()
.map(|item| -> &dyn fmt::Display { item })
.unwrap_or(&"unknown"),
udp_peer_addr
);
crate::forward_traffic::process_udp_over_tcp(udp_socket, tcp_stream, tcp_recv_timeout).await;
log::debug!(
"Closing forwarding for {}/TCP <-> {}/UDP",
Redact(tcp_peer_addr),
udp_peer_addr
);
Ok(())
} | Sets up a UDP socket bound to `udp_bind_ip` and connected to `udp_peer_addr` and forwards
traffic between that UDP socket and the given `tcp_stream` until the `tcp_stream` is closed.
`tcp_peer_addr` should be the remote addr that `tcp_stream` is connected to. | process_socket | rust | mullvad/udp-over-tcp | src/tcp2udp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp2udp.rs | Apache-2.0 |
pub fn kind(&self) -> ApplyTcpOptionsErrorKind {
use ApplyTcpOptionsErrorInternal::*;
match self.0 {
RecvBuffer(_) => ApplyTcpOptionsErrorKind::RecvBuffer,
SendBuffer(_) => ApplyTcpOptionsErrorKind::SendBuffer,
#[cfg(target_os = "linux")]
Mark(_) => ApplyTcpOptionsErrorKind::Mark,
TcpNoDelay(_) => ApplyTcpOptionsErrorKind::TcpNoDelay,
}
} | Returns the kind of error that happened as an enum | kind | rust | mullvad/udp-over-tcp | src/tcp_options.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp_options.rs | Apache-2.0 |
pub fn apply(socket: &TcpSocket, options: &TcpOptions) -> Result<(), ApplyTcpOptionsError> {
if let Some(recv_buffer_size) = options.recv_buffer_size {
socket
.set_recv_buffer_size(recv_buffer_size)
.map_err(ApplyTcpOptionsErrorInternal::RecvBuffer)?;
}
log::debug!(
"SO_RCVBUF: {}",
socket
.recv_buffer_size()
.map_err(ApplyTcpOptionsErrorInternal::RecvBuffer)?
);
if let Some(send_buffer_size) = options.send_buffer_size {
socket
.set_send_buffer_size(send_buffer_size)
.map_err(ApplyTcpOptionsErrorInternal::SendBuffer)?;
}
log::debug!(
"SO_SNDBUF: {}",
socket
.send_buffer_size()
.map_err(ApplyTcpOptionsErrorInternal::SendBuffer)?
);
#[cfg(target_os = "linux")]
{
if let Some(fwmark) = options.fwmark {
setsockopt(&socket, sockopt::Mark, &fwmark)
.map_err(ApplyTcpOptionsErrorInternal::Mark)?;
}
log::debug!(
"SO_MARK: {}",
getsockopt(&socket, sockopt::Mark).map_err(ApplyTcpOptionsErrorInternal::Mark)?
);
}
Ok(())
} | Applies the given options to the given TCP socket. | apply | rust | mullvad/udp-over-tcp | src/tcp_options.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp_options.rs | Apache-2.0 |
pub fn set_nodelay(tcp_stream: &TcpStream, nodelay: bool) -> Result<(), ApplyTcpOptionsError> {
// Configure TCP_NODELAY on the TCP stream
tcp_stream
.set_nodelay(nodelay)
.map_err(ApplyTcpOptionsErrorInternal::TcpNoDelay)?;
log::debug!(
"TCP_NODELAY: {}",
tcp_stream
.nodelay()
.map_err(ApplyTcpOptionsErrorInternal::TcpNoDelay)?
);
Ok(())
} | We need to apply the nodelay option separately as it is not currently exposed on TcpSocket.
=> https://github.com/tokio-rs/tokio/issues/5510 | set_nodelay | rust | mullvad/udp-over-tcp | src/tcp_options.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/tcp_options.rs | Apache-2.0 |
pub async fn new(
udp_listen_addr: SocketAddr,
tcp_forward_addr: SocketAddr,
tcp_options: crate::TcpOptions,
) -> Result<Self, Error> {
let tcp_socket = match &tcp_forward_addr {
SocketAddr::V4(..) => TcpSocket::new_v4(),
SocketAddr::V6(..) => TcpSocket::new_v6(),
}
.map_err(Error::CreateTcpSocket)?;
crate::tcp_options::apply(&tcp_socket, &tcp_options).map_err(Error::ApplyTcpOptions)?;
let udp_socket = UdpSocket::bind(udp_listen_addr)
.await
.map_err(Error::BindUdp)?;
match udp_socket.local_addr() {
Ok(addr) => log::info!("Listening on {}/UDP", addr),
Err(e) => log::error!("Unable to get UDP local addr: {}", e),
}
Ok(Self {
tcp_socket,
udp_socket,
tcp_forward_addr,
tcp_options,
})
} | Creates a TCP socket and binds to the given UDP address.
Just calling this constructor won't forward any traffic over the sockets (see `run`). | new | rust | mullvad/udp-over-tcp | src/udp2tcp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/udp2tcp.rs | Apache-2.0 |
pub async fn run(self) -> Result<(), Error> {
// Wait for the first datagram, to get the UDP peer_addr to connect to.
let mut tmp_buffer = crate::forward_traffic::datagram_buffer();
let (_udp_read_len, udp_peer_addr) = self
.udp_socket
.peek_from(tmp_buffer.as_mut())
.await
.map_err(Error::ReadUdp)?;
log::info!("Incoming connection from {}/UDP", Redact(udp_peer_addr));
log::info!("Connecting to {}/TCP", self.tcp_forward_addr);
let tcp_stream = self
.tcp_socket
.connect(self.tcp_forward_addr)
.await
.map_err(Error::ConnectTcp)?;
log::info!("Connected to {}/TCP", self.tcp_forward_addr);
crate::tcp_options::set_nodelay(&tcp_stream, self.tcp_options.nodelay)
.map_err(Error::ApplyTcpOptions)?;
// Connect the UDP socket to whoever sent the first datagram. This is where
// all the returned traffic will be sent to.
self.udp_socket
.connect(udp_peer_addr)
.await
.map_err(Error::ConnectUdp)?;
crate::forward_traffic::process_udp_over_tcp(
self.udp_socket,
tcp_stream,
self.tcp_options.recv_timeout,
)
.await;
log::debug!(
"Closing forwarding for {}/UDP <-> {}/TCP",
Redact(udp_peer_addr),
self.tcp_forward_addr,
);
Ok(())
} | Connects to the TCP address and runs the forwarding until the TCP socket is closed, or
an error occur. | run | rust | mullvad/udp-over-tcp | src/udp2tcp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/udp2tcp.rs | Apache-2.0 |
fn create_runtime(threads: Option<NonZeroU8>) -> tokio::runtime::Runtime {
let mut runtime = match threads.map(NonZeroU8::get) {
Some(1) => {
log::info!("Using a single thread");
tokio::runtime::Builder::new_current_thread()
}
Some(threads) => {
let mut runtime = tokio::runtime::Builder::new_multi_thread();
log::info!("Using {} threads", threads);
runtime.worker_threads(usize::from(threads));
runtime
}
None => tokio::runtime::Builder::new_multi_thread(),
};
runtime.enable_time();
runtime.enable_io();
runtime.build().expect("Failed to build async runtime")
} | Creates a Tokio runtime for the process to use.
If `threads` is `None` it uses the same amount of worker threads as system cores.
Creates a single threaded runtime if `threads` is `Some(1)`.
Otherwise it uses the specified number of worker threads. | create_runtime | rust | mullvad/udp-over-tcp | src/bin/tcp2udp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/src/bin/tcp2udp.rs | Apache-2.0 |
async fn setup_udp2tcp() -> Result<
(UdpSocket, TcpStream, JoinHandle<Result<(), udp2tcp::Error>>),
Box<dyn std::error::Error>,
> {
let tcp_listener = TcpListener::bind("127.0.0.1:0").await?;
let tcp_listen_addr = tcp_listener.local_addr().unwrap();
let udp2tcp = udp2tcp::Udp2Tcp::new(
"127.0.0.1:0".parse().unwrap(),
tcp_listen_addr,
TcpOptions::default(),
)
.await?;
let udp_listen_addr = udp2tcp.local_udp_addr().unwrap();
let join_handle = tokio::spawn(udp2tcp.run());
let udp_socket = UdpSocket::bind("127.0.0.1:0").await?;
udp_socket.connect(udp_listen_addr).await?;
// Send empty datagram to connect TCP socket
udp_socket.send(&[]).await?;
let mut tcp_stream = tcp_listener.accept().await?.0;
let mut buf = [0; 1024];
tcp_stream.read(&mut buf).await?;
Ok((udp_socket, tcp_stream, join_handle))
} | Spawns a Udp2Tcp instance and connects to boths ends of it.
Returns the UDP and TCP sockets that goes through it. | setup_udp2tcp | rust | mullvad/udp-over-tcp | tests/udp2tcp.rs | https://github.com/mullvad/udp-over-tcp/blob/master/tests/udp2tcp.rs | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.