tun2proxy/src/virtdevice.rs

80 lines
1.8 KiB
Rust
Raw Normal View History

2021-09-02 11:30:23 +02:00
use smoltcp::phy;
use smoltcp::phy::{Device, DeviceCapabilities};
use smoltcp::time::Instant;
#[derive(Default)]
pub struct VirtualTunDevice {
capabilities: DeviceCapabilities,
inbuf: Vec<Vec<u8>>,
2023-03-20 15:34:41 +01:00
outbuf: Vec<Vec<u8>>
2021-09-02 11:30:23 +02:00
}
impl VirtualTunDevice {
2022-08-01 14:36:58 +00:00
pub fn inject_packet(&mut self, buffer: &[u8]) {
2021-09-02 11:30:23 +02:00
let vec = Vec::from(buffer);
self.inbuf.push(vec);
}
2022-08-01 14:36:58 +00:00
pub fn exfiltrate_packet(&mut self) -> Option<Vec<u8>> {
2021-09-02 11:30:23 +02:00
self.outbuf.pop()
}
}
pub struct VirtRxToken {
buffer: Vec<u8>,
}
2023-03-20 15:34:41 +01:00
impl<'a> phy::RxToken for VirtRxToken {
fn consume<R, F>(mut self, f: F) -> R
2022-08-01 14:36:58 +00:00
where
2023-03-20 15:34:41 +01:00
F: FnOnce(&mut [u8]) -> R,
2021-09-02 11:30:23 +02:00
{
f(&mut self.buffer[..])
}
}
pub struct VirtTxToken<'a>(&'a mut VirtualTunDevice);
impl<'a> phy::TxToken for VirtTxToken<'a> {
2023-03-20 15:34:41 +01:00
fn consume<R, F>(self, len: usize, f: F) -> R
2022-08-01 14:36:58 +00:00
where
2023-03-20 15:34:41 +01:00
F: FnOnce(&mut [u8]) -> R,
2021-09-02 11:30:23 +02:00
{
let mut buffer = vec![0; len];
let result = f(&mut buffer);
2022-08-01 14:36:58 +00:00
self.0.outbuf.push(buffer);
2021-09-02 11:30:23 +02:00
result
}
}
2023-03-20 15:34:41 +01:00
impl Device for VirtualTunDevice {
type RxToken<'a> = VirtRxToken;
type TxToken<'a> = VirtTxToken<'a>;
2021-09-02 11:30:23 +02:00
2023-03-20 15:34:41 +01:00
fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
2021-09-02 11:30:23 +02:00
if let Some(buffer) = self.inbuf.pop() {
let rx = Self::RxToken { buffer };
let tx = VirtTxToken(self);
return Some((rx, tx));
}
None
}
2023-03-20 15:34:41 +01:00
fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
2021-09-02 11:30:23 +02:00
return Some(VirtTxToken(self));
}
fn capabilities(&self) -> DeviceCapabilities {
self.capabilities.clone()
}
}
2023-03-20 15:34:41 +01:00
impl<'a> VirtualTunDevice {
2021-09-02 11:30:23 +02:00
pub fn new(capabilities: DeviceCapabilities) -> Self {
Self {
capabilities,
..Default::default()
}
}
2022-08-01 14:36:58 +00:00
}