Cleanup and format

src/header/dlfcn/mod.rs

@@ -1,7 +1,7 @@
 //! dlfcn implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html
 
+use core::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 use core::{ptr, str};
-use core::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 
 use c_str::CStr;
 use platform::types::*;
@@ -38,7 +38,9 @@ pub unsafe extern "C" fn dlopen(filename: *const c_char, flags: c_int) -> *mut c
     let filename_opt = if filename.is_null() {
         None
     } else {
-        Some(str::from_utf8_unchecked(CStr::from_ptr(filename).to_bytes()))
+        Some(str::from_utf8_unchecked(
+            CStr::from_ptr(filename).to_bytes(),
+        ))
     };
 
     eprintln!("dlopen({:?}, {:#>04x})", filename_opt, flags);

src/header/mod.rs

@@ -1,4 +1,5 @@
 pub mod _aio;
+pub mod _fenv;
 pub mod arpa_inet;
 pub mod assert;
 pub mod ctype;
@@ -6,7 +7,6 @@ pub mod dirent;
 pub mod dlfcn;
 pub mod errno;
 pub mod fcntl;
-pub mod _fenv;
 pub mod float;
 pub mod fnmatch;
 pub mod getopt;
@@ -39,6 +39,7 @@ pub mod sys_statvfs;
 pub mod sys_time;
 pub mod sys_timeb;
 //pub mod sys_times;
+pub mod _wctype;
 pub mod sys_uio;
 pub mod sys_un;
 pub mod sys_utsname;
@@ -48,4 +49,3 @@ pub mod time;
 pub mod unistd;
 pub mod utime;
 pub mod wchar;
-pub mod _wctype;

src/header/netdb/db.rs

@@ -0,0 +1,31 @@
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+use c_str::CStr;
+use fs::File;
+use header::fcntl;
+use io::{self, BufRead, BufReader};
+
+pub struct Db(BufReader<File>);
+
+impl Db {
+    pub fn new(path: &CStr) -> io::Result<Self> {
+        File::open(path, fcntl::O_RDONLY)
+            .map(BufReader::new)
+            .map(Db)
+    }
+
+    pub fn read(&mut self) -> io::Result<Vec<String>> {
+        let mut parts = Vec::new();
+
+        let mut line = String::new();
+        self.0.read_line(&mut line)?;
+        if let Some(not_comment) = line.split('#').next() {
+            for part in not_comment.split_whitespace() {
+                parts.push(part.to_string());
+            }
+        }
+
+        Ok(parts)
+    }
+}

src/header/netdb/lookup.rs

@@ -0,0 +1,252 @@
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+use alloc::vec::{IntoIter, Vec};
+use core::mem;
+
+use platform::types::*;
+use platform::{Pal, Sys};
+
+use header::arpa_inet::htons;
+use header::errno::*;
+use header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
+use header::sys_socket;
+use header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
+use header::sys_socket::{sockaddr, socklen_t};
+use header::time;
+use header::time::timespec;
+
+use super::dns::{Dns, DnsQuery};
+use super::sys::get_dns_server;
+
+pub struct LookupHost(IntoIter<in_addr>);
+
+impl Iterator for LookupHost {
+    type Item = in_addr;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+pub fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
+    let dns_string = get_dns_server();
+
+    let dns_vec: Vec<u8> = dns_string
+        .trim()
+        .split(".")
+        .map(|octet| octet.parse::<u8>().unwrap_or(0))
+        .collect();
+
+    if dns_vec.len() == 4 {
+        let mut dns_arr = [0u8; 4];
+        for (i, octet) in dns_vec.iter().enumerate() {
+            dns_arr[i] = *octet;
+        }
+        let dns_addr = unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) };
+
+        let mut timespec = timespec::default();
+        Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
+        let tid = (timespec.tv_nsec >> 16) as u16;
+
+        let packet = Dns {
+            transaction_id: tid,
+            flags: 0x0100,
+            queries: vec![DnsQuery {
+                name: host.to_string(),
+                q_type: 0x0001,
+                q_class: 0x0001,
+            }],
+            answers: vec![],
+        };
+
+        let packet_data = packet.compile();
+        let packet_data_len = packet_data.len();
+
+        let packet_data_box = packet_data.into_boxed_slice();
+        let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
+
+        let dest = sockaddr_in {
+            sin_family: AF_INET as u16,
+            sin_port: htons(53),
+            sin_addr: in_addr { s_addr: dns_addr },
+            ..Default::default()
+        };
+        let dest_ptr = &dest as *const _ as *const sockaddr;
+
+        let sock = unsafe {
+            let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
+            if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
+                return Err(EIO);
+            }
+            if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
+                Box::from_raw(packet_data_ptr);
+                return Err(EIO);
+            }
+            sock
+        };
+
+        unsafe {
+            Box::from_raw(packet_data_ptr);
+        }
+
+        let i = 0 as socklen_t;
+        let mut buf = [0u8; 65536];
+        let buf_ptr = buf.as_mut_ptr() as *mut c_void;
+
+        let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
+        if count < 0 {
+            return Err(EIO);
+        }
+
+        match Dns::parse(&buf[..count as usize]) {
+            Ok(response) => {
+                let mut addrs = vec![];
+                for answer in response.answers.iter() {
+                    if answer.a_type == 0x0001 && answer.a_class == 0x0001 && answer.data.len() == 4
+                    {
+                        let addr = in_addr {
+                            s_addr: unsafe {
+                                mem::transmute::<[u8; 4], u32>([
+                                    answer.data[0],
+                                    answer.data[1],
+                                    answer.data[2],
+                                    answer.data[3],
+                                ])
+                            },
+                        };
+                        addrs.push(addr);
+                    }
+                }
+                Ok(LookupHost(addrs.into_iter()))
+            }
+            Err(_err) => Err(EINVAL),
+        }
+    } else {
+        Err(EINVAL)
+    }
+}
+
+pub fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
+    let dns_string = get_dns_server();
+
+    let dns_vec: Vec<u8> = dns_string
+        .trim()
+        .split('.')
+        .map(|octet| octet.parse::<u8>().unwrap_or(0))
+        .collect();
+
+    let mut dns_arr = [0u8; 4];
+
+    for (i, octet) in dns_vec.iter().enumerate() {
+        dns_arr[i] = *octet;
+    }
+
+    let mut addr_vec: Vec<u8> = unsafe { mem::transmute::<u32, [u8; 4]>(addr.s_addr).to_vec() };
+    addr_vec.reverse();
+    let mut name: Vec<u8> = vec![];
+    for octet in addr_vec {
+        for ch in format!("{}", octet).as_bytes() {
+            name.push(*ch);
+        }
+        name.push(b"."[0]);
+    }
+    name.pop();
+    for ch in b".IN-ADDR.ARPA" {
+        name.push(*ch);
+    }
+
+    if dns_vec.len() == 4 {
+        let mut timespec = timespec::default();
+        Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
+        let tid = (timespec.tv_nsec >> 16) as u16;
+
+        let packet = Dns {
+            transaction_id: tid,
+            flags: 0x0100,
+            queries: vec![DnsQuery {
+                name: String::from_utf8(name).unwrap(),
+                q_type: 0x000C,
+                q_class: 0x0001,
+            }],
+            answers: vec![],
+        };
+
+        let packet_data = packet.compile();
+        let packet_data_len = packet_data.len();
+        let packet_data_box = packet_data.into_boxed_slice();
+        let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
+
+        let dest = sockaddr_in {
+            sin_family: AF_INET as u16,
+            sin_port: htons(53),
+            sin_addr: in_addr {
+                s_addr: unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) },
+            },
+            ..Default::default()
+        };
+
+        let dest_ptr = &dest as *const _ as *const sockaddr;
+
+        let sock = unsafe {
+            let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
+            if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
+                return Err(EIO);
+            }
+            sock
+        };
+
+        unsafe {
+            if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
+                return Err(EIO);
+            }
+        }
+
+        unsafe {
+            Box::from_raw(packet_data_ptr);
+        }
+
+        let i = mem::size_of::<sockaddr_in>() as socklen_t;
+        let mut buf = [0u8; 65536];
+        let buf_ptr = buf.as_mut_ptr() as *mut c_void;
+
+        let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
+        if count < 0 {
+            return Err(EIO);
+        }
+
+        match Dns::parse(&buf[..count as usize]) {
+            Ok(response) => {
+                let mut names = vec![];
+                for answer in response.answers.iter() {
+                    if answer.a_type == 0x000C && answer.a_class == 0x0001 {
+                        // answer.data is encoded kinda weird.
+                        // Basically length-prefixed strings for each
+                        // subsection of the domain.
+                        // We need to parse this to insert periods where
+                        // they belong (ie at the end of each string)
+                        let data = parse_revdns_answer(&answer.data);
+                        names.push(data);
+                    }
+                }
+                Ok(names)
+            }
+            Err(_err) => Err(EINVAL),
+        }
+    } else {
+        Err(EINVAL)
+    }
+}
+
+fn parse_revdns_answer(data: &[u8]) -> Vec<u8> {
+    let mut cursor = 0;
+    let mut index = 0;
+    let mut output = data.to_vec();
+    while index < data.len() - 1 {
+        let offset = data[index] as usize;
+        index = cursor + offset + 1;
+        output[index] = b'.';
+        cursor = index;
+    }
+    //we don't want an extra period at the end
+    output.pop();
+    output
+}

