Add hello example

README.md

@@ -4,7 +4,7 @@ A userspace daemon for interprocess communication.
 
 ## Usage
 
-[Example usage](https://github.com/redox-os/ipcd/blob/master/examples/main.rs)
+See the `examples` folder. [Hello World example](https://github.com/redox-os/ipcd/blob/master/examples/hello.rs)
 
 Simply open `chan:<name>` with O_CREAT where `<name>` is any name you'd like to create a listener.  
 This listener can accept clients by calling `dup("listen")`.

examples/event.rs

@@ -65,8 +65,8 @@ fn main() -> io::Result<()> {
     assert_eq!(event.flags, syscall::EVENT_WRITE);
     println!("-> Accept event");
 
-    let dup = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
-    let mut dup = unsafe { File::from_raw_fd(dup) };
+    let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
+    let mut stream = unsafe { File::from_raw_fd(stream) };
 
     event_file.read(&mut event)?;
     assert_eq!(event.data, TOKEN_CLIENT);
@@ -74,7 +74,7 @@ fn main() -> io::Result<()> {
     println!("-> Writable event");
 
     event_file.write(&syscall::Event {
-        id: dup.as_raw_fd(),
+        id: stream.as_raw_fd(),
         flags: syscall::EVENT_READ | syscall::EVENT_WRITE,
         data: TOKEN_STREAM
     })?;
@@ -98,10 +98,10 @@ fn main() -> io::Result<()> {
     assert_eq!(event.flags, syscall::EVENT_READ);
     println!("-> Readable event");
 
-    assert_eq!(dup.read(&mut buf)?, 1);
+    assert_eq!(stream.read(&mut buf)?, 1);
     assert_eq!(buf[0], b'a');
 
-    dup.write(b"b")?;
+    stream.write(b"b")?;
 
     event_file.read(&mut event)?;
     assert_eq!(event.data, TOKEN_CLIENT);
@@ -117,7 +117,7 @@ fn main() -> io::Result<()> {
     assert_eq!(event.data, TOKEN_STREAM);
     println!("-> Readable event (EOF)");
 
-    assert_eq!(dup.read(&mut buf)?, 0);
+    assert_eq!(stream.read(&mut buf)?, 0);
 
     event_file.read(&mut event)?;
     assert_eq!(event.data, TOKEN_TIMER);

examples/hello.rs

@@ -0,0 +1,22 @@
+extern crate syscall;
+
+use std::{
+    fs::File,
+    io::{self, prelude::*},
+    os::unix::io::{AsRawFd, FromRawFd}
+};
+
+fn from_syscall_error(error: syscall::Error) -> io::Error {
+    io::Error::from_raw_os_error(error.errno as i32)
+}
+
+fn main() -> io::Result<()> {
+    let server = File::create("chan:hello")?;
+
+    loop {
+        let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
+        let mut stream = unsafe { File::from_raw_fd(stream) };
+
+        stream.write(b"Hello World!\n")?;
+    }
+}

examples/main.rs

@@ -20,13 +20,13 @@ fn main() -> io::Result<()> {
         // First client not accepted yet
         assert_eq!(File::open("chan:hello_world").unwrap_err().kind(), io::ErrorKind::ConnectionRefused);
 
-        let dup = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
-        let mut dup = unsafe { File::from_raw_fd(dup) };
+        let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
+        let mut stream = unsafe { File::from_raw_fd(stream) };
 
         println!("Testing basic I/O...");
 
-        dup.write(b"abc")?;
-        dup.flush()?;
+        stream.write(b"abc")?;
+        stream.flush()?;
         println!("-> Wrote message");
 
         assert_eq!(client.read(&mut buf)?, 3);
@@ -36,15 +36,15 @@ fn main() -> io::Result<()> {
         println!("Testing close...");
 
         drop(client);
-        assert_eq!(dup.write(b"a").unwrap_err().kind(), io::ErrorKind::BrokenPipe);
-        assert_eq!(dup.read(&mut buf)?, 0);
+        assert_eq!(stream.write(b"a").unwrap_err().kind(), io::ErrorKind::BrokenPipe);
+        assert_eq!(stream.read(&mut buf)?, 0);
     }
     println!("Testing alternative connect method...");
     let client = syscall::dup(server.as_raw_fd(), b"connect").map_err(from_syscall_error)?;
     let mut client = unsafe { File::from_raw_fd(client) };
 
-    let dup = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
-    let mut dup = unsafe { File::from_raw_fd(dup) };
+    let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
+    let mut stream = unsafe { File::from_raw_fd(stream) };
 
     println!("Testing blocking I/O...");
 
@@ -59,7 +59,7 @@ fn main() -> io::Result<()> {
         Ok(())
     });
 
-    assert_eq!(dup.read(&mut buf)?, 3);
+    assert_eq!(stream.read(&mut buf)?, 3);
     assert_eq!(&buf[..3], b"def");
     println!("-> Read message");
 
@@ -74,8 +74,8 @@ fn main() -> io::Result<()> {
     assert_eq!(client.read(&mut buf).unwrap_err().kind(), io::ErrorKind::WouldBlock);
     println!("-> Read would block");
     match syscall::dup(server.as_raw_fd(), b"listen") {
-        Ok(dup) => {
-            unsafe { File::from_raw_fd(dup); }
+        Ok(stream) => {
+            unsafe { File::from_raw_fd(stream); }
             panic!("this is supposed to fail");
         },
         Err(err) => {

examples/unnamed.rs

@@ -17,13 +17,13 @@ fn main() -> io::Result<()> {
     let client = syscall::dup(server.as_raw_fd(), b"connect").map_err(from_syscall_error)?;
     let mut client = unsafe { File::from_raw_fd(client) };
 
-    let dup = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
-    let mut dup = unsafe { File::from_raw_fd(dup) };
+    let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
+    let mut stream = unsafe { File::from_raw_fd(stream) };
 
     println!("Testing basic I/O...");
 
-    dup.write(b"abc")?;
-    dup.flush()?;
+    stream.write(b"abc")?;
+    stream.flush()?;
     println!("-> Wrote message");
 
     assert_eq!(client.read(&mut buf)?, 3);