Orbital (#16)

* Port previous ethernet scheme

* Add ipd

* Fix initfs rebuilds, use QEMU user networking addresses in ipd

* Add tcp/udp, netutils, dns, and network config

* Add fsync to network driver

* Add dns, router, subnet by default

* Fix e1000 driver. Make ethernet and IP non-blocking to avoid deadlocks

* Add orbital server, WIP

* Add futex

* Add orbutils and orbital

* Update libstd, orbutils, and orbital
Move ANSI key encoding to vesad

* Add orbital assets

* Update orbital

* Update to add login manager

* Add blocking primitives, block for most things except waitpid, update orbital

* Wait in waitpid and IRQ, improvements for other waits

* Fevent in root scheme

* WIP: Switch to using fevent

* Reorganize

* Event based e1000d driver

* Superuser-only access to some network schemes, display, and disk

* Superuser root and irq schemes

* Fix orbital

schemes/udpd/src/resource.rs

@@ -0,0 +1,114 @@
+use std::{cmp, mem};
+
+use resource_scheme::Resource;
+use syscall;
+use syscall::error::*;
+
+use common::{n16, Ipv4Addr, Checksum, IP_ADDR, Udp, UdpHeader};
+
+/// UDP resource
+pub struct UdpResource {
+    pub ip: usize,
+    pub data: Vec<u8>,
+    pub peer_addr: Ipv4Addr,
+    pub peer_port: u16,
+    pub host_port: u16,
+}
+
+impl Resource for UdpResource {
+    fn dup(&self) -> Result<Box<UdpResource>> {
+        match syscall::dup(self.ip) {
+            Ok(ip) => {
+                Ok(Box::new(UdpResource {
+                    ip: ip,
+                    data: self.data.clone(),
+                    peer_addr: self.peer_addr,
+                    peer_port: self.peer_port,
+                    host_port: self.host_port,
+                }))
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    fn path(&self, buf: &mut [u8]) -> Result<usize> {
+        let path_string = format!("udp:{}:{}/{}", self.peer_addr.to_string(), self.peer_port, self.host_port);
+        let path = path_string.as_bytes();
+
+        for (b, p) in buf.iter_mut().zip(path.iter()) {
+            *b = *p;
+        }
+
+        Ok(cmp::min(buf.len(), path.len()))
+    }
+
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        if ! self.data.is_empty() {
+            let mut bytes: Vec<u8> = Vec::new();
+            mem::swap(&mut self.data, &mut bytes);
+
+            // TODO: Allow splitting
+            let mut i = 0;
+            while i < buf.len() && i < bytes.len() {
+                buf[i] = bytes[i];
+                i += 1;
+            }
+
+            return Ok(i);
+        }
+
+        loop {
+            let mut bytes = [0; 65536];
+            let count = try!(syscall::read(self.ip, &mut bytes));
+
+            if let Some(datagram) = Udp::from_bytes(&bytes[..count]) {
+                if datagram.header.dst.get() == self.host_port &&
+                   datagram.header.src.get() == self.peer_port {
+                    // TODO: Allow splitting
+                    let mut i = 0;
+                    while i < buf.len() && i < datagram.data.len() {
+                        buf[i] = datagram.data[i];
+                        i += 1;
+                    }
+
+                    return Ok(i);
+                }
+            }
+        }
+    }
+
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        let mut udp = Udp {
+            header: UdpHeader {
+                src: n16::new(self.host_port),
+                dst: n16::new(self.peer_port),
+                len: n16::new((mem::size_of::<UdpHeader>() + buf.len()) as u16),
+                checksum: Checksum { data: 0 },
+            },
+            data: Vec::from(buf),
+        };
+
+        unsafe {
+            let proto = n16::new(0x11);
+            let datagram_len = n16::new((mem::size_of::<UdpHeader>() + udp.data.len()) as u16);
+            udp.header.checksum.data =
+                Checksum::compile(Checksum::sum((&IP_ADDR as *const Ipv4Addr) as usize,
+                                                mem::size_of::<Ipv4Addr>()) +
+                                  Checksum::sum((&self.peer_addr as *const Ipv4Addr) as usize,
+                                                mem::size_of::<Ipv4Addr>()) +
+                                  Checksum::sum((&proto as *const n16) as usize,
+                                                mem::size_of::<n16>()) +
+                                  Checksum::sum((&datagram_len as *const n16) as usize,
+                                                mem::size_of::<n16>()) +
+                                  Checksum::sum((&udp.header as *const UdpHeader) as usize,
+                                                mem::size_of::<UdpHeader>()) +
+                                  Checksum::sum(udp.data.as_ptr() as usize, udp.data.len()));
+        }
+
+        syscall::write(self.ip, &udp.to_bytes()).and(Ok(buf.len()))
+    }
+
+    fn sync(&mut self) -> Result<usize> {
+        syscall::fsync(self.ip)
+    }
+}