src/header/netdb/mod.rs

@@ -7,8 +7,7 @@ use core::{mem, ptr, slice, str};
 
 use alloc::boxed::Box;
 use alloc::str::SplitWhitespace;
-use alloc::string::{String, ToString};
-use alloc::vec::{IntoIter, Vec};
+use alloc::vec::Vec;
 
 use c_str::{CStr, CString};
 
@@ -17,19 +16,14 @@ use platform::rlb::{Line, RawLineBuffer};
 use platform::types::*;
 use platform::{Pal, Sys};
 
-use self::dns::{Dns, DnsQuery};
-
 use header::arpa_inet::{htons, inet_aton};
 use header::errno::*;
 use header::fcntl::O_RDONLY;
-use header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
+use header::netinet_in::{in_addr, sockaddr_in};
 use header::stdlib::atoi;
 use header::strings::strcasecmp;
-use header::sys_socket;
-use header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
+use header::sys_socket::constants::AF_INET;
 use header::sys_socket::{sockaddr, socklen_t};
-use header::time;
-use header::time::timespec;
 use header::unistd::SEEK_SET;
 
 #[cfg(target_os = "linux")]
@@ -40,17 +34,14 @@ pub mod sys;
 #[path = "redox.rs"]
 pub mod sys;
 
-const MAXADDRS: usize = 35;
-const MAXALIASES: usize = 35;
+//TODO: use self::db::Db;
+pub mod db;
 
-struct LookupHost(IntoIter<in_addr>);
+use self::lookup::{lookup_addr, lookup_host};
+pub mod lookup;
 
