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éant un tube
(pipe), executant un fork(), et en invoquant le shell avec la
commande donnée dans l'argument no 1.
Comme un tube est unidirectionnel par definition,
l'argument no 2 doit indiquer seulement une lecture
ou une écriture, et non pas les deux.
Le flux correspondant sera donc ouvert en lecture seule
ou é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 */
/****************************************/
}
}
}