Shell partially working.

hw7/task2/Cargo.toml

 authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
 
 [dependencies]
+nix = "0.9.0"

hw7/task2/src/lib.rs

+extern crate nix;
+
 use std::io::{BufRead, Write};
 use std::str::FromStr;
 use std::env;
-use std::ffi::OsString;
+use std::str::Split;
+use std::os::unix::io::RawFd;
+use std::ffi::{OsString, CString};
+use nix::unistd::ForkResult::{Child, Parent};
+use nix::sys::wait::{wait, WaitStatus};
+use nix::unistd::dup2;
+use nix::unistd::close;
+use nix::unistd::{execvp, fork, pipe, read, write};
 
 mod shellerror;
 
+use shellerror::ShellError;
+
 #[derive(PartialEq, Debug)]
 pub enum Command {
     Empty,
     Exit,
+    Program(String),
     Cd(Option<OsString>),
 }
 
-#[derive(PartialEq, Debug)]
-pub struct CommandNotFoundError;
-
 impl FromStr for Command {
-    type Err = CommandNotFoundError;
+    type Err = ShellError;
     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)
+            Some(_) => {
+                Ok(Command::Program(s.to_string()))
             }
             None => Ok(Command::Empty),
         }
     }
 }
 
-
 impl Command {
     /// If the passed String exists, set the path of the Cd in the enum (as OsString)
     /// Returns **Command**
 
     /// Runs a command.
     /// Currently only `cd` and `exit` are working.
-    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError> {
+    fn run(&mut self, command: Command) -> Result<(), ShellError> {
 
         match command {
-            Command::Empty => {}
+            Command::Empty => {},
+            Command::Program(cmd) => {
+
+                let mut commands = cmd.split('|');
+                let commands_vec: Vec<&str> = commands.collect();
+
+                if let Ok((reader, writer)) = pipe() {
+                    /*
+                    let pid = fork();
+                    match pid {
+                        Ok(Parent { .. }) => {
+                                //wait();
+                        }
+                        Ok(Child) => {
+
+                        }
+
+                        Err(_) => println!("Fatal error: Fork failed"),
+                    }
+                    */
+
+                    let sub_pid = fork();
+                    match sub_pid {
+                        Ok(Parent { .. }) => {
+                            if let Some(out) = commands_vec.get(1) {
+                                wait();
+                                close(writer).unwrap();
+                                dup2(reader, 0).unwrap();
+                                self.execute(out)
+                            } else {
+                                wait();
+                            }
+                        }
+                        Ok(Child) => {
+
+                            if let Some(thing) = commands_vec.get(0) {
+                                if let Some(_) = commands_vec.get(1) {
+                                    close(reader).unwrap();
+                                    dup2(writer, 1).unwrap();
+                                }
+                                self.execute(thing);
+                            }
+                        }
+
+                        Err(_) => println!("Fatal error: Fork failed"),
+                    }
+
+
+
+                }
+
+            },
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
                 command.exec_cd();
         }
         Ok(())
     }
+
+    fn execute(&self, cmd: &str){
+        let mut parts:Vec<&str> = cmd.split_whitespace().collect();
+        let args:Vec<CString> = parts.iter().map(|f| CString::new(*f).unwrap()).collect();
+        let t = args.into_boxed_slice();
+
+        execvp(&t[0], &t);
+    }
 }
+

hw7/task2/src/shellerror.rs

+#[derive(PartialEq, Debug)]
+pub struct ShellError;