-impl Iterator for LookupHost {
-    type Item = in_addr;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
+const MAXADDRS: usize = 35;
+const MAXALIASES: usize = 35;
 
 #[repr(C)]
 pub struct hostent {
@@ -69,6 +60,13 @@ pub struct netent {
     n_net: c_ulong,              /* network # */
 }
 
+#[repr(C)]
+pub struct protoent {
+    p_name: *mut c_char,         /* official protocol name */
+    p_aliases: *mut *mut c_char, /* alias list */
+    p_proto: c_int,              /* protocol # */
+}
+
 #[repr(C)]
 pub struct servent {
     s_name: *mut c_char,         /* official service name */
@@ -77,13 +75,6 @@ pub struct servent {
     s_proto: *mut c_char,        /* protocol to use */
 }
 
-#[repr(C)]
-pub struct protoent {
-    p_name: *mut c_char,         /* official protocol name */
-    p_aliases: *mut *mut c_char, /* alias list */
-    p_proto: c_int,              /* protocol # */
-}
-
 #[repr(C)]
 pub struct addrinfo {
     ai_flags: c_int,           /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
@@ -196,230 +187,6 @@ fn bytes_to_box_str(bytes: &[u8]) -> Box<str> {
     Box::from(core::str::from_utf8(bytes).unwrap_or(""))
 }
 
-fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
-    let dns_string = sys::get_dns_server();
-
-    let dns_vec: Vec<u8> = dns_string
-        .trim()
-        .split(".")
-        .map(|octet| octet.parse::<u8>().unwrap_or(0))
-        .collect();
-
-    if dns_vec.len() == 4 {
-        let mut dns_arr = [0u8; 4];
-        for (i, octet) in dns_vec.iter().enumerate() {
-            dns_arr[i] = *octet;
-        }
-        let dns_addr = unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) };
-
-        let mut timespec = timespec::default();
-        Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
-        let tid = (timespec.tv_nsec >> 16) as u16;
-
-        let packet = Dns {
-            transaction_id: tid,
-            flags: 0x0100,
-            queries: vec![DnsQuery {
-                name: host.to_string(),
-                q_type: 0x0001,
-                q_class: 0x0001,
-            }],
-            answers: vec![],
-        };
-
-        let packet_data = packet.compile();
-        let packet_data_len = packet_data.len();
-
-        let packet_data_box = packet_data.into_boxed_slice();
-        let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
-
-        let dest = sockaddr_in {
-            sin_family: AF_INET as u16,
-            sin_port: htons(53),
-            sin_addr: in_addr { s_addr: dns_addr },
-            ..Default::default()
-        };
-        let dest_ptr = &dest as *const _ as *const sockaddr;
-
-        let sock = unsafe {
-            let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
-            if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
-                return Err(EIO);
-            }
-            if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
-                Box::from_raw(packet_data_ptr);
-                return Err(EIO);
-            }
-            sock
-        };
-
-        unsafe {
-            Box::from_raw(packet_data_ptr);
-        }
-
-        let i = 0 as socklen_t;
-        let mut buf = [0u8; 65536];
-        let buf_ptr = buf.as_mut_ptr() as *mut c_void;
-
-        let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
-        if count < 0 {
-            return Err(EIO);
-        }
-
-        match Dns::parse(&buf[..count as usize]) {
-            Ok(response) => {
-                let mut addrs = vec![];
-                for answer in response.answers.iter() {
-                    if answer.a_type == 0x0001 && answer.a_class == 0x0001 && answer.data.len() == 4
-                    {
-                        let addr = in_addr {
-                            s_addr: unsafe {
-                                mem::transmute::<[u8; 4], u32>([
-                                    answer.data[0],
-                                    answer.data[1],
-                                    answer.data[2],
-                                    answer.data[3],
-                                ])
-                            },
-                        };
-                        addrs.push(addr);
-                    }
-                }
-                Ok(LookupHost(addrs.into_iter()))
-            }
-            Err(_err) => Err(EINVAL),
-        }
-    } else {
-        Err(EINVAL)
-    }
-}
-
-fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
-    let dns_string = sys::get_dns_server();
-
-    let dns_vec: Vec<u8> = dns_string
-        .trim()
-        .split('.')
-        .map(|octet| octet.parse::<u8>().unwrap_or(0))
-        .collect();
-
-    let mut dns_arr = [0u8; 4];
-
-    for (i, octet) in dns_vec.iter().enumerate() {
-        dns_arr[i] = *octet;
-    }
-
-    let mut addr_vec: Vec<u8> = unsafe { mem::transmute::<u32, [u8; 4]>(addr.s_addr).to_vec() };
-    addr_vec.reverse();
-    let mut name: Vec<u8> = vec![];
-    for octet in addr_vec {
-        for ch in format!("{}", octet).as_bytes() {
-            name.push(*ch);
-        }
-        name.push(b"."[0]);
-    }
-    name.pop();
-    for ch in b".IN-ADDR.ARPA" {
-        name.push(*ch);
-    }
-
-    if dns_vec.len() == 4 {
-        let mut timespec = timespec::default();
-        Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
-        let tid = (timespec.tv_nsec >> 16) as u16;
-
-        let packet = Dns {
-            transaction_id: tid,
-            flags: 0x0100,
-            queries: vec![DnsQuery {
-                name: String::from_utf8(name).unwrap(),
-                q_type: 0x000C,
-                q_class: 0x0001,
-            }],
-            answers: vec![],
-        };
-
-        let packet_data = packet.compile();
-        let packet_data_len = packet_data.len();
-        let packet_data_box = packet_data.into_boxed_slice();
-        let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
-
-        let dest = sockaddr_in {
-            sin_family: AF_INET as u16,
-            sin_port: htons(53),
-            sin_addr: in_addr {
-                s_addr: unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) },
-            },
-            ..Default::default()
-        };
-
-        let dest_ptr = &dest as *const _ as *const sockaddr;
-
-        let sock = unsafe {
-            let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
-            if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
-                return Err(EIO);
-            }
-            sock
-        };
-
-        unsafe {
-            if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
-                return Err(EIO);
-            }
-        }
-
-        unsafe {
-            Box::from_raw(packet_data_ptr);
-        }
-
-        let i = mem::size_of::<sockaddr_in>() as socklen_t;
-        let mut buf = [0u8; 65536];
-        let buf_ptr = buf.as_mut_ptr() as *mut c_void;
-
-        let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
-        if count < 0 {
-            return Err(EIO);
-        }
-
-        match Dns::parse(&buf[..count as usize]) {
-            Ok(response) => {
-                let mut names = vec![];
-                for answer in response.answers.iter() {
-                    if answer.a_type == 0x000C && answer.a_class == 0x0001 {
-                        // answer.data is encoded kinda weird.
-                        // Basically length-prefixed strings for each
-                        // subsection of the domain.
-                        // We need to parse this to insert periods where
-                        // they belong (ie at the end of each string)
-                        let data = parse_revdns_answer(&answer.data);
-                        names.push(data);
-                    }
-                }
-                Ok(names)
-            }
-            Err(_err) => Err(EINVAL),
-        }
-    } else {
-        Err(EINVAL)
-    }
-}
-
-fn parse_revdns_answer(data: &[u8]) -> Vec<u8> {
-    let mut cursor = 0;
-    let mut index = 0;
-    let mut output = data.to_vec();
-    while index < data.len() - 1 {
-        let offset = data[index] as usize;
-        index = cursor + offset + 1;
-        output[index] = b'.';
-        cursor = index;
-    }
-    //we don't want an extra period at the end
-    output.pop();
-    output
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn endhostent() {
     Sys::close(HOSTDB);
@@ -800,10 +567,7 @@ pub unsafe extern "C" fn getprotoent() -> *mut protoent {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn getservbyname(
-    name: *const c_char,
-    proto: *const c_char,
-) -> *mut servent {
+pub unsafe extern "C" fn getservbyname(name: *const c_char, proto: *const c_char) -> *mut servent {
     setservent(SERV_STAYOPEN);
     let mut p: *mut servent;
     if proto.is_null() {
@@ -1012,11 +776,7 @@ pub unsafe extern "C" fn getaddrinfo(
         Some(CStr::from_ptr(service))
     };
 
-    let hints_opt = if hints.is_null() {
-        None
-    } else {
-        Some(&*hints)
-    };
+    let hints_opt = if hints.is_null() { None } else { Some(&*hints) };
 
     eprintln!(
         "getaddrinfo({:?}, {:?})",
@@ -1038,6 +798,7 @@ pub unsafe extern "C" fn getnameinfo(
     servlen: socklen_t,
     flags: c_int,
 ) -> c_int {
+    //TODO: getnameinfo
     if addrlen as usize != mem::size_of::<sockaddr_in>() {
         return EAI_FAMILY;
     }
@@ -1088,5 +849,6 @@ pub extern "C" fn gai_strerror(errcode: c_int) -> *const c_char {
         EAI_SYSTEM => c_str!("System error"),
         EAI_OVERFLOW => c_str!("Overflow"),
         _ => c_str!("Unknown error"),
-    }.as_ptr()
+    }
+    .as_ptr()
 }

src/header/netinet_in/mod.rs

@@ -66,10 +66,10 @@ pub const INADDR_MAX_LOCAL_GROUP: u32 = 0xE000_00FF;
 
 #[no_mangle]
 pub static in6addr_any: in6_addr = in6_addr {
-    s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 };
 
 #[no_mangle]
 pub static in6addr_loopback: in6_addr = in6_addr {
-    s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+    s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
 };

src/header/pwd/mod.rs

@@ -169,15 +169,15 @@ pub unsafe extern "C" fn getpwnam_r(
         OptionPasswd::Error => {
             *result = ptr::null_mut();
             -1
-        },
+        }
         OptionPasswd::NotFound => {
             *result = ptr::null_mut();
             0
-        },
+        }
         OptionPasswd::Found(_) => {
             *result = out;
             0
-        },
+        }
     }
 }
 
@@ -199,15 +199,15 @@ pub unsafe extern "C" fn getpwuid_r(
         OptionPasswd::Error => {
             *result = ptr::null_mut();
             -1
-        },
+        }
         OptionPasswd::NotFound => {
             *result = ptr::null_mut();
             0
-        },
+        }
         OptionPasswd::Found(_) => {
             *result = out;
             0
-        },
+        }
     }
 }
 

