Basic I/O functions done

Author: Keating950

.gitignore

@@ -0,0 +1,3 @@
+/target
+Cargo.lock
+.idea

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "pipelib"
+version = "0.1.0"
+edition = "2018"
+authors = ["Keating K. Reid <[email protected]>"]
+description = "A thin wrapper over Unix pipes with polling functionality."
+license = "LGPL-2.1"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libc = "0.2.98"

src/lib.rs

@@ -0,0 +1,46 @@
+#![allow(unused)]
+mod pipe;
+mod reader;
+mod writer;
+
+use crate::{pipe::Pipe, reader::Reader, writer::Writer};
+use libc::c_int;
+
+pub(crate) mod crate_macros {
+    #[macro_export]
+    macro_rules! oserr {
+        () => {
+            std::io::Error::last_os_error()
+        };
+    }
+
+    #[macro_export]
+    macro_rules! assert_ok {
+        ($val:ident) => {
+            assert!($val.is_ok(), "{:?}", $val.unwrap_err())
+        };
+        ($e:expr) => {
+            let tmp = $e;
+            assert_ok!(tmp)
+        };
+    }
+}
+
+pub fn new() -> std::io::Result<(Reader, Writer)> {
+    let mut fds: [c_int; 2] = [-1, -1];
+    unsafe {
+        if libc::pipe(fds.as_mut_ptr()) != 0 {
+            return Err(oserr!());
+        }
+        for fd in fds {
+            if libc::fcntl(fd, libc::FD_CLOEXEC) != 0
+                || libc::fcntl(fd, libc::F_SETFL, libc::O_NONBLOCK) != 0
+            {
+                return Err(oserr!());
+            }
+        }
+    }
+    debug_assert_ne!(fds[0], -1);
+    debug_assert_ne!(fds[1], -1);
+    Ok((Reader::new(fds[0]), Writer::new(fds[1])))
+}

src/pipe.rs

@@ -0,0 +1,115 @@
+use crate::oserr;
+use libc::{self, c_int, c_void, size_t};
+use std::{
+    io::{self, prelude::*},
+    mem,
+    os::unix::io::{FromRawFd, IntoRawFd, RawFd},
+};
+
+#[derive(Debug)]
+pub(crate) struct Pipe(pub(crate) c_int);
+
+impl Pipe {
+    fn write_from_ptr(&mut self, buf: *const c_void, len: usize) -> io::Result<usize> {
+        let written = unsafe { libc::write(self.0, buf, len) };
+        if written < 0 {
+            Err(oserr!())
+        } else {
+            Ok(written as usize)
+        }
+    }
+
+    fn read_to_ptr(&self, buf: *mut c_void, len: usize) -> io::Result<usize> {
+        let bytes_read = unsafe { libc::read(self.0, buf, len as size_t) };
+        if bytes_read < 0 {
+            let e = oserr!();
+            match e.kind() {
+                io::ErrorKind::WouldBlock => Ok(0),
+                _ => return Err(e),
+            }
+        } else {
+            Ok(bytes_read as usize)
+        }
+    }
+}
+
+impl Write for Pipe {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let ptr = buf.as_ptr() as *const c_void;
+        self.write_from_ptr(ptr, buf.len())
+    }
+
+    fn write_all(&mut self, mut buf: &[u8]) -> io::Result<()> {
+        let mut to_write = buf.len();
+        let mut ptr = buf.as_ptr() as *const c_void;
+        while to_write > 0 {
+            let written = self.write_from_ptr(ptr, to_write)?;
+            to_write -= written;
+            unsafe { ptr.add(written) };
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Read for Pipe {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let ptr = buf.as_mut_ptr() as *mut c_void;
+        self.read_to_ptr(ptr, buf.len())
+    }
+}
+
+impl FromRawFd for Pipe {
+    #[inline]
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        Pipe(fd)
+    }
+}
+
+impl IntoRawFd for Pipe {
+    #[inline]
+    fn into_raw_fd(self) -> RawFd {
+        self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assert_ok;
+    use std::io::prelude::*;
+
+    #[test]
+    fn test_new() {
+        assert_ok!(crate::new());
+    }
+
+    #[test]
+    fn test_read_write() {
+        let test_msg = *b"Hello, world";
+        let mut buf: [u8; 12] = [0; 12];
+        let (mut reader, mut writer) = crate::new().unwrap();
+        assert_ok!(writer.write(&test_msg));
+        assert_ok!(reader.read(&mut buf));
+        assert_eq!(test_msg, buf);
+    }
+
+    #[test]
+    fn test_read_to_end() {
+        let test_msg = b"Hello, world".to_vec();
+        let mut buf: Vec<u8> = Vec::with_capacity(6);
+        let (mut reader, mut writer) = crate::new().unwrap();
+        assert_ok!(writer.write(&test_msg));
+        let res = reader.read_to_end(&mut buf);
+        assert_ok!(res);
+        let bytes_read = res.unwrap();
+        assert_eq!(bytes_read, test_msg.len());
+        assert_eq!(buf, test_msg);
+    }
+}

src/reader.rs

@@ -0,0 +1,42 @@
+use libc::c_int;
+
+use crate::pipe::Pipe;
+use std::{
+    io::{self, prelude::*},
+    os::unix::io::{FromRawFd, IntoRawFd, RawFd},
+};
+
+#[derive(Debug)]
+pub struct Reader(Pipe);
+
+impl Reader {
+    pub(crate) fn new(n: c_int) -> Reader {
+        Reader(Pipe(n))
+    }
+}
+
+impl Read for Reader {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        self.0.read_to_end(buf)
+    }
+}
+
+impl FromRawFd for Reader {
+    #[inline]
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        Reader(Pipe(fd))
+    }
+}
+
+impl IntoRawFd for Reader {
+    #[inline]
+    fn into_raw_fd(self) -> RawFd {
+        self.0.0
+    }
+}

src/writer.rs

@@ -0,0 +1,42 @@
+use libc::c_int;
+
+use crate::pipe::Pipe;
+use std::{
+    io::{self, prelude::*},
+    os::unix::io::{FromRawFd, IntoRawFd, RawFd},
+};
+
+#[derive(Debug)]
+pub struct Writer(Pipe);
+
+impl Writer {
+    pub(crate) fn new(n: c_int) -> Writer {
+        Writer(Pipe(n))
+    }
+}
+
+impl Write for Writer {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        self.0.flush()
+    }
+}
+
+impl FromRawFd for Writer {
+    #[inline]
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        Writer(Pipe(fd))
+    }
+}
+
+impl IntoRawFd for Writer {
+    #[inline]
+    fn into_raw_fd(self) -> RawFd {
+        self.0.0
+    }
+}