Beispiele und Tafelbilder 6.7.2018: Signale, Zombies, Sicherheit

20180706/make-zombies-1.c

+#include <stdio.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <unistd.h>
+ 
+int main(void){
+    pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
+    int i; // Laufvariable
+ 
+    for (i = 0; i < 10; ++i) {
+        // Der Vaterprozess erzeugt nun einen Kindprozess,
+        // welcher unabhängig vom Vaterprozess mit der
+        // erneuten Ausführung des Programms beginnt.
+        // Ein Kindprozess erzeugt keinen Fork von sich selbst.
+        pids[i] = fork();
+        if (pids[i] == 0) {
+            // dann befinden wir uns in einem der 10 Kindprozesse
+            // Der erste Kindprozess wartet 10 Sekunden und jeder
+            // weitere Kindprozess wartet 1 Sekunde kürzer als der
+            // vorige.
+            printf ("%d BRAINS! ", i);
+            sleep(10-i);
+            exit(0); // Kindprozess erfolgreich beenden
+        }
+    }
+
+//
+    // hier kommt nur der Vaterprozess vorbei
+    for (i = 0; i < 10; ++i){
+        // Der Vaterprozess wartet nun, bis der Reihe nach jeder
+        // seiner 10 Kindprozesse beendet ist. Leider wird auf das
+        // Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
+        // die anderen Kinder längst erfolgreich beendet wurden,
+        // blockiert das erste Kind eine Bereinigung der Prozesstabelle
+        waitpid(pids[i], NULL, 0);
+    }
+//
+
+//    while (1);
+    return 0; // Vaterprozess erfolgreich beenden
+}

20180706/make-zombies-2.c

+#include <stdio.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <unistd.h>
+ 
+int main(void){
+    pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
+    int i; // Laufvariable
+ 
+    for (i = 0; i < 10; ++i) {
+        // Der Vaterprozess erzeugt nun einen Kindprozess,
+        // welcher unabhängig vom Vaterprozess mit der
+        // erneuten Ausführung des Programms beginnt.
+        // Ein Kindprozess erzeugt keinen Fork von sich selbst.
+        pids[i] = fork();
+        if (pids[i] == 0) {
+            // dann befinden wir uns in einem der 10 Kindprozesse
+            // Der erste Kindprozess wartet 10 Sekunden und jeder
+            // weitere Kindprozess wartet 1 Sekunde kürzer als der
+            // vorige.
+            printf ("%d BRAINS! ", i);
+            sleep(10-i);
+            exit(0); // Kindprozess erfolgreich beenden
+        }
+    }
+
+//
+//    // hier kommt nur der Vaterprozess vorbei
+//    for (i = 0; i < 10; ++i){
+//        // Der Vaterprozess wartet nun, bis der Reihe nach jeder
+//        // seiner 10 Kindprozesse beendet ist. Leider wird auf das
+//        // Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
+//        // die anderen Kinder längst erfolgreich beendet wurden,
+//        // blockiert das erste Kind eine Bereinigung der Prozesstabelle
+//        waitpid(pids[i], NULL, 0);
+//    }
+//
+
+//    while (1);
+    return 0; // Vaterprozess erfolgreich beenden
+}

20180706/make-zombies-3.c

+#include <stdio.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <unistd.h>
+ 
+int main(void){
+    pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
+    int i; // Laufvariable
+ 
+    for (i = 0; i < 10; ++i) {
+        // Der Vaterprozess erzeugt nun einen Kindprozess,
+        // welcher unabhängig vom Vaterprozess mit der
+        // erneuten Ausführung des Programms beginnt.
+        // Ein Kindprozess erzeugt keinen Fork von sich selbst.
+        pids[i] = fork();
+        if (pids[i] == 0) {
+            // dann befinden wir uns in einem der 10 Kindprozesse
+            // Der erste Kindprozess wartet 10 Sekunden und jeder
+            // weitere Kindprozess wartet 1 Sekunde kürzer als der
+            // vorige.
+            printf ("%d BRAINS! ", i);
+            sleep(10-i);
+            exit(0); // Kindprozess erfolgreich beenden
+        }
+    }
+
+//
+//    // hier kommt nur der Vaterprozess vorbei
+//    for (i = 0; i < 10; ++i){
+//        // Der Vaterprozess wartet nun, bis der Reihe nach jeder
+//        // seiner 10 Kindprozesse beendet ist. Leider wird auf das
+//        // Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
+//        // die anderen Kinder längst erfolgreich beendet wurden,
+//        // blockiert das erste Kind eine Bereinigung der Prozesstabelle
+//        waitpid(pids[i], NULL, 0);
+//    }
+//
+
+    while (1);
+//    return 0; // Vaterprozess erfolgreich beenden
+}

20180706/signals-1.c

+#include <signal.h>
+#include <stdio.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGINT, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+  while (1);
+  return 0;
+}

20180706/signals-2.c

+#include <signal.h>
+#include <stdio.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGUSR1, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+  while (1);
+  return 0;
+}

20180706/signals-3.c

+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGVTALRM, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+
+  struct itimerval timer;
+  timer.it_value.tv_sec = 1;
+  timer.it_value.tv_usec = 0;
+  timer.it_interval.tv_sec = 1;
+  timer.it_interval.tv_usec = 0;
+  setitimer (ITIMER_VIRTUAL, &timer, NULL);
+
+  while (1);
+  return 0;
+}

20180706/signals-3a.c

+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGVTALRM, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+
+  struct itimerval timer;
+  timer.it_value.tv_sec = 1;
+  timer.it_value.tv_usec = 0;
+  timer.it_interval.tv_sec = 1;
+  timer.it_interval.tv_usec = 0;
+  setitimer (ITIMER_VIRTUAL, &timer, NULL);
+
+  while (1);
+}

20180706/signals-4.c

+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGVTALRM, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+
+  struct itimerval timer;
+  timer.it_value.tv_sec = 1;
+  timer.it_value.tv_usec = 0;
+  timer.it_interval.tv_sec = 1;
+  timer.it_interval.tv_usec = 0;
+  setitimer (ITIMER_VIRTUAL, &timer, NULL);
+
+  while (1)
+    sleep (10);
+  return 0;
+}

20180706/signals-5.c

+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  if (signal (SIGALRM, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+
+  struct itimerval timer;
+  timer.it_value.tv_sec = 1;
+  timer.it_value.tv_usec = 0;
+  timer.it_interval.tv_sec = 1;
+  timer.it_interval.tv_usec = 0;
+  setitimer (ITIMER_REAL, &timer, NULL);
+
+  while (1)
+    sleep (10);
+  return 0;
+}

20180706/signals-6.c

+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+
+static void signal_handler (int signo)
+{
+  printf ("Hello, world!\n");
+  alarm (1);
+}
+
+int main (void)
+{
+  if (signal (SIGALRM, signal_handler) == SIG_ERR)
+    {
+      fputs ("Error installing signal handler.\n", stderr);
+      return 1;
+    }
+  alarm (1);
+  while (1)
+    sleep (10);
+  return 0;
+}