src/header/regex/mod.rs

@@ -74,7 +74,7 @@ pub unsafe extern "C" fn regcomp(out: *mut regex_t, pat: *const c_char, cflags:
             };
             mem::forget(branches);
             0
-        },
+        }
         Err(CompileError::EmptyRepetition)
         | Err(CompileError::IntegerOverflow)
         | Err(CompileError::IllegalRange) => REG_BADBR,
@@ -146,7 +146,12 @@ pub unsafe extern "C" fn regexec(
 
 #[no_mangle]
 #[linkage = "weak"] // redefined in GIT
-pub extern "C" fn regerror(code: c_int, _regex: *const regex_t, out: *mut c_char, max: size_t) -> size_t {
+pub extern "C" fn regerror(
+    code: c_int,
+    _regex: *const regex_t,
+    out: *mut c_char,
+    max: size_t,
+) -> size_t {
     let string = match code {
         0 => "No error\0",
         REG_NOMATCH => "No match\0",

src/header/signal/mod.rs

@@ -49,7 +49,11 @@ pub extern "C" fn killpg(pgrp: pid_t, sig: c_int) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_sigmask(how: c_int, set: *const sigset_t, oldset: *mut sigset_t) -> c_int {
+pub extern "C" fn pthread_sigmask(
+    how: c_int,
+    set: *const sigset_t,
+    oldset: *mut sigset_t,
+) -> c_int {
     // On Linux and Redox, pthread_sigmask and sigprocmask are equivalent
     if sigprocmask(how, set, oldset) == 0 {
         0
@@ -165,10 +169,7 @@ extern "C" {
 }
 
 #[no_mangle]
-pub extern "C" fn signal(
-    sig: c_int,
-    func: extern "C" fn(c_int),
-) -> extern "C" fn(c_int) {
+pub extern "C" fn signal(sig: c_int, func: extern "C" fn(c_int)) -> extern "C" fn(c_int) {
     let sa = sigaction {
         sa_handler: func,
         sa_flags: SA_RESTART as c_ulong,

src/header/stdio/mod.rs

@@ -3,9 +3,9 @@
 use alloc::borrow::{Borrow, BorrowMut};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use core::{fmt, mem, ptr, slice, str};
 use core::fmt::Write as WriteFmt;
 use core::ops::{Deref, DerefMut};
+use core::{fmt, mem, ptr, slice, str};
 use va_list::VaList as va_list;
 
 use c_str::CStr;
@@ -291,7 +291,11 @@ pub unsafe extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t) -> c_int {
 
 /// Get a string from the stream
 #[no_mangle]
-pub unsafe extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) -> *mut c_char {
+pub unsafe extern "C" fn fgets(
+    original: *mut c_char,
+    max: c_int,
+    stream: *mut FILE,
+) -> *mut c_char {
     let mut stream = (*stream).lock();
     let mut out = original;
     let max = max as usize;
@@ -343,9 +347,7 @@ pub unsafe extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut F
 
     if max >= 1 {
         // Write the NUL byte
-        unsafe {
-            *out = 0;
-        }
+        *out = 0;
     }
     if wrote {
         original
@@ -570,7 +572,7 @@ pub unsafe extern "C" fn fwrite(
     stream: *mut FILE,
 ) -> size_t {
     if size == 0 || nitems == 0 {
-        return 0
+        return 0;
     }
     let mut stream = (*stream).lock();
     let buf = slice::from_raw_parts_mut(ptr as *mut u8, size as usize * nitems as usize);
@@ -865,7 +867,7 @@ pub unsafe extern "C" fn setvbuf(
         Buffer::Owned(vec![0; size as usize])
     // }
     } else {
-        unsafe { Buffer::Borrowed(slice::from_raw_parts_mut(buf as *mut u8, size)) }
+        Buffer::Borrowed(slice::from_raw_parts_mut(buf as *mut u8, size))
     };
     stream.flags |= F_SVB;
     0
@@ -928,7 +930,11 @@ pub unsafe extern "C" fn vprintf(format: *const c_char, ap: va_list) -> c_int {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn vasprintf(strp: *mut *mut c_char, format: *const c_char, ap: va_list) -> c_int {
+pub unsafe extern "C" fn vasprintf(
+    strp: *mut *mut c_char,
+    format: *const c_char,
+    ap: va_list,
+) -> c_int {
     let mut alloc_writer = platform::AllocStringWriter(ptr::null_mut(), 0);
     let ret = printf::printf(&mut alloc_writer, format, ap);
     *strp = alloc_writer.0 as *mut c_char;

src/header/stdlib/sort.rs

@@ -137,9 +137,7 @@ fn heap_sift_down(
             swap_idx = child;
             swap_ptr = first_child_ptr;
         }
-        if child < end
-            && comp(swap_ptr as *const c_void, second_child_ptr as *const c_void) < 0
-        {
+        if child < end && comp(swap_ptr as *const c_void, second_child_ptr as *const c_void) < 0 {
             swap_idx = child + 1;
             swap_ptr = second_child_ptr;
         }

src/header/sys_statvfs/mod.rs

@@ -1,7 +1,7 @@
 //! statvfs implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/sysstatvfs.h.html
 
 use c_str::CStr;
-use header::fcntl::{O_PATH};
+use header::fcntl::O_PATH;
 use platform::types::*;
 use platform::{Pal, Sys};
 

src/header/sys_timeb/mod.rs

@@ -21,7 +21,7 @@ pub unsafe extern "C" fn ftime(tp: *mut timeb) -> c_int {
     }
 
     (*tp).time = tv.tv_sec;
-    (*tp).millitm = (tv.tv_usec/1000) as c_ushort;
+    (*tp).millitm = (tv.tv_usec / 1000) as c_ushort;
     (*tp).timezone = tz.tz_minuteswest as c_short;
     (*tp).dstflag = tz.tz_dsttime as c_short;
 

src/header/sys_uio/mod.rs

@@ -17,10 +17,7 @@ pub struct iovec {
 
 impl iovec {
     unsafe fn to_slice(&self) -> &mut [u8] {
-        slice::from_raw_parts_mut(
-            self.iov_base as *mut u8,
-            self.iov_len as usize
-        )
+        slice::from_raw_parts_mut(self.iov_base as *mut u8, self.iov_len as usize)
     }
 }
 

src/header/unistd/mod.rs

@@ -486,7 +486,11 @@ pub extern "C" fn read(fildes: c_int, buf: *const c_void, nbyte: size_t) -> ssiz
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn readlink(path: *const c_char, buf: *mut c_char, bufsize: size_t) -> ssize_t {
+pub unsafe extern "C" fn readlink(
+    path: *const c_char,
+    buf: *mut c_char,
+    bufsize: size_t,
+) -> ssize_t {
     let path = CStr::from_ptr(path);
     let buf = slice::from_raw_parts_mut(buf as *mut u8, bufsize as usize);
     Sys::readlink(path, buf)

src/header/unistd/sysconf.rs

@@ -44,7 +44,9 @@ pub extern "C" fn sysconf(name: c_int) -> c_long {
         _SC_SYMLOOP_MAX => -1,
         _SC_HOST_NAME_MAX => 64,
         _ => {
-            unsafe { platform::errno = errno::EINVAL; }
+            unsafe {
+                platform::errno = errno::EINVAL;
+            }
             -1
         }
     }

src/header/wchar/mod.rs

@@ -169,12 +169,7 @@ pub unsafe extern "C" fn mbsnrtowcs(
     while (dst_ptr.is_null() || dst_offset < dst_len) && src_offset < src_len {
         let ps_copy = *ps;
         let mut wc: wchar_t = 0;
-        let amount = mbrtowc(
-            &mut wc,
-            src.add(src_offset),
-            src_len - src_offset,
-            ps,
-        );
+        let amount = mbrtowc(&mut wc, src.add(src_offset), src_len - src_offset, ps);
 
         // Stop in the event a decoding error occured.
         if amount == -1isize as usize {
@@ -363,7 +358,11 @@ pub unsafe extern "C" fn wcslen(ws: *const wchar_t) -> c_ulong {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcsncat(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
+pub unsafe extern "C" fn wcsncat(
+    ws1: *mut wchar_t,
+    ws2: *const wchar_t,
+    n: size_t,
+) -> *mut wchar_t {
     let len = wcslen(ws1);
     let dest = ws1.add(len as usize);
     let mut i = 0;
@@ -396,7 +395,11 @@ pub unsafe extern "C" fn wcsncmp(ws1: *const wchar_t, ws2: *const wchar_t, n: si
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcsncpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
+pub unsafe extern "C" fn wcsncpy(
+    ws1: *mut wchar_t,
+    ws2: *const wchar_t,
+    n: size_t,
+) -> *mut wchar_t {
     let mut i = 0;
     while i < n {
         let wc = *ws2.add(i);
@@ -523,13 +526,29 @@ pub unsafe extern "C" fn wmemcmp(ws1: *const wchar_t, ws2: *const wchar_t, n: si
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wmemcpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
-    string::memcpy(ws1 as *mut c_void, ws2 as *const c_void, n * mem::size_of::<wchar_t>()) as *mut wchar_t
+pub unsafe extern "C" fn wmemcpy(
+    ws1: *mut wchar_t,
+    ws2: *const wchar_t,
+    n: size_t,
+) -> *mut wchar_t {
+    string::memcpy(
+        ws1 as *mut c_void,
+        ws2 as *const c_void,
+        n * mem::size_of::<wchar_t>(),
+    ) as *mut wchar_t
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wmemmove(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
-    string::memmove(ws1 as *mut c_void, ws2 as *const c_void, n * mem::size_of::<wchar_t>()) as *mut wchar_t
+pub unsafe extern "C" fn wmemmove(
+    ws1: *mut wchar_t,
+    ws2: *const wchar_t,
+    n: size_t,
+) -> *mut wchar_t {
+    string::memmove(
+        ws1 as *mut c_void,
+        ws2 as *const c_void,
+        n * mem::size_of::<wchar_t>(),
+    ) as *mut wchar_t
 }
 
 #[no_mangle]

src/lib.rs

@@ -15,7 +15,6 @@
 #![feature(stmt_expr_attributes)]
 #![feature(str_internals)]
 #![feature(thread_local)]
-
 #![allow(clippy::cast_lossless)]
 #![allow(clippy::cast_ptr_alignment)]
 #![allow(clippy::derive_hash_xor_eq)]

src/macros.rs

@@ -3,9 +3,7 @@ macro_rules! c_str {
     ($lit:expr) => {
         #[allow(unused_unsafe)]
         unsafe {
-            $crate::c_str::CStr::from_bytes_with_nul_unchecked(
-                concat!($lit, "\0").as_bytes()
-            )
+            $crate::c_str::CStr::from_bytes_with_nul_unchecked(concat!($lit, "\0").as_bytes())
         }
     };
 }

src/platform/linux/mod.rs

@@ -36,16 +36,16 @@ const CLONE_SIGHAND: usize = 0x0800;
 #[repr(C)]
 #[derive(Default)]
 struct linux_statfs {
-    f_type: c_long, /* type of file system (see below) */
-    f_bsize: c_long, /* optimal transfer block size */
+    f_type: c_long,       /* type of file system (see below) */
+    f_bsize: c_long,      /* optimal transfer block size */
     f_blocks: fsblkcnt_t, /* total data blocks in file system */
-    f_bfree: fsblkcnt_t, /* free blocks in fs */
+    f_bfree: fsblkcnt_t,  /* free blocks in fs */
     f_bavail: fsblkcnt_t, /* free blocks available to unprivileged user */
-    f_files: fsfilcnt_t, /* total file nodes in file system */
-    f_ffree: fsfilcnt_t, /* free file nodes in fs */
-    f_fsid: c_long, /* file system id */
-    f_namelen: c_long, /* maximum length of filenames */
-    f_frsize: c_long, /* fragment size (since Linux 2.6) */
+    f_files: fsfilcnt_t,  /* total file nodes in file system */
+    f_ffree: fsfilcnt_t,  /* free file nodes in fs */
+    f_fsid: c_long,       /* file system id */
+    f_namelen: c_long,    /* maximum length of filenames */
+    f_frsize: c_long,     /* fragment size (since Linux 2.6) */
     f_flags: c_long,
     f_spare: [c_long; 4],
 }
@@ -64,7 +64,6 @@ fn e(sys: usize) -> usize {
 pub struct Sys;
 
 impl Sys {
-
     // fn getrusage(who: c_int, r_usage: *mut rusage) -> c_int {
     //     e(unsafe { syscall!(GETRUSAGE, who, r_usage) }) as c_int
     // }
@@ -163,7 +162,7 @@ impl Pal for Sys {
         let res = e(unsafe { syscall!(FSTATFS, fildes, kbuf_ptr) }) as c_int;
         if res == 0 {
             unsafe {
-                if ! buf.is_null() {
+                if !buf.is_null() {
                     (*buf).f_bsize = kbuf.f_bsize as c_ulong;
                     (*buf).f_frsize = if kbuf.f_frsize != 0 {
                         kbuf.f_frsize
@@ -327,7 +326,16 @@ impl Pal for Sys {
     }
 
     fn pte_clone() -> pid_t {
-        e(unsafe { syscall!(CLONE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, 0, 0, 0, 0) }) as pid_t
+        e(unsafe {
+            syscall!(
+                CLONE,
+                CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
+                0,
+                0,
+                0,
+                0
+            )
+        }) as pid_t
     }
 
     fn read(fildes: c_int, buf: &mut [u8]) -> ssize_t {

src/platform/mod.rs

@@ -104,13 +104,11 @@ impl Read for FileReader {
 pub struct AllocStringWriter(pub *mut u8, pub usize);
 impl Write for AllocStringWriter {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let ptr = unsafe {
-            realloc(self.0 as *mut c_void, self.1 + buf.len() + 1) as *mut u8
-        };
+        let ptr = unsafe { realloc(self.0 as *mut c_void, self.1 + buf.len() + 1) as *mut u8 };
         if ptr.is_null() {
             return Err(io::Error::new(
                 io::ErrorKind::Other,
-                "AllocStringWriter::write failed to allocate"
+                "AllocStringWriter::write failed to allocate",
             ));
         }
         self.0 = ptr;

src/platform/pte.rs

@@ -2,13 +2,13 @@
 
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
+use core::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 use core::{intrinsics, ptr};
-use core::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 
 use header::time::timespec;
 use mutex::{FUTEX_WAIT, FUTEX_WAKE};
-use platform::{Pal, Sys};
 use platform::types::{c_int, c_uint, c_void, pid_t};
+use platform::{Pal, Sys};
 
 pub struct Semaphore {
     lock: i32,
@@ -28,7 +28,7 @@ pub enum pte_osResult {
     PTE_OS_GENERAL_FAILURE,
     PTE_OS_TIMEOUT,
     PTE_OS_INTERRUPTED,
-    PTE_OS_INVALID_PARAM
+    PTE_OS_INVALID_PARAM,
 }
 
 use self::pte_osResult::*;
@@ -55,12 +55,13 @@ pub unsafe extern "C" fn pte_osInit() -> pte_osResult {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osThreadCreate(entryPoint: pte_osThreadEntryPoint,
-                                   _stackSize: c_int,
-                                   _initialPriority: c_int,
-                                   argv: *mut c_void,
-                                   ppte_osThreadHandle: *mut pte_osThreadHandle
-                                   ) -> pte_osResult {
+pub unsafe extern "C" fn pte_osThreadCreate(
+    entryPoint: pte_osThreadEntryPoint,
+    _stackSize: c_int,
+    _initialPriority: c_int,
+    argv: *mut c_void,
+    ppte_osThreadHandle: *mut pte_osThreadHandle,
+) -> pte_osResult {
     // XXX error handling
     let id = Sys::pte_clone();
     if id < 0 {
@@ -166,7 +167,10 @@ pub unsafe extern "C" fn pte_osThreadGetPriority(threadHandle: pte_osThreadHandl
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osThreadSetPriority(threadHandle: pte_osThreadHandle, newPriority: c_int) -> pte_osResult {
+pub unsafe extern "C" fn pte_osThreadSetPriority(
+    threadHandle: pte_osThreadHandle,
+    newPriority: c_int,
+) -> pte_osResult {
     PTE_OS_OK
 }
 
@@ -237,7 +241,10 @@ pub unsafe extern "C" fn pte_osMutexUnlock(handle: pte_osMutexHandle) -> pte_osR
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osSemaphoreCreate(initialValue: c_int, pHandle: *mut pte_osSemaphoreHandle) -> pte_osResult {
+pub unsafe extern "C" fn pte_osSemaphoreCreate(
+    initialValue: c_int,
+    pHandle: *mut pte_osSemaphoreHandle,
+) -> pte_osResult {
     *pHandle = Box::into_raw(Box::new(Semaphore {
         lock: 0,
         count: initialValue,
@@ -252,7 +259,10 @@ pub unsafe extern "C" fn pte_osSemaphoreDelete(handle: pte_osSemaphoreHandle) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osSemaphorePost(handle: pte_osSemaphoreHandle, count: c_int) -> pte_osResult {
+pub unsafe extern "C" fn pte_osSemaphorePost(
+    handle: pte_osSemaphoreHandle,
+    count: c_int,
+) -> pte_osResult {
     let semaphore = &mut *handle;
     pte_osMutexLock(&mut semaphore.lock);
     intrinsics::atomic_xadd(&mut semaphore.count, 1);
@@ -261,11 +271,14 @@ pub unsafe extern "C" fn pte_osSemaphorePost(handle: pte_osSemaphoreHandle, coun
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osSemaphorePend(handle: pte_osSemaphoreHandle, pTimeout: *mut c_uint) -> pte_osResult {
+pub unsafe extern "C" fn pte_osSemaphorePend(
+    handle: pte_osSemaphoreHandle,
+    pTimeout: *mut c_uint,
+) -> pte_osResult {
     //TODO: pTimeout
     let semaphore = &mut *handle;
     let mut acquired = false;
-    while ! acquired {
+    while !acquired {
         pte_osMutexLock(&mut semaphore.lock);
         if intrinsics::atomic_load(&mut semaphore.count) > 0 {
             intrinsics::atomic_xsub(&mut semaphore.count, 1);
@@ -278,7 +291,10 @@ pub unsafe extern "C" fn pte_osSemaphorePend(handle: pte_osSemaphoreHandle, pTim
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osSemaphoreCancellablePend(handle: pte_osSemaphoreHandle, pTimeout: *mut c_uint) -> pte_osResult {
+pub unsafe extern "C" fn pte_osSemaphoreCancellablePend(
+    handle: pte_osSemaphoreHandle,
+    pTimeout: *mut c_uint,
+) -> pte_osResult {
     //TODO
     pte_osSemaphorePend(handle, pTimeout)
 }
@@ -289,7 +305,11 @@ pub unsafe extern "C" fn pte_osAtomicExchange(ptarg: *mut c_int, val: c_int) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pte_osAtomicCompareExchange(pdest: *mut c_int, exchange: c_int, comp: c_int) -> c_int {
+pub unsafe extern "C" fn pte_osAtomicCompareExchange(
+    pdest: *mut c_int,
+    exchange: c_int,
+    comp: c_int,
+) -> c_int {
     intrinsics::atomic_cxchg(pdest, comp, exchange).0
 }
 
@@ -316,7 +336,10 @@ pub unsafe extern "C" fn pte_osTlsSetValue(index: c_uint, value: *mut c_void) ->
 
 #[no_mangle]
 pub unsafe extern "C" fn pte_osTlsGetValue(index: c_uint) -> *mut c_void {
-    locals().get_mut(&index).map(|x| *x).unwrap_or(ptr::null_mut())
+    locals()
+        .get_mut(&index)
+        .map(|x| *x)
+        .unwrap_or(ptr::null_mut())
 }
 
 #[no_mangle]

src/platform/redox/extra.rs

@@ -5,7 +5,10 @@ use platform::types::*;
 
 #[no_mangle]
 pub unsafe extern "C" fn redox_fpath(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t {
-    e(syscall::fpath(fd as usize, slice::from_raw_parts_mut(buf as *mut u8, count))) as ssize_t
+    e(syscall::fpath(
+        fd as usize,
+        slice::from_raw_parts_mut(buf as *mut u8, count),
+    )) as ssize_t
 }
 
 #[no_mangle]
@@ -14,7 +17,7 @@ pub unsafe extern "C" fn redox_physalloc(size: size_t) -> *mut c_void {
     if res == !0 {
         return ptr::null_mut();
     } else {
-        return res as *mut c_void
+        return res as *mut c_void;
     }
 }
 
@@ -24,12 +27,20 @@ pub unsafe extern "C" fn redox_physfree(physical_address: *mut c_void, size: siz
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn redox_physmap(physical_address: *mut c_void, size: size_t, flags: c_int) -> *mut c_void {
-    let res = e(syscall::physmap(physical_address as usize, size, flags as usize));
+pub unsafe extern "C" fn redox_physmap(
+    physical_address: *mut c_void,
+    size: size_t,
+    flags: c_int,
+) -> *mut c_void {
+    let res = e(syscall::physmap(
+        physical_address as usize,
+        size,
+        flags as usize,
+    ));
     if res == !0 {
         return ptr::null_mut();
     } else {
-        return res as *mut c_void
+        return res as *mut c_void;
     }
 }
 

src/platform/redox/mod.rs

@@ -599,14 +599,22 @@ impl Pal for Sys {
     }
 
     fn mkdir(path: &CStr, mode: mode_t) -> c_int {
-        match File::create(path, fcntl::O_DIRECTORY | fcntl::O_EXCL | fcntl::O_CLOEXEC, 0o777) {
+        match File::create(
+            path,
+            fcntl::O_DIRECTORY | fcntl::O_EXCL | fcntl::O_CLOEXEC,
+            0o777,
+        ) {
             Ok(_fd) => 0,
             Err(_) => -1,
         }
     }
 
     fn mkfifo(path: &CStr, mode: mode_t) -> c_int {
-        match File::create(path, fcntl::O_CREAT | fcntl::O_CLOEXEC, syscall::MODE_FIFO as mode_t | (mode & 0o777)) {
+        match File::create(
+            path,
+            fcntl::O_CREAT | fcntl::O_CLOEXEC,
+            syscall::MODE_FIFO as mode_t | (mode & 0o777),
+        ) {
             Ok(fd) => 0,
             Err(_) => -1,
         }
@@ -623,11 +631,14 @@ impl Pal for Sys {
         let map = Map {
             offset: off as usize,
             size: len,
-            flags: ((prot as usize) << 16) | ((flags as usize) & 0xFFFF)
+            flags: ((prot as usize) << 16) | ((flags as usize) & 0xFFFF),
         };
 
         if flags & MAP_ANON == MAP_ANON {
-            let fd = e(syscall::open("memory:", syscall::O_STAT | syscall::O_CLOEXEC)); // flags don't matter currently
+            let fd = e(syscall::open(
+                "memory:",
+                syscall::O_STAT | syscall::O_CLOEXEC,
+            )); // flags don't matter currently
             if fd == !0 {
                 return !0 as *mut c_void;
             }
@@ -815,7 +826,14 @@ impl Pal for Sys {
     }
 
     fn pte_clone() -> pid_t {
-        e(unsafe { syscall::clone(syscall::CLONE_VM | syscall::CLONE_FS | syscall::CLONE_FILES | syscall::CLONE_SIGHAND) }) as pid_t
+        e(unsafe {
+            syscall::clone(
+                syscall::CLONE_VM
+                    | syscall::CLONE_FS
+                    | syscall::CLONE_FILES
+                    | syscall::CLONE_SIGHAND,
+            )
+        }) as pid_t
     }
 
     fn read(fd: c_int, buf: &mut [u8]) -> ssize_t {
@@ -823,7 +841,10 @@ impl Pal for Sys {
     }
 
     fn readlink(pathname: &CStr, out: &mut [u8]) -> ssize_t {
-        let file = match File::open(pathname, fcntl::O_PATH | fcntl::O_SYMLINK | fcntl::O_CLOEXEC) {
+        let file = match File::open(
+            pathname,
+            fcntl::O_PATH | fcntl::O_SYMLINK | fcntl::O_CLOEXEC,
+        ) {
             Ok(ok) => ok,
             Err(_) => return -1,
         };
@@ -1084,7 +1105,7 @@ impl Pal for Sys {
     fn uname(utsname: *mut utsname) -> c_int {
         fn gethostname(name: &mut [u8]) -> io::Result<()> {
             if name.is_empty() {
-                return Ok(())
+                return Ok(());
             }
 
             let mut file = File::open(
@@ -1108,7 +1129,7 @@ impl Pal for Sys {
             match gethostname(unsafe {
                 slice::from_raw_parts_mut(
                     (*utsname).nodename.as_mut_ptr() as *mut u8,
-                    (*utsname).nodename.len()
+                    (*utsname).nodename.len(),
                 )
             }) {
                 Ok(_) => (),

src/platform/redox/signal.rs

@@ -1,13 +1,13 @@
 use core::mem;
 use syscall;
 
-use platform::errno;
 use super::super::types::*;
 use super::super::{Pal, PalSignal};
 use super::{e, Sys};
 use header::errno::EINVAL;
 use header::signal::{sigaction, sigset_t};
-use header::sys_time::{ITIMER_REAL, itimerval};
+use header::sys_time::{itimerval, ITIMER_REAL};
+use platform::errno;
 
 impl PalSignal for Sys {
     fn getitimer(which: c_int, out: *mut itimerval) -> c_int {
@@ -16,7 +16,7 @@ impl PalSignal for Sys {
             _ => unsafe {
                 errno = EINVAL;
                 return -1;
-            }
+            },
         };
 
         let fd = e(syscall::open(path, syscall::O_RDONLY | syscall::O_CLOEXEC));
@@ -35,9 +35,9 @@ impl PalSignal for Sys {
 
         unsafe {
             (*out).it_interval.tv_sec = spec.it_interval.tv_sec;
-            (*out).it_interval.tv_usec = spec.it_interval.tv_nsec/1000;
+            (*out).it_interval.tv_usec = spec.it_interval.tv_nsec / 1000;
             (*out).it_value.tv_sec = spec.it_value.tv_sec;
-            (*out).it_value.tv_usec = spec.it_value.tv_nsec/1000;
+            (*out).it_value.tv_usec = spec.it_value.tv_nsec / 1000;
         }
 
         0
@@ -61,7 +61,7 @@ impl PalSignal for Sys {
             _ => unsafe {
                 errno = EINVAL;
                 return -1;
-            }
+            },
         };
 
         let fd = e(syscall::open(path, syscall::O_RDWR | syscall::O_CLOEXEC));
@@ -75,11 +75,11 @@ impl PalSignal for Sys {
 
         if count != !0 {
             unsafe {
-                if ! old.is_null() {
+                if !old.is_null() {
                     (*old).it_interval.tv_sec = spec.it_interval.tv_sec;
-                    (*old).it_interval.tv_usec = spec.it_interval.tv_nsec/1000;
+                    (*old).it_interval.tv_usec = spec.it_interval.tv_nsec / 1000;
                     (*old).it_value.tv_sec = spec.it_value.tv_sec;
-                    (*old).it_value.tv_usec = spec.it_value.tv_nsec/1000;
+                    (*old).it_value.tv_usec = spec.it_value.tv_nsec / 1000;
                 }
 
                 spec.it_interval.tv_sec = (*new).it_interval.tv_sec;
@@ -136,11 +136,7 @@ impl PalSignal for Sys {
         } else {
             Some([unsafe { *set as u64 }, 0])
         };
-        let mut old_opt = if oset.is_null() {
-            None
-        } else {
-            Some([0, 0])
-        };
+        let mut old_opt = if oset.is_null() { None } else { Some([0, 0]) };
         let ret = e(syscall::sigprocmask(
             how as usize,
             new_opt.as_ref(),

src/start.rs

@@ -67,7 +67,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
     // Set up envp
     let envp = sp.envp();
     let mut len = 0;
-    while ! (*envp.add(len)).is_null() {
+    while !(*envp.add(len)).is_null() {
         len += 1;
     }
     platform::inner_environ = copy_string_array(envp, len);
@@ -102,11 +102,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
     }
 
     // not argv or envp, because programs like bash try to modify this *const* pointer :|
-    stdlib::exit(main(
-        argc,
-        platform::argv,
-        platform::environ,
-    ));
+    stdlib::exit(main(argc, platform::argv, platform::environ));
 
     unreachable!();
 }