Merge branch 'hw6' of https://github.com/themultiplexer/bsys-ws17-grp11 into hw6

hw6/task1/src/main.rs

@@ -3,37 +3,75 @@ use std::process;
 
 extern crate nix;
 
-use nix::unistd::{fork, getpid};
+use nix::unistd::{fork, pipe, read, write};
 use nix::sys::wait::wait;
+use std::str;
 use nix::sys::wait::WaitStatus;
 use nix::unistd::ForkResult::{Child, Parent};
+use std::os::unix::io::RawFd;
 
-fn main() {
+const BUFFER_SIZE: usize = 256;
 
- let arguments: Vec<String> = args().collect();
 
-    if arguments.len() != 0 {
-   
+fn main() {
 
-    let pid = fork();
-    match pid {
-        Ok(Child) => {
-            println!("hello, I am child (pid:{})", getpid());
-        }
+    let arguments: Vec<String> = args().collect();
+
+    if arguments.len() > 2 {
+        if let Ok((reader, writer)) = pipe() {
+            let numbers = arguments[1..].to_vec();
+
+            let pid = fork();
+            match pid {
+                Ok(Child) => {
+                    match read_from_pipe(reader) {
+                        Ok(msg_received) => {
+                            let vec = split_into_strings(&msg_received);
+
+                            let pid = fork();
+                            match pid {
+                                Ok(Child) => {
+                                    match sum_strings(vec) {
+                                        Ok(res) => println!("Sum = {}", res),
+                                        Err(e) => println!("{}", e),
+                                    }
+                                }
+                                Ok(Parent { .. }) => {
+                                    if let Ok(ws) = wait() {
+                                        if let WaitStatus::Exited(_, _) = ws {
+                                            match mul_strings(vec) {
+                                                Ok(res) => println!("Mul = {}", res),
+                                                Err(e) => println!("{}", e),
+                                            }
+                                        }
+                                    }
+                                }
+                                Err(_) => println!("Fatal error: Fork failed"),
+                            }
+
+                        }
+                        Err(_) => {}
+                    }
+                }
 
-        Ok(Parent { child }) => {
-            if let Ok(ws) = wait() {
-                if let WaitStatus::Exited(child_pid, exit_code) = ws {
-                
+                Ok(Parent { .. }) => {
+                    let mut args = String::new();
+                    for s in numbers {
+                        args = concatenate_strings(&args, &concatenate_strings(&s, " "));
+                    }
+                    println!("sending to children: {}", args);
+                    if let Err(_) = write(writer, args.as_bytes()) {
+                        println!("Broken pipe")
+                    }
+
+                    if let Err(_) = wait() {
+                        println!("Waiting on children failed")
+                    }
                 }
+
+                Err(_) => {}
             }
         }
-
-        Err(_) => {}
-    }
-
-
-
     } else {
         println!("Correct usage: number number <number> ...");
         process::exit(1)
@@ -41,14 +79,66 @@ fn main() {
 
 }
 
-fn concatenate_strings(){
+fn read_from_pipe(reader: RawFd) -> Result<String, String> {
+    let mut read_buf = [0u8; BUFFER_SIZE];
+    match read(reader, &mut read_buf) {
+        Ok(bytes_read) => {
+            match str::from_utf8(&read_buf[0..bytes_read]) {
+                Ok(msg_received) => Ok(msg_received.to_string()),
+                Err(_) => Err("Couldn't read".to_string()),
+            }
+        }
+        Err(_) => Err("Couldn't read".to_string()),
+    }
 }
 
-fn split_into_strings(){
+/// Concats the two given String *references* and returns them as a String.
+fn concatenate_strings<'a>(s1: &'a str, s2: &'a str) -> String {
+    s1.to_string() + s2
 }
 
-fn sum_strings(){
+/// Splits the given String reference and returns it as Vector.
+fn split_into_strings<'a>(s1: &'a str) -> Vec<String> {
+    s1.to_string()
+        .split_whitespace()
+        .map(|s| s.to_string())
+        .collect()
 }
 
-fn mul_strings(){
+/// Calculates the sum of the given Strings and returns them as a Result.
+fn sum_strings(v: Vec<String>) -> Result<i32, String> {
+    let mut sum = 0;
+    for x in v {
+        match x.parse::<i32>() {
+            Ok(val) => {
+                match i32::checked_add(sum, val) {
+                    Some(y) => {
+                        sum = y;
+                    }
+                    None => return Err("Overflow would happen in sum_strings()".to_string()),
+                }
+            }
+            Err(_) => return Err("Given String is not a int".to_string()),
+        }
+    }
+    Ok(sum)
+}
+
+/// Calculates the product of the given Strings and returns them as a Result.
+fn mul_strings(v: Vec<String>) -> Result<i32, String> {
+    let mut prod = 1;
+    for x in v {
+        match x.parse::<i32>() {
+            Ok(val) => {
+                match i32::checked_mul(prod, val) {
+                    Some(y) => {
+                        prod = y;
+                    }
+                    None => return Err("Overflow would happen in mul_strings()".to_string()),
+                }
+            }
+            Err(_) => return Err("Given String is not a int".to_string()),
+        }
+    }
+    Ok(prod)
 }

hw6/task2/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task2"
+version = "0.1.0"
+authors = ["Lorenz Bung <lorenz.bung@googlemail.com>"]
+
+[dependencies]

hw6/task2/src/command.rs

@@ -0,0 +1,63 @@
+use std::ffi::OsString;
+use std::str::FromStr;
+use std::env;
+
+pub enum Command {
+    Empty,
+    Exit,
+    Cd(Option<OsString>),
+}
+
+pub struct CommandNotFoundError;
+
+impl FromStr for Command {
+    type Err = CommandNotFoundError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+
+        let mut parts = s.split_whitespace();
+
+        match parts.next() {
+            Some("exit") => Ok(Command::Exit),
+            Some("cd") => Ok(Command::parse_cd(parts.next())),
+            Some(cmd) => {
+                //For use in next homework, to execute programs.
+                let _ = cmd;
+                Err(CommandNotFoundError)
+            }
+            None => Ok(Command::Empty),
+        }
+    }
+}
+
+
+impl Command {
+    /// If the passed String exists, set the path of the Cd in the enum
+    pub fn parse_cd(cmd: Option<&str>) -> Self {
+        match cmd {
+            None => Command::Cd(None),
+            Some(dest) => Command::Cd(Some(OsString::from(dest))),
+        }
+    }
+
+    pub fn exec_cd(&self) {
+        if let Command::Cd(None) = *self {
+            let possible_home = env::home_dir();
+
+            if let Some(home) = possible_home {
+                let home_path = home.as_path();
+                let _ = env::set_current_dir(home_path);
+            }
+
+        }
+
+        if let Command::Cd(Some(ref path)) = *self {
+            match path.to_str() {
+                Some(_) => {
+                    let _ = env::set_current_dir(path);
+                }
+                None => {}
+            }
+
+        }
+    }
+}

hw6/task2/src/main.rs

@@ -0,0 +1,21 @@
+use std::process;
+use shell::{Shell, R, W};
+use std::io;
+
+mod command;
+mod shell;
+
+
+fn main() {
+    let stdin = io::stdin();
+    let input = R(stdin.lock());
+
+    let stdout = io::stdout();
+    let output = W(stdout.lock());
+
+    let mut s = Shell::new(input, output, "schell".to_string());
+    match s.start() {
+        Ok(_) => process::exit(0),
+        Err(_) => process::exit(1),
+    }
+}

hw6/task2/src/shell.rs

@@ -0,0 +1,114 @@
+use std::io::{BufRead, Write, Read, StdinLock, StdoutLock};
+use std::io;
+
+use command::*;
+use std::str::FromStr;
+use std::env;
+
+///Tuple-Structs which hold Std-in and -out locks.
+pub struct R<'a>(pub StdinLock<'a>);
+pub struct W<'a>(pub StdoutLock<'a>);
+
+pub struct Shell<R, W> {
+    pub reader: R,
+    pub writer: W,
+    pub should_exit: bool,
+    pub name: String,
+}
+
+impl<'a> Shell<R<'a>, W<'a>> {
+    /// Creates a new Shell with a name, input and output.
+    pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
+        Shell {
+            reader: input,
+            writer: output,
+            should_exit: false,
+            name: name,
+        }
+    }
+    /// Initializes the Shell Loop.
+    /// Starts the shell.
+    pub fn start(&mut self) -> Result<(), &str> {
+        self.shell_loop()
+    }
+
+    /// Loops while exit hasn't been called.
+    /// When *prompt()* returns (the user hit enter) a Command is created through the FromStr-Trait.
+    /// If the Command-creation succeeds, run the command.
+    fn shell_loop(&mut self) -> Result<(), &str> {
+        while !self.should_exit {
+            if let Ok(line) = self.prompt() {
+                let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
+            }
+        }
+        Ok(())
+    }
+
+    /// Prints the shell prompt.
+    /// Waits for user input and returns the read line.
+    fn prompt(&mut self) -> Result<String, &str> {
+        match env::current_dir() {
+            Ok(pwd) => {
+                let _ = self.writer.write(
+                    format!("{} {} > ", self.name, pwd.display())
+                        .as_bytes(),
+                );
+                let _ = self.writer.flush();
+
+                let mut line: String = String::new();
+                let read_result = self.reader.read_line(&mut line);
+                match read_result {
+                    Ok(_) => Ok(line),
+                    Err(_) => Err("Error reading."),
+                }
+            }
+            Err(_) => return Err("Path Error"),
+        }
+    }
+
+    /// Runs a command.
+    /// Currently only `cd` and `exit` are working.
+    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError> {
+
+        match command {
+            Command::Empty => {}
+            Command::Exit => self.should_exit = true,
+            Command::Cd(_) => {
+                command.exec_cd();
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Implement Read-Trait for Tuple-Struct R
+/// Simply calls `read` of StdinLock
+impl<'a> Read for R<'a> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        self.0.read(buf)
+    }
+}
+
+/// Implement BufRead-Trait for Tuple-Struct R
+/// Simply calls `fill_buff` and `consume` from StdinLock
+impl<'a> BufRead for R<'a> {
+    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
+        self.0.fill_buf()
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.0.consume(amt)
+    }
+}
+
+/// Implement Write-Trait for Tuple-Struct W
+/// Simply calls `write` and `flush` from StdoutLock
+impl<'a> Write for W<'a> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
+        self.0.write(buf)
+    }
+
+    fn flush(&mut self) -> Result<(), io::Error> {
+        self.0.flush()
+    }
+}