Add trace macro and feature

Cargo.toml

@@ -35,6 +35,10 @@ sc = "0.2"
 redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git", branch = "relibc" }
 spin = "0.4"
 
+[features]
+default = ["trace"]
+trace = []
+
 [profile.dev]
 panic = "abort"
 

src/header/sys_socket/mod.rs

@@ -23,7 +23,11 @@ pub unsafe extern "C" fn accept(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::accept(socket, address, address_len)
+    trace_expr!(
+        Sys::accept(socket, address, address_len),
+        "accept({}, {:p}, {:p})",
+        socket, address, address_len
+    )
 }
 
 #[no_mangle]
@@ -32,7 +36,11 @@ pub unsafe extern "C" fn bind(
     address: *const sockaddr,
     address_len: socklen_t,
 ) -> c_int {
-    Sys::bind(socket, address, address_len)
+    trace_expr!(
+        Sys::bind(socket, address, address_len),
+        "bind({}, {:p}, {})",
+        socket, address, address_len
+    )
 }
 
 #[no_mangle]
@@ -41,7 +49,11 @@ pub unsafe extern "C" fn connect(
     address: *const sockaddr,
     address_len: socklen_t,
 ) -> c_int {
-    Sys::connect(socket, address, address_len)
+    trace_expr!(
+        Sys::connect(socket, address, address_len),
+        "connect({}, {:p}, {})",
+        socket, address, address_len
+    )
 }
 
 #[no_mangle]
@@ -50,7 +62,11 @@ pub unsafe extern "C" fn getpeername(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::getpeername(socket, address, address_len)
+    trace_expr!(
+        Sys::getpeername(socket, address, address_len),
+        "getpeername({}, {:p}, {:p})",
+        socket, address, address_len
+    )
 }
 
 #[no_mangle]
@@ -59,7 +75,11 @@ pub unsafe extern "C" fn getsockname(
     address: *mut sockaddr,
     address_len: *mut socklen_t,
 ) -> c_int {
-    Sys::getsockname(socket, address, address_len)
+    trace_expr!(
+        Sys::getsockname(socket, address, address_len),
+        "getsockname({}, {:p}, {:p})",
+        socket, address, address_len
+    )
 }
 
 // #[no_mangle]
@@ -104,7 +124,11 @@ 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)
+    trace_expr!(
+        Sys::recvfrom(socket, buffer, length, flags, address, address_len),
+        "recvfrom({}, {:p}, {}, {:#x}, {:p}, {:p})",
+        socket, buffer, length, flags, address, address_len
+    )
 }
 
 #[no_mangle]
@@ -126,7 +150,11 @@ 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)
+    trace_expr!(
+        Sys::sendto(socket, message, length, flags, dest_addr, dest_len),
+        "sendto({}, {:p}, {}, {:#x}, {:p}, {})",
+        socket, message, length, flags, dest_addr, dest_len
+    )
 }
 
 // #[no_mangle]
