Move file descriptors to schemas.

src/smolnetd/scheme/ip.rs

@@ -1,11 +1,15 @@
 use smoltcp::socket::{AsSocket, RawPacketBuffer, RawSocket, RawSocketBuffer, SocketHandle};
 use smoltcp::wire::{IpProtocol, IpVersion};
+use std::fs::File;
+use std::io::{Read, Write};
 use std::collections::BTreeMap;
+use syscall::SchemeMut;
 use syscall;
 
 use device::NetworkDevice;
 use error::Result;
 use super::{Smolnetd, SocketSet};
+use super::post_fevent;
 
 pub struct RawHandle {
     flags: usize,
@@ -17,23 +21,37 @@ pub struct IpScheme {
     next_ip_fd: usize,
     raw_sockets: BTreeMap<usize, RawHandle>,
     socket_set: SocketSet,
+    ip_file: File,
 }
 
 impl IpScheme {
-    pub fn new(socket_set: SocketSet) -> IpScheme {
+    pub fn new(socket_set: SocketSet, ip_file: File) -> IpScheme {
         IpScheme {
             next_ip_fd: 1,
             raw_sockets: BTreeMap::new(),
             socket_set,
+            ip_file,
         }
     }
 
-    pub fn notify_ready_sockets<F: FnMut(usize) -> Result<()>>(&self, mut f: F) -> Result<()> {
+    pub fn on_scheme_event(&mut self) -> Result<Option<()>> {
+        loop {
+            let mut packet = syscall::Packet::default();
+            if self.ip_file.read(&mut packet)? == 0 {
+                break;
+            }
+            self.handle(&mut packet);
+            self.ip_file.write_all(&packet)?;
+        }
+        Ok(None)
+    }
+
+    pub fn notify_sockets(&mut self) -> Result<()> {
         for (&fd, ref handle) in &self.raw_sockets {
             let mut socket_set = self.socket_set.borrow_mut();
             let socket: &mut RawSocket = socket_set.get_mut(handle.socket_handle).as_socket();
             if socket.can_send() {
-                f(fd)?
+                post_fevent(&mut self.ip_file, fd, syscall::EVENT_READ, 1)?;
             }
         }
         Ok(())

src/smolnetd/scheme/mod.rs

@@ -8,7 +8,6 @@ use std::mem;
 use std::rc::Rc;
 use std::str::FromStr;
 use std::time::Instant;
-use syscall::SchemeMut;
 use syscall;
 
 use buffer_pool::{Buffer, BufferPool};
@@ -24,8 +23,6 @@ type SocketSet = Rc<RefCell<smoltcp::socket::SocketSet<'static, 'static, 'static
 
 pub struct Smolnetd {
     network_file: Rc<RefCell<File>>,
-    ip_file: File,
-    udp_file: File,
     time_file: File,
 
     iface: smoltcp::iface::EthernetInterface<'static, 'static, 'static, NetworkDevice>,
@@ -71,11 +68,9 @@ impl Smolnetd {
             iface,
             socket_set: socket_set.clone(),
             startup_time: Instant::now(),
-            ip_file,
-            udp_file,
             time_file,
-            ip_scheme: IpScheme::new(socket_set.clone()),
-            udp_scheme: UdpScheme::new(socket_set.clone()),
+            ip_scheme: IpScheme::new(socket_set.clone(), ip_file),
+            udp_scheme: UdpScheme::new(socket_set.clone(), udp_file),
             input_queue,
             network_file,
             input_buffer_pool: BufferPool::new(Self::INGRESS_PACKET_SIZE),
@@ -90,27 +85,11 @@ impl Smolnetd {
     }
 
     pub fn on_ip_scheme_event(&mut self) -> Result<Option<()>> {
-        loop {
-            let mut packet = syscall::Packet::default();
-            if self.ip_file.read(&mut packet)? == 0 {
-                break;
-            }
-            self.ip_scheme.handle(&mut packet);
-            self.ip_file.write_all(&packet)?;
-        }
-        Ok(None)
+        self.ip_scheme.on_scheme_event()
     }
 
     pub fn on_udp_scheme_event(&mut self) -> Result<Option<()>> {
-        loop {
-            let mut packet = syscall::Packet::default();
-            if self.udp_file.read(&mut packet)? == 0 {
-                break;
-            }
-            self.udp_scheme.handle(&mut packet);
-            self.udp_file.write_all(&packet)?;
-        }
-        Ok(None)
+        self.udp_scheme.on_scheme_event()
     }
 
     pub fn on_time_event(&mut self) -> Result<Option<()>> {
@@ -171,12 +150,8 @@ impl Smolnetd {
     }
 
     fn notify_raw_sockets(&mut self) -> Result<()> {
-        let ip_file = &mut self.ip_file;
-        self.ip_scheme
-            .notify_ready_sockets(|fd| post_fevent(ip_file, fd, syscall::EVENT_READ, 1))?;
-        let udp_file = &mut self.udp_file;
-        self.udp_scheme
-            .notify_ready_sockets(|fd| post_fevent(udp_file, fd, syscall::EVENT_READ, 1))
+        self.ip_scheme.notify_sockets()?;
+        self.udp_scheme.notify_sockets()
     }
 }
 

src/smolnetd/scheme/udp.rs

@@ -1,14 +1,18 @@
 use smoltcp::socket::{AsSocket, SocketHandle, UdpPacketBuffer, UdpSocket, UdpSocketBuffer};
 use smoltcp::wire::{IpAddress, IpEndpoint, Ipv4Address};
 use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{Read, Write};
 use std::str::FromStr;
 use std::str;
+use syscall::SchemeMut;
 use syscall;
 
 use device::NetworkDevice;
 use error::Result;
 use super::{Smolnetd, SocketSet};
 use port_set::PortSet;
+use super::post_fevent;
 
 enum Setting {
     Ttl,
@@ -42,25 +46,40 @@ pub struct UdpScheme {
     udp_fds: BTreeMap<usize, FdHandle>,
     socket_set: SocketSet,
     port_set: PortSet,
+    udp_file: File,
 }
 
 impl UdpScheme {
-    pub fn new(socket_set: SocketSet) -> UdpScheme {
+    pub fn new(socket_set: SocketSet, udp_file: File) -> UdpScheme {
         UdpScheme {
             next_udp_fd: 1,
             udp_fds: BTreeMap::new(),
             socket_set,
-            port_set: PortSet::new(1025u16, 0xFFFFu16).expect("Wrong UDP port numbers"),
+            // 49152..65535 is the suggested range for dynamic private ports
+            port_set: PortSet::new(49152u16, 65535u16).expect("Wrong UDP port numbers"),
+            udp_file,
         }
     }
 
-    pub fn notify_ready_sockets<F: FnMut(usize) -> Result<()>>(&self, mut f: F) -> Result<()> {
+    pub fn on_scheme_event(&mut self) -> Result<Option<()>> {
+        loop {
+            let mut packet = syscall::Packet::default();
+            if self.udp_file.read(&mut packet)? == 0 {
+                break;
+            }
+            self.handle(&mut packet);
+            self.udp_file.write_all(&packet)?;
+        }
+        Ok(None)
+    }
+
+    pub fn notify_sockets(&mut self) -> Result<()> {
         for (&fd, handle) in &self.udp_fds {
             if let &FdHandle::Socket(UdpHandle { socket_handle, .. }) = handle {
                 let mut socket_set = self.socket_set.borrow_mut();
                 let socket: &mut UdpSocket = socket_set.get_mut(socket_handle).as_socket();
                 if socket.can_send() {
-                    f(fd)?
+                    post_fevent(&mut self.udp_file, fd, syscall::EVENT_READ, 1)?;
                 }
             }
         }