p_fork ok
This commit is contained in:
srifi jose
parent
40b1703374
commit
d54e5da572
@ -0,0 +1,16 @@
|
||||
CFLAGS = -Wall -g -std=gnu99
|
||||
|
||||
EXECUTABLES = demo_base \
|
||||
demo_exit \
|
||||
demo_sleep \
|
||||
demo_fork \
|
||||
demo_exec_scan \
|
||||
demo_exec_arg \
|
||||
demo_strtok
|
||||
|
||||
|
||||
all : ${EXECUTABLES}
|
||||
|
||||
clean :
|
||||
@rm -f core *.o *.out *~
|
||||
@rm -f ${EXECUTABLES}
|
||||
@ -0,0 +1,21 @@
|
||||
/**************************************/
|
||||
/* demo_base : demonstration basique */
|
||||
/**************************************/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
|
||||
int main (int argc, char* argv[], char* envp[])
|
||||
// argc = compteur d'arguments
|
||||
// argv et envp = tableau de pointeurs de chaines
|
||||
{
|
||||
if (argc != 2){
|
||||
fprintf(stdout, "\nSyntaxe : %s nom-de-variable\n\n", argv[0]);
|
||||
exit (1);
|
||||
}
|
||||
printf ("\nProcessus %d (pere : %d) - 2eme mot ='%s'\n", getpid (), getppid (),
|
||||
getenv(argv[1]));
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,25 @@
|
||||
/*************************************************************/
|
||||
/* demo_exec_arg : */
|
||||
/* - Reservation de la place max des arguments */
|
||||
/* (20 car.), */
|
||||
/* - 1er paramètre = la commande a executer, */
|
||||
/* - 2ème paramètre et suivant = paramètres de */
|
||||
/* la commande */
|
||||
/* - execution (avec prise en compte de la */
|
||||
/* variable PATH). */
|
||||
/*************************************************************/
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
int main (int argc, char* argv[])
|
||||
{
|
||||
char* argv2[argc];
|
||||
int i;
|
||||
printf(" argc=%i \n", argc);
|
||||
for (i= 1; i <= argc; i++)
|
||||
{
|
||||
argv2[i-1] = argv[i];
|
||||
printf(" argv[%i] = %s\n", i, argv2[i-1]);
|
||||
}
|
||||
execvp (argv2[0],argv2);
|
||||
printf ("\nERREUR : execvp impossible\n");
|
||||
}
|
||||
@ -0,0 +1,22 @@
|
||||
/***************************************************************/
|
||||
/* demo_exec_scan : */
|
||||
/* - Reservation de la place max des arguments */
|
||||
/* (30 car.), */
|
||||
/* - lecture du nom de la commande a executer, */
|
||||
/* - lecture d'un param. obligatoire, */
|
||||
/* - execution (avec prise en compte de la */
|
||||
/* variable PATH). */
|
||||
/***************************************************************/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main ()
|
||||
{ char *argv[3];
|
||||
argv[0] = (char*) malloc(30); argv[1] = (char*)malloc(30);
|
||||
printf ("Nom de la commande a executer : "); scanf ("%s", argv[0]);
|
||||
printf ("Un argument (obligatoire) : "); scanf ("%s", argv[1]);
|
||||
argv[2] = (char*)0;
|
||||
execvp (argv[0],argv);
|
||||
printf ("\nERREUR : execvp impossible\n");
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
/*************************************************/
|
||||
/* demo_exit : envoi d'un code de retour */
|
||||
/*************************************************/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
if (argc != 2) {fprintf (stderr, "Syntaxe : %s code-de-retour \n", argv[0]); exit(-1);}
|
||||
exit (atoi (argv[1]));
|
||||
}
|
||||
|
||||
/// Par exemple, tester en bash avec :
|
||||
|
||||
/// if ./demo_exit 3 ; then echo OK ; else echo KO ; fi
|
||||
|
||||
/// Puis avec .\demo_exit 0 ...
|
||||
|
||||
|
||||
@ -0,0 +1,13 @@
|
||||
/******************************************************/
|
||||
/* demo_fork : Ce programme illustre le mecanisme de */
|
||||
/* duplication d'images de LINUX. */
|
||||
/******************************************************/
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
int main()
|
||||
{ int res;
|
||||
res = fork();
|
||||
if (res == -1) {perror ("demo_fork - fork"); exit (1);}
|
||||
printf ("\nProcessus %d (pere : %d) - res ='%d'\n", getpid (), getppid (), res);
|
||||
}
|
||||
@ -0,0 +1,23 @@
|
||||
/*************************************************/
|
||||
/* demo_sleep : Utilisation de "sleep" */
|
||||
/*************************************************/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
int main (int argc, char* argv[])
|
||||
/* argc : compteur d'arguments */
|
||||
/* argv : tableau de pointeurs de chaines */
|
||||
{
|
||||
if (argc != 2)
|
||||
{
|
||||
fprintf (stderr, "Syntaxe : %s duree-du-sleep\n", argv[0]);
|
||||
exit (1);
|
||||
}
|
||||
printf("\n%s (Pid = %d): Regardez-moi avec ps ... Je m'endors %s secondes.\n",
|
||||
argv[0], getpid(),argv[1]);
|
||||
sleep (atoi(argv[1]));
|
||||
printf("%s (Pid = %d): Je me reveille après %s secondes.\n\n",
|
||||
argv[0], getpid(), argv[1]);
|
||||
}
|
||||
@ -0,0 +1,20 @@
|
||||
/// M311 - demonstration : gets, strtok
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
|
||||
int main()
|
||||
{
|
||||
char *mot;
|
||||
char *ligne = malloc (80);
|
||||
ligne = fgets (ligne, 80, stdin);
|
||||
printf("===%s===\n", ligne);
|
||||
mot = strtok (ligne, " ");
|
||||
while (mot != NULL)
|
||||
{
|
||||
printf("%s\n", mot);
|
||||
mot = strtok (NULL, " ");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,23 @@
|
||||
/*******************************************************/
|
||||
/* p_fichier: Ce programme crée un nouveau */
|
||||
/* processus avec fork */
|
||||
/* - Le processus pere ouvre un nouveau fichier en */
|
||||
/* création de nom donné en argument */
|
||||
/* - Le processus fils écrit une chaine donnee en */
|
||||
/* argument dans le fichier puis meurt */
|
||||
/* - Le processus pere affiche le fichier puis meurt */
|
||||
/* */
|
||||
/* syntaxe : p_fichier fichier chaine */
|
||||
/*******************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main (int argc, char* argv[]) {
|
||||
|
||||
if (argc != 3) fprintf (stderr, "\nSyntaxe: %s <fichier> <chaine>\n\n", argv[0]);
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
/*******************************************************/ /* */
|
||||
/* p_fork : Ce programme illustre le mecanisme de */
|
||||
/* duplication de processus de LINUX. */
|
||||
/* Le processus pere affiche N etoiles, alors */
|
||||
/* que le processus fils affiche N slashs. */
|
||||
/* La valeur de N est transmise en premier argument */
|
||||
/* de la commande. */
|
||||
/* */
|
||||
/*******************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
|
||||
int res = fork();
|
||||
int max = atoi(argv[1]);
|
||||
|
||||
if (res < 0)
|
||||
{
|
||||
printf("ERREUR FORK\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
if (res == 0)
|
||||
{ /************************** FILS ***********************/
|
||||
printf("Je suis le fils :\n");
|
||||
printf("pid : %d\n", getpid());
|
||||
printf("ppid : %d\n", getppid());
|
||||
for (int i = 0; i < max; i++)
|
||||
{
|
||||
printf("/");
|
||||
}
|
||||
printf("\n\n");
|
||||
}
|
||||
else
|
||||
{ /************************** PERE ***********************/
|
||||
printf("Je suis le père :\n");
|
||||
printf("pid : %d\n", getpid());
|
||||
printf("ppid : %d\n", getppid());
|
||||
|
||||
for (int i = 0; i < max; i++)
|
||||
{
|
||||
printf("*");
|
||||
}
|
||||
printf("\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,41 @@
|
||||
/*********************************************************/
|
||||
/* */
|
||||
/* p_fork_exec : Prototype extremement simplifie d' une */
|
||||
/* boucle de SHELL : */
|
||||
/* - Le pere lit une commande a executer (fait) */
|
||||
/* - Le pere se duplique et attend la fin du fils */
|
||||
/* - Le pere affiche OK si le fils s'est "bien" fini */
|
||||
/* (exit avec 0) et KO sinon. */
|
||||
/* et KO sinon. */
|
||||
/* - Le fils execute la commande lue par le pere */
|
||||
/* (avec utilisation de la variable PATH). */
|
||||
/* */
|
||||
/*********************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main ()
|
||||
|
||||
{ char *arguments[3];
|
||||
|
||||
arguments[0] = (char*) malloc(30);
|
||||
arguments[1] = (char*) malloc(30);
|
||||
|
||||
printf ("\n=============================\n");
|
||||
printf (" BIENVENUE SOUS p_fork_exec \n");
|
||||
printf ("=============================\n\n");
|
||||
|
||||
printf ("? Nom de la commande a executer : "); scanf ("%s", arguments[0]);
|
||||
printf ("? Un argument (obligatoire) : "); scanf ("%s", arguments[1]);
|
||||
|
||||
arguments[2] = (char*)0;
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
|
||||
printf ("\n==============================\n");
|
||||
printf (" p_fork_exec: FIN DE SESSION \n");
|
||||
printf ("==============================\n\n");
|
||||
}
|
||||
@ -0,0 +1,20 @@
|
||||
/*******************************************************/ /* */
|
||||
/* p_fork_wait : Ce programme illustre le mecanisme */
|
||||
/* de duplication de processus de LINUX. */
|
||||
/* Le processus fils affiche N slashs,pendant */
|
||||
/* que le père attend la fin du fils pour afficher */
|
||||
/* un message de fin. */
|
||||
/* La valeur de N est transmise en premier argument */
|
||||
/* de la commande. */
|
||||
/* */
|
||||
/*******************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main (int argc, char* argv[]) {
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
/*******************************************************/ /* */
|
||||
/* p_fork_wait_exit : Ce programme illustre le */
|
||||
/* mecanisme de duplication de processus */
|
||||
/* de LINUX. */
|
||||
/* Le processus pere attend le fils. */
|
||||
/* Le processus fils dort quelques secondes puis ... */
|
||||
/* Le processus fils affiche un message puis retourne */
|
||||
/* un code de retour pris dans argv[1]. */
|
||||
/* Le pere affiche "Operation reussie" si le fils */
|
||||
/* s'est bien terminé, et "Echec d'operation" sinon. */
|
||||
/* */
|
||||
/* Convention : "bien terminé" == (code de retour == 0)*/
|
||||
/* */
|
||||
/* Technique : Utiliser wait (adresse) et WEXITSTATUS */
|
||||
/* */
|
||||
/*******************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main (int argc, char* argv[]) {
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
|
||||
}
|
||||
@ -0,0 +1,31 @@
|
||||
/*******************************************************/ /* */
|
||||
/* p_system : Ce programme définit une fonction */
|
||||
/* "p_system" qui reproduit le fonctionnement */
|
||||
/* de la routine system(3). */
|
||||
/* */
|
||||
/*******************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
int p_system (char* commande){
|
||||
printf ("Execution de p_system avec : %s\n", commande);
|
||||
|
||||
/**********************/
|
||||
/* PARTIE A COMPLETER */
|
||||
/**********************/
|
||||
return 0; // A modifier ...
|
||||
}
|
||||
|
||||
int main(int argc, char * argv[]){
|
||||
int res;
|
||||
if (argc != 2) {
|
||||
fprintf (stderr, "\nSyntaxe : %s \"une ligne de commande\"\n\n", argv[0]); exit (1);}
|
||||
|
||||
res = p_system (argv[1]);
|
||||
|
||||
printf ("Code de retour : %d\n", res);
|
||||
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user