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

use std::{
    collections::VecDeque,
    sync::{Arc, Mutex},
};

use twizzler_async::FlagBlock;

use crate::{
    link::ethernet::{EthernetAddr, EthernetError},
    link::nic::{NetworkInterface, NicBuffer, SendableBuffer},
};

struct LoopbackInner {
    buffer: VecDeque<Arc<NicBuffer>>,
}

pub(super) struct Loopback {
    inner: Mutex<LoopbackInner>,
    flag: FlagBlock,
}

impl Loopback {
    pub(super) fn new() -> Self {
        Self {
            inner: Mutex::new(LoopbackInner {
                buffer: VecDeque::new(),
            }),
            flag: FlagBlock::new(),
        }
    }
}

#[async_trait::async_trait]
impl NetworkInterface for Loopback {
    fn get_ethernet_addr(&self) -> EthernetAddr {
        EthernetAddr::from([0; 6])
    }

    async fn send_ethernet(
        &self,
        header_buffer: NicBuffer,
        buffers: &[SendableBuffer],
    ) -> Result<(), EthernetError> {
        // yeah i know this is really slow
        let mut inner = self.inner.lock().unwrap();
        let slice = header_buffer.as_bytes();
        let total_len = buffers.iter().fold(0usize, |t, b| t + b.as_bytes().len()) + slice.len();
        let mut nb = NicBuffer::allocate(total_len);
        let nb_bytes = nb.as_bytes_mut();
        nb_bytes[0..slice.len()].copy_from_slice(slice);
        let mut off = slice.len();
        for buffer in buffers {
            let slice = buffer.as_bytes();
            nb_bytes[off..(off + slice.len())].copy_from_slice(slice);
            off += slice.len();
        }
        inner.buffer.push_back(Arc::new(nb));
        self.flag.signal_all();
        Ok(())
    }

    async fn recv_ethernet(&self) -> Result<Vec<Arc<NicBuffer>>, EthernetError> {
        loop {
            let fut = {
                let mut inner = self.inner.lock().unwrap();
                if !inner.buffer.is_empty() {
                    let mut v = vec![];
                    while let Some(buf) = inner.buffer.pop_front() {
                        v.push(buf);
                    }
                    return Ok(v);
                }

                self.flag.wait()
            };
            fut.await;
        }
    }
}