Run fmt.sh

src/header/aio/mod.rs

@@ -1,4 +1,4 @@
-use header::time::{timespec, sigevent};
+use header::time::{sigevent, timespec};
 use platform::types::*;
 
 pub struct aiocb {

src/header/arpa_inet/mod.rs

@@ -7,9 +7,9 @@ use header::errno::*;
 use header::netinet_in::{in_addr, in_addr_t};
 use header::sys_socket::constants::*;
 use header::sys_socket::socklen_t;
+use platform;
 use platform::c_str;
 use platform::types::*;
-use platform;
 
 #[no_mangle]
 pub extern "C" fn htonl(hostlong: u32) -> u32 {

src/header/netdb/dns/answer.rs

@@ -18,5 +18,5 @@ pub struct DnsAnswer {
     pub a_class: u16,
     pub ttl_a: u16,
     pub ttl_b: u16,
-    pub data: Vec<u8>
+    pub data: Vec<u8>,
 }

src/header/netdb/dns/mod.rs

@@ -11,10 +11,10 @@
 pub use self::answer::DnsAnswer;
 pub use self::query::DnsQuery;
 
-use core::slice;
-use core::u16;
 use alloc::String;
 use alloc::Vec;
+use core::slice;
+use core::u16;
 
 mod answer;
 mod query;
@@ -23,7 +23,7 @@ mod query;
 #[derive(Copy, Clone, Debug, Default)]
 #[repr(packed)]
 pub struct n16 {
-    inner: u16
+    inner: u16,
 }
 
 impl n16 {
@@ -33,7 +33,9 @@ impl n16 {
 
     pub fn from_bytes(bytes: &[u8]) -> Self {
         n16 {
-            inner: unsafe { slice::from_raw_parts(bytes.as_ptr() as *const u16, bytes.len()/2)[0] }
+            inner: unsafe {
+                slice::from_raw_parts(bytes.as_ptr() as *const u16, bytes.len() / 2)[0]
+            },
         }
     }
 }
@@ -41,7 +43,7 @@ impl n16 {
 impl From<u16> for n16 {
     fn from(value: u16) -> Self {
         n16 {
-            inner: value.to_be()
+            inner: value.to_be(),
         }
     }
 }
@@ -57,7 +59,7 @@ pub struct Dns {
     pub transaction_id: u16,
     pub flags: u16,
     pub queries: Vec<DnsQuery>,
-    pub answers: Vec<DnsAnswer>
+    pub answers: Vec<DnsAnswer>,
 }
 
 impl Dns {
@@ -100,75 +102,67 @@ impl Dns {
         let mut i = 0;
 
         macro_rules! pop_u8 {
-            () => {
-                {
-                    i += 1;
-                    if i > data.len() {
-                        return Err(format!("{}: {}: pop_u8", file!(), line!()));
-                    }
-                    data[i - 1]
+            () => {{
+                i += 1;
+                if i > data.len() {
+                    return Err(format!("{}: {}: pop_u8", file!(), line!()));
                 }
-            };
+                data[i - 1]
+            }};
         };
 
         macro_rules! pop_n16 {
-            () => {
-                {
-                    i += 2;
-                    if i > data.len() {
-                        return Err(format!("{}: {}: pop_n16", file!(), line!()));
-                    }
-                    u16::from(n16::from_bytes(&data[i - 2 .. i]))
+            () => {{
+                i += 2;
+                if i > data.len() {
+                    return Err(format!("{}: {}: pop_n16", file!(), line!()));
                 }
-            };
+                u16::from(n16::from_bytes(&data[i - 2..i]))
+            }};
         };
 
         macro_rules! pop_data {
-            () => {
-                {
-                    let mut data = Vec::new();
-
-                    let data_len = pop_n16!();
-                    for _data_i in 0..data_len {
-                        data.push(pop_u8!());
-                    }
+            () => {{
+                let mut data = Vec::new();
 
-                    data
+                let data_len = pop_n16!();
+                for _data_i in 0..data_len {
+                    data.push(pop_u8!());
                 }
-            };
+
+                data
+            }};
         };
 
         macro_rules! pop_name {
-            () => {
-                {
-                    let mut name = String::new();
-                    let old_i = i;
-
-                    loop {
-                        let name_len = pop_u8!();
-                        if name_len & name_ind == name_ind {
-                            i -= 1;
-                            i = (pop_n16!() - ((name_ind as u16) << 8)) as usize;
-                            continue;
-                        }
-                        if name_len == 0 {
-                            break;
-                        }
-                        if ! name.is_empty() {
-                            name.push('.');
-                        }
-                        for _name_i in 0..name_len {
-                            name.push(pop_u8!() as char);
-                        }
+            () => {{
+                let mut name = String::new();
+                let old_i = i;
+
+                loop {
+                    let name_len = pop_u8!();
+                    if name_len & name_ind == name_ind {
+                        i -= 1;
+                        i = (pop_n16!() - ((name_ind as u16) << 8)) as usize;
+                        continue;
                     }
-
-                    if i <= old_i {
-                        i = old_i + 2;
+                    if name_len == 0 {
+                        break;
+                    }
+                    if !name.is_empty() {
+                        name.push('.');
                     }
+                    for _name_i in 0..name_len {
+                        name.push(pop_u8!() as char);
+                    }
+                }
 
-                    name
+                if i <= old_i {
+                    i = old_i + 2;
                 }
-            };
+
+                name
+            }};
         };
 
         let transaction_id = pop_n16!();
@@ -183,7 +177,7 @@ impl Dns {
             queries.push(DnsQuery {
                 name: pop_name!(),
                 q_type: pop_n16!(),
-                q_class: pop_n16!()
+                q_class: pop_n16!(),
             });
         }
 
@@ -195,7 +189,7 @@ impl Dns {
                 a_class: pop_n16!(),
                 ttl_a: pop_n16!(),
                 ttl_b: pop_n16!(),
-                data: pop_data!()
+                data: pop_data!(),
             });
         }
 

src/header/netdb/dns/query.rs

@@ -14,5 +14,5 @@ use alloc::String;
 pub struct DnsQuery {
     pub name: String,
     pub q_type: u16,
-    pub q_class: u16
+    pub q_class: u16,
 }

src/header/netdb/linux.rs

@@ -1,13 +1,13 @@
 use alloc::string::String;
+use c_str::CString;
 use platform::rawfile::RawFile;
-use platform::Line;
 use platform::rlb::RawLineBuffer;
-use c_str::CString;
+use platform::Line;
 
 pub fn get_dns_server() -> String {
     let fd = match RawFile::open(&CString::new("/etc/resolv.conf").unwrap(), 0, 0) {
         Ok(fd) => fd,
-        Err(_) => return String::new() // TODO: better error handling
+        Err(_) => return String::new(), // TODO: better error handling
     };
 
     let mut rlb = RawLineBuffer::new(*fd);

src/header/netdb/mod.rs

@@ -2,36 +2,36 @@
 
 mod dns;
 
-use core::{mem, str, ptr};
 use core::str::FromStr;
+use core::{mem, ptr, str};
 
-use alloc::{Vec, String};
+use alloc::boxed::Box;
 use alloc::str::SplitWhitespace;
 use alloc::string::ToString;
 use alloc::vec::IntoIter;
-use alloc::boxed::Box;
+use alloc::{String, Vec};
 
 use c_str::CString;
 
 use platform;
-use platform::{Pal, Sys};
-use platform::types::*;
-use platform::rlb::{Line, RawLineBuffer};
 use platform::c_str;
+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, IPPROTO_UDP, sockaddr_in};
+use header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
 use header::stdlib::atoi;
 use header::strings::strcasecmp;
-use header::sys_socket::constants::{SOCK_DGRAM, AF_INET};
-use header::sys_socket::{sockaddr, socklen_t};
 use header::sys_socket;
-use header::time::timespec;
+use header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
+use header::sys_socket::{sockaddr, socklen_t};
 use header::time;
+use header::time::timespec;
 use header::unistd::SEEK_SET;
 
 #[cfg(target_os = "linux")]
@@ -49,7 +49,7 @@ struct LookupHost(IntoIter<in_addr>);
 
 impl Iterator for LookupHost {
     type Item = in_addr;
-    fn next (&mut self) -> Option<Self::Item> {
+    fn next(&mut self) -> Option<Self::Item> {
         self.0.next()
     }
 }
@@ -65,37 +65,37 @@ pub struct hostent {
 
 #[repr(C)]
 pub struct netent {
-    n_name: *mut c_char, /* official name of net */
+    n_name: *mut c_char,         /* official name of net */
     n_aliases: *mut *mut c_char, /* alias list */
-    n_addrtype: c_int, /* net address type */
-    n_net: c_ulong, /* network # */
+    n_addrtype: c_int,           /* net address type */
+    n_net: c_ulong,              /* network # */
 }
 
 #[repr(C)]
 pub struct servent {
-    s_name: *mut c_char, /* official service name */
+    s_name: *mut c_char,         /* official service name */
     s_aliases: *mut *mut c_char, /* alias list */
-    s_port: c_int, /* port # */
-    s_proto: *mut c_char, /* protocol to use */
+    s_port: c_int,               /* port # */
+    s_proto: *mut c_char,        /* protocol to use */
 }
 
 #[repr(C)]
 pub struct protoent {
-    p_name: *mut c_char, /* official protocol name */
+    p_name: *mut c_char,         /* official protocol name */
     p_aliases: *mut *mut c_char, /* alias list */
-    p_proto: c_int, /* protocol # */
+    p_proto: c_int,              /* protocol # */
 }
 
 #[repr(C)]
 pub struct addrinfo {
-    ai_flags: c_int, /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
-    ai_family: c_int, /* PF_xxx */
-    ai_socktype: c_int, /* SOCK_xxx */
-    ai_protocol: c_int, /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
-    ai_addrlen: size_t, /* length of ai_addr */
+    ai_flags: c_int,           /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
+    ai_family: c_int,          /* PF_xxx */
+    ai_socktype: c_int,        /* SOCK_xxx */
+    ai_protocol: c_int,        /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+    ai_addrlen: size_t,        /* length of ai_addr */
     ai_canonname: *mut c_char, /* canonical name for hostname */
-    ai_addr: *mut sockaddr, /* binary address */
-    ai_next: *mut addrinfo, /* next structure in linked list */
+    ai_addr: *mut sockaddr,    /* binary address */
+    ai_next: *mut addrinfo,    /* next structure in linked list */
 }
 
 static mut NETDB: c_int = 0;
@@ -114,16 +114,16 @@ static mut NET_STAYOPEN: c_int = 0;
 static mut HOSTDB: c_int = 0;
 static mut HOST_ENTRY: hostent = hostent {
     h_name: ptr::null_mut(),
-    h_aliases: ptr::null_mut(), 
+    h_aliases: ptr::null_mut(),
     h_addrtype: 0,
     h_length: 0,
-    h_addr_list: ptr::null_mut(), 
+    h_addr_list: ptr::null_mut(),
 };
 static mut HOST_NAME: Option<Vec<u8>> = None;
 static mut HOST_ALIASES: Option<Vec<Vec<u8>>> = None;
 static mut HOST_ADDR: Option<in_addr> = None;
 static mut HOST_ADDR_LIST: [*mut c_char; 2] = [ptr::null_mut(); 2];
-static mut _HOST_ADDR_LIST: [u8;4] = [0u8;4];
+static mut _HOST_ADDR_LIST: [u8; 4] = [0u8; 4];
 static mut H_POS: usize = 0;
 static mut HOST_STAYOPEN: c_int = 0;
 
@@ -144,7 +144,7 @@ static mut PROTO_ENTRY: protoent = protoent {
 static mut PROTO_NAME: Option<Vec<u8>> = None;
 static mut PROTO_ALIASES: Option<Vec<Vec<u8>>> = None;
 static mut PROTO_NUM: Option<c_int> = None;
-static mut P_POS: usize = 0; 
+static mut P_POS: usize = 0;
 static mut PROTO_STAYOPEN: c_int = 0;
 
 static mut SERVDB: c_int = 0;
@@ -153,7 +153,6 @@ static mut SERV_ENTRY: servent = servent {
     s_aliases: ptr::null_mut(),
     s_port: 0 as c_int,
     s_proto: ptr::null_mut(),
-
 };
 static mut SERV_NAME: Option<Vec<u8>> = None;
 static mut SERV_ALIASES: Option<Vec<Vec<u8>>> = None;
@@ -178,11 +177,11 @@ fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
         .collect();
 
     if dns_vec.len() == 4 {
-        let mut dns_arr =  [0u8;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 dns_addr = unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) };
 
         let mut timespec = timespec::default();
         Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
@@ -191,33 +190,29 @@ fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
         let packet = Dns {
             transaction_id: tid,
             flags: 0x0100,
-            queries: vec![
-                DnsQuery {
-                    name: host.to_string(),
-                    q_type: 0x0001,
-                    q_class: 0x0001,
-                },
-            ],
+            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_box = packet_data.into_boxed_slice();
         let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
 
-        let sock = unsafe {sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32)};
+        let sock = unsafe { sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32) };
 
         let mut dest = sockaddr_in {
             sin_family: AF_INET as u16,
             sin_port: htons(53),
-            sin_addr: in_addr {
-                s_addr: dns_addr,
-            },
+            sin_addr: in_addr { s_addr: dns_addr },
             ..Default::default()
         };
-        
+
         let dest_ptr = &mut dest as *mut _ as *mut sockaddr;
 
         unsafe {
@@ -232,7 +227,7 @@ fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
         }
 
         let mut i = 0 as socklen_t;
-        let mut buf = [0u8;65536];
+        let mut buf = [0u8; 65536];
         let buf_ptr = buf.as_mut_ptr() as *mut c_void;
 
         let mut count = -1;
@@ -241,26 +236,28 @@ fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
         let from_ptr = &mut from as *mut sockaddr;
 
         unsafe {
-            count = sys_socket::recvfrom(sock, buf_ptr, 65536, 0, from_ptr, &mut i as *mut socklen_t);
+            count =
+                sys_socket::recvfrom(sock, buf_ptr, 65536, 0, from_ptr, &mut i as *mut socklen_t);
         }
         if count < 0 {
-            return Err(EIO)
+            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
+                    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],
-                            ])},
+                            s_addr: unsafe {
+                                mem::transmute::<[u8; 4], u32>([
+                                    answer.data[0],
+                                    answer.data[1],
+                                    answer.data[2],
+                                    answer.data[3],
+                                ])
+                            },
                         };
                         addrs.push(addr);
                     }
@@ -283,13 +280,13 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
         .map(|octet| octet.parse::<u8>().unwrap_or(0))
         .collect();
 
-    let mut dns_arr =  [0u8;4];
+    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() };
+    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 {
@@ -311,13 +308,11 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
         let packet = Dns {
             transaction_id: tid,
             flags: 0x0100,
-            queries: vec![
-                DnsQuery {
-                    name: String::from_utf8(name).unwrap(),
-                    q_type: 0x000C,
-                    q_class: 0x0001,
-                },
-            ],
+            queries: vec![DnsQuery {
+                name: String::from_utf8(name).unwrap(),
+                q_type: 0x000C,
+                q_class: 0x0001,
+            }],
             answers: vec![],
         };
 
@@ -327,13 +322,13 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
         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 sock = unsafe {sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32)};
+        let sock = unsafe { sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32) };
 
         let mut 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) },
+                s_addr: unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) },
             },
             ..Default::default()
         };
