#include <stdio.

h>
/*
programme ​ print.c qui affiche à l'écran la chaîne de caractères qui
lui est passée en paramètre en ligne de commande
*/

int main(int argc, char const *argv[]) {

//Si le nombre des argument (incluant le nom de l'executable lui meme)

//est < 2 : le nom du programme seulement a été passé
if (argc < 2)
{
printf("usage: %s message\n",argv[0]);
return 0;
}

printf("%s\n", argv[1]);

return 0;
}

#include <unistd.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/wait.h>

/*
un programme ​ prog1 qui crée un processus fils qui exécute ​ print avec l’argument
salut
en utilisant la fonction ​ execl
int execl(const char *path, const char *arg, ...);
*/
int main(int argc, char const *argv[]) {
/* code */
pid_t pid;

//Création du processus fils

if ((pid=fork()) < 0)
{
/* code */
perror("Erreur de fork");
}
//Processus Fils
else if(pid == 0)
{
//Appel du programme précédement créé (TP3 EX3 a) avec un message salut
if(execl("/home/abdelhak/Documents/TPs_OS/OS-S6/TP3/TP3_EX3_a","TP3_EX3_a","Salut",
(char *) NULL))
{
/* code */
//la famille de exec retourne -1 en cas d'erreur
perror("execl error");
}
}

//Processus Père doit attendre la terminaison de son fils

wait(NULL);

return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include<stdlib.h>
/*
un programme qui crée un processus fils affichant à chaque seconde le nombre de secondes
écoulées. Le processus père arrête le processus fils au bout de 10 secondes.
*/

int main(int argc, char const *argv[]) {

/* code */
int i = 0;
int pidfils = fork();

// en cas d'erreur de création de processus

if(pidfils < 0)
{
perror("Erreur de fork");
exit(-1);
}

if (pidfils > 0)
{
/* Processus père */
//dormir 10 secondes et tuer le processus fils de pid = pidfils avec le signal SIGKILL : 9
//(kill -l) pour voir la liste des signaux disponible

sleep(10);
kill(pidfils,SIGKILL);
}
else //Pocessus fils
{
//Processus vivant durant 10 secondes avant sa terminaison par son père
while (1) //Boucle infinie
{
//processus fils affichant à chaque seconde le nombre de secondes
 //écoulées
sleep(1);
i++;
printf("%d\n", i);
}
}
return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

/*
Un programme qui crée 2 processus, l’un faisant la commande ls -l, l’autre ps -l. Le
père devra
attendre la fin de ses deux fils et afficher quel a été le premier processus à terminer.
*/

int main(int argc, char const *argv[]) {

pid_t pid1,pid2;
int status;

/* Création du premier Processus */

if ((pid1=fork()) < 0)
{
/* En cas d'erreur de création du processus */
perror("la création d'un processus fils a échoué");
exit(1);
}
/*Processus père affiche le pid de son fils nouvellement créé*/
else if(pid1 > 0)
printf("Processus créé avec Pid : %d\n",pid1);

//Processus fils exécute la premère commande ls -l

if (pid1 == 0)
{
execlp("ls", "ls", "-l",(char *) NULL);
perror("Erreur d'exécution de execlp");
exit(-1);
}

if ((pid2=fork()) < 0)
{
/* code */
perror("la création d'un processus fils a échoué");
exit(-1);
}
else if (pid2 > 0)
{
printf("Processus créé avec Pid : %d\n",pid2 );
}

//Processus fils 2 execute la commande ps -l

if (pid2 == 0)
{
execlp("ps", "ps", "-l",NULL);
perror("Erreur d'exécution de execlp");
exit(-1);
}
else
{
 //Code exécuter par le processus père
//Pid du premier processus arrivé sera affecté a la variable premier_arrive
pid_t premier_arrive = wait(&status);
//2 eme arrivé
wait(&status);

printf("Premier processus à terminer: %d \n", premier_arrive);

}

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

int main(void)
{
pid_t pid;

int i;

if((pid = fork()) == -1) //returns -1: erreur 0=returned to the child >0 = pid
{
perror("fork");
exit(1);
}
if(pid == 0) // fils 1
{
for(i=1; i <= 50; i++)
 {
printf("%d \n",i);
}
//printf("Fils 1");
return 0;
//exit(0);
}

if((pid = fork()) == -1)

{
perror("fork");
exit(1);
}
if(pid==0) //fils2
{
//printf("Fils 2");
for(i = 51; i <= 100; i++)
{
printf("%d \n",i);
}
return 0;
}

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

int main(void)
{
pid_t pid;

int i;

if((pid = fork()) == -1)

{
perror("fork");
exit(1);
}
if(pid == 0) // fils 1
{
for(i=1; i <= 50; i++)
{
printf("%d \n",i);
}
//printf("Fils 1");
return 0;
}

//parent wait for the child process to finish

wait(NULL);
//similar to :
//waitpid(-1, NULL, 0);
/*which will suspends the execution of the calling
process until any one child process exits. Here,
1st argument of waitpid indicates wait for any child
process to end.*/

if((pid = fork()) == -1)

{
perror("fork");
 exit(1);
}
if(pid==0) //fils2
{
//printf("Fils 2");
for(i = 51; i <= 100; i++)
{
printf("%d \n",i);
}
return 0;
}

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

/* TD3 EX 1 a
Who & ps & ls -l
*/

int main(int argc, char const *argv[]) {

/* code */
pid_t pid1, pid2;
int status;
//pid = fork();
//if (pid==-1)
if ((pid1=fork())==-1) {
/* code */
 perror("la création d'un processus fils a échoué");
exit(1);
}

if (pid1 == 0) {
/* code */
execlp("who", "who", NULL);
perror("EXECLP");
// waitpid(getppid(),&status,0);
exit(1);
}

if ((pid2=fork())==-1) {
/* code */
perror("la création d'un processus fils a échoué");
exit(1);
}

if (pid2 == 0) {
/* code */
printf("\n##### Waiting for parent ...");
execlp("ps", "ps", NULL);
perror("EXECLP");
printf("\n##### Waiting for parent ...");
//waitpid(getppid(),&status,0);
printf("\n##### Waiting for parent finiched");
exit(1);

execlp("ls", "ls","-l", NULL);

perror("EXECLP");
 wait(NULL);
wait(NULL);
exit(0);

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

/* TD3 EX 2 b
Who ; ps ; ls -l
*/

int main(int argc, char const *argv[]) {

/* code */
pid_t pid;

if ((pid=fork())==-1) {
/* code */
perror("la création d'un processus fils a échoué");
exit(1);
}

if (pid == 0) {
/* code */
execlp("who", "who", NULL);
perror("EXECLP");
 exit(1);
}

wait(NULL);

if ((pid=fork())==-1) {
/* code */
perror("la création d'un processus fils a échoué");
exit(1);
}

if (pid == 0) {
/* code */
execlp("ps", "ps", NULL);
perror("EXECLP");
exit(1);
}

wait(NULL);

execlp("ls", "ls","-l", NULL);

perror("EXECLP");
exit(1);

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>
int main(int argc, char const *argv[]) {
/* code */

pid_t respid;
int n,i,status;

if(argc != 2){

fprintf(stderr, "Usage: %s <nb fils> \n",argv[0]);

exit(1);
}

n = atoi(argv[1]);

for ( i = 0; i < n; i++) {

/* code */
respid = fork();

if(respid == -1){
perror("fork");
exit(2);
}

if (respid == 0){
/* code */

fprintf(stdout, "PID = %d, pidpere = %d, Proc group = %d\n", getpid(),getppid(),getpgid(getpid()));

exit(0);
}
}

/* for ( i = 0; i < n; i++) {

 // code
respid = wait(&status);
printf("fils %d termine \n",respid );
}*/
return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

int main(int argc, char const *argv[]) {

/* code */

pid_t respid, ancetre;

int n,i,status;

if(argc != 2){

fprintf(stderr, "Usage: %s <nb fils> \n",argv[0]);

exit(1);
}

n = atoi(argv[1]);
ancetre = getpid();

for ( i = 0; i < n; i++) {

/* code */
respid =fork();
 if(respid == -1){
perror("fork");
exit(2);
}

//fils
if (respid == 0) {
/* code */

fprintf(stdout, "PID = %d, pidpere = %d, pidanctre = %d \n", getpid(),getppid(), ancetre);

}
//PERE
else{

respid = wait(&status);
printf("fils %d termine \n",respid );
exit(0);
}
}

return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>

int main(int argc, char const *argv[]) {

pid_t pidG,pidD;
int n,i;

if(argc != 2){

fprintf(stderr, "Usage: creer nb fils \n");

exit(1);
}

n = atoi(argv[1]);
fprintf(stdout, "process racine pid : %d\n",getpid());

for ( i = 0; i < n; i++)

{
//creation de fils gauche
pidG = fork();

//Erreur de creation de fils

if (pidG == -1)
{
/* code */
perror("fork");
exit(2);
}

// fils
if (pidG == 0)
{
fprintf(stdout, "fils gauche = %d , (pere = %d)\n",getpid(),getppid() );
}
else //
{
pidD = fork();
 //Erreur Creation Fils droit
if (pidD == -1)
{
perror("fork");
exit(2);
}
if (pidD == 0)
{
fprintf(stdout, "fils droit = %d , (pere = %d)\n", getpid(),getppid());
}
//pere
else
{
waitpid(pidG, NULL, 0);
printf("fils %d termine \n",pidG );
waitpid(pidD, NULL, 0);
printf("fils %d termine \n",pidD );

exit(0);

}
}
}
return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include <sys/wait.h>
int main(int argc, char const *argv[]) {

pid_t pid;
int desc,nbLu;
char buf;

desc = open("fichier",O_RDONLY,0655);
//printf(" descriptor : %d\n",desc);

if (desc == -1) {
perror("open");
exit(1);
}

pid = fork();

if (pid == -1) {
perror("fork");
exit(1);
}

do {
nbLu = read(desc,&buf,1);
fprintf(stdout, "Lu : %c (pid = %d)\n",buf,getpid());
sleep(2);
} while(nbLu > 0);
close(desc);
return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include <sys/wait.h>

//Avoid using char const * argv[] -> not compatible with argument type of
//execvp when shifting the argv by 1 : argv + 1.
//Use char * argv[] instead
//pointer to X" is always allowed to be convert to "pointer to const X

int main(int argc, char *argv[]) {

if (argc < 2)
{
fprintf(stderr, "Usage :%s commande [arg] [arg] ....\n",argv[0]);
exit(1);
}

/* Compléter ! : Utiliser la fonction execvp(const char *file, char *const argv[])*/

//execvp(argv[1], argv + 1);

//OR
execvp(argv[1],&argv[1]);

//en cas d'erreur d'exécution du Execvp

perror("Erreur d'exécution de execvp");

return 0;
}