School-DUT-info/M311-Principes-des-systemes-d-exploitation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

"depot M311"

Browse Source
This commit is contained in:
JunkJumper
2020-05-02 00:01:03 +02:00
parent f0c24b24e0
commit 16e128821d
83 changed files with 0 additions and 2045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/Makefile
View File

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

20
S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_dup2.c
View File

@@ -1,20 +0,0 @@
///********************/
///* 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;
}

35
S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_fork_fork.c
View File

@@ -1,35 +0,0 @@
/********************/
/* 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;
}

16
S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_pipe.c
View File

@@ -1,16 +0,0 @@
///********************/
///* 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;
}

51
S3T_TP_04_PROCESSUS-3-SGF-2/Demonstrations/demo_pipe_fork.c
View File

@@ -1,51 +0,0 @@
/// 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;
}

11
S3T_TP_04_PROCESSUS-3-SGF-2/Makefile
View File

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

47
S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_popen_demo.c
View File

@@ -1,47 +0,0 @@
/**
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;
}

17
S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_puiss.c
View File

@@ -1,17 +0,0 @@
#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;
}

22
S3T_TP_04_PROCESSUS-3-SGF-2/POPEN_sources/m311_somme_puiss.c
View File

@@ -1,22 +0,0 @@
#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;
}

51
S3T_TP_04_PROCESSUS-3-SGF-2/p_pipe.c
View File

@@ -1,51 +0,0 @@
///***************************************************************/
///* */
///* 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 */
///*************************************************/
}
}

69
S3T_TP_04_PROCESSUS-3-SGF-2/p_pipe_arg.c
View File

@@ -1,69 +0,0 @@
///************************************************************/
///* */
///* 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 */
/****************************************/
}
}
}