Shell and its pipe now fully working.

hw7/task2/src/lib.rs

 extern crate nix;
 
 use std::io::{BufRead, Write};
-use std::str::FromStr;
+use std::str::{FromStr, Split};
 use std::env;
-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};
+use nix::sys::wait::{wait, waitpid, WaitStatus};
+use nix::unistd::{dup2, close, execvp, fork, pipe, read, write};
 
 mod shellerror;
 
                 
                 let needs_pipe = commands_vec.len() == 2;
 
-                if let Ok((reader, writer)) = pipe() {
+
 
                     let fi = fork();
                     match fi {
-                        Ok(Parent { .. }) => {
+                        Ok(Parent { child }) => {
                             wait();
-                        }
-                        Ok(Child) => {
-                            if let Some(first) = commands_vec.get(0) {
-                                if needs_pipe {
-                                    close(reader).unwrap();
-                                    dup2(writer, 1).unwrap();
-                                }
-                                self.execute(first);
-                            }
-                        }
-                        Err(_) => println!("Fatal error: Fork failed"),
-                    }
-
 
-                    let sec = fork();
-                    match sec {
-                        Ok(Parent { .. }) => {
-                            wait();
                         }
                         Ok(Child) => {
-                            if let Some(second) = commands_vec.get(1) {
-                                close(1).unwrap();
-                                close(writer).unwrap();
-                                dup2(reader, 0).unwrap();
-                                self.execute(second);
+                            if let Ok((reader, writer)) = pipe() {
+                                let sec = fork();
+                                match sec {
+                                    Ok(Parent { child }) => {
+                                        wait();
+                                        if let Some(second) = commands_vec.get(1) {
+                                            close(writer).unwrap();
+                                            dup2(reader, 0).unwrap();
+                                            self.execute(second);
+                                        }
+                                    }
+                                    Ok(Child) => {
+                                        if let Some(first) = commands_vec.get(0) {
+                                            if needs_pipe {
+                                                close(reader).unwrap();
+                                                dup2(writer, 1).unwrap();
+                                            }
+                                            self.execute(first);
+                                        }
+                                    }
+                                    Err(_) => println!("Fatal error: Fork failed"),
+                                }
                             }
                         }
                         Err(_) => println!("Fatal error: Fork failed"),
                     }
 
-                }
-
             },
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
         let args:Vec<CString> = parts.iter().map(|f| CString::new(*f).unwrap()).collect();
         let t = args.into_boxed_slice();
 
-        execvp(&t[0], &t);
+        execvp(&t[0], &t).unwrap();
     }
 }