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

hw5/task1/src/child/mod.rs

@@ -1,7 +1,36 @@
+use nix::unistd::{fork, getpid};
+use nix::sys::wait::wait;
+use nix::unistd::ForkResult::{Child, Parent};
 
-
+mod pstree;
 
 pub fn run_childs(start_pid: i32, arg: &str) -> Result<(), String> {
-    let count = arg.parse::<u32>();
-    match count { }
+    let count = arg.parse::<u8>();
+    match count {
+        Ok(value) => {
+            for i in 0..value {
+                let pid = fork();
+                match pid {
+                    Ok(Child) => {
+                        println!("hello, I am child (pid:{})", getpid());
+                    }
+                    Ok(Parent { child }) => {
+                        println!("hello, I am parent of {} (pid:{})", child, getpid());
+                        match wait(){
+                            Ok(ws) => { println!("{:?}", ws); }
+                            Err(_) => {}
+                        }
+                    }
+                    // panic, fork should never fail unless there is a
+                    // serious problem with the OS
+                    Err(_) => panic!("fork failed"),
+                }
+            }
+            pstree::print(start_pid);
+            Ok(())
+        },
+        Err(_) => {
+            Err("Parse Failed".to_string())
+        },
+    }
 }

hw5/task1/src/child/pstree.rs

@@ -0,0 +1,92 @@
+use procinfo::pid;
+
+/// Datenstruktur für einen Prozess.
+pub struct Process {
+    name: String,
+    pid: i32,
+    ppid: i32,
+}
+
+impl Process {
+    /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
+    pub fn new(with_pid: i32) -> Self {
+        if let Ok(stat) = pid::stat(with_pid) {
+            Process {
+                name: stat.command,
+                pid: stat.pid,
+                ppid: stat.ppid,
+            }
+        } else {
+            panic!("Internal Error: Process not found")
+        }
+    }
+
+    /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
+    pub fn me() -> Self {
+        if let Ok(my_pid) = pid::stat_self() {
+            Process::new(my_pid.pid)
+        } else {
+            panic!("Internal Error: I don't have a PID but I am running.")
+        }
+    }
+
+    /// Prüft ob das Prozess-Struct ein Elternprozess besitzt.
+    pub fn has_parent(&self) -> bool {
+        self.ppid != 0
+    }
+
+    /// Gibt den Elternprozess zurück.
+    pub fn parent(&self) -> Self {
+        Process::new(self.ppid)
+    }
+
+    /// Prüft ob das Prozess-Struct einen (entfernten) Elternprozess mit dem übergebenen pid hat.
+    pub fn has_parent_with_pid(&self, pid: i32) -> bool {
+        if self.pid == pid {
+            return true;
+        }
+
+        if self.has_parent() {
+            return self.parent().has_parent_with_pid(pid);
+        }
+
+        false
+    }
+
+    /// Gibt über Rekursion über die Eltern eine Prozesskette aus.
+    pub fn print_recursive(&self, to_pid: i32, output: &mut String) {
+
+        if output.len() == 0 {
+            *output = format!("{}({}){}", self.name, self.pid, output);
+        } else {
+            *output = format!("{}({})---{}", self.name, self.pid, output);
+        }
+
+        if self.has_parent() && self.pid != to_pid {
+            self.parent().print_recursive(to_pid, output);
+        }
+    }
+}
+
+/// Geht von eigenem Prozess aus und gibt die Prozesskette bis zum übergebenem PID aus
+/// und fängt mögliche Fehler ab.
+pub fn print(pid: i32) -> bool {
+
+    if let Err(_) = pid::stat(pid) {
+        println!("Invalid PID");
+        return false;
+    }
+
+    let my_proc = Process::me();
+
+    if !my_proc.has_parent_with_pid(pid) {
+        println!("This Process has no parent {}", pid);
+        return false;
+    }
+
+    let mut output = String::new();
+    my_proc.print_recursive(pid, &mut output);
+    println!("{}", output);
+
+    true
+}

hw5/task1/src/main.rs

@@ -1,4 +1,5 @@
 extern crate procinfo;
+extern crate nix;
 
 use std::env::args;
 
@@ -14,14 +15,18 @@ fn main() {
 
         match procinfo::pid::stat_self(){
             Ok(stat) => {
-                child::run_childs(stat.pid, &arguments[2]);
+                let result = child::run_childs(stat.pid, &arguments[1]);
+                match result {
+                    Ok(_) => {},
+                    Err(_) => {},
+                }
             },
             Err(_) => {},
         }
 
 
     } else {
-        zombie::run_zombie();
+        //zombie::run_zombie();
     }
 
 }