Merge pull request #19 from sajattack/redox-fixes

redox fixes

src/platform/src/lib.rs

@@ -13,8 +13,10 @@ pub use sys::*;
 #[path = "linux/mod.rs"]
 mod sys;
 
-#[cfg(all(not(feature = "no_std"), target_os = "redox"))]
-#[path = "redox/mod.rs"]
+#[cfg(all(not(feature="no_std"), target_os = "redox"))]
+#[macro_use]
+extern crate syscall;
+#[path="redox/mod.rs"]
 mod sys;
 
 pub mod types;

src/platform/src/redox/mod.rs

@@ -4,7 +4,9 @@ use c_str;
 use types::*;
 
 pub fn brk(addr: *const c_void) -> c_int {
-    syscall::brk(addr as usize).unwrap_or(-1) as c_int
+    unsafe {
+        syscall::brk(addr as usize).unwrap_or(0-1) as c_int
+    }
 }
 
 pub fn chdir(path: *const c_char) -> c_int {
@@ -13,8 +15,9 @@ pub fn chdir(path: *const c_char) -> c_int {
 }
 
 pub fn chown(path: *const c_char, owner: uid_t, group: gid_t) -> c_int {
-    let fd = syscall::open(cstr_to_slice(path));
-    syscall::fchown(fd as usize, owner as usize, group as usize).unwrap_or(-1) as c_int
+    let path = unsafe { c_str(path) };
+    let fd = syscall::open(path, 0x0001).unwrap();
+    syscall::fchown(fd as usize, owner as u32, group as u32).unwrap_or(0-1) as c_int
 }
 
 pub fn close(fd: c_int) -> c_int {
@@ -23,11 +26,11 @@ pub fn close(fd: c_int) -> c_int {
 }
 
 pub fn dup(fd: c_int) -> c_int {
-    syscall::dup(fd as usize, &[]).unwrap_or(-1) as c_int
+    syscall::dup(fd as usize, &[]).unwrap_or(0-1) as c_int
 }
 
 pub fn dup2(fd1: c_int, fd2: c_int) -> c_int {
-    syscall::dup2(fd1 as usize, fd2 as usize, &[]).unwrap_or(-1) as c_int
+    syscall::dup2(fd1 as usize, fd2 as usize, &[]).unwrap_or(0-1) as c_int
 }
 
 pub fn exit(status: c_int) -> ! {
@@ -36,65 +39,71 @@ pub fn exit(status: c_int) -> ! {
 }
 
 pub fn fchown(fd: c_int, owner: uid_t, group: gid_t) -> c_int {
-    syscall::fchown(owner as usize, group as usize).unwrap_or(-1) as c_int
+    syscall::fchown(fd as usize, owner as u32, group as u32).unwrap_or(0-1) as c_int
 }
 
 pub fn fchdir(fd: c_int) -> c_int {
-    let result = fpath(fd as usize, &[]);
+    let path: &mut [u8] = &mut[0; 4096];
+    let result = syscall::fpath(fd as usize, path);
     if result.is_ok() {
-        syscall::chdir(path).unwrap_or(-1) as c_int
+        syscall::chdir(path).unwrap_or(0-1) as c_int
     } else {
         -1
     }
 }
 
 pub fn fsync(fd: c_int) -> c_int {
-    syscall::fsync(fd as usize).unwrap_or(-1) as c_int
+    syscall::fsync(fd as usize).unwrap_or(0-1) as c_int
 }
 
 pub fn ftruncate(fd: c_int, len: off_t) -> c_int {
-    syscall::ftruncate(fd as usize, len as usize).unwrap_or(-1) as c_int
+    syscall::ftruncate(fd as usize, len as usize).unwrap_or(0-1) as c_int
 }
 
-pub fn getcwd(buf: *mut c_char, size: size_t) -> c_int {
+pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char {
     // XXX: do something with size maybe
-    let rbuf = unsafe { c_str(buf) };
+    let rbuf: &mut [u8] = &mut[0; 4096];
     syscall::getcwd(rbuf);
-    unsafe { &*(rbuf as *mut [c_char]) }
+    unsafe {
+        let buf = *rbuf.as_ptr() as *mut c_char;
+    }
+    buf 
 }
 
 pub fn getegid() -> gid_t {
-    syscall::getegid().unwrap_or(-1) as gid_t
+    syscall::getegid().unwrap() as gid_t
 }
 
 pub fn geteuid() -> uid_t {
-    syscall::geteuid().unwrap_or(-1) as uid_t
+    syscall::geteuid().unwrap() as uid_t
 }
 
 pub fn getgid() -> gid_t {
-    syscall::getgid().unwrap_or(-1) as gid_t
+    syscall::getgid().unwrap() as gid_t
 }
 
 pub fn getpgid(pid: pid_t) -> pid_t {
-    syscall::getpgid(pid as usize).unwrap_or(-1) as pid_t
+    syscall::getpgid(pid as usize).unwrap() as pid_t
 }
 
 pub fn getpid() -> pid_t {
-    syscall::getpid().unwrap_or(-1) as pid_t
+    syscall::getpid().unwrap() as pid_t
 }
 
 pub fn getppid() -> pid_t {
-    syscall::getppid().unwrap_or(-1) as pid_t
+    syscall::getppid().unwrap() as pid_t
 }
 
 pub fn getuid() -> uid_t {
-    syscall::getuid().unwrap_or(-1) as pid_t
+    syscall::getuid().unwrap() as pid_t
 }
 
 pub fn link(path1: *const c_char, path2: *const c_char) -> c_int {
     let path1 = unsafe { c_str(path1) };
     let path2 = unsafe { c_str(path2) };
-    syscall::link(path1, path2).unwrap_or(-1) as c_int
+    unsafe {
+        syscall::link(path1.as_ptr(), path2.as_ptr()).unwrap_or(0-1) as c_int
+    }
 }
 
 pub fn open(path: *const c_char, oflag: c_int, mode: mode_t) -> c_int {