Replace usize with RawFd where it makes sense.

src/ethernetd/main.rs

@@ -6,7 +6,7 @@ use event::EventQueue;
 use std::cell::RefCell;
 use std::fs::File;
 use std::io::{Result, Read, Write};
-use std::os::unix::io::FromRawFd;
+use std::os::unix::io::{RawFd, FromRawFd};
 use std::process;
 use std::rc::Rc;
 
@@ -16,7 +16,7 @@ use scheme::EthernetScheme;
 
 mod scheme;
 
-fn daemon(network_fd: usize, socket_fd: usize) {
+fn daemon(network_fd: RawFd, socket_fd: RawFd) {
     let network = unsafe { File::from_raw_fd(network_fd) };
     let socket = Rc::new(RefCell::new(unsafe { File::from_raw_fd(socket_fd) }));
     let scheme = Rc::new(RefCell::new(EthernetScheme::new(network)));
@@ -95,7 +95,7 @@ fn main() {
                 println!("ethernetd: providing ethernet:");
                 match syscall::open(":ethernet", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK) {
                     Ok(socket_fd) => {
-                        daemon(network_fd, socket_fd);
+                        daemon(network_fd as RawFd, socket_fd as RawFd);
                     },
                     Err(err) => {
                         println!("ethernetd: failed to create ethernet scheme: {}", err);

src/ethernetd/scheme.rs

@@ -156,7 +156,7 @@ impl SchemeMut for EthernetScheme {
     fn fsync(&mut self, id: usize) -> Result<usize> {
         let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
-        syscall::fsync(self.network.as_raw_fd())
+        syscall::fsync(self.network.as_raw_fd() as usize)
     }
 
     fn close(&mut self, id: usize) -> Result<usize> {

src/ipd/interface/ethernet.rs

@@ -2,7 +2,7 @@ use netutils::{getcfg, n16, Ipv4Addr, MacAddr, Ipv4, EthernetII, EthernetIIHeade
 use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::{Result, Read, Write};
-use std::os::unix::io::FromRawFd;
+use std::os::unix::io::{RawFd, FromRawFd};
 
 use interface::Interface;
 
@@ -18,7 +18,7 @@ pub struct EthernetInterface {
 }
 
 impl EthernetInterface {
-    pub fn new(arp_fd: usize, ip_fd: usize) -> Self {
+    pub fn new(arp_fd: RawFd, ip_fd: RawFd) -> Self {
         EthernetInterface {
             mac: MacAddr::from_str(&getcfg("mac").unwrap().trim()),
             ip: Ipv4Addr::from_str(&getcfg("ip").unwrap().trim()),

src/ipd/main.rs

@@ -9,7 +9,7 @@ use std::cell::RefCell;
 use std::collections::{BTreeMap, VecDeque};
 use std::fs::File;
 use std::io::{self, Read, Write};
-use std::os::unix::io::FromRawFd;
+use std::os::unix::io::{RawFd, FromRawFd};
 use std::{process, slice, str};
 use std::rc::Rc;
 use syscall::data::Packet;
@@ -260,7 +260,7 @@ impl SchemeMut for Ipd {
     }
 }
 
-fn daemon(arp_fd: usize, ip_fd: usize, scheme_fd: usize) {
+fn daemon(arp_fd: RawFd, ip_fd: RawFd, scheme_fd: RawFd) {
     let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
 
     let ipd = Rc::new(RefCell::new(Ipd::new(scheme_file)));
@@ -326,7 +326,7 @@ fn main() {
                     println!("ipd: providing ip:");
                     match syscall::open(":ip", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK) {
                         Ok(scheme_fd) => {
-                            daemon(arp_fd, ip_fd, scheme_fd);
+                            daemon(arp_fd as RawFd, ip_fd as RawFd, scheme_fd as RawFd);
                         },
                         Err(err) => {
                             println!("ipd: failed to create ip scheme: {}", err);

src/tcpd/main.rs

@@ -10,7 +10,7 @@ use std::fs::File;
 use std::io::{self, Read, Write};
 use std::{mem, process, slice, str};
 use std::ops::{Deref, DerefMut};
-use std::os::unix::io::FromRawFd;
+use std::os::unix::io::{RawFd, FromRawFd};
 use std::rc::Rc;
 
 use event::EventQueue;
@@ -916,7 +916,7 @@ impl SchemeMut for Tcpd {
     }
 }
 
-fn daemon(scheme_fd: usize, tcp_fd: usize, time_fd: usize) {
+fn daemon(scheme_fd: RawFd, tcp_fd: RawFd, time_fd: RawFd) {
     let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
     let tcp_file = unsafe { File::from_raw_fd(tcp_fd) };
     let time_file = unsafe { File::from_raw_fd(time_fd) };
@@ -959,7 +959,7 @@ fn main() {
                         println!("tcpd: providing tcp:");
                         match syscall::open(":tcp", O_RDWR | O_CREAT | O_NONBLOCK) {
                             Ok(scheme_fd) => {
-                                daemon(scheme_fd, tcp_fd, time_fd);
+                                daemon(scheme_fd as RawFd, tcp_fd as RawFd, time_fd as RawFd);
                             },
                             Err(err) => {
                                 println!("tcpd: failed to create tcp scheme: {}", err);

src/udpd/main.rs

@@ -10,7 +10,7 @@ use std::fs::File;
 use std::io::{self, Read, Write};
 use std::{mem, process, slice, str};
 use std::ops::{Deref, DerefMut};
-use std::os::unix::io::FromRawFd;
+use std::os::unix::io::{RawFd, FromRawFd};
 use std::rc::Rc;
 
 use event::EventQueue;
@@ -522,7 +522,7 @@ impl SchemeMut for Udpd {
         Ok(0)
     }
 }
-fn daemon(scheme_fd: usize, udp_fd: usize, time_fd: usize) {
+fn daemon(scheme_fd: RawFd, udp_fd: RawFd, time_fd: RawFd) {
     let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
     let udp_file = unsafe { File::from_raw_fd(udp_fd) };
     let time_file = unsafe { File::from_raw_fd(time_fd) };
@@ -565,7 +565,7 @@ fn main() {
                         println!("udpd: providing udp:");
                         match syscall::open(":udp", O_RDWR | O_CREAT | O_NONBLOCK) {
                             Ok(scheme_fd) => {
-                                daemon(scheme_fd, udp_fd, time_fd);
+                                daemon(scheme_fd as RawFd, udp_fd as RawFd, time_fd as RawFd);
                             },
                             Err(err) => {
                                 println!("udpd: failed to create udp scheme: {}", err);