Add 'netstack/' from commit 'ad9d652062ebe90682e96cb4a80d09760f48a457'

git-subtree-dir: netstack
git-subtree-mainline: 9fae54dc2b
git-subtree-split: ad9d652062

netstack/src/dnsd/main.rs

@@ -0,0 +1,102 @@
+#[macro_use]
+extern crate log;
+
+use anyhow::{Context, Result};
+use event::EventQueue;
+use ioslice::IoSlice;
+use libredox::Fd;
+use redox_netstack::logger;
+use scheme::Dnsd;
+use std::fs::File;
+use std::os::unix::io::{FromRawFd, RawFd};
+use std::process;
+
+mod scheme;
+
+fn run(daemon: redox_daemon::Daemon) -> Result<()> {
+    use libredox::flag::*;
+
+    let dns_fd =
+        Fd::open(":dns", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :dns")?;
+
+    let time_path = format!("/scheme/time/{}", CLOCK_MONOTONIC);
+    let time_fd = Fd::open(&time_path, O_RDWR, 0).context("failed to open time")?;
+
+    let nameserver_fd = Fd::open(
+        "/scheme/netcfg/resolv/nameserver",
+        O_RDWR | O_CREAT | O_NONBLOCK,
+        0,
+    )
+    .context("failed to open nameserver")?;
+
+    let event_queue = EventQueue::<EventSource>::new().context("failed to create event queue")?;
+
+    event_queue
+        .subscribe(
+            dns_fd.raw(),
+            EventSource::DnsScheme,
+            event::EventFlags::READ,
+        )
+        .context("failed to listen to time events")?;
+    event_queue
+        .subscribe(
+            nameserver_fd.raw(),
+            EventSource::NameserverScheme,
+            event::EventFlags::READ,
+        )
+        .context("failed to listen to nameserver socket events")?;
+    event_queue
+        .subscribe(time_fd.raw(), EventSource::Timer, event::EventFlags::READ)
+        .context("failed to listen to timer events")?;
+
+    let (dns_file, time_file) = unsafe {
+        (
+            File::from_raw_fd(dns_fd.into_raw() as RawFd),
+            File::from_raw_fd(time_fd.into_raw() as RawFd),
+        )
+    };
+
+    let mut dnsd = Dnsd::new(dns_file, time_file, &event_queue);
+
+    let new_ns =
+        libredox::call::mkns(&[IoSlice::new(b"dns")]).expect("dnsd: failed to create namespace");
+    libredox::call::setrens(new_ns, new_ns).expect("dnsd: failed to enter namespace");
+
+    daemon.ready().expect("dnsd: failed to notify parent");
+
+    for event_res in event_queue.iter() {
+        let event = event_res.context("failed to read from event queue")?;
+        match event.user_data {
+            EventSource::DnsScheme => {
+                if !dnsd.on_dns_file_event()? {
+                    break;
+                }
+            }
+            EventSource::NameserverScheme => dnsd.on_nameserver_event()?,
+            EventSource::Timer => dnsd.on_time_event()?,
+            EventSource::Other => dnsd.on_unknown_fd_event(event.fd as RawFd)?,
+        }
+    }
+    Ok(())
+}
+
+fn main() {
+    redox_daemon::Daemon::new(move |daemon| {
+        logger::init_logger("dnsd");
+        if let Err(err) = run(daemon) {
+            error!("dnsd: {}", err);
+            process::exit(1);
+        }
+        process::exit(0);
+    })
+    .expect("dnsd: failed to daemonize");
+}
+
+event::user_data! {
+    enum EventSource {
+        DnsScheme,
+        NameserverScheme,
+        Timer,
+        Other,
+    }
+}

netstack/src/dnsd/scheme.rs

@@ -0,0 +1,548 @@
+use std::borrow::ToOwned;
+use std::collections::btree_map::Entry;
+use std::collections::VecDeque;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs::File;
+use std::io::{ErrorKind, Read, Write};
+use std::mem;
+use std::net::Ipv4Addr;
+use std::os::unix::io::RawFd;
+use std::rc::Rc;
+use std::str;
+use std::str::FromStr;
+
+use libredox::flag;
+use syscall;
+use syscall::data::TimeSpec;
+use syscall::{
+    Error as SyscallError, EventFlags as SyscallEventFlags, Packet as SyscallPacket,
+    Result as SyscallResult, SchemeMut,
+};
+
+use event::EventQueue;
+use redox_netstack::error::{Error, Result};
+
+use dns_parser::{Builder, Packet as DNSPacket, RRData, ResponseCode};
+use dns_parser::{QueryClass, QueryType};
+
+use crate::EventSource;
+
+enum DnsFile {
+    Resolved { data: Rc<[u8]>, pos: usize },
+    Waiting { domain: String },
+    Timeout,
+    Failed,
+}
+
+enum Domain {
+    Resolved {
+        data: Rc<[u8]>,
+    },
+    Requested {
+        waiting_fds: BTreeSet<usize>,
+        socket_fd: RawFd,
+    },
+}
+
+enum DnsParsingResult {
+    WakeUpFiles(BTreeSet<usize>),
+    FailFiles(BTreeSet<usize>),
+}
+
+struct Domains {
+    nameserver: Ipv4Addr,
+    domains: BTreeMap<Rc<str>, Domain>,
+    requests: BTreeMap<RawFd, Rc<str>>,
+    resolved_timeouts: VecDeque<(TimeSpec, Rc<str>)>,
+    requested_timeouts: VecDeque<(TimeSpec, Rc<str>)>,
+}
+
+impl Domains {
+    fn new() -> Domains {
+        let mut domains = Domains {
+            nameserver: Ipv4Addr::new(8, 8, 8, 8),
+            domains: BTreeMap::new(),
+            requests: BTreeMap::new(),
+            resolved_timeouts: VecDeque::new(),
+            requested_timeouts: VecDeque::new(),
+        };
+        domains.update_nameserver();
+        domains
+    }
+
+    pub fn update_nameserver(&mut self) {
+        if let Ok(mut file) = File::open("/scheme/netcfg/resolv/nameserver") {
+            let mut nameserver = String::new();
+            if file.read_to_string(&mut nameserver).is_ok() {
+                if let Some(line) = nameserver.lines().next() {
+                    if let Ok(ip) = Ipv4Addr::from_str(line) {
+                        trace!("Changing nameserver to {}", ip);
+                        self.nameserver = ip;
+                    }
+                }
+            }
+        }
+    }
+
+    fn request_domain(&mut self, domain: &str, queue: &EventQueue<EventSource>) -> Option<RawFd> {
+        trace!("Requesting domain {}", domain);
+        let mut builder = Builder::new_query(1, true);
+        builder.add_question(domain, QueryType::A, QueryClass::IN);
+        let packet = builder.build().ok()?;
+        let udp_fd = libredox::call::open(
+            &format!("udp:{}:53", self.nameserver),
+            libredox::flag::O_RDWR | libredox::flag::O_CREAT | libredox::flag::O_NONBLOCK,
+            0,
+        )
+        .ok()?;
+        if libredox::call::write(udp_fd, &packet) != Ok(packet.len()) {
+            libredox::call::close(udp_fd).ok()?;
+            return None;
+        }
+        queue
+            .subscribe(udp_fd, EventSource::Other, event::EventFlags::READ)
+            .ok()?;
+        self.requests
+            .insert(udp_fd as RawFd, domain.to_owned().into());
+        Some(udp_fd as RawFd)
+    }
+
+    fn on_time_event(
+        &mut self,
+        cur_time: &TimeSpec,
+        queue: &EventQueue<EventSource>,
+    ) -> Result<BTreeSet<usize>> {
+        while let Some((timeout, domain)) = self.resolved_timeouts.pop_front() {
+            if timeout.tv_sec > cur_time.tv_sec
+                || (timeout.tv_sec == cur_time.tv_sec && timeout.tv_nsec > cur_time.tv_nsec)
+            {
+                self.resolved_timeouts.push_front((timeout, domain));
+                break;
+            }
+            trace!("Timing out resolved domain {:?}", domain);
+            match self.domains.entry(domain) {
+                Entry::Vacant(_) => {}
+                Entry::Occupied(e) => {
+                    if let Domain::Resolved { .. } = *e.get() {
+                        e.remove();
+                    }
+                }
+            }
+        }
+
+        let mut fds_to_wakeup = BTreeSet::new();
+
+        while let Some((timeout, domain)) = self.requested_timeouts.pop_front() {
+            if timeout.tv_sec > cur_time.tv_sec
+                || (timeout.tv_sec == cur_time.tv_sec && timeout.tv_nsec > cur_time.tv_nsec)
+            {
+                self.requested_timeouts.push_front((timeout, domain));
+                break;
+            }
+            trace!("Timing out requested domain {:?}", domain);
+            match self.domains.entry(domain) {
+                Entry::Vacant(_) => {}
+                Entry::Occupied(e) => {
+                    if let Domain::Requested { .. } = *e.get() {
+                        if let Domain::Requested {
+                            mut waiting_fds,
+                            socket_fd,
+                        } = e.remove()
+                        {
+                            fds_to_wakeup.append(&mut waiting_fds);
+                            queue.unsubscribe(socket_fd as usize).map_err(|e| {
+                                Error::from_syscall_error(e.into(), "unsubscribe failure")
+                            })?;
+                            let _ = libredox::call::close(socket_fd as usize);
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(fds_to_wakeup)
+    }
+
+    fn on_fd_event(
+        &mut self,
+        fd: RawFd,
+        cur_time: &TimeSpec,
+        queue: &EventQueue<EventSource>,
+    ) -> Option<DnsParsingResult> {
+        let e = match self.requests.entry(fd) {
+            Entry::Vacant(_) => {
+                return None;
+            }
+            Entry::Occupied(e) => e,
+        };
+        let mut buf = [0u8; 0x1000];
+        let readed = libredox::call::read(fd as usize, &mut buf).ok()?;
+        if readed == 0 {
+            return None;
+        }
+        let pkt = DNSPacket::parse(&buf).ok()?;
+        if pkt.header.response_code != ResponseCode::NoError || pkt.answers.is_empty() {
+            if let Some(query) = pkt.questions.iter().next() {
+                if query.qname.to_string().to_lowercase() == e.get().as_ref() {
+                    queue.unsubscribe(fd as usize).ok()?;
+                    libredox::call::close(fd as usize).ok()?;
+                    let domain = e.remove();
+                    self.requested_timeouts
+                        .retain(|&(_, ref d)| d.as_ref() != domain.as_ref());
+                    if let Entry::Occupied(e) = self.domains.entry(domain) {
+                        let domain_data = e.remove();
+                        return if let Domain::Requested { waiting_fds, .. } = domain_data {
+                            Some(DnsParsingResult::FailFiles(waiting_fds))
+                        } else {
+                            None
+                        };
+                    }
+                }
+            }
+            return None;
+        }
+        let mut result = String::new();
+        for answer in pkt.answers {
+            if answer.name.to_string().to_lowercase() != e.get().as_ref() {
+                continue;
+            }
+            if let RRData::A(ip) = answer.data {
+                result += &format!("{}\n", ip);
+            }
+        }
+        if result.is_empty() {
+            return None;
+        }
+        let data = Rc::from(result.into_bytes());
+        queue.unsubscribe(fd as usize).ok()?;
+        libredox::call::close(fd as usize).ok()?;
+        let domain = e.remove();
+        let mut domain_data = Domain::Resolved { data };
+        trace!("On FD event {} {} resolved", fd, domain);
+
+        let mut resolved_timeout = *cur_time;
+        resolved_timeout.tv_sec += Dnsd::RESOLVED_TIMEOUT_S;
+
+        self.resolved_timeouts
+            .push_back((resolved_timeout, Rc::clone(&domain)));
+
+        self.requested_timeouts
+            .retain(|&(_, ref d)| d.as_ref() != domain.as_ref());
+
+        match self.domains.entry(domain) {
+            Entry::Vacant(e) => {
+                e.insert(domain_data);
+                None
+            }
+            Entry::Occupied(mut e) => {
+                mem::swap(e.get_mut(), &mut domain_data);
+                if let Domain::Requested { waiting_fds, .. } = domain_data {
+                    Some(DnsParsingResult::WakeUpFiles(waiting_fds))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    fn file_from_domain(
+        &mut self,
+        domain: &str,
+        fd: usize,
+        cur_time: &TimeSpec,
+        queue: &EventQueue<EventSource>,
+    ) -> DnsFile {
+        if let Some(domain_data) = self.domains.get_mut(domain) {
+            match *domain_data {
+                Domain::Resolved { ref data } => DnsFile::Resolved {
+                    data: Rc::clone(data),
+                    pos: 0,
+                },
+                Domain::Requested {
+                    ref mut waiting_fds,
+                    ..
+                } => {
+                    waiting_fds.insert(fd);
+                    DnsFile::Waiting {
+                        domain: domain.to_owned(),
+                    }
+                }
+            }
+        } else {
+            if let Some(socket_fd) = self.request_domain(domain, queue) {
+                let mut waiting_fds = BTreeSet::new();
+                let domain = domain.to_owned().into();
+                waiting_fds.insert(fd);
+                self.domains.insert(
+                    Rc::clone(&domain),
+                    Domain::Requested {
+                        waiting_fds,
+                        socket_fd,
+                    },
+                );
+                let mut timeout = *cur_time;
+                timeout.tv_sec += Dnsd::REQUEST_TIMEOUT_S;
+                self.requested_timeouts.push_back((timeout, domain));
+            }
+            DnsFile::Waiting {
+                domain: domain.to_owned(),
+            }
+        }
+    }
+
+    fn unwait_fd(&mut self, domain: &str, fd: usize) {
+        if let Some(domain_data) = self.domains.get_mut(domain) {
+            if let Domain::Requested {
+                ref mut waiting_fds,
+                ..
+            } = *domain_data
+            {
+                waiting_fds.remove(&fd);
+            }
+        }
+    }
+}
+
+pub struct Dnsd<'q> {
+    dns_file: File,
+    time_file: File,
+    queue: &'q EventQueue<EventSource>,
+    files: BTreeMap<usize, DnsFile>,
+    domains: Domains,
+    wait_map: BTreeMap<usize, SyscallPacket>,
+    next_fd: usize,
+}
+
+impl<'q> Dnsd<'q> {
+    const RESOLVED_TIMEOUT_S: i64 = 5 * 60;
+    const REQUEST_TIMEOUT_S: i64 = 30;
+    const TIME_EVENT_TIMEOUT_S: i64 = 5;
+
+    pub fn new(dns_file: File, time_file: File, queue: &'q EventQueue<EventSource>) -> Self {
+        Dnsd {
+            dns_file,
+            time_file,
+            queue,
+            files: BTreeMap::new(),
+            domains: Domains::new(),
+            wait_map: BTreeMap::new(),
+            next_fd: 1,
+        }
+    }
+
+    pub fn on_time_event(&mut self) -> Result<()> {
+        let mut time = TimeSpec::default();
+        if self.time_file.read(&mut time)? < mem::size_of::<TimeSpec>() {
+            return Err(Error::from_syscall_error(
+                syscall::Error::new(syscall::EBADF),
+                "Can't read current time",
+            ));
+        }
+
+        let fds_to_wakeup = self.domains.on_time_event(&time, self.queue)?;
+        if !fds_to_wakeup.is_empty() {
+            for fd in &fds_to_wakeup {
+                if let Some(file) = self.files.get_mut(fd) {
+                    *file = DnsFile::Timeout;
+                }
+            }
+            self.wakeup_fds(&fds_to_wakeup);
+        }
+
+        time.tv_sec += Dnsd::TIME_EVENT_TIMEOUT_S;
+        self.time_file
+            .write_all(&time)
+            .map_err(|e| Error::from_io_error(e, "Failed to write to time file"))?;
+        Ok(())
+    }
+
+    pub fn on_dns_file_event(&mut self) -> Result<bool> {
+        loop {
+            let mut packet = SyscallPacket::default();
+            match self.dns_file.read(&mut packet) {
+                Ok(0) => {
+                    //TODO: Cleanup must occur
+                    return Ok(false);
+                }
+                Ok(_) => (),
+                Err(err) => {
+                    if err.kind() == ErrorKind::WouldBlock {
+                        return Ok(true);
+                    } else {
+                        return Err(Error::from(err));
+                    }
+                }
+            }
+            // TODO: implement cancellation
+            let a = packet.a;
+            self.handle(&mut packet);
+            if packet.a != (-syscall::EWOULDBLOCK) as usize {
+                self.dns_file.write_all(&packet)?;
+            } else {
+                packet.a = a;
+                self.handle_block(packet)?;
+            }
+        }
+    }
+
+    pub fn on_unknown_fd_event(&mut self, fd: RawFd) -> Result<()> {
+        trace!("Unknown fd event {}", fd);
+        let cur_time = libredox::call::clock_gettime(libredox::flag::CLOCK_MONOTONIC)
+            .map_err(|e| Error::from_syscall_error(e.into(), "Can't get time"))?;
+        // TODO
+        let cur_time = TimeSpec {
+            tv_sec: cur_time.tv_sec,
+            tv_nsec: cur_time.tv_nsec as _,
+        };
+
+        match self.domains.on_fd_event(fd, &cur_time, self.queue) {
+            Some(DnsParsingResult::FailFiles(fds_to_fail)) => {
+                for fd in &fds_to_fail {
+                    if let Some(file) = self.files.get_mut(fd) {
+                        *file = DnsFile::Failed;
+                    }
+                }
+                self.wakeup_fds(&fds_to_fail);
+            }
+            Some(DnsParsingResult::WakeUpFiles(fds_to_wakeup)) => {
+                self.wakeup_fds(&fds_to_wakeup);
+            }
+            None => {}
+        }
+        Ok(())
+    }
+
+    pub fn on_nameserver_event(&mut self) -> Result<()> {
+        self.domains.update_nameserver();
+        Ok(())
+    }
+
+    fn wakeup_fds(&mut self, fds_to_wakeup: &BTreeSet<usize>) {
+        let mut syscall_packets = vec![];
+        for fd in fds_to_wakeup {
+            if let Some(packet) = self.wait_map.remove(fd) {
+                syscall_packets.push(packet);
+            }
+        }
+
+        for mut packet in syscall_packets.drain(..) {
+            self.handle(&mut packet);
+            let _ = self.dns_file.write_all(&packet);
+        }
+    }
+
+    fn handle_block(&mut self, packet: SyscallPacket) -> Result<()> {
+        let fd = packet.b;
+        self.wait_map.insert(fd, packet);
+        Ok(())
+    }
+
+    fn validate_domain(domain: &str) -> bool {
+        if domain.len() > 256 {
+            return false;
+        }
+
+        for part in domain.split('.') {
+            if part.len() >= 63 {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
+impl SchemeMut for Dnsd<'_> {
+    fn open(&mut self, url: &str, _flags: usize, _uid: u32, _gid: u32) -> SyscallResult<usize> {
+        let domain = url.to_lowercase();
+        if domain.is_empty() || !Dnsd::validate_domain(&domain) {
+            return Err(SyscallError::new(syscall::EINVAL));
+        }
+        let fd = self.next_fd;
+        self.next_fd += 1;
+        let cur_time = libredox::call::clock_gettime(flag::CLOCK_MONOTONIC)?;
+        let dns_file = self.domains.file_from_domain(
+            &domain,
+            fd,
+            &TimeSpec {
+                tv_sec: cur_time.tv_sec,
+                tv_nsec: cur_time.tv_nsec as i32,
+            },
+            self.queue,
+        );
+        self.files.insert(fd, dns_file);
+        trace!("Open {} {}", &domain, fd);
+        Ok(fd)
+    }
+
+    fn close(&mut self, fd: usize) -> SyscallResult<usize> {
+        trace!("Close {}", fd);
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        if let DnsFile::Waiting { ref domain } = *file {
+            self.domains.unwait_fd(domain, fd);
+        }
+
+        self.files.remove(&fd);
+        Ok(0)
+    }
+
+    fn write(&mut self, _fd: usize, _buf: &[u8]) -> SyscallResult<usize> {
+        Err(SyscallError::new(syscall::EINVAL))
+    }
+
+    fn read(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult<usize> {
+        trace!("Read {}", fd);
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        let cur_time = libredox::call::clock_gettime(flag::CLOCK_MONOTONIC)?;
+
+        if let DnsFile::Waiting { ref domain } = *file {
+            *file = self.domains.file_from_domain(
+                domain,
+                fd,
+                &TimeSpec {
+                    tv_sec: cur_time.tv_sec,
+                    tv_nsec: cur_time.tv_nsec as i32,
+                },
+                self.queue,
+            );
+        }
+
+        match *file {
+            DnsFile::Resolved {
+                ref data,
+                ref mut pos,
+            } => {
+                let mut i = 0;
+                while i < buf.len() && *pos < data.len() {
+                    buf[i] = data[*pos];
+                    i += 1;
+                    *pos += 1;
+                }
+                Ok(i)
+            }
+            DnsFile::Waiting { .. } => Err(SyscallError::new(syscall::EWOULDBLOCK)),
+            DnsFile::Timeout => Err(SyscallError::new(syscall::ETIMEDOUT)),
+            DnsFile::Failed => Err(SyscallError::new(syscall::ENODATA)),
+        }
+    }
+
+    fn fevent(
+        &mut self,
+        _fd: usize,
+        _events: SyscallEventFlags,
+    ) -> SyscallResult<SyscallEventFlags> {
+        Ok(SyscallEventFlags::empty())
+    }
+
+    fn fsync(&mut self, _fd: usize) -> SyscallResult<usize> {
+        Ok(0)
+    }
+}

netstack/src/lib/error.rs

@@ -0,0 +1,66 @@
+use std::convert;
+use std::fmt;
+use std::io::Error as IOError;
+use std::result;
+use syscall::error::Error as SyscallError;
+
+#[derive(Debug)]
+enum ErrorType {
+    Syscall(SyscallError),
+    IOError(IOError),
+    Other,
+}
+
+#[derive(Debug)]
+pub struct Error {
+    error_type: ErrorType,
+    descr: String,
+}
+
+impl Error {
+    pub fn from_syscall_error<S: Into<String>>(syscall_error: SyscallError, descr: S) -> Error {
+        Error {
+            error_type: ErrorType::Syscall(syscall_error),
+            descr: descr.into(),
+        }
+    }
+
+    pub fn from_io_error<S: Into<String>>(io_error: IOError, descr: S) -> Error {
+        Error {
+            error_type: ErrorType::IOError(io_error),
+            descr: descr.into(),
+        }
+    }
+
+    pub fn other_error<S: Into<String>>(descr: S) -> Error {
+        Error {
+            error_type: ErrorType::Other,
+            descr: descr.into(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
+        match self.error_type {
+            ErrorType::Syscall(ref syscall_error) => {
+                write!(f, "{}: syscall error: {}", self.descr, syscall_error)
+            }
+            ErrorType::IOError(ref io_error) => {
+                write!(f, "{} : io error : {}", self.descr, io_error)
+            }
+            ErrorType::Other => {
+                write!(f, "{}", self.descr)
+            }
+        }
+    }
+}
+impl std::error::Error for Error {}
+
+impl convert::From<IOError> for Error {
+    fn from(e: IOError) -> Self {
+        Error::from_io_error(e, "")
+    }
+}
+
+pub type Result<T> = result::Result<T, Error>;

netstack/src/lib/lib.rs

@@ -0,0 +1,2 @@
+pub mod error;
+pub mod logger;

netstack/src/lib/logger.rs

@@ -0,0 +1,17 @@
+use redox_log::{OutputBuilder, RedoxLogger};
+
+pub fn init_logger(process_name: &str) {
+    if let Err(_) = RedoxLogger::new()
+        .with_output(
+            OutputBuilder::stdout()
+                .with_ansi_escape_codes()
+                .flush_on_newline(true)
+                .with_filter(log::LevelFilter::Trace)
+                .build(),
+        )
+        .with_process_name(process_name.into())
+        .enable()
+    {
+        eprintln!("{process_name}: Failed to init logger")
+    }
+}

netstack/src/smolnetd/buffer_pool.rs

@@ -0,0 +1,96 @@
+use std::cell::RefCell;
+use std::mem::{replace, swap};
+use std::ops::{Deref, DerefMut, Drop};
+use std::rc::Rc;
+
+type BufferStack = Rc<RefCell<Vec<Vec<u8>>>>;
+
+pub struct Buffer {
+    buffer: Vec<u8>,
+    stack: BufferStack,
+}
+
+impl Buffer {
+    pub fn resize(&mut self, new_len: usize) {
+        self.buffer.resize(new_len, 0u8);
+    }
+
+    pub fn move_out(&mut self) -> Buffer {
+        Buffer {
+            buffer: replace(&mut self.buffer, vec![]),
+            stack: Rc::clone(&self.stack),
+        }
+    }
+}
+
+impl AsRef<[u8]> for Buffer {
+    fn as_ref(&self) -> &[u8] {
+        &self.buffer
+    }
+}
+
+impl AsMut<[u8]> for Buffer {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer
+    }
+}
+
+impl Deref for Buffer {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        &self.buffer
+    }
+}
+
+impl DerefMut for Buffer {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.buffer
+    }
+}
+
+impl Drop for Buffer {
+    fn drop(&mut self) {
+        if self.buffer.capacity() > 0 {
+            let mut tmp = vec![];
+            swap(&mut tmp, &mut self.buffer);
+            {
+                let mut stack = self.stack.borrow_mut();
+                stack.push(tmp);
+            }
+        }
+    }
+}
+
+pub struct BufferPool {
+    buffers_size: usize,
+    stack: BufferStack,
+}
+
+impl BufferPool {
+    pub fn new(buffers_size: usize) -> BufferPool {
+        BufferPool {
+            buffers_size,
+            stack: Rc::new(RefCell::new(vec![])),
+        }
+    }
+
+    pub fn get_buffer(&mut self) -> Buffer {
+        let buffer = match self.stack.borrow_mut().pop() {
+            None => vec![0u8; self.buffers_size],
+            Some(mut v) => {
+                // memsetting the buffer with `resize` would be a waste of time
+                let capacity = v.capacity();
+                unsafe {
+                    v.set_len(capacity);
+                }
+                v
+            }
+        };
+
+        Buffer {
+            buffer,
+            stack: Rc::clone(&self.stack),
+        }
+    }
+}

netstack/src/smolnetd/link/ethernet.rs

@@ -0,0 +1,412 @@
+use std::collections::btree_map::Entry;
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{ErrorKind, Read, Write};
+use std::rc::Rc;
+
+use smoltcp::storage::PacketMetadata;
+use smoltcp::time::{Duration, Instant};
+use smoltcp::wire::{
+    ArpOperation, ArpPacket, ArpRepr, EthernetAddress, EthernetFrame, EthernetProtocol,
+    EthernetRepr, IpAddress, IpCidr, Ipv4Address, Ipv4Cidr,
+};
+
+use super::LinkDevice;
+
+struct Neighbor {
+    hardware_address: EthernetAddress,
+    expires_at: Instant,
+}
+
+#[derive(Debug, Default)]
+enum ArpState {
+    #[default]
+    Discovered,
+    Discovering {
+        target: Ipv4Address,
+        tries: u32,
+        silent_until: Instant,
+    },
+}
+
+type PacketBuffer = smoltcp::storage::PacketBuffer<'static, IpAddress>;
+
+const EMPTY_MAC: EthernetAddress = EthernetAddress([0; 6]);
+
+pub struct EthernetLink {
+    name: Rc<str>,
+    neighbor_cache: BTreeMap<IpAddress, Neighbor>,
+    arp_state: ArpState,
+    waiting_packets: PacketBuffer,
+    input_buffer: Vec<u8>,
+    output_buffer: Vec<u8>,
+    network_file: File,
+    hardware_address: Option<EthernetAddress>,
+    ip_address: Option<Ipv4Cidr>,
+}
+
+impl EthernetLink {
+    // TODO: Review these constants
+    const MAX_WAITING_PACKET_COUNT: usize = 10;
+    const MTU: usize = 1500;
+    const WAITING_PACKET_BUFFER_SIZE: usize = Self::MTU * Self::MAX_WAITING_PACKET_COUNT;
+
+    const NEIGHBOR_LIVE_TIME: Duration = Duration::from_secs(60);
+    const ARP_SILENCE_TIME: Duration = Duration::from_secs(1);
+
+    pub fn new(name: &str, network_file: File) -> Self {
+        let waiting_packets = PacketBuffer::new(
+            vec![PacketMetadata::EMPTY; Self::MAX_WAITING_PACKET_COUNT],
+            vec![0u8; Self::WAITING_PACKET_BUFFER_SIZE],
+        );
+
+        Self {
+            name: name.into(),
+            network_file,
+            waiting_packets,
+            hardware_address: None,
+            ip_address: None,
+            input_buffer: vec![0u8; Self::MTU],
+            output_buffer: Vec::with_capacity(Self::MTU),
+            arp_state: Default::default(),
+            neighbor_cache: Default::default(),
+        }
+    }
+
+    fn send_to<F>(&mut self, dst: EthernetAddress, size: usize, f: F, proto: EthernetProtocol)
+    where
+        F: FnOnce(&mut [u8]),
+    {
+        let Some(hardware_address) = self.hardware_address else {
+            return;
+        };
+
+        let repr = EthernetRepr {
+            src_addr: hardware_address,
+            dst_addr: dst,
+            ethertype: proto,
+        };
+
+        self.output_buffer.clear();
+        self.output_buffer.resize(repr.buffer_len() + size, 0);
+        let mut frame = EthernetFrame::new_unchecked(&mut self.output_buffer);
+        repr.emit(&mut frame);
+
+        f(frame.payload_mut());
+
+        if let Err(_) = self.network_file.write_all(&self.output_buffer) {
+            error!(
+                "Dropped outboud packet on {} (failed to write to network file)",
+                self.name
+            )
+        }
+    }
+
+    fn process_arp(&mut self, packet: &[u8], now: Instant) {
+        let Some(hardware_address) = self.hardware_address else {
+            return;
+        };
+
+        let Some(ip_addr) = self.ip_address else {
+            return;
+        };
+
+        let Ok(repr) = ArpPacket::new_checked(packet).and_then(|packet| ArpRepr::parse(&packet))
+        else {
+            debug!("Dropped incomming arp packet on {} (Malformed)", self.name);
+            return;
+        };
+
+        match repr {
+            ArpRepr::EthernetIpv4 {
+                operation,
+                source_hardware_addr,
+                source_protocol_addr,
+                target_hardware_addr,
+                target_protocol_addr,
+            } => {
+                let is_unicast_mac =
+                    target_hardware_addr != EMPTY_MAC && !target_hardware_addr.is_broadcast();
+
+                if is_unicast_mac && hardware_address != target_hardware_addr {
+                    // Only process packet that are for us
+                    return;
+                }
+
+                if let ArpOperation::Unknown(_) = operation {
+                    return;
+                }
+
+                if !source_hardware_addr.is_unicast()
+                    || source_protocol_addr.is_broadcast()
+                    || source_protocol_addr.is_multicast()
+                    || source_protocol_addr.is_unspecified()
+                {
+                    return;
+                }
+
+                if ip_addr.address() != target_protocol_addr {
+                    return;
+                }
+
+                self.neighbor_cache.insert(
+                    IpAddress::Ipv4(source_protocol_addr),
+                    Neighbor {
+                        hardware_address: source_hardware_addr,
+                        expires_at: now + Self::NEIGHBOR_LIVE_TIME,
+                    },
+                );
+
+                if let ArpOperation::Request = operation {
+                    let response = ArpRepr::EthernetIpv4 {
+                        operation: ArpOperation::Reply,
+                        source_hardware_addr: hardware_address,
+                        source_protocol_addr: ip_addr.address(),
+                        target_hardware_addr: source_hardware_addr,
+                        target_protocol_addr: source_protocol_addr,
+                    };
+
+                    self.send_to(
+                        source_hardware_addr,
+                        response.buffer_len(),
+                        |buf| response.emit(&mut ArpPacket::new_unchecked(buf)),
+                        EthernetProtocol::Arp,
+                    );
+                }
+                self.check_waiting_packets(source_protocol_addr, source_hardware_addr, now);
+            }
+            _ => {}
+        }
+    }
+
+    fn check_waiting_packets(&mut self, ip: Ipv4Address, mac: EthernetAddress, now: Instant) {
+        let mut waiting_packets =
+            std::mem::replace(&mut self.waiting_packets, PacketBuffer::new(vec![], vec![]));
+        loop {
+            match waiting_packets.peek() {
+                Ok((IpAddress::Ipv4(dst), _)) if dst == &ip => {}
+                Ok((IpAddress::Ipv4(dst), _)) => {
+                    self.arp_state = ArpState::Discovering {
+                        target: *dst,
+                        tries: 0,
+                        silent_until: Instant::ZERO,
+                    };
+                    self.send_arp(now);
+                    break;
+                }
+                Err(_) => {
+                    self.arp_state = ArpState::Discovered;
+                    break;
+                }
+            }
+
+            let (_, packet) = waiting_packets.dequeue().unwrap();
+            self.send_to(
+                mac,
+                packet.len(),
+                |buf| buf.copy_from_slice(packet),
+                EthernetProtocol::Ipv4,
+            );
+        }
+
+        self.waiting_packets = waiting_packets;
+    }
+
+    fn drop_waiting_packets(&mut self, ip: Ipv4Address, now: Instant) {
+        loop {
+            match self.waiting_packets.peek() {
+                Ok((IpAddress::Ipv4(dst), _)) if dst == &ip => {}
+                Ok((IpAddress::Ipv4(dst), _)) => {
+                    self.arp_state = ArpState::Discovering {
+                        target: *dst,
+                        tries: 0,
+                        silent_until: Instant::ZERO,
+                    };
+
+                    self.send_arp(now);
+
+                    return;
+                }
+                Err(_) => {
+                    self.arp_state = ArpState::Discovered;
+                    return;
+                }
+            }
+
+            let _ = self.waiting_packets.dequeue();
+            debug!(
+                "Dropped packet on {} because neighbor was not found",
+                self.name
+            )
+        }
+    }
+
+    fn handle_missing_neighbor(&mut self, next_hop: IpAddress, packet: &[u8], now: Instant) {
+        let Ok(buf) = self.waiting_packets.enqueue(packet.len(), next_hop) else {
+            warn!(
+                "Dropped packet on {} because waiting queue was full",
+                self.name
+            );
+            return;
+        };
+        buf.copy_from_slice(packet);
+
+        let IpAddress::Ipv4(next_hop) = next_hop;
+        if let ArpState::Discovered = self.arp_state {
+            self.arp_state = ArpState::Discovering {
+                target: next_hop,
+                tries: 0,
+                silent_until: Instant::ZERO,
+            };
+
+            self.send_arp(now)
+        }
+    }
+
+    fn send_arp(&mut self, now: Instant) {
+        let Some(hardware_address) = self.hardware_address else {
+            return;
+        };
+
+        let Some(ip_address) = self.ip_address else {
+            return;
+        };
+
+        match self.arp_state {
+            ArpState::Discovered => {}
+            ArpState::Discovering { silent_until, .. } if silent_until > now => {}
+            ArpState::Discovering { target, tries, .. } if tries >= 3 => {
+                self.drop_waiting_packets(target, now)
+            }
+            ArpState::Discovering {
+                target,
+                ref mut tries,
+                ref mut silent_until,
+            } => {
+                let arp_repr = ArpRepr::EthernetIpv4 {
+                    operation: ArpOperation::Request,
+                    source_hardware_addr: hardware_address,
+                    source_protocol_addr: ip_address.address(),
+                    target_hardware_addr: EthernetAddress::BROADCAST,
+                    target_protocol_addr: target,
+                };
+
+                *tries += 1;
+                *silent_until = now + Self::ARP_SILENCE_TIME;
+
+                self.send_to(
+                    EthernetAddress::BROADCAST,
+                    arp_repr.buffer_len(),
+                    |buf| arp_repr.emit(&mut ArpPacket::new_unchecked(buf)),
+                    EthernetProtocol::Arp,
+                );
+            }
+        }
+    }
+}
+
+impl LinkDevice for EthernetLink {
+    fn send(&mut self, next_hop: IpAddress, packet: &[u8], now: Instant) {
+        let local_broadcast = match self.ip_address.and_then(|cidr| cidr.broadcast()) {
+            Some(addr) => IpAddress::Ipv4(addr) == next_hop,
+            None => false,
+        };
+
+        if local_broadcast || next_hop.is_broadcast() {
+            self.send_to(
+                EthernetAddress::BROADCAST,
+                packet.len(),
+                |buf| buf.copy_from_slice(packet),
+                EthernetProtocol::Ipv4,
+            );
+            return;
+        }
+
+        match self.neighbor_cache.entry(next_hop) {
+            Entry::Vacant(_) => self.handle_missing_neighbor(next_hop, packet, now),
+            Entry::Occupied(e) => {
+                if e.get().expires_at < now {
+                    e.remove();
+                    self.handle_missing_neighbor(next_hop, packet, now)
+                } else {
+                    let mac = e.get().hardware_address;
+                    self.send_to(
+                        mac,
+                        packet.len(),
+                        |buf| buf.copy_from_slice(packet),
+                        EthernetProtocol::Ipv4,
+                    )
+                }
+            }
+        }
+    }
+
+    fn recv(&mut self, now: Instant) -> Option<&[u8]> {
+        let Some(hardware_address) = self.hardware_address else {
+            return None;
+        };
+
+        let mut input_buffer = std::mem::replace(&mut self.input_buffer, Vec::new());
+        loop {
+            if let Err(e) = self.network_file.read(&mut input_buffer) {
+                if e.kind() != ErrorKind::WouldBlock {
+                    error!("Failed to read ethernet device on link {}", self.name);
+                } else {
+                    // No packet to read but we check if we have arp to send
+                    self.send_arp(now);
+                }
+                self.input_buffer = input_buffer;
+                return None;
+            }
+            let packet = EthernetFrame::new_unchecked(&input_buffer[..]);
+            let Ok(repr) = EthernetRepr::parse(&packet) else {
+                debug!("Dropped incomming frame on {} (Malformed)", self.name);
+                continue;
+            };
+
+            // We let EMPTY_MAC pass because somehow this is the mac used when net=redir is used
+            if !repr.dst_addr.is_broadcast()
+                && repr.dst_addr != EMPTY_MAC
+                && repr.dst_addr != hardware_address
+            {
+                // Drop packets which are not for us
+                continue;
+            }
+
+            match repr.ethertype {
+                EthernetProtocol::Ipv4 => {
+                    self.input_buffer = input_buffer;
+                    return Some(EthernetFrame::new_unchecked(&self.input_buffer[..]).payload());
+                }
+                EthernetProtocol::Arp => self.process_arp(packet.payload(), now),
+                _ => continue,
+            }
+        }
+    }
+
+    fn name(&self) -> &Rc<str> {
+        &self.name
+    }
+
+    fn can_recv(&self) -> bool {
+        // We don't buffer any packets so we can't receive immediatly
+        false
+    }
+
+    fn mac_address(&self) -> Option<EthernetAddress> {
+        self.hardware_address
+    }
+
+    fn set_mac_address(&mut self, addr: EthernetAddress) {
+        self.hardware_address = Some(addr)
+    }
+
+    fn ip_address(&self) -> Option<IpCidr> {
+        Some(IpCidr::Ipv4(self.ip_address?))
+    }
+
+    fn set_ip_address(&mut self, addr: IpCidr) {
+        let IpCidr::Ipv4(addr) = addr;
+        self.ip_address = Some(addr);
+    }
+}

netstack/src/smolnetd/link/loopback.rs

@@ -0,0 +1,63 @@
+use std::rc::Rc;
+
+use smoltcp::storage::PacketMetadata;
+use smoltcp::time::Instant;
+
+use crate::scheme::Smolnetd;
+
+use super::LinkDevice;
+
+pub type PacketBuffer = smoltcp::storage::PacketBuffer<'static, ()>;
+
+pub struct LoopbackDevice {
+    name: Rc<str>,
+    buffer: PacketBuffer,
+}
+
+impl Default for LoopbackDevice {
+    fn default() -> Self {
+        let buffer = PacketBuffer::new(
+            vec![PacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0u8; 1500 * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        LoopbackDevice {
+            name: "loopback".into(),
+            buffer,
+        }
+    }
+}
+
+impl LinkDevice for LoopbackDevice {
+    fn send(&mut self, _next_hop: smoltcp::wire::IpAddress, packet: &[u8], _now: Instant) {
+        match self.buffer.enqueue(packet.len(), ()) {
+            Err(_) => warn!("loopback dropped packet because buffer was full"),
+            Ok(buf) => buf.copy_from_slice(packet),
+        }
+    }
+
+    fn recv(&mut self, _now: Instant) -> Option<&[u8]> {
+        self.buffer.dequeue().ok().map(|((), buf)| &*buf)
+    }
+
+    fn name(&self) -> &std::rc::Rc<str> {
+        &self.name
+    }
+
+    fn can_recv(&self) -> bool {
+        !self.buffer.is_empty()
+    }
+
+    fn mac_address(&self) -> Option<smoltcp::wire::EthernetAddress> {
+        None
+    }
+
+    fn set_mac_address(&mut self, _addr: smoltcp::wire::EthernetAddress) {}
+
+    fn ip_address(&self) -> Option<smoltcp::wire::IpCidr> {
+        Some("127.0.0.1/8".parse().unwrap())
+    }
+
+    fn set_ip_address(&mut self, _addr: smoltcp::wire::IpCidr) {
+        todo!()
+    }
+}

netstack/src/smolnetd/link/mod.rs

@@ -0,0 +1,65 @@
+pub mod ethernet;
+pub mod loopback;
+
+use std::rc::Rc;
+
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
+
+/// Represent a link layer device (eth0, loopback...)
+pub trait LinkDevice {
+    /// Send the given packet to the machine with the `next_hop` ip address
+    /// This method cannot fail so it's the implementor responsability
+    /// to buffer packets which can't be sent immediatly or decide to
+    /// drop them if necessary
+    fn send(&mut self, next_hop: IpAddress, packet: &[u8], now: Instant);
+
+    /// Returns None if nothing is received.
+    /// Returns an Ip packet otherwise
+    fn recv(&mut self, now: Instant) -> Option<&[u8]>;
+
+    /// Returns the LinkDevice display name used to refer to it and for lookups
+    fn name(&self) -> &Rc<str>;
+
+    /// Returns wether this device have packets pending
+    fn can_recv(&self) -> bool;
+
+    fn mac_address(&self) -> Option<EthernetAddress>;
+    fn set_mac_address(&mut self, addr: EthernetAddress);
+
+    fn ip_address(&self) -> Option<IpCidr>;
+    fn set_ip_address(&mut self, addr: IpCidr);
+}
+
+#[derive(Default)]
+pub struct DeviceList {
+    inner: Vec<Box<dyn LinkDevice>>,
+}
+
+impl DeviceList {
+    pub fn push<T: LinkDevice + 'static>(&mut self, dev: T) {
+        self.inner.push(Box::new(dev))
+    }
+
+    pub fn get(&self, device_name: &str) -> Option<&dyn LinkDevice> {
+        self.inner
+            .iter()
+            .find(|dev| dev.name().as_ref() == device_name)
+            .map(|device| device.as_ref())
+    }
+
+    pub fn get_mut(&mut self, device_name: &str) -> Option<&mut (dyn LinkDevice + 'static)> {
+        self.inner
+            .iter_mut()
+            .find(|dev| dev.name().as_ref() == device_name)
+            .map(|device| device.as_mut())
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &(dyn LinkDevice + 'static)> {
+        self.inner.iter().map(|b| b.as_ref())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (dyn LinkDevice + 'static)> {
+        self.inner.iter_mut().map(|b| b.as_mut())
+    }
+}

netstack/src/smolnetd/main.rs

@@ -0,0 +1,175 @@
+#[macro_use]
+extern crate log;
+use std::process;
+
+use anyhow::{anyhow, bail, Context, Result};
+use event::{EventFlags, EventQueue};
+use libredox::flag::{O_CREAT, O_NONBLOCK, O_RDWR};
+use libredox::Fd;
+
+use redox_netstack::logger;
+use scheme::Smolnetd;
+use smoltcp::wire::EthernetAddress;
+
+mod buffer_pool;
+mod link;
+mod port_set;
+mod router;
+mod scheme;
+
+fn get_network_adapter() -> Result<String> {
+    use std::fs;
+
+    let mut adapters = vec![];
+
+    for entry_res in fs::read_dir("/scheme")? {
+        let Ok(entry) = entry_res else {
+            continue;
+        };
+
+        let Ok(scheme) = entry.file_name().into_string() else {
+            continue;
+        };
+
+        if !scheme.starts_with("network") {
+            continue;
+        }
+
+        adapters.push(scheme);
+    }
+
+    if adapters.is_empty() {
+        bail!("no network adapter found");
+    } else {
+        let adapter = adapters.remove(0);
+        if !adapters.is_empty() {
+            // FIXME allow using multiple network adapters at the same time
+            warn!("Multiple network adapters found. Only {adapter} will be used");
+        }
+        Ok(adapter)
+    }
+}
+
+fn run(daemon: redox_daemon::Daemon) -> Result<()> {
+    let adapter = get_network_adapter()?;
+    trace!("opening {adapter}:");
+    let network_fd = Fd::open(&format!("/scheme/{adapter}"), O_RDWR | O_NONBLOCK, 0)
+        .map_err(|e| anyhow!("failed to open {adapter}: {e}"))?;
+
+    let hardware_addr = std::fs::read(format!("/scheme/{adapter}/mac"))
+        .map(|mac_address| EthernetAddress::from_bytes(&mac_address))
+        .context("failed to get mac address from network adapter")?;
+
+    trace!("opening :ip");
+    let ip_fd = Fd::open(":ip", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :ip")?;
+
+    trace!("opening :udp");
+    let udp_fd =
+        Fd::open(":udp", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :udp")?;
+
+    trace!("opening :tcp");
+    let tcp_fd =
+        Fd::open(":tcp", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :tcp")?;
+
+    trace!("opening :icmp");
+    let icmp_fd =
+        Fd::open(":icmp", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :icmp")?;
+
+    trace!("opening :netcfg");
+    let netcfg_fd =
+        Fd::open(":netcfg", O_RDWR | O_CREAT | O_NONBLOCK, 0).context("failed to open :netcfg")?;
+
+    let time_path = format!("/scheme/time/{}", syscall::CLOCK_MONOTONIC);
+    let time_fd = Fd::open(&time_path, O_RDWR, 0).context("failed to open /scheme/time")?;
+
+    event::user_data! {
+        enum EventSource {
+            Network,
+            Time,
+            IpScheme,
+            UdpScheme,
+            TcpScheme,
+            IcmpScheme,
+            NetcfgScheme,
+        }
+    }
+
+    let event_queue = EventQueue::<EventSource>::new().context("failed to create event queue")?;
+
+    daemon.ready().expect("smolnetd: failed to notify parent");
+
+    event_queue
+        .subscribe(network_fd.raw(), EventSource::Network, EventFlags::READ)
+        .context("failed to listen to network events")?;
+
+    event_queue
+        .subscribe(time_fd.raw(), EventSource::Time, EventFlags::READ)
+        .context("failed to listen to timer events")?;
+
+    event_queue
+        .subscribe(ip_fd.raw(), EventSource::IpScheme, EventFlags::READ)
+        .context("failed to listen to ip scheme events")?;
+
+    event_queue
+        .subscribe(udp_fd.raw(), EventSource::UdpScheme, EventFlags::READ)
+        .context("failed to listen to udp scheme events")?;
+
+    event_queue
+        .subscribe(tcp_fd.raw(), EventSource::TcpScheme, EventFlags::READ)
+        .context("failed to listen to tcp scheme events")?;
+
+    event_queue
+        .subscribe(icmp_fd.raw(), EventSource::IcmpScheme, EventFlags::READ)
+        .context("failed to listen to icmp scheme events")?;
+
+    event_queue
+        .subscribe(netcfg_fd.raw(), EventSource::NetcfgScheme, EventFlags::READ)
+        .context("failed to listen to netcfg scheme events")?;
+
+    let mut smolnetd = Smolnetd::new(
+        network_fd,
+        hardware_addr,
+        ip_fd,
+        udp_fd,
+        tcp_fd,
+        icmp_fd,
+        time_fd,
+        netcfg_fd,
+    );
+
+    libredox::call::setrens(0, 0).context("smolnetd: failed to enter null namespace")?;
+
+    let all = {
+        use EventSource::*;
+        [Network, Time, IpScheme, UdpScheme, IcmpScheme, NetcfgScheme].map(Ok)
+    };
+
+    for event_res in all
+        .into_iter()
+        .chain(event_queue.map(|r| r.map(|e| e.user_data)))
+    {
+        match event_res? {
+            EventSource::Network => smolnetd.on_network_scheme_event()?,
+            EventSource::Time => smolnetd.on_time_event()?,
+            EventSource::IpScheme => smolnetd.on_ip_scheme_event()?,
+            EventSource::UdpScheme => smolnetd.on_udp_scheme_event()?,
+            EventSource::TcpScheme => smolnetd.on_tcp_scheme_event()?,
+            EventSource::IcmpScheme => smolnetd.on_icmp_scheme_event()?,
+            EventSource::NetcfgScheme => smolnetd.on_netcfg_scheme_event()?,
+        }
+    }
+    Ok(())
+}
+
+fn main() {
+    redox_daemon::Daemon::new(move |daemon| {
+        logger::init_logger("smolnetd");
+
+        if let Err(err) = run(daemon) {
+            error!("smoltcpd: {}", err);
+            process::exit(1);
+        }
+        process::exit(0);
+    })
+    .expect("smoltcp: failed to daemonize");
+}

netstack/src/smolnetd/port_set.rs

@@ -0,0 +1,62 @@
+use std::collections::btree_map::{BTreeMap, Entry};
+
+pub struct PortSet {
+    from: u16,
+    range: u16,
+    next: u16,
+    ports: BTreeMap<u16, usize>,
+}
+
+impl PortSet {
+    pub fn new(from: u16, to: u16) -> Option<PortSet> {
+        if from > to {
+            return None;
+        }
+        Some(PortSet {
+            from,
+            range: to - from + 1,
+            next: 0,
+            ports: BTreeMap::new(),
+        })
+    }
+
+    pub fn get_port(&mut self) -> Option<u16> {
+        if self.ports.len() >= self.range as usize {
+            return None;
+        }
+
+        let port = loop {
+            if let Entry::Vacant(entry) = self.ports.entry(self.next) {
+                entry.insert(1);
+                let port = self.from + self.next;
+                self.next = self.next.wrapping_add(1);
+                break port;
+            }
+            self.next = self.next.wrapping_add(1);
+        };
+
+        Some(port)
+    }
+
+    pub fn claim_port(&mut self, port: u16) -> bool {
+        if let Entry::Vacant(entry) = self.ports.entry(port) {
+            entry.insert(1);
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn acquire_port(&mut self, port: u16) {
+        *self.ports.entry(port).or_insert(0) += 1;
+    }
+
+    pub fn release_port(&mut self, port: u16) {
+        if let Entry::Occupied(mut entry) = self.ports.entry(port) {
+            *entry.get_mut() -= 1;
+            if *entry.get() == 0 {
+                entry.remove();
+            }
+        }
+    }
+}

netstack/src/smolnetd/router/mod.rs

@@ -0,0 +1,190 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use smoltcp::phy::{Device, DeviceCapabilities, Medium};
+use smoltcp::storage::PacketMetadata;
+use smoltcp::time::Instant;
+use smoltcp::wire::IpAddress;
+
+use self::route_table::RouteTable;
+use crate::link::DeviceList;
+use crate::scheme::Smolnetd;
+
+pub mod route_table;
+
+pub type PacketBuffer = smoltcp::storage::PacketBuffer<'static, ()>;
+
+pub struct Router {
+    rx_buffer: PacketBuffer,
+    tx_buffer: PacketBuffer,
+    devices: Rc<RefCell<DeviceList>>,
+    route_table: Rc<RefCell<RouteTable>>,
+}
+
+impl Router {
+    pub fn new(devices: Rc<RefCell<DeviceList>>, route_table: Rc<RefCell<RouteTable>>) -> Self {
+        let rx_buffer = PacketBuffer::new(
+            vec![PacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0u8; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        let tx_buffer = PacketBuffer::new(
+            vec![PacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0u8; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        Self {
+            rx_buffer,
+            tx_buffer,
+            devices,
+            route_table,
+        }
+    }
+
+    pub const MTU: usize = 1486;
+
+    pub fn can_recv(&self) -> bool {
+        let mut can_recv = false;
+        for dev in self.devices.borrow().iter() {
+            can_recv |= dev.can_recv();
+        }
+        can_recv
+    }
+
+    pub fn poll(&mut self, now: Instant) {
+        for dev in self.devices.borrow_mut().iter_mut() {
+            if self.rx_buffer.is_full() {
+                break;
+            }
+
+            loop {
+                if self.rx_buffer.is_full() {
+                    break;
+                }
+
+                let Some(buf) = dev.recv(now) else {
+                    break;
+                };
+
+                self.rx_buffer
+                    .enqueue(buf.len(), ())
+                    .expect("We checked if it was full")
+                    .copy_from_slice(buf);
+            }
+        }
+    }
+
+    pub fn dispatch(&mut self, now: Instant) {
+        while let Ok(((), packet)) = self.tx_buffer.dequeue() {
+            if let Ok(mut packet) = smoltcp::wire::Ipv4Packet::new_checked(packet) {
+                let dst_addr = IpAddress::Ipv4(packet.dst_addr());
+                if packet.dst_addr().is_broadcast() {
+                    let buf = packet.into_inner();
+                    for dev in self.devices.borrow_mut().iter_mut() {
+                        dev.send(dst_addr, buf, now)
+                    }
+                } else {
+                    let route_table = self.route_table.borrow();
+                    let Some(rule) = route_table.lookup_rule(&dst_addr) else {
+                        warn!("No route found for destination: {}", dst_addr);
+                        continue;
+                    };
+
+                    let next_hop = match rule.via {
+                        Some(via) => via,
+                        None => dst_addr,
+                    };
+
+                    let mut devices = self.devices.borrow_mut();
+                    let Some(dev) = devices.get_mut(&rule.dev) else {
+                        warn!("Device {} not found", rule.dev);
+                        // TODO: Remove route if device doesn't exist anymore ?
+                        continue;
+                    };
+
+                    let IpAddress::Ipv4(src) = rule.src;
+                    if src != packet.src_addr() {
+                        packet.set_src_addr(src);
+                        packet.fill_checksum()
+                    }
+
+                    dev.send(next_hop, packet.into_inner(), now);
+                }
+            }
+        }
+    }
+}
+
+impl Device for Router {
+    type RxToken<'a> = RxToken<'a>;
+
+    type TxToken<'a> = TxToken<'a>;
+
+    fn receive(
+        &mut self,
+        _timestamp: smoltcp::time::Instant,
+    ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+        if self.rx_buffer.is_empty() || self.tx_buffer.is_full() {
+            None
+        } else {
+            Some((
+                RxToken {
+                    rx_buffer: &mut self.rx_buffer,
+                },
+                TxToken {
+                    tx_buffer: &mut self.tx_buffer,
+                },
+            ))
+        }
+    }
+
+    fn transmit(&mut self, _timestamp: smoltcp::time::Instant) -> Option<Self::TxToken<'_>> {
+        if self.tx_buffer.is_full() {
+            None
+        } else {
+            Some(TxToken {
+                tx_buffer: &mut self.tx_buffer,
+            })
+        }
+    }
+
+    fn capabilities(&self) -> smoltcp::phy::DeviceCapabilities {
+        let mut caps = DeviceCapabilities::default();
+        caps.medium = Medium::Ip;
+        caps.max_transmission_unit = Router::MTU;
+        caps.max_burst_size = Some(Smolnetd::SOCKET_BUFFER_SIZE);
+        caps
+    }
+}
+
+pub struct TxToken<'a> {
+    tx_buffer: &'a mut PacketBuffer,
+}
+
+impl smoltcp::phy::TxToken for TxToken<'_> {
+    fn consume<R, F>(self, len: usize, f: F) -> R
+    where
+        F: FnOnce(&mut [u8]) -> R,
+    {
+        f(self
+            .tx_buffer
+            .enqueue(len, ())
+            .expect("This was checked before creating the TxToken"))
+    }
+}
+
+pub struct RxToken<'a> {
+    rx_buffer: &'a mut PacketBuffer,
+}
+
+impl<'a> smoltcp::phy::RxToken for RxToken<'a> {
+    fn consume<R, F>(self, f: F) -> R
+    where
+        F: FnOnce(&[u8]) -> R,
+    {
+        let ((), buf) = self
+            .rx_buffer
+            .dequeue()
+            .expect("This was checked before creating the RxToken");
+
+        f(buf)
+    }
+}

netstack/src/smolnetd/router/route_table.rs

@@ -0,0 +1,99 @@
+use std::fmt::Display;
+use std::rc::Rc;
+
+use smoltcp::wire::{IpAddress, IpCidr};
+
+#[derive(Debug)]
+pub struct Rule {
+    pub filter: IpCidr,
+    pub via: Option<IpAddress>,
+    pub dev: Rc<str>,
+    pub src: IpAddress,
+}
+
+impl Rule {
+    pub fn new(filter: IpCidr, via: Option<IpAddress>, dev: Rc<str>, src: IpAddress) -> Self {
+        Self {
+            filter,
+            via,
+            dev,
+            src,
+        }
+    }
+}
+
+impl Display for Rule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.filter.prefix_len() == 0 {
+            write!(f, "default")?;
+        } else {
+            write!(f, "{} ", self.filter)?;
+        }
+
+        if let Some(via) = self.via {
+            write!(f, " via {}", via)?;
+        }
+
+        write!(f, " dev {}", self.dev)?;
+        write!(f, " src {}", self.src)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct RouteTable {
+    rules: Vec<Rule>,
+}
+
+impl RouteTable {
+    pub fn lookup_rule(&self, dst: &IpAddress) -> Option<&Rule> {
+        self.rules
+            .iter()
+            .rev()
+            .find(|rule| rule.filter.contains_addr(dst))
+    }
+
+    pub fn lookup_src_addr(&self, dst: &IpAddress) -> Option<IpAddress> {
+        Some(self.lookup_rule(dst)?.src)
+    }
+
+    pub fn lookup_gateway(&self, dst: &IpAddress) -> Option<IpAddress> {
+        self.lookup_rule(dst)?.via
+    }
+
+    pub fn lookup_device(&self, dst: &IpAddress) -> Option<Rc<str>> {
+        Some(self.lookup_rule(dst)?.dev.clone())
+    }
+
+    pub fn insert_rule(&mut self, new_rule: Rule) {
+        let i = match self
+            .rules
+            .binary_search_by_key(&new_rule.filter.prefix_len(), |rule| {
+                rule.filter.prefix_len()
+            }) {
+            Ok(i) | Err(i) => i,
+        };
+        self.rules.insert(i, new_rule);
+    }
+
+    pub fn remove_rule(&mut self, filter: IpCidr) {
+        self.rules.retain(|rule| rule.filter != filter);
+    }
+
+    pub fn change_src(&mut self, old_src: IpAddress, new_src: IpAddress) {
+        for rule in self.rules.iter_mut().filter(|rule| rule.src == old_src) {
+            rule.src = new_src;
+        }
+    }
+}
+
+impl Display for RouteTable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for rule in self.rules.iter() {
+            writeln!(f, "{}", rule)?;
+        }
+
+        Ok(())
+    }
+}

netstack/src/smolnetd/scheme/icmp.rs

@@ -0,0 +1,278 @@
+use smoltcp::iface::SocketHandle;
+use smoltcp::socket::icmp::{
+    Endpoint as IcmpEndpoint, PacketBuffer as IcmpSocketBuffer,
+    PacketMetadata as IcmpPacketMetadata, Socket as IcmpSocket,
+};
+use smoltcp::wire::{Icmpv4Packet, Icmpv4Repr, IpAddress, IpListenEndpoint};
+use std::mem;
+use std::str;
+use syscall;
+use syscall::{Error as SyscallError, Result as SyscallResult};
+
+use super::socket::{Context, DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme};
+use super::{Smolnetd, SocketSet};
+use crate::port_set::PortSet;
+use crate::router::Router;
+
+pub type IcmpScheme = SocketScheme<IcmpSocket<'static>>;
+
+enum IcmpSocketType {
+    Echo,
+    Udp,
+}
+
+pub struct IcmpData {
+    socket_type: IcmpSocketType,
+    ip: IpAddress,
+    ident: u16,
+}
+
+impl<'a> SchemeSocket for IcmpSocket<'a> {
+    type SchemeDataT = PortSet;
+    type DataT = IcmpData;
+    type SettingT = ();
+
+    fn new_scheme_data() -> Self::SchemeDataT {
+        PortSet::new(1u16, 0xffffu16).expect("Wrong ICMP ident values")
+    }
+
+    fn can_send(&self) -> bool {
+        self.can_send()
+    }
+
+    fn can_recv(&self) -> bool {
+        self.can_recv()
+    }
+
+    fn may_recv(&self) -> bool {
+        true
+    }
+
+    fn get_setting(
+        _file: &SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &mut [u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn set_setting(
+        _file: &mut SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &[u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn hop_limit(&self) -> u8 {
+        self.hop_limit().unwrap_or(64)
+    }
+
+    fn set_hop_limit(&mut self, hop_limit: u8) {
+        self.set_hop_limit(Some(hop_limit));
+    }
+
+    fn new_socket(
+        socket_set: &mut SocketSet,
+        path: &str,
+        _uid: u32,
+        ident_set: &mut Self::SchemeDataT,
+        _context: &Context,
+    ) -> SyscallResult<(SocketHandle, Self::DataT)> {
+        use std::str::FromStr;
+
+        let mut parts = path.split('/');
+        let method = parts
+            .next()
+            .ok_or_else(|| syscall::Error::new(syscall::EINVAL))?;
+
+        match method {
+            "echo" => {
+                let addr = parts
+                    .next()
+                    .ok_or_else(|| syscall::Error::new(syscall::EINVAL))?;
+                let ip =
+                    IpAddress::from_str(addr).map_err(|_| syscall::Error::new(syscall::EINVAL))?;
+
+                let socket = IcmpSocket::new(
+                    IcmpSocketBuffer::new(
+                        vec![IcmpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+                        vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+                    ),
+                    IcmpSocketBuffer::new(
+                        vec![IcmpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+                        vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+                    ),
+                );
+                let handle = socket_set.add(socket);
+                let icmp_socket = socket_set.get_mut::<IcmpSocket>(handle);
+                let ident = ident_set
+                    .get_port()
+                    .ok_or_else(|| SyscallError::new(syscall::EINVAL))?;
+                icmp_socket
+                    .bind(IcmpEndpoint::Ident(ident))
+                    .map_err(|_| syscall::Error::new(syscall::EINVAL))?;
+                let socket_data = IcmpData {
+                    socket_type: IcmpSocketType::Echo,
+                    ident,
+                    ip,
+                };
+                Ok((handle, socket_data))
+            }
+            "udp" => {
+                let addr = parts
+                    .next()
+                    .ok_or_else(|| syscall::Error::new(syscall::EINVAL))?;
+                let ip =
+                    IpAddress::from_str(addr).map_err(|_| syscall::Error::new(syscall::EINVAL))?;
+
+                let socket = IcmpSocket::new(
+                    IcmpSocketBuffer::new(
+                        vec![IcmpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+                        vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+                    ),
+                    IcmpSocketBuffer::new(
+                        vec![IcmpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+                        vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+                    ),
+                );
+                let handle = socket_set.add(socket);
+                let icmp_socket = socket_set.get_mut::<IcmpSocket>(handle);
+                let ident = ident_set
+                    .get_port()
+                    .ok_or_else(|| SyscallError::new(syscall::EINVAL))?;
+                icmp_socket
+                    .bind(IcmpEndpoint::Udp(IpListenEndpoint::from(ident)))
+                    .map_err(|_| syscall::Error::new(syscall::EINVAL))?;
+                let socket_data = IcmpData {
+                    socket_type: IcmpSocketType::Udp,
+                    ident,
+                    ip,
+                };
+                Ok((handle, socket_data))
+            }
+            _ => Err(syscall::Error::new(syscall::EINVAL)),
+        }
+    }
+
+    fn close_file(
+        &self,
+        file: &SchemeFile<Self>,
+        ident_set: &mut Self::SchemeDataT,
+    ) -> SyscallResult<()> {
+        if let SchemeFile::Socket(ref file) = *file {
+            ident_set.release_port(file.data.ident);
+        }
+        Ok(())
+    }
+
+    fn write_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &[u8],
+    ) -> SyscallResult<Option<usize>> {
+        if self.can_send() {
+            match file.data.socket_type {
+                IcmpSocketType::Echo => {
+                    if buf.len() < mem::size_of::<u16>() {
+                        return Err(SyscallError::new(syscall::EINVAL));
+                    }
+                    let (&seq_buf, payload) = buf.split_first_chunk::<2>().unwrap();
+                    let seq_no = u16::from_be_bytes(seq_buf);
+                    let icmp_repr = Icmpv4Repr::EchoRequest {
+                        ident: file.data.ident,
+                        seq_no,
+                        data: payload,
+                    };
+
+                    let icmp_payload = self
+                        .send(icmp_repr.buffer_len(), file.data.ip)
+                        .map_err(|_| syscall::Error::new(syscall::EINVAL))?;
+                    let mut icmp_packet = Icmpv4Packet::new_unchecked(icmp_payload);
+                    //TODO: replace Default with actual caps
+                    icmp_repr.emit(&mut icmp_packet, &Default::default());
+                    Ok(Some(buf.len()))
+                }
+                IcmpSocketType::Udp => Err(SyscallError::new(syscall::EINVAL)),
+            }
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn read_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<Option<usize>> {
+        while self.can_recv() {
+            let (payload, _) = self.recv().expect("Can't recv icmp packet");
+            let icmp_packet = Icmpv4Packet::new_unchecked(&payload);
+            //TODO: replace default with actual caps
+            let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &Default::default()).unwrap();
+
+            if let Icmpv4Repr::EchoReply { seq_no, data, .. } = icmp_repr {
+                if buf.len() < mem::size_of::<u16>() + data.len() {
+                    return Err(SyscallError::new(syscall::EINVAL));
+                }
+                buf[0..2].copy_from_slice(&seq_no.to_be_bytes());
+
+                for i in 0..data.len() {
+                    buf[mem::size_of::<u16>() + i] = data[i];
+                }
+
+                return Ok(Some(mem::size_of::<u16>() + data.len()));
+            }
+        }
+
+        if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn dup(
+        _socket_set: &mut SocketSet,
+        _file: &mut SchemeFile<Self>,
+        _path: &str,
+        _: &mut Self::SchemeDataT,
+    ) -> SyscallResult<DupResult<Self>> {
+        Err(SyscallError::new(syscall::EBADF))
+    }
+
+    fn fpath(&self, file: &SchemeFile<Self>, buf: &mut [u8]) -> SyscallResult<usize> {
+        if let SchemeFile::Socket(ref socket_file) = *file {
+            match socket_file.data.socket_type {
+                IcmpSocketType::Echo => {
+                    let path = format!("icmp:echo/{}", socket_file.data.ip);
+                    let path = path.as_bytes();
+
+                    let mut i = 0;
+                    while i < buf.len() && i < path.len() {
+                        buf[i] = path[i];
+                        i += 1;
+                    }
+
+                    Ok(i)
+                }
+                IcmpSocketType::Udp => {
+                    let path = format!("icmp:udp/{}", socket_file.data.ip);
+                    let path = path.as_bytes();
+
+                    let mut i = 0;
+                    while i < buf.len() && i < path.len() {
+                        buf[i] = path[i];
+                        i += 1;
+                    }
+
+                    Ok(i)
+                }
+            }
+        } else {
+            Err(SyscallError::new(syscall::EBADF))
+        }
+    }
+}

netstack/src/smolnetd/scheme/ip.rs

@@ -0,0 +1,147 @@
+use smoltcp::iface::SocketHandle;
+use smoltcp::socket::raw::{
+    PacketBuffer as RawSocketBuffer, PacketMetadata as RawPacketMetadata, Socket as RawSocket,
+};
+use smoltcp::wire::{IpProtocol, IpVersion};
+use std::str;
+use syscall;
+use syscall::{Error as SyscallError, Result as SyscallResult};
+
+use crate::router::Router;
+
+use super::socket::{Context, DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme};
+use super::{Smolnetd, SocketSet};
+
+pub type IpScheme = SocketScheme<RawSocket<'static>>;
+
+impl<'a> SchemeSocket for RawSocket<'a> {
+    type SchemeDataT = ();
+    type DataT = ();
+    type SettingT = ();
+
+    fn new_scheme_data() -> Self::SchemeDataT {
+        ()
+    }
+
+    fn can_send(&self) -> bool {
+        self.can_send()
+    }
+
+    fn can_recv(&self) -> bool {
+        self.can_recv()
+    }
+
+    fn may_recv(&self) -> bool {
+        true
+    }
+
+    fn get_setting(
+        _file: &SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &mut [u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn set_setting(
+        _file: &mut SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &[u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn hop_limit(&self) -> u8 {
+        0
+    }
+
+    fn set_hop_limit(&mut self, _hop_limit: u8) {}
+
+    fn new_socket(
+        socket_set: &mut SocketSet,
+        path: &str,
+        uid: u32,
+        _: &mut Self::SchemeDataT,
+        _context: &Context,
+    ) -> SyscallResult<(SocketHandle, Self::DataT)> {
+        if uid != 0 {
+            return Err(SyscallError::new(syscall::EACCES));
+        }
+        let proto =
+            u8::from_str_radix(path, 16).or_else(|_| Err(SyscallError::new(syscall::ENOENT)))?;
+
+        let rx_buffer = RawSocketBuffer::new(
+            vec![RawPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        let tx_buffer = RawSocketBuffer::new(
+            vec![RawPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        let ip_socket = RawSocket::new(
+            IpVersion::Ipv4,
+            IpProtocol::from(proto),
+            rx_buffer,
+            tx_buffer,
+        );
+
+        let socket_handle = socket_set.add(ip_socket);
+        Ok((socket_handle, ()))
+    }
+
+    fn close_file(&self, _: &SchemeFile<Self>, _: &mut Self::SchemeDataT) -> SyscallResult<()> {
+        Ok(())
+    }
+
+    fn write_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &[u8],
+    ) -> SyscallResult<Option<usize>> {
+        if self.can_send() {
+            self.send_slice(buf).expect("Can't send slice");
+            Ok(Some(buf.len()))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn read_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<Option<usize>> {
+        if self.can_recv() {
+            let length = self.recv_slice(buf).expect("Can't receive slice");
+            Ok(Some(length))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn dup(
+        _socket_set: &mut SocketSet,
+        _file: &mut SchemeFile<Self>,
+        _path: &str,
+        _: &mut Self::SchemeDataT,
+    ) -> SyscallResult<DupResult<Self>> {
+        Err(SyscallError::new(syscall::EBADF))
+    }
+
+    fn fpath(&self, _file: &SchemeFile<Self>, buf: &mut [u8]) -> SyscallResult<usize> {
+        let path = format!("ip:{}", self.ip_protocol());
+        let path = path.as_bytes();
+
+        let mut i = 0;
+        while i < buf.len() && i < path.len() {
+            buf[i] = path[i];
+            i += 1;
+        }
+
+        Ok(i)
+    }
+}

netstack/src/smolnetd/scheme/mod.rs

@@ -0,0 +1,292 @@
+use crate::link::ethernet::EthernetLink;
+use crate::link::LinkDevice;
+use crate::link::{loopback::LoopbackDevice, DeviceList};
+use crate::router::route_table::{RouteTable, Rule};
+use crate::router::Router;
+use crate::scheme::smoltcp::iface::SocketSet as SmoltcpSocketSet;
+use libredox::Fd;
+use netutils::getcfg;
+use smoltcp;
+use smoltcp::iface::{Config, Interface as SmoltcpInterface};
+use smoltcp::phy::Tracer;
+use smoltcp::time::{Duration, Instant};
+use smoltcp::wire::{
+    EthernetAddress, HardwareAddress, IpAddress, IpCidr, IpListenEndpoint, Ipv4Address,
+};
+use std::cell::RefCell;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::mem::size_of;
+use std::os::fd::{FromRawFd, RawFd};
+use std::rc::Rc;
+use std::str::FromStr;
+use syscall;
+use syscall::data::TimeSpec;
+
+use self::icmp::IcmpScheme;
+use self::ip::IpScheme;
+use self::netcfg::NetCfgScheme;
+use self::tcp::TcpScheme;
+use self::udp::UdpScheme;
+use redox_netstack::error::{Error, Result};
+
+mod icmp;
+mod ip;
+mod netcfg;
+mod socket;
+mod tcp;
+mod udp;
+
+type SocketSet = SmoltcpSocketSet<'static>;
+type Interface = Rc<RefCell<SmoltcpInterface>>;
+
+const MAX_DURATION: Duration = Duration::from_micros(u64::MAX);
+const MIN_DURATION: Duration = Duration::from_micros(0);
+
+pub struct Smolnetd {
+    router_device: Tracer<Router>,
+    iface: Interface,
+    time_file: File,
+
+    socket_set: Rc<RefCell<SocketSet>>,
+    timer: ::std::time::Instant,
+
+    ip_scheme: IpScheme,
+    udp_scheme: UdpScheme,
+    tcp_scheme: TcpScheme,
+    icmp_scheme: IcmpScheme,
+    netcfg_scheme: NetCfgScheme,
+}
+
+impl Smolnetd {
+    pub const MAX_PACKET_SIZE: usize = 2048;
+    pub const SOCKET_BUFFER_SIZE: usize = 128; //packets
+    pub const MIN_CHECK_TIMEOUT: Duration = Duration::from_millis(10);
+    pub const MAX_CHECK_TIMEOUT: Duration = Duration::from_millis(500);
+
+    pub fn new(
+        network_file: Fd,
+        hardware_addr: EthernetAddress,
+        ip_file: Fd,
+        udp_file: Fd,
+        tcp_file: Fd,
+        icmp_file: Fd,
+        time_file: Fd,
+        netcfg_file: Fd,
+    ) -> Smolnetd {
+        let protocol_addrs = vec![
+            //This is a placeholder IP for DHCP
+            IpCidr::new(IpAddress::v4(0, 0, 0, 0), 8),
+        ];
+
+        let default_gw = Ipv4Address::from_str(getcfg("ip_router").unwrap().trim())
+            .expect("Can't parse the 'ip_router' cfg.");
+
+        let devices = Rc::new(RefCell::new(DeviceList::default()));
+        let route_table = Rc::new(RefCell::new(RouteTable::default()));
+        let mut network_device = Tracer::new(
+            Router::new(Rc::clone(&devices), Rc::clone(&route_table)),
+            |_timestamp, printer| trace!("{}", printer),
+        );
+
+        let config = Config::new(HardwareAddress::Ip);
+        let mut iface = SmoltcpInterface::new(config, &mut network_device, Instant::now());
+        iface.update_ip_addrs(|ip_addrs| ip_addrs.extend(protocol_addrs));
+        iface
+            .routes_mut()
+            .add_default_ipv4_route(default_gw)
+            .expect("Failed to add default gateway");
+
+        let iface = Rc::new(RefCell::new(iface));
+        let socket_set = Rc::new(RefCell::new(SocketSet::new(vec![])));
+
+        let loopback = LoopbackDevice::default();
+        route_table.borrow_mut().insert_rule(Rule::new(
+            "127.0.0.0/8".parse().unwrap(),
+            None,
+            Rc::clone(loopback.name()),
+            "127.0.0.1".parse().unwrap(),
+        ));
+
+        let mut eth0 = EthernetLink::new("eth0", unsafe {
+            File::from_raw_fd(network_file.into_raw() as RawFd)
+        });
+        eth0.set_mac_address(hardware_addr);
+
+        devices.borrow_mut().push(loopback);
+        devices.borrow_mut().push(eth0);
+
+        Smolnetd {
+            iface: Rc::clone(&iface),
+            router_device: network_device,
+            socket_set: Rc::clone(&socket_set),
+            timer: ::std::time::Instant::now(),
+            time_file: unsafe { File::from_raw_fd(time_file.into_raw() as RawFd) },
+            ip_scheme: IpScheme::new(
+                Rc::clone(&iface),
+                Rc::clone(&route_table),
+                Rc::clone(&socket_set),
+                unsafe { File::from_raw_fd(ip_file.into_raw() as RawFd) },
+            ),
+            udp_scheme: UdpScheme::new(
+                Rc::clone(&iface),
+                Rc::clone(&route_table),
+                Rc::clone(&socket_set),
+                unsafe { File::from_raw_fd(udp_file.into_raw() as RawFd) },
+            ),
+            tcp_scheme: TcpScheme::new(
+                Rc::clone(&iface),
+                Rc::clone(&route_table),
+                Rc::clone(&socket_set),
+                unsafe { File::from_raw_fd(tcp_file.into_raw() as RawFd) },
+            ),
+            icmp_scheme: IcmpScheme::new(
+                Rc::clone(&iface),
+                Rc::clone(&route_table),
+                Rc::clone(&socket_set),
+                unsafe { File::from_raw_fd(icmp_file.into_raw() as RawFd) },
+            ),
+            netcfg_scheme: NetCfgScheme::new(
+                Rc::clone(&iface),
+                unsafe { File::from_raw_fd(netcfg_file.into_raw() as RawFd) },
+                Rc::clone(&route_table),
+                Rc::clone(&devices),
+            ),
+        }
+    }
+
+    pub fn on_network_scheme_event(&mut self) -> Result<()> {
+        self.poll()?;
+        Ok(())
+    }
+
+    pub fn on_ip_scheme_event(&mut self) -> Result<()> {
+        self.ip_scheme.on_scheme_event()?;
+        let _ = self.poll()?;
+        Ok(())
+    }
+
+    pub fn on_udp_scheme_event(&mut self) -> Result<()> {
+        self.udp_scheme.on_scheme_event()?;
+        let _ = self.poll()?;
+        Ok(())
+    }
+
+    pub fn on_tcp_scheme_event(&mut self) -> Result<()> {
+        self.tcp_scheme.on_scheme_event()?;
+        let _ = self.poll()?;
+        Ok(())
+    }
+
+    pub fn on_icmp_scheme_event(&mut self) -> Result<()> {
+        self.icmp_scheme.on_scheme_event()?;
+        let _ = self.poll()?;
+        Ok(())
+    }
+
+    pub fn on_time_event(&mut self) -> Result<()> {
+        let timeout = self.poll()?;
+        self.schedule_time_event(timeout)?;
+        //TODO: Fix network scheme to ensure events are not missed
+        self.on_network_scheme_event()
+    }
+
+    pub fn on_netcfg_scheme_event(&mut self) -> Result<()> {
+        self.netcfg_scheme.on_scheme_event()?;
+        Ok(())
+    }
+
+    fn schedule_time_event(&mut self, timeout: Duration) -> Result<()> {
+        let mut time = TimeSpec::default();
+        if self.time_file.read(&mut time)? < size_of::<TimeSpec>() {
+            return Err(Error::from_syscall_error(
+                syscall::Error::new(syscall::EBADF),
+                "Can't read current time",
+            ));
+        }
+        let mut time_ms = time.tv_sec * 1000i64 + i64::from(time.tv_nsec) / 1_000_000i64;
+        time_ms += timeout.total_millis() as i64;
+        time.tv_sec = time_ms / 1000;
+        time.tv_nsec = ((time_ms % 1000) * 1_000_000) as i32;
+        self.time_file
+            .write_all(&time)
+            .map_err(|e| Error::from_io_error(e, "Failed to write to time file"))?;
+        Ok(())
+    }
+
+    fn poll(&mut self) -> Result<Duration> {
+        let timeout = {
+            let mut iter_limit = 10usize;
+            let mut iface = self.iface.borrow_mut();
+            let mut socket_set = self.socket_set.borrow_mut();
+
+            loop {
+                let timestamp = Instant::from(self.timer);
+                if iter_limit == 0 {
+                    break MIN_DURATION;
+                }
+                iter_limit -= 1;
+
+                self.router_device.get_mut().poll(timestamp);
+
+                // TODO: Check what if the bool returned by poll can be useful
+                iface.poll(timestamp, &mut self.router_device, &mut socket_set);
+
+                self.router_device.get_mut().dispatch(timestamp);
+
+                if !self.router_device.get_ref().can_recv() {
+                    match iface.poll_delay(timestamp, &socket_set) {
+                        Some(delay) if delay == Duration::ZERO => {}
+                        Some(delay) => break ::std::cmp::min(MAX_DURATION, delay),
+                        None => break MAX_DURATION,
+                    };
+                }
+            }
+        };
+
+        self.notify_sockets()?;
+
+        Ok(::std::cmp::min(
+            ::std::cmp::max(Smolnetd::MIN_CHECK_TIMEOUT, timeout),
+            Smolnetd::MAX_CHECK_TIMEOUT,
+        ))
+    }
+
+    fn notify_sockets(&mut self) -> Result<()> {
+        self.ip_scheme.notify_sockets()?;
+        self.udp_scheme.notify_sockets()?;
+        self.tcp_scheme.notify_sockets()?;
+        self.icmp_scheme.notify_sockets()
+    }
+}
+
+fn post_fevent(scheme_file: &mut File, fd: usize, event: usize, data_len: usize) -> Result<()> {
+    scheme_file
+        .write(&syscall::Packet {
+            id: 0,
+            pid: 0,
+            uid: 0,
+            gid: 0,
+            a: syscall::number::SYS_FEVENT,
+            b: fd,
+            c: event,
+            d: data_len,
+        })
+        .map(|_| ())
+        .map_err(|e| Error::from_io_error(e, "failed to post fevent"))
+}
+
+fn parse_endpoint(socket: &str) -> IpListenEndpoint {
+    let mut socket_parts = socket.split(':');
+    let host = Ipv4Address::from_str(socket_parts.next().unwrap_or(""))
+        .ok()
+        .filter(|addr| !addr.is_unspecified())
+        .map(IpAddress::Ipv4);
+
+    let port = socket_parts
+        .next()
+        .unwrap_or("")
+        .parse::<u16>()
+        .unwrap_or(0);
+    IpListenEndpoint { addr: host, port }
+}

netstack/src/smolnetd/scheme/netcfg/mod.rs

@@ -0,0 +1,539 @@
+#[macro_use]
+mod nodes;
+mod notifier;
+
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{ErrorKind, Read, Write};
+use std::mem;
+use std::rc::Rc;
+use std::str;
+use std::str::FromStr;
+use syscall;
+use syscall::data::Stat;
+use syscall::flag::{MODE_DIR, MODE_FILE};
+use syscall::{
+    Error as SyscallError, EventFlags as SyscallEventFlags, Packet as SyscallPacket,
+    Result as SyscallResult, SchemeMut,
+};
+
+use crate::link::DeviceList;
+use crate::router::route_table::{RouteTable, Rule};
+
+use self::nodes::*;
+use self::notifier::*;
+use super::{post_fevent, Interface};
+use redox_netstack::error::{Error, Result};
+
+const WRITE_BUFFER_MAX_SIZE: usize = 0xffff;
+
+fn gateway_cidr() -> IpCidr {
+    // TODO: const fn
+    IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0)
+}
+
+fn parse_route(value: &str, route_table: &RouteTable) -> SyscallResult<Rule> {
+    let mut parts = value.split_whitespace();
+    let cidr_str = parts.next().ok_or(SyscallError::new(syscall::EINVAL))?;
+    let cidr = match cidr_str {
+        "default" => gateway_cidr(),
+        cidr_str => cidr_str
+            .parse()
+            .map_err(|_| SyscallError::new(syscall::EINVAL))?,
+    };
+
+    let via: IpAddress = match parts.next().ok_or(SyscallError::new(syscall::EINVAL))? {
+        "via" => parts
+            .next()
+            .ok_or(SyscallError::new(syscall::EINVAL))?
+            .parse()
+            .map_err(|_| SyscallError::new(syscall::EINVAL))?,
+        _ => return Err(SyscallError::new(syscall::EINVAL)),
+    };
+
+    if !via.is_unicast() {
+        return Err(SyscallError::new(syscall::EINVAL));
+    }
+
+    let rule = route_table
+        .lookup_rule(&via)
+        .ok_or(SyscallError::new(syscall::EINVAL))?;
+
+    Ok(Rule::new(cidr, Some(via), rule.dev.clone(), rule.src))
+}
+
+fn mk_root_node(
+    iface: Interface,
+    notifier: NotifierRef,
+    dns_config: DNSConfigRef,
+    route_table: Rc<RefCell<RouteTable>>,
+    devices: Rc<RefCell<DeviceList>>,
+) -> CfgNodeRef {
+    cfg_node! {
+        "resolv" => {
+            "nameserver" => {
+                rw [dns_config, notifier] (Option<Ipv4Address>, None)
+                || {
+                    format!("{}\n", dns_config.borrow().name_server)
+                }
+                |cur_value, line| {
+                    if cur_value.is_none() {
+                        let ip = Ipv4Address::from_str(line.trim())
+                            .map_err(|_| SyscallError::new(syscall::EINVAL))?;
+                        if ip.is_broadcast() || ip.is_multicast() || ip.is_unspecified() {
+                            return Err(SyscallError::new(syscall::EINVAL));
+                        }
+                        *cur_value = Some(ip);
+                        Ok(())
+                    } else {
+                        Err(SyscallError::new(syscall::EINVAL))
+                    }
+                }
+                |cur_value| {
+                    if let Some(ip) = *cur_value {
+                        dns_config.borrow_mut().name_server = ip;
+                        notifier.borrow_mut().schedule_notify("resolv/nameserver");
+                    }
+                    Ok(())
+                }
+            }
+        },
+        "route" => {
+            "list" => {
+                ro [route_table] || {
+                    format!("{}", route_table.borrow())
+                }
+            },
+            "add" => {
+                wo [iface, notifier, route_table] (Option<Rule>, None)
+                |cur_value, line| {
+                    if cur_value.is_none() {
+                        let route = parse_route(line, &route_table.borrow())?;
+                        *cur_value = Some(route);
+                        Ok(())
+                    } else {
+                        Err(SyscallError::new(syscall::EINVAL))
+                    }
+                }
+                |cur_value| {
+                    if let Some(route) = cur_value.take() {
+                        route_table.borrow_mut().insert_rule(route);
+                        notifier.borrow_mut().schedule_notify("route/list");
+                        Ok(())
+                    } else {
+                        Err(SyscallError::new(syscall::EINVAL))
+                    }
+                }
+            },
+            "rm" => {
+                wo [iface, notifier, route_table] (Option<IpCidr>, None)
+                |cur_value, line| {
+                    if cur_value.is_none() {
+                        match line.parse() {
+                            Ok(cidr) => {
+                                *cur_value = Some(cidr);
+                                Ok(())
+                            }
+                            Err(_) => Err(SyscallError::new(syscall::EINVAL))
+                        }
+                    } else {
+                        Err(SyscallError::new(syscall::EINVAL))
+                    }
+                }
+                |cur_value| {
+                    if let Some(cidr) = *cur_value {
+                        route_table.borrow_mut().remove_rule(cidr);
+                        notifier.borrow_mut().schedule_notify("route/list");
+                        Ok(())
+                    } else {
+                        Err(SyscallError::new(syscall::EINVAL))
+                    }
+                }
+            },
+        },
+        "ifaces" => {
+            "eth0" => {
+                "mac" => {
+                    rw [iface, notifier, devices] (Option<EthernetAddress>, None)
+                    || {
+                        match devices.borrow().get("eth0") {
+                            Some(dev) => {
+                                match dev.mac_address() {
+                                    Some(addr) => format!("{addr}\n"),
+                                    None => "Not configured\n".into(),
+                                }
+                            }
+                            None => "Device not found\n".into(),
+                        }
+                    }
+                    |cur_value, line| {
+                        if cur_value.is_none() {
+                            let mac = EthernetAddress::from_str(line).
+                                map_err(|_| SyscallError::new(syscall::EINVAL))?;
+                            if !mac.is_unicast() {
+                                return Err(SyscallError::new(syscall::EINVAL));
+                            }
+                            *cur_value = Some(mac);
+                            Ok(())
+                        } else {
+                            Err(SyscallError::new(syscall::EINVAL))
+                        }
+                    }
+                    |cur_value| {
+                        if let Some(mac) = *cur_value {
+                            if let Some(dev) = devices.borrow_mut().get_mut("eth0") {
+                                dev.set_mac_address(mac);
+                                notifier.borrow_mut().schedule_notify("ifaces/eth0/mac");
+                            }
+                        }
+                        Ok(())
+                    }
+                },
+                "addr" => {
+                    "list" => {
+                        ro [devices]
+                        || {
+                            let res = match devices.borrow().get("eth0") {
+                                Some(dev) => {
+                                    match dev.ip_address() {
+                                        Some(addr) => format!("{addr}\n"),
+                                        None => "Not configured\n".into(),
+                                    }
+                                }
+                                None => "Device not found\n".into(),
+                            };
+                            res
+                        }
+                    },
+                    "set" => {
+                        wo [iface, notifier, devices, route_table] (Option<IpCidr>, None)
+                        |cur_value, line| {
+                            if cur_value.is_none() {
+                                let cidr = IpCidr::from_str(line)
+                                    .map_err(|_| SyscallError::new(syscall::EINVAL))?;
+                                if !cidr.address().is_unicast() {
+                                    return Err(SyscallError::new(syscall::EINVAL));
+                                }
+                                *cur_value = Some(cidr);
+                                Ok(())
+                            } else {
+                                Err(SyscallError::new(syscall::EINVAL))
+                            }
+                        }
+                        |cur_value| {
+                            // TODO: Multiple IPs
+                            if let Some(cidr) = cur_value.take() {
+                                if let Some(dev) = devices.borrow_mut().get_mut("eth0") {
+
+                                    let mut route_table = route_table.borrow_mut();
+                                    if let Some(old_addr) = dev.ip_address() {
+                                        let IpCidr::Ipv4(old_v4_cidr) = old_addr;
+                                        let old_network = IpCidr::Ipv4(old_v4_cidr.network());
+
+                                        route_table.remove_rule(old_network);
+                                        route_table.change_src(old_addr.address(), cidr.address());
+                                        iface.borrow_mut().update_ip_addrs(|addrs| addrs.retain(|addr| *addr != old_addr))
+                                    }
+
+                                    dev.set_ip_address(cidr);
+                                    // FIXME: Here, the insert 0 is a workaround to let UDP sockets
+                                    // work with this interface only.
+                                    // Smoltcp takes the first ip address when looking for a source
+                                    // ip address when sending UDP packets.
+                                    // This behavior will have to be fixed as it's our route table
+                                    // job to find give this source.
+                                    iface.borrow_mut().update_ip_addrs(|addrs| addrs.insert(0, cidr).unwrap());
+
+                                    let IpCidr::Ipv4(v4_cidr) = cidr;
+                                    let network_cidr = IpCidr::Ipv4(v4_cidr.network());
+                                    route_table.insert_rule(Rule::new(network_cidr, None, dev.name().clone(), cidr.address()))
+                                }
+                                notifier.borrow_mut().schedule_notify("ifaces/eth0/addr/list");
+                                notifier.borrow_mut().schedule_notify("route/list");
+                            }
+                            Ok(())
+                        }
+                    },
+                }
+            }
+        }
+    }
+}
+
+struct DNSConfig {
+    name_server: Ipv4Address,
+}
+
+type DNSConfigRef = Rc<RefCell<DNSConfig>>;
+
+struct NetCfgFile {
+    path: String,
+    is_dir: bool,
+    is_writable: bool,
+    is_readable: bool,
+    node_writer: Option<Box<dyn NodeWriter>>,
+    read_buf: Vec<u8>,
+    write_buf: Vec<u8>,
+    pos: usize,
+    uid: u32,
+    done: bool,
+}
+
+impl NetCfgFile {
+    fn commit(&mut self) -> SyscallResult<()> {
+        if let Some(ref mut node_writer) = self.node_writer {
+            if !self.write_buf.is_empty() {
+                let line = str::from_utf8(&self.write_buf)
+                    .or_else(|_| Err(SyscallError::new(syscall::EINVAL)))?;
+                node_writer.write_line(line)?;
+            }
+            node_writer.commit()?;
+            self.write_buf.clear();
+        }
+        Ok(())
+    }
+
+    fn consume_lines(&mut self) -> SyscallResult<()> {
+        if let Some(ref mut node_writer) = self.node_writer {
+            let mut swap_with = None;
+            {
+                let mut lines = self.write_buf.split(|&c| c == b'\n');
+                if let Some(mut cur_line) = lines.next() {
+                    let mut consumed = false;
+                    for next_line in lines {
+                        let line = str::from_utf8(cur_line)
+                            .or_else(|_| Err(SyscallError::new(syscall::EINVAL)))?;
+                        trace!("writing line {}", line);
+                        node_writer.write_line(line)?;
+                        cur_line = next_line;
+                        consumed = true;
+                    }
+                    if consumed {
+                        swap_with = Some(From::from(cur_line))
+                    }
+                }
+            }
+            if let Some(ref mut new_vec) = swap_with {
+                mem::swap(&mut self.write_buf, new_vec);
+            }
+            Ok(())
+        } else {
+            Err(SyscallError::new(syscall::EBADF))
+        }
+    }
+}
+
+pub struct NetCfgScheme {
+    scheme_file: File,
+    next_fd: usize,
+    files: BTreeMap<usize, NetCfgFile>,
+    root_node: CfgNodeRef,
+    notifier: NotifierRef,
+}
+
+impl NetCfgScheme {
+    pub fn new(
+        iface: Interface,
+        scheme_file: File,
+        route_table: Rc<RefCell<RouteTable>>,
+        devices: Rc<RefCell<DeviceList>>,
+    ) -> NetCfgScheme {
+        let notifier = Notifier::new_ref();
+        let dns_config = Rc::new(RefCell::new(DNSConfig {
+            name_server: Ipv4Address::new(8, 8, 8, 8),
+        }));
+        NetCfgScheme {
+            scheme_file,
+            next_fd: 1,
+            files: BTreeMap::new(),
+            root_node: mk_root_node(
+                iface,
+                Rc::clone(&notifier),
+                dns_config,
+                route_table,
+                devices,
+            ),
+            notifier,
+        }
+    }
+
+    pub fn on_scheme_event(&mut self) -> Result<Option<()>> {
+        let result = loop {
+            let mut packet = SyscallPacket::default();
+            match self.scheme_file.read(&mut packet) {
+                Ok(0) => {
+                    //TODO: Cleanup must occur
+                    break Some(());
+                }
+                Ok(_) => (),
+                Err(err) => {
+                    if err.kind() == ErrorKind::WouldBlock {
+                        break None;
+                    } else {
+                        return Err(Error::from(err));
+                    }
+                }
+            }
+            self.handle(&mut packet);
+            self.scheme_file.write_all(&packet)?;
+        };
+        self.notify_scheduled_fds();
+        Ok(result)
+    }
+
+    fn notify_scheduled_fds(&mut self) {
+        let fds_to_notify = self.notifier.borrow_mut().get_notified_fds();
+        for fd in fds_to_notify {
+            let _ = post_fevent(&mut self.scheme_file, fd, syscall::EVENT_READ.bits(), 1);
+        }
+    }
+}
+
+impl SchemeMut for NetCfgScheme {
+    fn open(&mut self, path: &str, _flags: usize, uid: u32, _gid: u32) -> SyscallResult<usize> {
+        let mut current_node = Rc::clone(&self.root_node);
+        for part in path.split('/') {
+            if part.is_empty() {
+                continue;
+            }
+            let next_node = current_node
+                .borrow_mut()
+                .open(part)
+                .ok_or_else(|| SyscallError::new(syscall::EINVAL))?;
+            current_node = next_node;
+        }
+        let current_node = current_node.borrow();
+        let read_buf = Vec::from(current_node.read());
+        let fd = self.next_fd;
+        trace!("open {} {}", fd, path);
+        self.next_fd += 1;
+        self.files.insert(
+            fd,
+            NetCfgFile {
+                path: path.to_owned(),
+                is_dir: current_node.is_dir(),
+                is_writable: current_node.is_writable(),
+                is_readable: current_node.is_readable(),
+                node_writer: if current_node.is_writable() {
+                    current_node.new_writer()
+                } else {
+                    None
+                },
+                uid,
+                pos: 0,
+                read_buf,
+                write_buf: vec![],
+                done: false,
+            },
+        );
+        Ok(fd)
+    }
+
+    fn close(&mut self, fd: usize) -> SyscallResult<usize> {
+        trace!("close {}", fd);
+        if let Some(mut file) = self.files.remove(&fd) {
+            self.notifier.borrow_mut().unsubscribe(&file.path, fd);
+            if !file.done {
+                file.commit().map(|_| 0)
+            } else {
+                Ok(0)
+            }
+        } else {
+            Err(SyscallError::new(syscall::EBADF))
+        }
+    }
+
+    fn write(&mut self, fd: usize, buf: &[u8]) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        if file.done {
+            return Err(SyscallError::new(syscall::EBADF));
+        }
+
+        if file.uid != 0 {
+            return Err(SyscallError::new(syscall::EACCES));
+        }
+
+        if (WRITE_BUFFER_MAX_SIZE - file.write_buf.len()) < buf.len() {
+            return Err(SyscallError::new(syscall::EMSGSIZE));
+        }
+
+        file.write_buf.extend_from_slice(buf);
+
+        if let Err(e) = file.consume_lines() {
+            trace!("Failed write {} {}", fd, e);
+            file.done = true;
+            return Err(e);
+        }
+
+        Ok(buf.len())
+    }
+
+    fn read(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        let mut i = 0;
+        while i < buf.len() && file.pos < file.read_buf.len() {
+            buf[i] = file.read_buf[file.pos];
+            i += 1;
+            file.pos += 1;
+        }
+        Ok(i)
+    }
+
+    fn fstat(&mut self, fd: usize, stat: &mut Stat) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        stat.st_mode = if file.is_dir { MODE_DIR } else { MODE_FILE };
+        if file.is_writable {
+            stat.st_mode |= 0o222;
+        }
+        if file.is_readable {
+            stat.st_mode |= 0o444;
+        }
+        stat.st_uid = 0;
+        stat.st_gid = 0;
+        stat.st_size = file.read_buf.len() as u64;
+
+        Ok(0)
+    }
+
+    fn fevent(&mut self, fd: usize, events: SyscallEventFlags) -> SyscallResult<SyscallEventFlags> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+        if events.contains(syscall::EVENT_READ) {
+            self.notifier.borrow_mut().subscribe(&file.path, fd);
+        } else {
+            self.notifier.borrow_mut().unsubscribe(&file.path, fd);
+        }
+        Ok(SyscallEventFlags::empty())
+    }
+
+    fn fsync(&mut self, fd: usize) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        if !file.done {
+            let res = file.commit().map(|_| 0);
+            file.done = true;
+            res
+        } else {
+            Err(SyscallError::new(syscall::EBADF))
+        }
+    }
+}

netstack/src/smolnetd/scheme/netcfg/nodes.rs

@@ -0,0 +1,270 @@
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use syscall::Result as SyscallResult;
+
+pub type CfgNodeRef = Rc<RefCell<dyn CfgNode>>;
+
+pub trait NodeWriter {
+    fn write_line(&mut self, _: &str) -> SyscallResult<()> {
+        Ok(())
+    }
+
+    fn commit(&mut self) -> SyscallResult<()> {
+        Ok(())
+    }
+}
+
+pub struct SimpleWriter<T, WL, C>
+where
+    WL: 'static + Fn(&mut T, &str) -> SyscallResult<()>,
+    C: 'static + Fn(&mut T) -> SyscallResult<()>,
+{
+    data: T,
+    write_line: WL,
+    commit: C,
+}
+
+impl<T, WL, C> NodeWriter for SimpleWriter<T, WL, C>
+where
+    WL: 'static + Fn(&mut T, &str) -> SyscallResult<()>,
+    C: 'static + Fn(&mut T) -> SyscallResult<()>,
+{
+    fn write_line(&mut self, line: &str) -> SyscallResult<()> {
+        (self.write_line)(&mut self.data, line)
+    }
+
+    fn commit(&mut self) -> SyscallResult<()> {
+        (self.commit)(&mut self.data)
+    }
+}
+
+impl<T, WL, C> SimpleWriter<T, WL, C>
+where
+    WL: 'static + Fn(&mut T, &str) -> SyscallResult<()>,
+    C: 'static + Fn(&mut T) -> SyscallResult<()>,
+{
+    pub fn new_boxed(data: T, write_line: WL, commit: C) -> Box<Self> {
+        Box::new(SimpleWriter {
+            data,
+            write_line,
+            commit,
+        })
+    }
+}
+
+pub trait CfgNode {
+    fn is_dir(&self) -> bool {
+        false
+    }
+
+    fn is_writable(&self) -> bool {
+        false
+    }
+
+    fn is_readable(&self) -> bool {
+        true
+    }
+
+    fn read(&self) -> String {
+        String::new()
+    }
+
+    fn open(&self, _file: &str) -> Option<CfgNodeRef> {
+        None
+    }
+
+    fn new_writer(&self) -> Option<Box<dyn NodeWriter>> {
+        None
+    }
+}
+
+pub struct RONode<F>
+where
+    F: Fn() -> String,
+{
+    read_fun: F,
+}
+
+impl<F> CfgNode for RONode<F>
+where
+    F: Fn() -> String,
+{
+    fn read(&self) -> String {
+        (self.read_fun)()
+    }
+}
+
+impl<F> RONode<F>
+where
+    F: 'static + Fn() -> String,
+{
+    pub fn new_ref(read_fun: F) -> CfgNodeRef {
+        Rc::new(RefCell::new(RONode { read_fun }))
+    }
+}
+
+pub struct WONode<W>
+where
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    new_writer: W,
+}
+
+impl<W> CfgNode for WONode<W>
+where
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    fn is_readable(&self) -> bool {
+        false
+    }
+
+    fn is_writable(&self) -> bool {
+        true
+    }
+
+    fn new_writer(&self) -> Option<Box<dyn NodeWriter>> {
+        Some((self.new_writer)())
+    }
+}
+
+impl<W> WONode<W>
+where
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    pub fn new_ref(new_writer: W) -> CfgNodeRef {
+        Rc::new(RefCell::new(WONode { new_writer }))
+    }
+}
+
+pub struct RWNode<F, W>
+where
+    F: Fn() -> String,
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    read_fun: F,
+    new_writer: W,
+}
+
+impl<F, W> CfgNode for RWNode<F, W>
+where
+    F: Fn() -> String,
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    fn read(&self) -> String {
+        (self.read_fun)()
+    }
+
+    fn is_writable(&self) -> bool {
+        true
+    }
+
+    fn new_writer(&self) -> Option<Box<dyn NodeWriter>> {
+        Some((self.new_writer)())
+    }
+}
+
+impl<F, W> RWNode<F, W>
+where
+    F: 'static + Fn() -> String,
+    W: 'static + Fn() -> Box<dyn NodeWriter>,
+{
+    pub fn new_ref(read_fun: F, new_writer: W) -> CfgNodeRef {
+        Rc::new(RefCell::new(RWNode {
+            read_fun,
+            new_writer,
+        }))
+    }
+}
+
+pub struct StaticDirNode {
+    child_nodes: BTreeMap<String, CfgNodeRef>,
+}
+
+impl CfgNode for StaticDirNode {
+    fn is_dir(&self) -> bool {
+        true
+    }
+
+    fn read(&self) -> String {
+        let mut files = String::new();
+        for child in self.child_nodes.keys() {
+            if !files.is_empty() {
+                files.push('\n');
+            }
+            files += child;
+        }
+        files
+    }
+
+    fn open(&self, file: &str) -> Option<CfgNodeRef> {
+        self.child_nodes.get(file).map(|node| Rc::clone(node))
+    }
+}
+
+impl StaticDirNode {
+    pub fn new_ref(child_nodes: BTreeMap<String, CfgNodeRef>) -> CfgNodeRef {
+        Rc::new(RefCell::new(StaticDirNode { child_nodes }))
+    }
+}
+
+macro_rules! cfg_node {
+    (val $e:expr) => {
+        $e
+    };
+    (ro [ $($c:ident),* ] || $b:block ) => {
+        {
+            $(let $c = $c.clone();)*
+            RONode::new_ref(move|| $b)
+        }
+    };
+    (wo [ $($c:ident),* ] ( $et:ty , $e:expr ) |$data_i:ident, $line_i:ident|
+     $write_line:block |$data_i2:ident| $commit:block) => {
+        {
+            $(#[allow(unused_variables)] let $c = $c.clone();)*
+            let new_writer = move || -> Box<dyn NodeWriter> {
+                let write_line = {
+                    $(#[allow(unused_variables)] let $c = $c.clone();)*
+                    move |$data_i: &mut $et, $line_i: &str| $write_line
+                };
+                let commit = {
+                    $(#[allow(unused_variables)] let $c = $c.clone();)*
+                    move |$data_i2: &mut $et| $commit
+                };
+                let data: $et = $e;
+                SimpleWriter::new_boxed(data, write_line, commit)
+            };
+            WONode::new_ref(new_writer)
+        }
+    };
+    (rw [ $($c:ident),* ] ( $et:ty , $e:expr ) || $read_fun:block |$data_i:ident, $line_i:ident|
+     $write_line:block |$data_i2:ident| $commit:block) => {
+        {
+            let read_fun = {
+                $(#[allow(unused_variables)] let $c = $c.clone();)*
+                move || $read_fun
+            };
+            $(#[allow(unused_variables)] let $c = $c.clone();)*
+            let new_writer = move || -> Box<dyn NodeWriter> {
+                let write_line = {
+                    $(#[allow(unused_variables)] let $c = $c.clone();)*
+                    move |$data_i: &mut $et, $line_i: &str| $write_line
+                };
+                let commit = {
+                    $(#[allow(unused_variables)] let $c = $c.clone();)*
+                    move |$data_i2: &mut $et| $commit
+                };
+                let data: $et = $e;
+                SimpleWriter::new_boxed(data, write_line, commit)
+            };
+            RWNode::new_ref(read_fun, new_writer)
+        }
+    };
+    ($($e:expr => { $($t:tt)* }),* $(,)*) => {
+        {
+            let mut children = BTreeMap::new();
+            $(children.insert($e.into(), cfg_node!($($t)*));)*
+            StaticDirNode::new_ref(children)
+        }
+    };
+}

netstack/src/smolnetd/scheme/netcfg/notifier.rs

@@ -0,0 +1,62 @@
+use std::cell::RefCell;
+use std::collections::btree_map::Entry;
+use std::collections::{BTreeMap, BTreeSet};
+use std::rc::Rc;
+
+pub struct Notifier {
+    listeners: BTreeMap<String, BTreeSet<usize>>,
+    notified: BTreeSet<usize>,
+}
+
+pub type NotifierRef = Rc<RefCell<Notifier>>;
+
+impl Notifier {
+    pub fn new_ref() -> NotifierRef {
+        Rc::new(RefCell::new(Notifier {
+            listeners: BTreeMap::new(),
+            notified: BTreeSet::new(),
+        }))
+    }
+
+    pub fn subscribe(&mut self, path: &str, fd: usize) {
+        trace!("Sub fd {} to {}", fd, path);
+        match self.listeners.entry(path.to_owned()) {
+            Entry::Occupied(mut e) => {
+                e.get_mut().insert(fd);
+            }
+            Entry::Vacant(e) => {
+                let mut fds = BTreeSet::new();
+                fds.insert(fd);
+                e.insert(fds);
+            }
+        }
+    }
+
+    pub fn unsubscribe(&mut self, path: &str, fd: usize) {
+        let empty = if let Some(fds) = self.listeners.get_mut(path) {
+            if fds.remove(&fd) {
+                trace!("Unsub fd {} from {}", fd, path);
+            }
+            fds.is_empty()
+        } else {
+            false
+        };
+        if empty {
+            self.listeners.remove(path);
+        }
+    }
+
+    pub fn schedule_notify(&mut self, path: &str) {
+        trace!("Notifying {}", path);
+        if let Some(fds) = self.listeners.get(path) {
+            self.notified.extend(fds);
+        }
+    }
+
+    pub fn get_notified_fds(&mut self) -> BTreeSet<usize> {
+        use std::mem::swap;
+        let mut notified = BTreeSet::new();
+        swap(&mut self.notified, &mut notified);
+        notified
+    }
+}

netstack/src/smolnetd/scheme/socket.rs

@@ -0,0 +1,837 @@
+use std::cell::RefCell;
+use std::collections::btree_map::Entry;
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{ErrorKind, Read, Write};
+use std::marker::PhantomData;
+use std::mem;
+use std::ops::Deref;
+use std::ops::DerefMut;
+use std::rc::Rc;
+use std::str;
+
+use libredox::flag::{self, CLOCK_MONOTONIC};
+use syscall::data::TimeSpec;
+use syscall::flag::{EVENT_READ, EVENT_WRITE};
+use syscall::{self, KSMSG_CANCEL};
+use syscall::{
+    Error as SyscallError, EventFlags as SyscallEventFlags, Packet as SyscallPacket,
+    Result as SyscallResult, SchemeBlockMut,
+};
+
+use super::Interface;
+use crate::router::route_table::RouteTable;
+use crate::scheme::smoltcp::iface::SocketHandle;
+use redox_netstack::error::{Error, Result};
+use smoltcp::socket::AnySocket;
+
+use super::{post_fevent, SocketSet};
+
+pub struct Context {
+    pub iface: Interface,
+    pub route_table: Rc<RefCell<RouteTable>>,
+}
+
+pub struct NullFile {
+    pub flags: usize,
+    pub uid: u32,
+    pub gid: u32,
+}
+
+pub struct SocketFile<DataT> {
+    pub flags: usize,
+    pub data: DataT,
+
+    events: usize,
+    socket_handle: SocketHandle,
+    read_notified: bool,
+    write_notified: bool,
+    read_timeout: Option<TimeSpec>,
+    write_timeout: Option<TimeSpec>,
+}
+
+impl<DataT> SocketFile<DataT> {
+    pub fn clone_with_data(&self, data: DataT) -> SocketFile<DataT> {
+        SocketFile {
+            flags: self.flags,
+            events: self.events,
+            read_notified: false, // we still want to notify about this new socket
+            write_notified: false,
+            read_timeout: self.read_timeout,
+            write_timeout: self.write_timeout,
+            socket_handle: self.socket_handle,
+            data,
+        }
+    }
+
+    pub fn new_with_data(socket_handle: SocketHandle, data: DataT) -> SocketFile<DataT> {
+        SocketFile {
+            flags: 0,
+            events: 0,
+            read_notified: false,
+            write_notified: false,
+            read_timeout: None,
+            write_timeout: None,
+            socket_handle,
+            data,
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+enum Setting<SettingT: Copy> {
+    Ttl,
+    ReadTimeout,
+    WriteTimeout,
+    #[allow(dead_code)]
+    Other(SettingT),
+}
+
+pub struct SettingFile<SettingT: Copy> {
+    fd: usize,
+    socket_handle: SocketHandle,
+    setting: Setting<SettingT>,
+}
+
+pub enum SchemeFile<SocketT>
+where
+    SocketT: SchemeSocket,
+{
+    Setting(SettingFile<SocketT::SettingT>),
+    Socket(SocketFile<SocketT::DataT>),
+}
+
+impl<SocketT> SchemeFile<SocketT>
+where
+    SocketT: SchemeSocket,
+{
+    pub fn socket_handle(&self) -> SocketHandle {
+        match *self {
+            SchemeFile::Socket(SocketFile { socket_handle, .. })
+            | SchemeFile::Setting(SettingFile { socket_handle, .. }) => socket_handle,
+        }
+    }
+
+    pub fn events(&mut self, socket_set: &mut SocketSet) -> usize
+    where
+        SocketT: AnySocket<'static>,
+    {
+        let mut revents = 0;
+        if let &mut SchemeFile::Socket(SocketFile {
+            socket_handle,
+            events,
+            ref mut read_notified,
+            ref mut write_notified,
+            ..
+        }) = self
+        {
+            let socket = socket_set.get::<SocketT>(socket_handle);
+
+            if events & syscall::EVENT_READ.bits() == syscall::EVENT_READ.bits()
+                && (socket.can_recv() || !socket.may_recv())
+            {
+                if !*read_notified {
+                    *read_notified = true;
+                    revents |= EVENT_READ.bits();
+                }
+            } else {
+                *read_notified = false;
+            }
+
+            if events & syscall::EVENT_WRITE.bits() == syscall::EVENT_WRITE.bits()
+                && socket.can_send()
+            {
+                if !*write_notified {
+                    *write_notified = true;
+                    revents |= EVENT_WRITE.bits();
+                }
+            } else {
+                *write_notified = false;
+            }
+        }
+        revents
+    }
+}
+
+#[derive(Default, Clone)]
+struct WaitHandle {
+    until: Option<TimeSpec>,
+    packet: SyscallPacket,
+}
+
+type WaitQueue = Vec<WaitHandle>;
+
+pub type DupResult<T> = Option<(
+    SchemeFile<T>,
+    Option<(SocketHandle, <T as SchemeSocket>::DataT)>,
+)>;
+
+pub trait SchemeSocket
+where
+    Self: ::std::marker::Sized,
+{
+    type SchemeDataT;
+    type DataT;
+    type SettingT: Copy;
+
+    fn new_scheme_data() -> Self::SchemeDataT;
+
+    fn can_send(&self) -> bool;
+    fn can_recv(&self) -> bool;
+    fn may_recv(&self) -> bool;
+
+    fn hop_limit(&self) -> u8;
+    fn set_hop_limit(&mut self, hop_limit: u8);
+
+    fn get_setting(
+        file: &SocketFile<Self::DataT>,
+        setting: Self::SettingT,
+        buf: &mut [u8],
+    ) -> SyscallResult<usize>;
+    fn set_setting(
+        file: &mut SocketFile<Self::DataT>,
+        setting: Self::SettingT,
+        buf: &[u8],
+    ) -> SyscallResult<usize>;
+
+    fn new_socket(
+        sockets: &mut SocketSet,
+        path: &str,
+        uid: u32,
+        data: &mut Self::SchemeDataT,
+        context: &Context,
+    ) -> SyscallResult<(SocketHandle, Self::DataT)>;
+
+    fn close_file(
+        &self,
+        file: &SchemeFile<Self>,
+        data: &mut Self::SchemeDataT,
+    ) -> SyscallResult<()>;
+
+    fn write_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &[u8],
+    ) -> SyscallResult<Option<usize>>;
+
+    fn read_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<Option<usize>>;
+
+    fn fpath(&self, file: &SchemeFile<Self>, buf: &mut [u8]) -> SyscallResult<usize>;
+
+    fn dup(
+        sockets: &mut SocketSet,
+        file: &mut SchemeFile<Self>,
+        path: &str,
+        data: &mut Self::SchemeDataT,
+    ) -> SyscallResult<DupResult<Self>>;
+}
+
+pub struct SocketScheme<SocketT>
+where
+    SocketT: SchemeSocket + AnySocket<'static>,
+{
+    next_fd: usize,
+    nulls: BTreeMap<usize, NullFile>,
+    files: BTreeMap<usize, SchemeFile<SocketT>>,
+    ref_counts: BTreeMap<SocketHandle, usize>,
+    context: Context,
+    socket_set: Rc<RefCell<SocketSet>>,
+    scheme_file: File,
+    wait_queue: WaitQueue,
+    scheme_data: SocketT::SchemeDataT,
+    _phantom_socket: PhantomData<SocketT>,
+}
+
+impl<SocketT> SocketScheme<SocketT>
+where
+    SocketT: SchemeSocket + AnySocket<'static>,
+{
+    pub fn new(
+        iface: Interface,
+        route_table: Rc<RefCell<RouteTable>>,
+        socket_set: Rc<RefCell<SocketSet>>,
+        scheme_file: File,
+    ) -> SocketScheme<SocketT> {
+        SocketScheme {
+            next_fd: 1,
+            nulls: BTreeMap::new(),
+            files: BTreeMap::new(),
+            ref_counts: BTreeMap::new(),
+            socket_set,
+            scheme_data: SocketT::new_scheme_data(),
+            scheme_file,
+            wait_queue: Vec::new(),
+            _phantom_socket: PhantomData,
+            context: Context { iface, route_table },
+        }
+    }
+
+    pub fn on_scheme_event(&mut self) -> Result<Option<()>> {
+        let result = loop {
+            let mut packet = SyscallPacket::default();
+            match self.scheme_file.read(&mut packet) {
+                Ok(0) => {
+                    //TODO: Cleanup must occur
+                    break Some(());
+                }
+                Ok(_) => (),
+                Err(err) => {
+                    if err.kind() == ErrorKind::WouldBlock {
+                        break None;
+                    } else {
+                        return Err(Error::from(err));
+                    }
+                }
+            }
+            if packet.a == KSMSG_CANCEL {
+                println!("smolnetd: todo: handle cancellation");
+                continue;
+            }
+            if let Some(a) = self.handle(&mut packet) {
+                packet.a = a;
+                self.scheme_file.write_all(&packet)?;
+            } else {
+                match self.handle_block(&mut packet) {
+                    Ok(timeout) => {
+                        self.wait_queue.push(WaitHandle {
+                            until: timeout,
+                            packet,
+                        });
+                    }
+                    Err(err) => {
+                        packet.a = (-err.errno) as usize;
+                        self.scheme_file.write_all(&packet)?;
+                        return Err(Error::from_syscall_error(
+                            err,
+                            "Can't handle blocked socket",
+                        ));
+                    }
+                }
+            }
+        };
+        Ok(result)
+    }
+
+    pub fn notify_sockets(&mut self) -> Result<()> {
+        let cur_time = libredox::call::clock_gettime(flag::CLOCK_MONOTONIC)
+            .map_err(|e| Error::from_syscall_error(e.into(), "Can't get time"))?;
+
+        // Notify non-blocking sockets
+        for (&fd, ref mut file) in &mut self.files {
+            let events = {
+                let mut socket_set = self.socket_set.borrow_mut();
+                file.events(&mut socket_set)
+            };
+            if events > 0 {
+                post_fevent(&mut self.scheme_file, fd, events, 1)?;
+            }
+        }
+
+        // Wake up blocking queue
+        let mut i = 0;
+        while i < self.wait_queue.len() {
+            let mut packet = self.wait_queue[i].packet;
+            if let Some(a) = self.handle(&packet) {
+                self.wait_queue.remove(i);
+                packet.a = a;
+                self.scheme_file.write_all(&packet)?;
+            } else {
+                match self.wait_queue[i].until {
+                    Some(until)
+                        if (until.tv_sec < cur_time.tv_sec
+                            || (until.tv_sec == cur_time.tv_sec
+                                && i64::from(until.tv_nsec) < i64::from(cur_time.tv_nsec))) =>
+                    {
+                        self.wait_queue.remove(i);
+                        packet.a = (-syscall::ETIMEDOUT) as usize;
+                        self.scheme_file.write_all(&packet)?;
+                    }
+                    _ => {
+                        i += 1;
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn handle_block(&mut self, packet: &mut SyscallPacket) -> SyscallResult<Option<TimeSpec>> {
+        let fd = packet.b;
+        let (read_timeout, write_timeout) = {
+            let file = self
+                .files
+                .get(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+            if let SchemeFile::Socket(ref scheme_file) = *file {
+                Ok((scheme_file.read_timeout, scheme_file.write_timeout))
+            } else {
+                Err(SyscallError::new(syscall::EBADF))
+            }
+        }?;
+
+        let mut timeout = match packet.a {
+            syscall::SYS_WRITE => write_timeout,
+            syscall::SYS_READ => read_timeout,
+            _ => None,
+        };
+
+        if let Some(ref mut timeout) = timeout {
+            let cur_time = libredox::call::clock_gettime(CLOCK_MONOTONIC)?;
+            *timeout = add_time(
+                timeout,
+                &TimeSpec {
+                    tv_sec: cur_time.tv_sec,
+                    tv_nsec: cur_time.tv_nsec as i32,
+                },
+            )
+        }
+
+        Ok(timeout)
+    }
+
+    fn get_setting(
+        &mut self,
+        fd: usize,
+        setting: Setting<SocketT::SettingT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+        let file = match *file {
+            SchemeFile::Socket(ref mut file) => file,
+            _ => {
+                return Err(SyscallError::new(syscall::EBADF));
+            }
+        };
+
+        match setting {
+            Setting::Other(setting) => SocketT::get_setting(file, setting, buf),
+            Setting::Ttl => {
+                if let Some(hop_limit) = buf.get_mut(0) {
+                    let socket_set = self.socket_set.borrow();
+                    let socket = socket_set.get::<SocketT>(file.socket_handle);
+                    *hop_limit = socket.hop_limit();
+                    Ok(1)
+                } else {
+                    Err(SyscallError::new(syscall::EIO))
+                }
+            }
+            Setting::ReadTimeout | Setting::WriteTimeout => {
+                let timespec = match (setting, file.read_timeout, file.write_timeout) {
+                    (Setting::ReadTimeout, Some(read_timeout), _) => read_timeout,
+                    (Setting::WriteTimeout, _, Some(write_timeout)) => write_timeout,
+                    _ => {
+                        return Ok(0);
+                    }
+                };
+
+                if buf.len() < mem::size_of::<TimeSpec>() {
+                    Ok(0)
+                } else {
+                    let count = timespec.deref().read(buf).map_err(|err| {
+                        SyscallError::new(err.raw_os_error().unwrap_or(syscall::EIO))
+                    })?;
+                    Ok(count)
+                }
+            }
+        }
+    }
+
+    fn update_setting(
+        &mut self,
+        fd: usize,
+        setting: Setting<SocketT::SettingT>,
+        buf: &[u8],
+    ) -> SyscallResult<usize> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+        let file = match *file {
+            SchemeFile::Socket(ref mut file) => file,
+            _ => {
+                return Err(SyscallError::new(syscall::EBADF));
+            }
+        };
+        match setting {
+            Setting::ReadTimeout | Setting::WriteTimeout => {
+                let (timeout, count) = {
+                    if buf.len() < mem::size_of::<TimeSpec>() {
+                        (None, 0)
+                    } else {
+                        let mut timespec = TimeSpec::default();
+                        let count = timespec.deref_mut().write(buf).map_err(|err| {
+                            SyscallError::new(err.raw_os_error().unwrap_or(syscall::EIO))
+                        })?;
+                        (Some(timespec), count)
+                    }
+                };
+                match setting {
+                    Setting::ReadTimeout => {
+                        file.read_timeout = timeout;
+                    }
+                    Setting::WriteTimeout => {
+                        file.write_timeout = timeout;
+                    }
+                    _ => {}
+                };
+                Ok(count)
+            }
+            Setting::Ttl => {
+                if let Some(hop_limit) = buf.get(0) {
+                    let mut socket_set = self.socket_set.borrow_mut();
+                    let socket = socket_set.get_mut::<SocketT>(file.socket_handle);
+                    socket.set_hop_limit(*hop_limit);
+                    Ok(1)
+                } else {
+                    Err(SyscallError::new(syscall::EIO))
+                }
+            }
+            Setting::Other(setting) => SocketT::set_setting(file, setting, buf),
+        }
+    }
+}
+
+impl<SocketT> syscall::SchemeBlockMut for SocketScheme<SocketT>
+where
+    SocketT: SchemeSocket + AnySocket<'static>,
+{
+    fn open(
+        &mut self,
+        path: &str,
+        flags: usize,
+        uid: u32,
+        _gid: u32,
+    ) -> SyscallResult<Option<usize>> {
+        if path.is_empty() {
+            let null = NullFile {
+                flags,
+                uid,
+                gid: _gid,
+            };
+
+            let id = self.next_fd;
+            self.next_fd += 1;
+
+            self.nulls.insert(id, null);
+
+            Ok(Some(id))
+        } else {
+            let (socket_handle, data) = SocketT::new_socket(
+                &mut self.socket_set.borrow_mut(),
+                path,
+                uid,
+                &mut self.scheme_data,
+                &self.context,
+            )?;
+
+            let file = SchemeFile::Socket(SocketFile {
+                flags,
+                events: 0,
+                socket_handle,
+                read_notified: false,
+                write_notified: false,
+                write_timeout: None,
+                read_timeout: None,
+                data,
+            });
+
+            let id = self.next_fd;
+            self.next_fd += 1;
+
+            self.ref_counts.insert(socket_handle, 1);
+            self.files.insert(id, file);
+
+            Ok(Some(id))
+        }
+    }
+
+    fn close(&mut self, fd: usize) -> SyscallResult<Option<usize>> {
+        if let Some(_null) = self.nulls.remove(&fd) {
+            return Ok(Some(0));
+        }
+
+        let socket_handle = {
+            let file = self
+                .files
+                .get(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+            file.socket_handle()
+        };
+        let scheme_file = self.files.remove(&fd);
+        let mut socket_set = self.socket_set.borrow_mut();
+        if let Some(scheme_file) = scheme_file {
+            let socket = socket_set.get::<SocketT>(socket_handle);
+            socket.close_file(&scheme_file, &mut self.scheme_data)?;
+        }
+
+        self.wait_queue.retain(
+            |&WaitHandle {
+                 packet: SyscallPacket { a, .. },
+                 ..
+             }| a != fd,
+        );
+
+        let remove = match self.ref_counts.entry(socket_handle) {
+            Entry::Vacant(_) => {
+                warn!("Closing a socket_handle with no ref");
+                true
+            }
+            Entry::Occupied(mut e) => {
+                if *e.get() == 0 {
+                    warn!("Closing a socket_handle with no ref");
+                    e.remove();
+                    true
+                } else {
+                    *e.get_mut() -= 1;
+                    if *e.get() == 0 {
+                        e.remove();
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+        };
+
+        if remove {
+            socket_set.remove(socket_handle);
+        }
+        Ok(Some(0))
+    }
+
+    fn write(&mut self, fd: usize, buf: &[u8]) -> SyscallResult<Option<usize>> {
+        let (fd, setting) = {
+            let file = self
+                .files
+                .get_mut(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+            match *file {
+                SchemeFile::Setting(ref setting_handle) => {
+                    (setting_handle.fd, setting_handle.setting)
+                }
+                SchemeFile::Socket(ref mut file) => {
+                    let mut socket_set = self.socket_set.borrow_mut();
+                    let socket = socket_set.get_mut::<SocketT>(file.socket_handle);
+                    let ret = SocketT::write_buf(socket, file, buf);
+                    match ret {
+                        Ok(None) => {}
+                        _ => file.write_notified = false,
+                    }
+                    return ret;
+                }
+            }
+        };
+        self.update_setting(fd, setting, buf).map(Some)
+    }
+
+    fn read(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult<Option<usize>> {
+        let (fd, setting) = {
+            let file = self
+                .files
+                .get_mut(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+            match *file {
+                SchemeFile::Setting(ref setting_handle) => {
+                    (setting_handle.fd, setting_handle.setting)
+                }
+                SchemeFile::Socket(ref mut file) => {
+                    let mut socket_set = self.socket_set.borrow_mut();
+                    let socket = socket_set.get_mut::<SocketT>(file.socket_handle);
+
+                    let ret = SocketT::read_buf(socket, file, buf);
+                    match ret {
+                        Ok(None) => {}
+                        _ => file.read_notified = false,
+                    }
+
+                    return ret;
+                }
+            }
+        };
+        self.get_setting(fd, setting, buf).map(Some)
+    }
+
+    fn dup(&mut self, fd: usize, buf: &[u8]) -> SyscallResult<Option<usize>> {
+        let path = str::from_utf8(buf).or_else(|_| Err(SyscallError::new(syscall::EINVAL)))?;
+
+        if let Some((flags, uid, gid)) = self
+            .nulls
+            .get(&fd)
+            .map(|null| (null.flags, null.uid, null.gid))
+        {
+            return self.open(path, flags, uid, gid);
+        }
+
+        let new_file = {
+            let file = self
+                .files
+                .get_mut(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+            let socket_handle = file.socket_handle();
+
+            let (new_handle, update_with) = match path {
+                "hop_limit" => (
+                    SchemeFile::Setting(SettingFile {
+                        socket_handle,
+                        fd,
+                        setting: Setting::Ttl,
+                    }),
+                    None,
+                ),
+                "read_timeout" => (
+                    SchemeFile::Setting(SettingFile {
+                        socket_handle,
+                        fd,
+                        setting: Setting::ReadTimeout,
+                    }),
+                    None,
+                ),
+                "write_timeout" => (
+                    SchemeFile::Setting(SettingFile {
+                        socket_handle,
+                        fd,
+                        setting: Setting::WriteTimeout,
+                    }),
+                    None,
+                ),
+                _ => match SocketT::dup(
+                    &mut self.socket_set.borrow_mut(),
+                    file,
+                    path,
+                    &mut self.scheme_data,
+                )? {
+                    Some(some) => some,
+                    None => return Ok(None),
+                },
+            };
+
+            if let Some((socket_handle, data)) = update_with {
+                if let SchemeFile::Socket(ref mut file) = *file {
+                    // We replace the socket_handle pointed by file so update the ref_counts
+                    // accordingly
+                    self.ref_counts
+                        .entry(file.socket_handle)
+                        .and_modify(|e| *e = e.saturating_sub(1))
+                        .or_insert(0);
+
+                    *self.ref_counts.entry(socket_handle).or_insert(0) += 1;
+
+                    file.socket_handle = socket_handle;
+                    file.data = data;
+                }
+            }
+            *self
+                .ref_counts
+                .entry(new_handle.socket_handle())
+                .or_insert(0) += 1;
+            new_handle
+        };
+
+        let id = self.next_fd;
+        self.files.insert(id, new_file);
+        self.next_fd += 1;
+
+        Ok(Some(id))
+    }
+
+    fn fevent(
+        &mut self,
+        fd: usize,
+        events: SyscallEventFlags,
+    ) -> SyscallResult<Option<SyscallEventFlags>> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+        match *file {
+            SchemeFile::Setting(_) => return Err(SyscallError::new(syscall::EBADF)),
+            SchemeFile::Socket(ref mut file) => {
+                file.events = events.bits();
+                file.read_notified = false; // resend missed events
+                file.write_notified = false;
+            }
+        }
+        let mut socket_set = self.socket_set.borrow_mut();
+        let revents = SyscallEventFlags::from_bits_truncate(file.events(&mut socket_set));
+        Ok(Some(revents))
+    }
+
+    fn fsync(&mut self, fd: usize) -> SyscallResult<Option<usize>> {
+        {
+            let _file = self
+                .files
+                .get_mut(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+        }
+        Ok(Some(0))
+        // TODO Implement fsyncing
+        // self.0.network_fsync()
+    }
+
+    fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult<Option<usize>> {
+        let file = self
+            .files
+            .get_mut(&fd)
+            .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+        let socket_set = self.socket_set.borrow();
+        let socket = socket_set.get::<SocketT>(file.socket_handle());
+
+        socket.fpath(file, buf).map(Some)
+    }
+
+    fn fcntl(&mut self, fd: usize, cmd: usize, arg: usize) -> SyscallResult<Option<usize>> {
+        if let Some(ref mut null) = self.nulls.get_mut(&fd) {
+            match cmd {
+                syscall::F_GETFL => Ok(Some(null.flags)),
+                syscall::F_SETFL => {
+                    null.flags = arg & !syscall::O_ACCMODE;
+                    Ok(Some(0))
+                }
+                _ => Err(SyscallError::new(syscall::EINVAL)),
+            }
+        } else {
+            let file = self
+                .files
+                .get_mut(&fd)
+                .ok_or_else(|| SyscallError::new(syscall::EBADF))?;
+
+            if let SchemeFile::Socket(ref mut socket_file) = *file {
+                match cmd {
+                    syscall::F_GETFL => Ok(Some(socket_file.flags)),
+                    syscall::F_SETFL => {
+                        socket_file.flags = arg & !syscall::O_ACCMODE;
+                        Ok(Some(0))
+                    }
+                    _ => Err(SyscallError::new(syscall::EINVAL)),
+                }
+            } else {
+                Err(SyscallError::new(syscall::EBADF))
+            }
+        }
+    }
+}
+
+fn add_time(a: &TimeSpec, b: &TimeSpec) -> TimeSpec {
+    let mut secs = a.tv_sec + b.tv_sec;
+    let mut nsecs = a.tv_nsec + b.tv_nsec;
+
+    secs += i64::from(nsecs) / 1_000_000_000;
+    nsecs %= 1_000_000_000;
+
+    TimeSpec {
+        tv_sec: secs,
+        tv_nsec: nsecs,
+    }
+}

netstack/src/smolnetd/scheme/tcp.rs

@@ -0,0 +1,301 @@
+use smoltcp::iface::SocketHandle;
+use smoltcp::socket::tcp::{Socket as TcpSocket, SocketBuffer as TcpSocketBuffer};
+use smoltcp::wire::{IpEndpoint, IpListenEndpoint};
+use std::fmt::Write;
+use std::str;
+use syscall;
+use syscall::{Error as SyscallError, Result as SyscallResult};
+
+use super::socket::{Context, DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme};
+use super::{parse_endpoint, SocketSet};
+use crate::port_set::PortSet;
+
+pub type TcpScheme = SocketScheme<TcpSocket<'static>>;
+
+impl<'a> SchemeSocket for TcpSocket<'a> {
+    type SchemeDataT = PortSet;
+    type DataT = Option<IpListenEndpoint>;
+    type SettingT = ();
+
+    fn new_scheme_data() -> Self::SchemeDataT {
+        PortSet::new(49_152u16, 65_535u16).expect("Wrong TCP port numbers")
+    }
+
+    fn can_send(&self) -> bool {
+        self.can_send()
+    }
+
+    fn can_recv(&self) -> bool {
+        self.can_recv()
+    }
+
+    fn may_recv(&self) -> bool {
+        self.may_recv()
+    }
+
+    fn hop_limit(&self) -> u8 {
+        self.hop_limit().unwrap_or(64)
+    }
+
+    fn set_hop_limit(&mut self, hop_limit: u8) {
+        self.set_hop_limit(Some(hop_limit));
+    }
+
+    fn get_setting(
+        _file: &SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &mut [u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn set_setting(
+        _file: &mut SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &[u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn new_socket(
+        socket_set: &mut SocketSet,
+        path: &str,
+        uid: u32,
+        port_set: &mut Self::SchemeDataT,
+        context: &Context,
+    ) -> SyscallResult<(SocketHandle, Self::DataT)> {
+        trace!("TCP open {}", path);
+        let mut parts = path.split('/');
+        let remote_endpoint = parse_endpoint(parts.next().unwrap_or(""));
+        let mut local_endpoint = parse_endpoint(parts.next().unwrap_or(""));
+
+        if local_endpoint.port > 0 && local_endpoint.port <= 1024 && uid != 0 {
+            return Err(SyscallError::new(syscall::EACCES));
+        }
+
+        let rx_packets = vec![0; 0xffff];
+        let tx_packets = vec![0; 0xffff];
+        let rx_buffer = TcpSocketBuffer::new(rx_packets);
+        let tx_buffer = TcpSocketBuffer::new(tx_packets);
+        let socket = TcpSocket::new(rx_buffer, tx_buffer);
+
+        if local_endpoint.port == 0 {
+            local_endpoint.port = port_set
+                .get_port()
+                .ok_or_else(|| SyscallError::new(syscall::EINVAL))?;
+        } else if !port_set.claim_port(local_endpoint.port) {
+            return Err(SyscallError::new(syscall::EADDRINUSE));
+        }
+
+        let socket_handle = socket_set.add(socket);
+
+        let tcp_socket = socket_set.get_mut::<TcpSocket>(socket_handle);
+
+        let listen_enpoint = if remote_endpoint.is_specified() {
+            let local_endpoint_addr = match local_endpoint.addr {
+                Some(addr) if !addr.is_unspecified() => Some(addr),
+                _ => {
+                    let route_table = context.route_table.borrow();
+                    let addr = route_table
+                        .lookup_src_addr(&remote_endpoint.addr.expect("Checked in is_specified"));
+                    if matches!(addr, None) {
+                        error!("Opening a TCP connection with a probably invalid source IP as no route have been found for destination: {}", remote_endpoint);
+                    }
+                    addr
+                }
+            };
+            let local_endpoint = IpListenEndpoint {
+                addr: local_endpoint_addr,
+                port: local_endpoint.port,
+            };
+
+            trace!("Connecting tcp {} {}", local_endpoint, remote_endpoint);
+            tcp_socket
+                .connect(
+                    context.iface.borrow_mut().context(),
+                    IpEndpoint::new(remote_endpoint.addr.unwrap(), remote_endpoint.port),
+                    local_endpoint,
+                )
+                .expect("Can't connect tcp socket ");
+            None
+        } else {
+            trace!("Listening tcp {}", local_endpoint);
+            tcp_socket
+                .listen(local_endpoint)
+                .expect("Can't listen on local endpoint");
+            Some(local_endpoint)
+        };
+
+        Ok((socket_handle, listen_enpoint))
+    }
+
+    fn close_file(
+        &self,
+        file: &SchemeFile<Self>,
+        port_set: &mut Self::SchemeDataT,
+    ) -> SyscallResult<()> {
+        if let SchemeFile::Socket(SocketFile { data, .. }) = *file {
+            if let Some(endpoint) = self.local_endpoint() {
+                // Socket was connected on some port
+                port_set.release_port(endpoint.port);
+            } else if let Some(endpoint) = data {
+                // Socket was listening on some port
+                port_set.release_port(endpoint.port);
+            }
+        }
+        Ok(())
+    }
+
+    fn write_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &[u8],
+    ) -> SyscallResult<Option<usize>> {
+        if !self.is_active() {
+            Err(SyscallError::new(syscall::ENOTCONN))
+        } else if self.can_send() {
+            self.send_slice(buf).expect("Can't send slice");
+            Ok(Some(buf.len()))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-write
+        }
+    }
+
+    fn read_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<Option<usize>> {
+        if !self.is_active() {
+            Err(SyscallError::new(syscall::ENOTCONN))
+        } else if self.can_recv() {
+            let length = self.recv_slice(buf).expect("Can't receive slice");
+            Ok(Some(length))
+        } else if !self.may_recv() {
+            Ok(Some(0))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn dup(
+        socket_set: &mut SocketSet,
+        file: &mut SchemeFile<Self>,
+        path: &str,
+        port_set: &mut Self::SchemeDataT,
+    ) -> SyscallResult<DupResult<Self>> {
+        let socket_handle = file.socket_handle();
+
+        let (is_active, local_endpoint) = {
+            let socket = socket_set.get::<TcpSocket>(socket_handle);
+            (socket.is_active(), socket.local_endpoint())
+        };
+
+        let file = match path {
+            "listen" => {
+                if let SchemeFile::Socket(ref tcp_handle) = *file {
+                    let Some(listen_enpoint) = tcp_handle.data else {
+                        // This socket is not listening so we can't accept a connection
+                        return Err(SyscallError::new(syscall::EINVAL));
+                    };
+
+                    if !is_active {
+                        // Socket listening but no connection received
+                        if tcp_handle.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+                            return Err(SyscallError::new(syscall::EAGAIN));
+                        } else {
+                            return Ok(None);
+                        }
+                    }
+                    trace!("TCP creating new listening socket");
+                    // We pass None as data because this new handle is to the active connection so
+                    // not a listening socket
+                    let new_handle = SchemeFile::Socket(tcp_handle.clone_with_data(None));
+
+                    // Creating a socket to continue listening
+                    let rx_packets = vec![0; 0xffff];
+                    let tx_packets = vec![0; 0xffff];
+                    let rx_buffer = TcpSocketBuffer::new(rx_packets);
+                    let tx_buffer = TcpSocketBuffer::new(tx_packets);
+                    let socket = TcpSocket::new(rx_buffer, tx_buffer);
+                    let new_socket_handle = socket_set.add(socket);
+                    {
+                        let tcp_socket = socket_set.get_mut::<TcpSocket>(new_socket_handle);
+                        tcp_socket
+                            .listen(listen_enpoint)
+                            .expect("Can't listen on local endpoint");
+                    }
+                    // We got a new connection to the socket so acquire the port
+                    port_set.acquire_port(
+                        local_endpoint
+                            .expect("Socket was active so local endpoint must be set")
+                            .port,
+                    );
+                    return Ok(Some((
+                        new_handle,
+                        Some((new_socket_handle, Some(listen_enpoint))),
+                    )));
+                } else {
+                    return Err(SyscallError::new(syscall::EBADF));
+                }
+            }
+            _ => {
+                trace!("TCP dup unknown {}", path);
+                if let SchemeFile::Socket(ref tcp_handle) = *file {
+                    SchemeFile::Socket(tcp_handle.clone_with_data(tcp_handle.data))
+                } else {
+                    SchemeFile::Socket(SocketFile::new_with_data(socket_handle, None))
+                }
+            }
+        };
+
+        if let SchemeFile::Socket(_) = file {
+            if let Some(local_endpoint) = local_endpoint {
+                port_set.acquire_port(local_endpoint.port);
+            }
+        }
+
+        Ok(Some((file, None)))
+    }
+
+    fn fpath(&self, file: &SchemeFile<Self>, buf: &mut [u8]) -> SyscallResult<usize> {
+        let unspecified = "0.0.0.0:0";
+        let mut path = String::from("tcp:");
+        match self.remote_endpoint() {
+            Some(endpoint) => write!(&mut path, "{}", endpoint).unwrap(),
+            None => path.push_str(unspecified),
+        }
+        path.push('/');
+        match (self.local_endpoint(), file) {
+            (Some(endpoint), _) => write!(&mut path, "{}", endpoint).unwrap(),
+            (
+                None,
+                SchemeFile::Socket(SocketFile {
+                    data: Some(endpoint),
+                    ..
+                }),
+            ) => {
+                if endpoint.is_specified() {
+                    write!(&mut path, "{}", endpoint).unwrap()
+                } else {
+                    write!(&mut path, "0.0.0.0:{}", endpoint.port).unwrap()
+                }
+            }
+            _ => path.push_str(unspecified),
+        }
+        trace!("fpath: {}", path);
+        let path = path.as_bytes();
+
+        let mut i = 0;
+        while i < buf.len() && i < path.len() {
+            buf[i] = path[i];
+            i += 1;
+        }
+
+        Ok(i)
+    }
+}

netstack/src/smolnetd/scheme/udp.rs

@@ -0,0 +1,208 @@
+use smoltcp::iface::SocketHandle;
+use smoltcp::socket::udp::{
+    PacketBuffer as UdpSocketBuffer, PacketMetadata as UdpPacketMetadata, Socket as UdpSocket,
+};
+use smoltcp::wire::{IpEndpoint, IpListenEndpoint};
+use std::str;
+use syscall;
+use syscall::{Error as SyscallError, Result as SyscallResult};
+
+use super::socket::{Context, DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme};
+use super::{parse_endpoint, Smolnetd, SocketSet};
+use crate::port_set::PortSet;
+use crate::router::Router;
+
+pub type UdpScheme = SocketScheme<UdpSocket<'static>>;
+
+impl<'a> SchemeSocket for UdpSocket<'a> {
+    type SchemeDataT = PortSet;
+    type DataT = IpListenEndpoint;
+    type SettingT = ();
+
+    fn new_scheme_data() -> Self::SchemeDataT {
+        PortSet::new(49_152u16, 65_535u16).expect("Wrong UDP port numbers")
+    }
+
+    fn can_send(&self) -> bool {
+        self.can_send()
+    }
+
+    fn can_recv(&self) -> bool {
+        self.can_recv()
+    }
+
+    fn may_recv(&self) -> bool {
+        true
+    }
+
+    fn hop_limit(&self) -> u8 {
+        self.hop_limit().unwrap_or(64)
+    }
+
+    fn set_hop_limit(&mut self, hop_limit: u8) {
+        self.set_hop_limit(Some(hop_limit));
+    }
+
+    fn get_setting(
+        _file: &SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &mut [u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn set_setting(
+        _file: &mut SocketFile<Self::DataT>,
+        _setting: Self::SettingT,
+        _buf: &[u8],
+    ) -> SyscallResult<usize> {
+        Ok(0)
+    }
+
+    fn new_socket(
+        socket_set: &mut SocketSet,
+        path: &str,
+        uid: u32,
+        port_set: &mut Self::SchemeDataT,
+        _context: &Context,
+    ) -> SyscallResult<(SocketHandle, Self::DataT)> {
+        let mut parts = path.split('/');
+        let remote_endpoint = parse_endpoint(parts.next().unwrap_or(""));
+        let mut local_endpoint = parse_endpoint(parts.next().unwrap_or(""));
+
+        if local_endpoint.port > 0 && local_endpoint.port <= 1024 && uid != 0 {
+            return Err(SyscallError::new(syscall::EACCES));
+        }
+
+        let rx_buffer = UdpSocketBuffer::new(
+            vec![UdpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        let tx_buffer = UdpSocketBuffer::new(
+            vec![UdpPacketMetadata::EMPTY; Smolnetd::SOCKET_BUFFER_SIZE],
+            vec![0; Router::MTU * Smolnetd::SOCKET_BUFFER_SIZE],
+        );
+        let udp_socket = UdpSocket::new(rx_buffer, tx_buffer);
+
+        if local_endpoint.port == 0 {
+            local_endpoint.port = port_set
+                .get_port()
+                .ok_or_else(|| SyscallError::new(syscall::EINVAL))?;
+        } else if !port_set.claim_port(local_endpoint.port) {
+            return Err(SyscallError::new(syscall::EADDRINUSE));
+        }
+
+        let socket_handle = socket_set.add(udp_socket);
+
+        let udp_socket = socket_set.get_mut::<UdpSocket>(socket_handle);
+        udp_socket
+            .bind(local_endpoint)
+            .expect("Can't bind udp socket to local endpoint");
+
+        Ok((socket_handle, remote_endpoint))
+    }
+
+    fn close_file(
+        &self,
+        file: &SchemeFile<Self>,
+        port_set: &mut Self::SchemeDataT,
+    ) -> SyscallResult<()> {
+        if let SchemeFile::Socket(_) = *file {
+            port_set.release_port(self.endpoint().port);
+        }
+        Ok(())
+    }
+
+    fn write_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &[u8],
+    ) -> SyscallResult<Option<usize>> {
+        if !file.data.is_specified() {
+            return Err(SyscallError::new(syscall::EADDRNOTAVAIL));
+        }
+        if self.can_send() {
+            let endpoint = file.data;
+            let endpoint = IpEndpoint::new(
+                endpoint
+                    .addr
+                    .expect("If we can send, this should be specified"),
+                endpoint.port,
+            );
+            self.send_slice(buf, endpoint).expect("Can't send slice");
+            Ok(Some(buf.len()))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn read_buf(
+        &mut self,
+        file: &mut SocketFile<Self::DataT>,
+        buf: &mut [u8],
+    ) -> SyscallResult<Option<usize>> {
+        if self.can_recv() {
+            let (length, _) = self.recv_slice(buf).expect("Can't receive slice");
+            Ok(Some(length))
+        } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK {
+            Err(SyscallError::new(syscall::EAGAIN))
+        } else {
+            Ok(None) // internally scheduled to re-read
+        }
+    }
+
+    fn dup(
+        socket_set: &mut SocketSet,
+        file: &mut SchemeFile<Self>,
+        path: &str,
+        port_set: &mut Self::SchemeDataT,
+    ) -> SyscallResult<DupResult<Self>> {
+        let socket_handle = file.socket_handle();
+        let file = match path {
+            _ => {
+                let remote_endpoint = parse_endpoint(path);
+                if let SchemeFile::Socket(ref udp_handle) = *file {
+                    SchemeFile::Socket(udp_handle.clone_with_data(
+                        if remote_endpoint.is_specified() {
+                            remote_endpoint
+                        } else {
+                            udp_handle.data
+                        },
+                    ))
+                } else {
+                    SchemeFile::Socket(SocketFile::new_with_data(socket_handle, remote_endpoint))
+                }
+            }
+        };
+
+        let endpoint = {
+            let socket = socket_set.get::<UdpSocket>(socket_handle);
+            socket.endpoint()
+        };
+
+        if let SchemeFile::Socket(_) = file {
+            port_set.acquire_port(endpoint.port);
+        }
+
+        Ok(Some((file, None)))
+    }
+
+    fn fpath(&self, file: &SchemeFile<Self>, buf: &mut [u8]) -> SyscallResult<usize> {
+        if let SchemeFile::Socket(ref socket_file) = *file {
+            let path = format!("udp:{}/{}", socket_file.data, self.endpoint());
+            let path = path.as_bytes();
+
+            let mut i = 0;
+            while i < buf.len() && i < path.len() {
+                buf[i] = path[i];
+                i += 1;
+            }
+
+            Ok(i)
+        } else {
+            Err(SyscallError::new(syscall::EBADF))
+        }
+    }
+}