@@ -147,7 +175,11 @@ pub unsafe extern "C" fn sendto(
 
 #[no_mangle]
 pub unsafe extern "C" fn socket(domain: c_int, kind: c_int, protocol: c_int) -> c_int {
-    Sys::socket(domain, kind, protocol)
+    trace_expr!(
+        Sys::socket(domain, kind, protocol),
+        "socket({}, {}, {})",
+        domain, kind, protocol,
+    )
 }
 
 // #[no_mangle]

src/macros.rs

@@ -32,6 +32,49 @@ macro_rules! eprintln {
     ($fmt:expr, $($arg:tt)*) => (eprint!(concat!($fmt, "\n"), $($arg)*));
 }
 
+#[macro_export]
+#[cfg(not(feature = "trace"))]
+macro_rules! trace {
+    ($($arg:tt)*) => ();
+}
+
+#[macro_export]
+#[cfg(feature = "trace")]
+macro_rules! trace {
+    ($($arg:tt)*) => (eprintln!($($arg)*));
+}
+
+#[macro_export]
+#[cfg(not(feature = "trace"))]
+macro_rules! trace_expr {
+    ($expr:expr, $($arg:tt)*) => ($expr);
+}
+
+#[cfg(feature = "trace")]
+pub fn trace_error() -> (isize, &'static str) {
+    use header::errno::STR_ERROR;
+    use platform;
+    use platform::types::c_int;
+
+    let errno = unsafe { platform::errno } as isize;
+    if errno >= 0 && errno < STR_ERROR.len() as isize {
+        (errno, STR_ERROR[errno as usize])
+    } else {
+        (errno, "Unknown error")
+    }
+}
+
+#[macro_export]
+#[cfg(feature = "trace")]
+macro_rules! trace_expr {
+    ($expr:expr, $($arg:tt)*) => ({
+        trace!("{} {:?}", format_args!($($arg)*), $crate::macros::trace_error());
+        let ret = $expr;
+        trace!("{} = {} {:?}", format_args!($($arg)*), ret, $crate::macros::trace_error());
+        ret
+    });
+}
+
 #[macro_export]
 macro_rules! strto_impl {
     (

src/platform/redox/socket.rs

@@ -136,13 +136,30 @@ impl PalSocket for Sys {
             errno = syscall::EOPNOTSUPP;
             return -1;
         }
-        if address != ptr::null_mut()
-            && address_len != ptr::null_mut()
-            && Self::getpeername(socket, address, address_len) < 0
-        {
-            return -1;
+        if address == ptr::null_mut() || address_len == ptr::null_mut() {
+            Self::read(socket, slice::from_raw_parts_mut(buf as *mut u8, len))
+        } else {
+            let fd = e(syscall::dup(socket as usize, b"listen"));
+            if fd < 0 {
+                return -1;
+            }
+
+            let mut path = [0; 4096];
+            let path_len = e(syscall::fpath(fd, &mut path));
+            if path_len < 0 {
+                let _ = syscall::close(fd);
+                return -1;
+            }
+
+            // XXX process path and write to address
+            println!("listen path: {}", ::core::str::from_utf8_unchecked(&path[..path_len]));
+
+            let ret = Self::read(fd as i32, slice::from_raw_parts_mut(buf as *mut u8, len));
+
+            let _ = syscall::close(fd);
+
+            ret
         }
-        Self::read(socket, slice::from_raw_parts_mut(buf as *mut u8, len))
     }
 
     unsafe fn sendto(
@@ -153,15 +170,39 @@ impl PalSocket for Sys {
         dest_addr: *const sockaddr,
         dest_len: socklen_t,
     ) -> ssize_t {
-        if dest_addr != ptr::null() || dest_len != 0 {
-            errno = syscall::EISCONN;
-            return -1;
-        }
         if flags != 0 {
             errno = syscall::EOPNOTSUPP;
             return -1;
         }
-        Self::write(socket, slice::from_raw_parts(buf as *const u8, len))
+        if dest_addr == ptr::null() || dest_len == 0 {
+            Self::write(socket, slice::from_raw_parts(buf as *const u8, len))
+        } else if (*dest_addr).sa_family as i32 == AF_INET && dest_len >= mem::size_of::<sockaddr_in>() as u32 {
+            let data = &*(dest_addr as *const sockaddr_in);
+            let addr = data.sin_addr.s_addr;
+            let port = in_port_t::from_be(data.sin_port);
+            let path = format!(
+                "{}.{}.{}.{}:{}",
+                addr >> 8 * 3,
+                addr >> 8 * 2 & 0xFF,
+                addr >> 8 & 0xFF,
+                addr & 0xFF,
+                port
+            );
+
+            let fd = e(syscall::dup(socket as usize, path.as_bytes()));
+            if fd < 0 {
+                return -1;
+            }
+
+            let ret = Self::write(fd as i32, slice::from_raw_parts(buf as *const u8, len));
+
+            let _ = syscall::close(fd);
+
+            ret
+        } else {
+            errno = syscall::EINVAL;
+            -1
+        }
     }
 
     unsafe fn socket(domain: c_int, mut kind: c_int, protocol: c_int) -> c_int {