Finished fork logic. Fixed mul_strings.

hw6/task1/src/main.rs

 
 extern crate nix;
 
-use nix::unistd::{fork, getpid, pipe, read, write};
+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;
+
+const BUFFER_SIZE : usize = 256;
+
 
 fn main() {
 
     let arguments: Vec<String> = args().collect();
 
-    const BUFFER_SIZE : usize = 256;
-
     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(_) => {},
+                    }
 
-        let (reader, writer) = pipe().unwrap();
-        let numbers = arguments[1..].to_vec();
-
-        let pid = fork();
-        match pid {
-            Ok(Child) => {
-                let mut read_buf = [0u8; BUFFER_SIZE];
-                let bytes_read = read(reader, &mut read_buf).unwrap();
-                let msg_received = str::from_utf8(&read_buf[0 .. bytes_read]).unwrap();
-
-
-                match sum_strings(split_into_strings(msg_received)) {
-                    Ok(res) => {
-                        println!("{}", res)
-                    },
-                    Err(_) => {},
-                }
-
-                //let result = sum_strings(numbers);
-
-            }
 
-            Ok(Parent { child }) => {
-                for s in numbers {
-                    write(writer, concatenate_strings(s, " ").as_bytes());
                 }
 
+                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 Ok(ws) = wait() {
-                    if let WaitStatus::Exited(child_pid, exit_code) = ws {
-                        println!("Parent exits");
+                    if let Err(_) = wait() {
+                        println!("Waiting on children failed")
                     }
                 }
-            }
 
-            Err(_) => {}
+                Err(_) => {}
+            }
         }
-
-
-
     } else {
         println!("Correct usage: number number <number> ...");
         process::exit(1)
 
 }
 
+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()),
+    }
+}
+
 /// 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
 }
 
 /// Calculates the sum of the given Strings and returns them as a Result.
-fn sum_strings(v: Vec<&str>) -> Result<i32, &str> {
+fn sum_strings(v: Vec<String>) -> Result<i32, String> {
     let mut sum = 0;
     for x in v {
         match x.parse::<i32>() {
                     Some(y) => {
                         sum = y;
                     }
-                    None => return Err("Overflow would happen in sum_strings()"),
+                    None => return Err("Overflow would happen in sum_strings()".to_string()),
                 }
             }
-            Err(_) => return Err("Given String is not a int"),
+            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<&str>) -> Result<i32, &str> {
-    let mut prod = 0;
+fn mul_strings(v: Vec<String>) -> Result<i32, String> {
+    let mut prod = 1;
     for x in v {
         match x.parse::<i32>() {
             Ok(val) => {
                     Some(y) => {
                         prod = y;
                     }
-                    None => return Err("Overflow would happen in mul_strings()"),
+                    None => return Err("Overflow would happen in mul_strings()".to_string()),
                 }
             }
-            Err(_) => return Err("Given String is not a int"),
+            Err(_) => return Err("Given String is not a int".to_string()),
         }
     }
     Ok(prod)