@@ -351,16 +346,17 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
         }
 
         let mut i = mem::size_of::<sockaddr_in>() as socklen_t;
-        let mut buf = [0u8;65536];
+        let mut buf = [0u8; 65536];
         let buf_ptr = buf.as_mut_ptr() as *mut c_void;
 
         let mut count = -1;
 
         unsafe {
-            count = sys_socket::recvfrom(sock, buf_ptr, 65536, 0, dest_ptr, &mut i as *mut socklen_t);
+            count =
+                sys_socket::recvfrom(sock, buf_ptr, 65536, 0, dest_ptr, &mut i as *mut socklen_t);
         }
         if count < 0 {
-            return Err(EIO)
+            return Err(EIO);
         }
 
         match Dns::parse(&buf[..count as usize]) {
@@ -427,13 +423,20 @@ pub unsafe extern "C" fn endservent() {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn gethostbyaddr(v: *const c_void, length: socklen_t, format:c_int) -> *const hostent {
+pub unsafe extern "C" fn gethostbyaddr(
+    v: *const c_void,
+    length: socklen_t,
+    format: c_int,
+) -> *const hostent {
     let addr: in_addr = *(v as *mut in_addr);
 
     // check the hosts file first
     let mut p: *const hostent;
     sethostent(HOST_STAYOPEN);
-    while { p=gethostent(); p!=ptr::null()} {
+    while {
+        p = gethostent();
+        p != ptr::null()
+    } {
         let mut cp = (*p).h_addr_list;
         loop {
             if cp.is_null() {
@@ -442,9 +445,9 @@ pub unsafe extern "C" fn gethostbyaddr(v: *const c_void, length: socklen_t, form
             if (*cp).is_null() {
                 break;
             }
-            let mut cp_slice: [i8;4] = [0i8;4];
+            let mut cp_slice: [i8; 4] = [0i8; 4];
             (*cp).copy_to(cp_slice.as_mut_ptr(), 4);
-            let cp_s_addr = mem::transmute::<[i8;4], u32>(cp_slice);
+            let cp_s_addr = mem::transmute::<[i8; 4], u32>(cp_slice);
             if cp_s_addr == addr.s_addr {
                 sethostent(HOST_STAYOPEN);
                 return p;
@@ -456,37 +459,38 @@ pub unsafe extern "C" fn gethostbyaddr(v: *const c_void, length: socklen_t, form
     //TODO actually get aliases
     let mut _host_aliases: Vec<Vec<u8>> = Vec::new();
     _host_aliases.push(vec![b'\0']);
-    let mut host_aliases: Vec<*mut i8> = Vec::new(); 
+    let mut host_aliases: Vec<*mut i8> = Vec::new();
     host_aliases.push(ptr::null_mut());
     HOST_ALIASES = Some(_host_aliases);
 
-
     match lookup_addr(addr) {
         Ok(s) => {
-            _HOST_ADDR_LIST = mem::transmute::<u32, [u8;4]>(addr.s_addr);
+            _HOST_ADDR_LIST = mem::transmute::<u32, [u8; 4]>(addr.s_addr);
             HOST_ADDR_LIST = [_HOST_ADDR_LIST.as_mut_ptr() as *mut c_char, ptr::null_mut()];
             let mut host_name = s[0].to_vec();
             HOST_NAME = Some(host_name);
             HOST_ENTRY = hostent {
                 h_name: HOST_NAME.as_mut().unwrap().as_mut_ptr() as *mut c_char,
-                h_aliases: host_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8, 
+                h_aliases: host_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8,
                 h_addrtype: format,
                 h_length: length as i32,
-                h_addr_list: HOST_ADDR_LIST.as_mut_ptr()
+                h_addr_list: HOST_ADDR_LIST.as_mut_ptr(),
             };
             &HOST_ENTRY
         }
-        Err(e) => { platform::errno = e; return ptr::null(); }
+        Err(e) => {
+            platform::errno = e;
+            return ptr::null();
+        }
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
-
     // check if some idiot gave us an address instead of a name
     let mut octets = str::from_utf8_unchecked(c_str(name)).split('.');
-    let mut s_addr = [0u8;4];
-    let mut is_addr = true; 
+    let mut s_addr = [0u8; 4];
+    let mut is_addr = true;
     for i in 0..4 {
         if let Some(n) = octets.next().and_then(|x| u8::from_str(x).ok()) {
             s_addr[i] = n;
@@ -500,7 +504,7 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
 
     if is_addr == true {
         let addr = in_addr {
-            s_addr: mem::transmute::<[u8;4], u32>(s_addr),
+            s_addr: mem::transmute::<[u8; 4], u32>(s_addr),
         };
         return gethostbyaddr(&addr as *const _ as *const c_void, 4, AF_INET);
     }
@@ -508,7 +512,10 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
     // check the hosts file first
     let mut p: *const hostent;
     sethostent(HOST_STAYOPEN);
-    while { p = gethostent(); p!=ptr::null() } {
+    while {
+        p = gethostent();
+        p != ptr::null()
+    } {
         if strcasecmp((*p).h_name, name) == 0 {
             sethostent(HOST_STAYOPEN);
             return p;
@@ -531,33 +538,39 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
 
     let mut host = match lookup_host(str::from_utf8_unchecked(c_str(name))) {
         Ok(lookuphost) => lookuphost,
-        Err(e) => { platform::errno = e; return ptr::null() }
+        Err(e) => {
+            platform::errno = e;
+            return ptr::null();
+        }
     };
     let host_addr = match host.next() {
         Some(result) => result,
-        None => { platform::errno = ENOENT; return ptr::null() }
+        None => {
+            platform::errno = ENOENT;
+            return ptr::null();
+        }
     };
 
     let host_name: Vec<u8> = c_str(name).to_vec();
     HOST_NAME = Some(host_name);
-    _HOST_ADDR_LIST = mem::transmute::<u32, [u8;4]>(host_addr.s_addr);
+    _HOST_ADDR_LIST = mem::transmute::<u32, [u8; 4]>(host_addr.s_addr);
     HOST_ADDR_LIST = [_HOST_ADDR_LIST.as_mut_ptr() as *mut c_char, ptr::null_mut()];
     HOST_ADDR = Some(host_addr);
 
     //TODO actually get aliases
     let mut _host_aliases: Vec<Vec<u8>> = Vec::new();
     _host_aliases.push(vec![b'\0']);
-    let mut host_aliases: Vec<*mut i8> = Vec::new(); 
+    let mut host_aliases: Vec<*mut i8> = Vec::new();
     host_aliases.push(ptr::null_mut());
     host_aliases.push(ptr::null_mut());
     HOST_ALIASES = Some(_host_aliases);
 
     HOST_ENTRY = hostent {
         h_name: HOST_NAME.as_mut().unwrap().as_mut_ptr() as *mut c_char,
-        h_aliases: host_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8, 
+        h_aliases: host_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8,
         h_addrtype: AF_INET,
         h_length: 4,
-        h_addr_list: HOST_ADDR_LIST.as_mut_ptr()
+        h_addr_list: HOST_ADDR_LIST.as_mut_ptr(),
     };
     sethostent(HOST_STAYOPEN);
     &HOST_ENTRY as *const hostent
@@ -576,7 +589,9 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
         r = match rlb.next() {
             Line::Some(s) => bytes_to_box_str(s),
             _ => {
-                if HOST_STAYOPEN == 0 { endhostent(); }
+                if HOST_STAYOPEN == 0 {
+                    endhostent();
+                }
                 return ptr::null();
             }
         };
@@ -592,7 +607,7 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
     let mut addr = mem::uninitialized();
     inet_aton(addr_cstr, &mut addr);
 
-    _HOST_ADDR_LIST = mem::transmute::<u32, [u8;4]>(addr.s_addr);
+    _HOST_ADDR_LIST = mem::transmute::<u32, [u8; 4]>(addr.s_addr);
     HOST_ADDR_LIST = [_HOST_ADDR_LIST.as_mut_ptr() as *mut c_char, ptr::null_mut()];
 
     HOST_ADDR = Some(addr);
@@ -605,14 +620,19 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
     loop {
         let mut alias = match iter.next() {
             Some(s) => s.as_bytes().to_vec(),
-            _ => break
+            _ => break,
         };
         alias.push(b'\0');
         _host_aliases.push(alias);
     }
     HOST_ALIASES = Some(_host_aliases);
 
-    let mut host_aliases: Vec<*mut i8> = HOST_ALIASES.as_mut().unwrap().iter_mut().map(|x| x.as_mut_ptr() as *mut i8).collect();
+    let mut host_aliases: Vec<*mut i8> = HOST_ALIASES
+        .as_mut()
+        .unwrap()
+        .iter_mut()
+        .map(|x| x.as_mut_ptr() as *mut i8)
+        .collect();
     host_aliases.push(ptr::null_mut());
     host_aliases.push(ptr::null_mut());
 
@@ -623,12 +643,12 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
         h_aliases: host_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8,
         h_addrtype: AF_INET,
         h_length: 4,
-        h_addr_list: HOST_ADDR_LIST.as_mut_ptr()
+        h_addr_list: HOST_ADDR_LIST.as_mut_ptr(),
     };
-        if HOST_STAYOPEN == 0 { 
-            endhostent(); 
-        }
-        &HOST_ENTRY as *const hostent
+    if HOST_STAYOPEN == 0 {
+        endhostent();
+    }
+    &HOST_ENTRY as *const hostent
 }
 
 pub unsafe extern "C" fn getnetbyaddr(net: u32, net_type: c_int) -> *const netent {
@@ -647,8 +667,10 @@ pub unsafe extern "C" fn getnetent() -> *const netent {
 pub unsafe extern "C" fn getprotobyname(name: *const c_char) -> *const protoent {
     let mut p: *const protoent;
     setprotoent(PROTO_STAYOPEN);
-    while {p=getprotoent();
-           p!=ptr::null()} {
+    while {
+        p = getprotoent();
+        p != ptr::null()
+    } {
         if strcasecmp((*p).p_name, name) == 0 {
             setprotoent(PROTO_STAYOPEN);
             return p;
@@ -664,15 +686,15 @@ pub unsafe extern "C" fn getprotobyname(name: *const c_char) -> *const protoent
                 setprotoent(PROTO_STAYOPEN);
                 break;
             }
-			if strcasecmp(*cp, name) == 0 {
+            if strcasecmp(*cp, name) == 0 {
                 setprotoent(PROTO_STAYOPEN);
-			    return p;
-			}
-			cp = cp.offset(1);
-	    }
+                return p;
+            }
+            cp = cp.offset(1);
+        }
     }
     setprotoent(PROTO_STAYOPEN);
-    
+
     platform::errno = ENOENT;
     ptr::null() as *const protoent
 }
@@ -681,8 +703,10 @@ pub unsafe extern "C" fn getprotobyname(name: *const c_char) -> *const protoent
 pub unsafe extern "C" fn getprotobynumber(number: c_int) -> *const protoent {
     setprotoent(PROTO_STAYOPEN);
     let mut p: *const protoent;
-    while {p=getprotoent();
-           p!=ptr::null()} {
+    while {
+        p = getprotoent();
+        p != ptr::null()
+    } {
         if (*p).p_proto == number {
             setprotoent(PROTO_STAYOPEN);
             return p;
@@ -691,7 +715,7 @@ pub unsafe extern "C" fn getprotobynumber(number: c_int) -> *const protoent {
     setprotoent(PROTO_STAYOPEN);
     platform::errno = ENOENT;
     ptr::null() as *const protoent
- }
+}
 
 #[no_mangle]
 pub unsafe extern "C" fn getprotoent() -> *const protoent {
@@ -707,9 +731,11 @@ pub unsafe extern "C" fn getprotoent() -> *const protoent {
         r = match rlb.next() {
             Line::Some(s) => bytes_to_box_str(s),
             _ => {
-                if PROTO_STAYOPEN == 0 { endprotoent(); }
+                if PROTO_STAYOPEN == 0 {
+                    endprotoent();
+                }
                 return ptr::null();
-            },
+            }
         };
     }
     rlb.next();
@@ -728,43 +754,53 @@ pub unsafe extern "C" fn getprotoent() -> *const protoent {
     loop {
         let mut alias = match iter.next() {
             Some(s) => s.as_bytes().to_vec(),
-            None => break
+            None => break,
         };
         alias.push(b'\0');
         _proto_aliases.push(alias);
     }
-    let mut proto_aliases: Vec<*mut i8> = _proto_aliases.iter_mut().map(|x| x.as_mut_ptr() as *mut i8).collect();
+    let mut proto_aliases: Vec<*mut i8> = _proto_aliases
+        .iter_mut()
+        .map(|x| x.as_mut_ptr() as *mut i8)
+        .collect();
     proto_aliases.push(ptr::null_mut());
 
     PROTO_ALIASES = Some(_proto_aliases);
     PROTO_NAME = Some(proto_name);
 
-
-    PROTO_ENTRY = protoent { 
+    PROTO_ENTRY = protoent {
         p_name: PROTO_NAME.as_mut().unwrap().as_mut_slice().as_mut_ptr() as *mut c_char,
         p_aliases: proto_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8,
-        p_proto: PROTO_NUM.unwrap()           
+        p_proto: PROTO_NUM.unwrap(),
     };
-        if PROTO_STAYOPEN == 0 { endprotoent(); }
-        &PROTO_ENTRY as *const protoent
+    if PROTO_STAYOPEN == 0 {
+        endprotoent();
+    }
+    &PROTO_ENTRY as *const protoent
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn getservbyname(
     name: *const c_char,
-    proto: *const c_char)
--> *const servent {
+    proto: *const c_char,
+) -> *const servent {
     setservent(SERV_STAYOPEN);
     let mut p: *const servent;
     if proto.is_null() {
-        while { p = getservent(); p!=ptr::null() } {
+        while {
+            p = getservent();
+            p != ptr::null()
+        } {
             if strcasecmp((*p).s_name, name) == 0 {
                 setservent(SERV_STAYOPEN);
                 return p;
             }
         }
     } else {
-        while { p = getservent(); p!=ptr::null() } {
+        while {
+            p = getservent();
+            p != ptr::null()
+        } {
             if strcasecmp((*p).s_name, name) == 0 && strcasecmp((*p).s_proto, proto) == 0 {
                 setservent(SERV_STAYOPEN);
                 return p;
@@ -777,21 +813,24 @@ pub unsafe extern "C" fn getservbyname(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn getservbyport(
-    port: c_int,
-    proto: *const c_char)
--> *const servent {
+pub unsafe extern "C" fn getservbyport(port: c_int, proto: *const c_char) -> *const servent {
     setservent(SERV_STAYOPEN);
     let mut p: *const servent;
     if proto.is_null() {
-        while { p=getservent(); p!=ptr::null()} {
-                if (*p).s_port == port {
-                    setservent(SERV_STAYOPEN);
-                    return p;
-                }
+        while {
+            p = getservent();
+            p != ptr::null()
+        } {
+            if (*p).s_port == port {
+                setservent(SERV_STAYOPEN);
+                return p;
+            }
         }
     } else {
-        while { p=getservent(); p!=ptr::null()} {
+        while {
+            p = getservent();
+            p != ptr::null()
+        } {
             if (*p).s_port == port && strcasecmp((*p).s_proto, proto) == 0 {
                 setservent(SERV_STAYOPEN);
                 return p;
@@ -816,14 +855,16 @@ pub unsafe extern "C" fn getservent() -> *const servent {
         r = match rlb.next() {
             Line::Some(s) => bytes_to_box_str(s),
             _ => {
-                if SERV_STAYOPEN == 0 { endservent(); }
+                if SERV_STAYOPEN == 0 {
+                    endservent();
+                }
                 return ptr::null();
             }
         };
     }
 
     rlb.next();
-    S_POS = rlb.line_pos(); 
+    S_POS = rlb.line_pos();
 
     let mut iter: SplitWhitespace = r.split_whitespace();
     let mut serv_name: Vec<u8> = iter.next().unwrap().as_bytes().to_vec();
@@ -848,26 +889,28 @@ pub unsafe extern "C" fn getservent() -> *const servent {
      *}
      *let mut serv_aliases: Vec<*mut i8> = _serv_aliases.iter_mut().map(|x| x.as_mut_ptr() as *mut i8).collect();
      *serv_aliases.push(ptr::null_mut());
-     * 
+     *
      */
     let mut _serv_aliases: Vec<Vec<u8>> = Vec::new();
     _serv_aliases.push(vec![b'\0']);
-    let mut serv_aliases: Vec<*mut i8> = Vec::new(); 
+    let mut serv_aliases: Vec<*mut i8> = Vec::new();
     serv_aliases.push(ptr::null_mut());
     serv_aliases.push(ptr::null_mut());
-    
+
     SERV_ALIASES = Some(_serv_aliases);
     SERV_NAME = Some(serv_name);
     SERV_PROTO = Some(proto);
 
     SERV_ENTRY = servent {
         s_name: SERV_NAME.as_mut().unwrap().as_mut_slice().as_mut_ptr() as *mut c_char,
-        s_aliases: serv_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8, 
+        s_aliases: serv_aliases.as_mut_slice().as_mut_ptr() as *mut *mut i8,
         s_port: SERV_PORT.unwrap(),
-        s_proto: SERV_PROTO.as_mut().unwrap().as_mut_slice().as_mut_ptr() as *mut c_char
+        s_proto: SERV_PROTO.as_mut().unwrap().as_mut_slice().as_mut_ptr() as *mut c_char,
     };
 
-    if SERV_STAYOPEN == 0 { endservent(); }
+    if SERV_STAYOPEN == 0 {
+        endservent();
+    }
     &SERV_ENTRY as *const servent
 }
 
@@ -877,7 +920,7 @@ pub unsafe extern "C" fn sethostent(stayopen: c_int) {
     if HOSTDB == 0 {
         HOSTDB = Sys::open(&CString::new("/etc/hosts").unwrap(), O_RDONLY, 0)
     } else {
-       Sys::lseek(HOSTDB, 0, SEEK_SET);
+        Sys::lseek(HOSTDB, 0, SEEK_SET);
     }
     H_POS = 0;
 }
@@ -888,8 +931,8 @@ pub unsafe extern "C" fn setnetent(stayopen: c_int) {
     if NETDB == 0 {
         NETDB = Sys::open(&CString::new("/etc/networks").unwrap(), O_RDONLY, 0)
     } else {
-       Sys::lseek(NETDB, 0, SEEK_SET);
-       N_POS = 0;
+        Sys::lseek(NETDB, 0, SEEK_SET);
+        N_POS = 0;
     }
 }
 
@@ -899,8 +942,8 @@ pub unsafe extern "C" fn setprotoent(stayopen: c_int) {
     if PROTODB == 0 {
         PROTODB = Sys::open(&CString::new("/etc/protocols").unwrap(), O_RDONLY, 0)
     } else {
-       Sys::lseek(PROTODB, 0, SEEK_SET);
-       P_POS = 0;
+        Sys::lseek(PROTODB, 0, SEEK_SET);
+        P_POS = 0;
     }
 }
 
@@ -910,8 +953,8 @@ pub unsafe extern "C" fn setservent(stayopen: c_int) {
     if SERVDB == 0 {
         SERVDB = Sys::open(&CString::new("/etc/services").unwrap(), O_RDONLY, 0)
     } else {
-       Sys::lseek(SERVDB, 0, SEEK_SET);
-       S_POS = 0;
+        Sys::lseek(SERVDB, 0, SEEK_SET);
+        S_POS = 0;
     }
 }
 
@@ -919,8 +962,8 @@ pub unsafe extern "C" fn getaddrinfo(
     node: *const c_char,
     service: *const c_char,
     hints: *const addrinfo,
-    res: *mut *mut addrinfo)
--> c_int {
+    res: *mut *mut addrinfo,
+) -> c_int {
     unimplemented!();
 }
 
@@ -931,8 +974,8 @@ pub unsafe extern "C" fn getnameinfo(
     hostlen: socklen_t,
     serv: *mut c_char,
     servlen: socklen_t,
-    flags: c_int)
--> c_int {
+    flags: c_int,
+) -> c_int {
     unimplemented!();
 }
 

src/header/pwd/mod.rs

@@ -6,8 +6,8 @@ use c_str::CStr;
 use header::{errno, fcntl};
 use platform;
 use platform::types::*;
-use platform::{Line, RawFile, RawLineBuffer};
 use platform::Sys;
+use platform::{Line, RawFile, RawLineBuffer};
 
 #[repr(C)]
 pub struct passwd {
@@ -61,7 +61,7 @@ where
         let line = match rlb.next() {
             Line::Error => return OptionPasswd::Error,
             Line::EOF => return OptionPasswd::NotFound,
-            Line::Some(line) => line
+            Line::Some(line) => line,
         };
 
         // Parse into passwd

src/header/stdio/printf.rs

@@ -1,5 +1,5 @@
 use core::fmt::Write as CoreWrite;
-use core::{slice, str, ptr};
+use core::{ptr, slice, str};
 
 use platform::types::*;
 use platform::{self, Write};

src/header/sys_socket/mod.rs

@@ -23,11 +23,7 @@ pub unsafe extern "C" fn accept(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::accept(
-        socket,
-        address,
-        address_len,
-    )
+    Sys::accept(socket, address, address_len)
 }
 
 #[no_mangle]
@@ -36,11 +32,7 @@ pub unsafe extern "C" fn bind(
     address: *const sockaddr,
     address_len: socklen_t,
 ) -> c_int {
-    Sys::bind(
-        socket,
-        address,
-        address_len,
-    )
+    Sys::bind(socket, address, address_len)
 }
 
 #[no_mangle]
@@ -49,11 +41,7 @@ pub unsafe extern "C" fn connect(
     address: *const sockaddr,
     address_len: socklen_t,
 ) -> c_int {
-    Sys::connect(
-        socket,
-        address,
-        address_len,
-    )
+    Sys::connect(socket, address, address_len)
 }
 
 #[no_mangle]
@@ -62,11 +50,7 @@ pub unsafe extern "C" fn getpeername(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::getpeername(
-        socket,
-        address,
-        address_len,
-    )
+    Sys::getpeername(socket, address, address_len)
 }
 
 #[no_mangle]
@@ -75,11 +59,7 @@ pub unsafe extern "C" fn getsockname(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::getsockname(
-        socket,
-        address,
-        address_len,
-    )
+    Sys::getsockname(socket, address, address_len)
 }
 
 #[no_mangle]
@@ -124,14 +104,7 @@ pub unsafe extern "C" fn recvfrom(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> ssize_t {
-    Sys::recvfrom(
-        socket,
-        buffer,
-        length,
-        flags,
-        address,
-        address_len,
-    )
+    Sys::recvfrom(socket, buffer, length, flags, address, address_len)
 }
 
 #[no_mangle]
@@ -153,14 +126,7 @@ pub unsafe extern "C" fn sendto(
     dest_addr: *const sockaddr,
     dest_len: socklen_t,
 ) -> ssize_t {
-    Sys::sendto(
-        socket,
-        message,
-        length,
-        flags,
-        dest_addr,
-        dest_len,
-    )
+    Sys::sendto(socket, message, length, flags, dest_addr, dest_len)
 }
 
 #[no_mangle]

src/header/sys_time/mod.rs

@@ -1,9 +1,9 @@
 //! sys/time implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/systime.h.html
 
 use c_str::CStr;
+use header::time::timespec;
 use platform::types::*;
 use platform::{Pal, Sys};
-use header::time::timespec;
 
 pub const ITIMER_REAL: c_int = 0;
 pub const ITIMER_VIRTUAL: c_int = 1;
@@ -44,19 +44,12 @@ pub extern "C" fn setitimer(
     value: *const itimerval,
     ovalue: *mut itimerval,
 ) -> c_int {
-    Sys::setitimer(
-        which,
-        value,
-        ovalue,
-    )
+    Sys::setitimer(which, value, ovalue)
 }
 
 #[no_mangle]
 pub extern "C" fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int {
-    Sys::gettimeofday(
-        tp,
-        tzp,
-    )
+    Sys::gettimeofday(tp, tzp)
 }
 
 // #[no_mangle]

src/header/sys_utsname/mod.rs

@@ -16,8 +16,8 @@ pub struct utsname {
 
 #[cfg(target_os = "linux")]
 mod inner {
-    use platform::{Pal, Sys};
     use super::*;
+    use platform::{Pal, Sys};
 
     #[no_mangle]
     pub unsafe extern "C" fn uname(uts: *mut utsname) -> c_int {

src/header/time/mod.rs

@@ -336,10 +336,7 @@ pub unsafe extern "C" fn mktime(t: *mut tm) -> time_t {
 
 #[no_mangle]
 pub extern "C" fn nanosleep(rqtp: *const timespec, rmtp: *mut timespec) -> c_int {
-    Sys::nanosleep(
-        rqtp,
-        rmtp,
-    )
+    Sys::nanosleep(rqtp, rmtp)
 }
 
 #[no_mangle]

src/header/unistd/mod.rs

@@ -4,10 +4,10 @@ use core::{ptr, slice};
 
 use c_str::CStr;
 use header::sys_time;
+use header::time::timespec;
 use platform;
 use platform::types::*;
 use platform::{Pal, Sys};
-use header::time::timespec;
 
 pub use self::brk::*;
 pub use self::getopt::*;

src/platform/linux/mod.rs

@@ -7,13 +7,13 @@ use c_str::CStr;
 use header::dirent::dirent;
 use header::errno::{EINVAL, ENOSYS};
 use header::signal::SIGCHLD;
+use header::sys_ioctl::{winsize, TCGETS, TCSETS, TIOCGWINSZ};
 use header::sys_resource::rusage;
 use header::sys_select::fd_set;
 use header::sys_stat::stat;
 use header::sys_time::{itimerval, timeval, timezone};
 use header::sys_times::tms;
 use header::sys_utsname::utsname;
-use header::sys_ioctl::{winsize, TCGETS, TCSETS, TIOCGWINSZ};
 use header::termios::termios;
 use header::time::timespec;
 

src/platform/linux/signal.rs

@@ -1,9 +1,9 @@
 use core::mem;
 
-use header::signal::{sigaction, sigset_t};
 use super::super::types::*;
 use super::super::PalSignal;
 use super::{e, Sys};
+use header::signal::{sigaction, sigset_t};
 
 impl PalSignal for Sys {
     fn kill(pid: pid_t, sig: c_int) -> c_int {

src/platform/linux/socket.rs

@@ -1,7 +1,7 @@
-use header::sys_socket::{sockaddr, socklen_t};
 use super::super::types::*;
 use super::super::PalSocket;
 use super::{e, Sys};
+use header::sys_socket::{sockaddr, socklen_t};
 
 impl PalSocket for Sys {
     unsafe fn accept(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int {

src/platform/pal/signal.rs

@@ -1,6 +1,6 @@
-use header::signal::{sigaction, sigset_t};
 use super::super::types::*;
 use super::super::Pal;
+use header::signal::{sigaction, sigset_t};
 
 pub trait PalSignal: Pal {
     fn kill(pid: pid_t, sig: c_int) -> c_int {

src/platform/pal/socket.rs

@@ -1,6 +1,6 @@
-use header::sys_socket::{sockaddr, socklen_t};
 use super::super::types::*;
 use super::super::Pal;
+use header::sys_socket::{sockaddr, socklen_t};
 
 pub trait PalSocket: Pal {
     unsafe fn accept(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int {

src/platform/rawfile.rs

@@ -69,11 +69,15 @@ pub fn file_read_all(path: &CStr) -> Result<Vec<u8>, ()> {
         len += read as usize;
 
         if read == 0 {
-            unsafe { buf.set_len(len); }
+            unsafe {
+                buf.set_len(len);
+            }
             return Ok(buf);
         }
         if read < 0 {
-            unsafe { buf.set_len(len); }
+            unsafe {
+                buf.set_len(len);
+            }
             return Err(());
         }
     }

src/platform/redox/signal.rs

@@ -1,9 +1,9 @@
 use syscall;
 
-use header::signal::{sigaction, sigset_t};
 use super::super::types::*;
 use super::super::{Pal, PalSignal};
 use super::{e, Sys};
+use header::signal::{sigaction, sigset_t};
 
 #[thread_local]
 static mut SIG_HANDLER: Option<extern "C" fn(c_int)> = None;

src/platform/redox/socket.rs

@@ -2,12 +2,12 @@ use core::{mem, ptr, slice};
 use syscall::flag::*;
 use syscall::{self, Result};
 
-use header::netinet_in::{in_addr_t, in_port_t, sockaddr_in};
-use header::sys_socket::constants::*;
-use header::sys_socket::{sockaddr, socklen_t};
 use super::super::types::*;
 use super::super::{errno, Pal, PalSocket};
 use super::{e, Sys};
+use header::netinet_in::{in_addr_t, in_port_t, sockaddr_in};
+use header::sys_socket::constants::*;
+use header::sys_socket::{sockaddr, socklen_t};
 
 macro_rules! bind_or_connect {
     (bind $path:expr) => {
@@ -30,9 +30,9 @@ macro_rules! bind_or_connect {
         let port = data.sin_port;
         let path = format!(
             bind_or_connect!($mode "{}.{}.{}.{}:{}"),
-            addr >> 8*3,
-            addr >> 8*2 & 0xFF,
-            addr >> 8   & 0xFF,
+            addr >> 8 * 3,
+            addr >> 8 * 2 & 0xFF,
+            addr >> 8 & 0xFF,
             addr & 0xFF,
             port
         );
@@ -48,7 +48,7 @@ macro_rules! bind_or_connect {
             return -1;
         }
         0
-    }}
+    }};
 }
 
 unsafe fn inner_get_name(

src/platform/rlb.rs

@@ -1,7 +1,7 @@
 use alloc::vec::Vec;
 
-use platform::{Pal, Sys};
 use platform::types::*;
+use platform::{Pal, Sys};
 
 use header::unistd::{lseek, SEEK_SET};
 /// Implements an `Iterator` which returns on either newline or EOF.
@@ -10,14 +10,14 @@ pub struct RawLineBuffer {
     pub fd: c_int,
     buf: Vec<u8>,
     newline: Option<usize>,
-    read: usize
+    read: usize,
 }
 
 #[derive(PartialEq)]
 pub enum Line<'a> {
     Error,
     EOF,
-    Some(&'a [u8])
+    Some(&'a [u8]),
 }
 
 impl RawLineBuffer {
@@ -26,7 +26,7 @@ impl RawLineBuffer {
             fd: fd,
             buf: Vec::new(),
             newline: None,
-            read: 0
+            read: 0,
         }
     }