"debut TD0"

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/Makefile

@@ -0,0 +1,13 @@
+CFLAGS = -Wall -std=gnu99
+
+EXECUTABLES = demo_dup2 \
+	demo_pipe \
+	demo_pipe_fork
+
+
+
+all : ${EXECUTABLES}
+
+clean :
+	@rm -f core *.o *.out *~
+	@rm -f ${EXECUTABLES}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_dup2.c

@@ -0,0 +1,20 @@
+///********************/
+///*  demo_dup2 : ... */
+///********************/
+# include <stdio.h>
+# include <fcntl.h>
+# include <unistd.h>
+
+# define ENTREE_STANDARD 0
+int main()
+{ int descr_group;
+  char c;
+  descr_group = open ("/etc/passwd", O_RDONLY);
+  dup2 (descr_group, ENTREE_STANDARD);/// retour a tester ...
+  c = getchar();
+  while (c != EOF)
+  {
+     putchar(c); c = getchar();
+  }
+  return 0;
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_fork_fork.c

@@ -0,0 +1,35 @@
+/********************/
+/*  demo_dup2 : ... */
+/********************/
+# include <stdio.h>
+# include <fcntl.h>
+# include <unistd.h>
+#include <stdlib.h>
+
+int main()
+{ int res;
+  int tp[2];
+  pipe (tp);
+  if ((res = fork()) ==-1) {perror ("fork1"); exit (1); } 
+  else if (res != 0) // Pere
+       { 
+          if ((res = res = fork()) ==-1) {perror ("fork2"); exit (1); } 
+          else if (res != 0)
+               { // pere
+                  execlp ("who", "who", NULL);
+               } 
+              else // Fils2
+              { 
+                 close (tp[0]);
+                 dup2 (tp[1], 1);
+                 execlp ("ls", "ls", "-la", NULL);
+              } 
+       }    
+      else // Fils1
+        {
+           close (tp[1]);
+           dup2 (tp[0], 0);
+           execlp ("wc", "wc", "-l", NULL);
+        }  
+   return 0;
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_pipe.c

@@ -0,0 +1,16 @@
+///********************/
+///*  demo_pipe : ... */
+///********************/
+# include <stdio.h>
+# include <unistd.h>
+
+char string[] = "hello";
+int main()
+{ char buf[70];
+  int  fds[2];
+  pipe (fds);
+  write(fds[1], string, 6);
+  read (fds[0], buf, 6);
+  printf ("Chaine provenant du pipe-line : %s \n", buf);
+  return 0;
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_pipe_fork.c

@@ -0,0 +1,51 @@
+
+/// demo_pipe_fork : ...
+/// - Demande de descripteurs de pipe line,
+/// - demande de fork,
+/// - PERE : lit des car. au clavier, ecrit dans le pipe-line
+///          (apres fermeture du descr. inutile),
+/// - FILS : lit dans le pipe-line, ecrit les car. recus
+///         (apres fermeture du descr. inutile),
+
+#include <stdio.h>
+#include <unistd.h>
+
+# define READ 0
+# define WRITE 1
+int main ()
+{ int  pid , tabpipe[2];
+  FILE *stream;
+  char c;
+  char * type;
+  pipe (tabpipe); /// Retour à tester
+  pid = fork();
+  if (pid < 0) printf ("ERREUR FORK");
+  else
+    if (pid == 0)
+    { /// FILS  : LIT DANS LE PIPE-LINE
+     type = "r";
+     stream = fdopen (tabpipe[0], type);
+     close (tabpipe[WRITE]);
+     /// Lecture dans le pipe-line, ecriture sur stdout
+      c = fgetc(stream);
+      while ( c != EOF)
+       { printf("Car. recu : %c \n",c); fflush (stdout);
+         c = fgetc(stream);
+       }
+    }
+    else
+    { /// PERE  : ECRIT DANS LE PIPE-LINE
+     printf ("Message a envoyer (ctrl.D pour finir) : ");
+     close ( tabpipe[READ] );
+     type ="w";
+     stream = fdopen (tabpipe[1], type);
+     /// Lecture sur stdin, ecriture dans le pipe-line
+     c=getchar();
+     while ( c != EOF)
+      { fputc(c, stream); fflush (stream);
+        c=getchar();
+      }
+     /// Production de la fin de fichier
+     fclose (stream); }
+ return 0;
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/Makefile

@@ -0,0 +1,11 @@
+CFLAGS = -Wall -std=gnu99
+
+EXECUTABLES =   p_pipe\
+		p_pipe_arg
+
+
+all : ${EXECUTABLES}
+
+clean :
+	@rm -f core *.o *.out *~
+	@rm -f ${EXECUTABLES}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_popen_demo.c

@@ -0,0 +1,47 @@
+/**
+Auteur : RC (inspiration MS)
+Squelette du programme popen_somme
+Cf. algorithme dans la fonction main
+
+NB : La fonction popen() engendre un processus en cr<63>ant un tube
+(pipe), executant un fork(), et en invoquant le shell avec la
+commande donn<6E>e dans l'argument no 1.
+Comme un tube est unidirectionnel par definition,
+l'argument no 2 doit indiquer seulement une lecture
+ou une <20>criture, et non pas les deux.
+Le flux correspondant sera donc ouvert en lecture seule
+ou <20>criture seule.
+Cf. man ...
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#define MAX_COMMANDE 100
+
+int main (int argc, char *argv[])
+{
+    assert (argc == 3);
+    /// Syntaxe : ./a.out <x> <n>
+    /// Exemple : ./a.out 2 10
+    ///           Resultat : 2047
+    int x;
+    int n;
+    FILE *fPin;
+    char commande[MAX_COMMANDE];
+    int somme;
+    int l;
+    char unResultat[10];
+
+    /// "n" boucles "for" avec le compteur l
+    {
+        /// Preparation de la commande pour popen(avec sprintf)
+        /// Creation du fils et du pipeline et test d'erreur...
+        /// Avec fscanf, lecture de la valeur x^l produite par ...
+        /// Fermeture avec pclose
+        /// Incrementation de la somme
+    }
+    /// affichage du resultat
+    return 0;
+}
+

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_puiss.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <math.h>
+
+int main(int argc, char* argv[])
+{
+/// Syntaxe ./argv[0] x n
+/// Resultat sur stdout : x^n
+    assert (argc == 3);
+    int x = atoi (argv[1]);
+    int n = atoi (argv[2]);
+
+    printf ("%.0f\n",pow (x, n));
+    return 0;
+}
+

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_somme_puiss.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <math.h>
+
+int main(int argc, char* argv[])
+{
+/// Syntaxe ./argv[0] x n
+/// Resultat sur stdout : somme x^i avec i entre 0 et n
+    assert (argc == 3);
+    int x = atoi (argv[1]);
+    int n = atoi (argv[2]);
+    int somme = 0;
+    int i;
+    for (i = 0; i<=n ; i++)
+    {
+        somme+=pow(x,i);
+        printf ("... %d\n", somme);/// Mise au point
+    }
+    printf ("%d\n", somme);
+    return 0;
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/p_pipe.c

@@ -0,0 +1,51 @@
+///***************************************************************/
+///*                                                             */
+///* p_pipe      : - Demande de descripteurs de pipeline,        */
+///*               - Demande de fork,                            */
+///*      - PERE : execute la commande wc-l depuis le pipeline   */
+///*               (apres avoir ferme le descripteur inutile),   */
+///*      - FILS : execute la commande ls -ls vers le pipeline   */
+///*               (apres avoir ferme le descripteur inutile).   */
+///*                                                             */
+///***************************************************************/
+///*  - Version 1 : utiliser dup2 et execlp                      */
+///*  - Version 2 : utiliser dup  et execlp                      */
+///*  - Version 3 : utiliser dup2  et execl ET                   */
+///*                Le comportement du pere (ci-dessus) est      */
+///*                est fait dans un deuxieme fils               */
+///*                                                             */
+///*  Ne pas utiliser d'initialisation dynamique de tableau      */
+///***************************************************************/
+
+# include <stdio.h>
+# include <stdlib.h>
+# include <stdlib.h>
+# include <unistd.h>
+
+# define READ  0
+# define WRITE 1
+# define ENTREE 0
+# define SORTIE 1
+
+int main ()
+{ int  res;
+
+  ///******************** PERE ***********************/
+  ///*     PARTIE A COMPLETER                        */
+  ///*************************************************/
+
+  res = fork();
+
+  if (res < 0) { perror ("ERREUR FORK"); exit (2);}
+  else
+    if (res == 0)
+      { ///******************** FILS ***********************/
+        ///*    PARTIE A COMPLETER                         */
+        ///*************************************************/
+      }
+    else
+      { ///******************** PERE ***********************/
+        ///*     PARTIE A COMPLETER                        */
+        ///*************************************************/
+      }
+}

2019-2020/S3T_TP_04_PROCESSUS-3-SGF-2/p_pipe_arg.c

@@ -0,0 +1,69 @@
+///************************************************************/
+///*                                                          */
+///* p_pipe_arg  : - Demande de descripteurs de pipe-line,    */
+///*               - Demande de fork,                         */
+///*               - PERE : recupere en parametres du main    */
+///*                 les N mots qui correspondent a la        */
+///*                 commande qui doit s'executer en lisant   */
+///*                 dans le pipe-line,                       */
+///*               - FILS : recupere en parametres du main    */
+///*                 les M mots suivants qui correspondent    */
+///*                 a la commande qui doit s'executer en     */
+///*                 lisant dans le pipe-line                 */
+///*                     s'executer vers le pipe-line.        */
+///* EXEMPLE     : p_pipe_arg who wc  <====> who | wc         */
+///************************************************************/
+///*  - Version 1 :  N = 1 et M = 1 (equivalent ls | wc)      */
+///*  - Version 2 : N = 1 et M = 1 ET                         */
+///*                Le comportement du pere (ci-dessus) est   */
+///*                est fait dans un deuxieme fils.           */
+///*  - Version 3 : N = 2 et M = 2 ET                         */
+///*                Le comportement du pere (ci-dessus) est   */
+///*                est fait dans un petit-fils.              */
+///*                                                          */
+///*  Ne pas utiliser d'initialisation dynamique de tableau   */
+///************************************************************/
+
+# include <stdio.h>
+# include <stdlib.h>
+# include <unistd.h>
+
+# define READ  0
+# define WRITE 1
+# define ENTREE 0
+# define SORTIE 1
+
+int main (int argc, char* argv[])
+
+{
+    int  resultat ;
+
+    if (argc != 3)
+        fprintf (stderr, "SYNTAXE : %s commande1 commande2\n", argv[0]);
+
+    {
+        ///**************** PERE ******************/
+        ///*   PARTIE A COMPLETER                 */
+        ///****************************************/
+
+        resultat = fork();
+        if (resultat < 0)
+        {
+            perror("ERREUR FORK");
+            exit (2) ;
+        }
+        else if (resultat == 0)
+        {
+            ///**************** FILS ******************/
+            ///*   PARTIE A COMPLETER                 */
+            ///****************************************/
+        }
+        else
+        {
+            /**************** PERE ******************/
+            /*   PARTIE A COMPLETER                 */
+            /****************************************/
+
+        }
+    }
+}