/*

Programa 1

Programa que hace uso de las llamadas al sistema fork(), getpid() y getppid().

Ejemplifica la creación de un proceso hijo y la obtención del identificador de

proceso para cada proceso.

*/
#include <stdio.h>

main()
{
int pidP, pidH;

pidH = fork(); /* Se crea el proceso hijo */

if (pidH!=0) { /* código del padre */
pidP=getpid();
printf("\n Soy el padre mi identificador de proceso es:%d", pidP);
printf ("\n Mi hijo tiene el pid=%d", pidH);
}
else{ /* código del hijo */
printf("\n Soy el hijo mi pid es: %d\n", getpid());
printf("\n El pid de mi padre es: %d\n", getppid());
}
}
/*
Programa 2

Programa que hace uso de las llamadas al sistema wait() y exit() para
una comunicación primitiva entre procesos padre e hijo

*/
#include <stdio.h>
#include <stdlib.h>

main()
{
int i= 10,
j= 12,
pid,
estado;

pid = fork(); /* Se crea el proceso hijo */

if (pid) { /*código del padre*/
printf("\n Soy el padre y el identificador de mi proceso hijo es:%d\n", pid);
printf ("\n Ahora esperare a que termine mi hijo");
wait(&estado); /* recibe el valor enviado por el hijo en la variable estado */
estado = estado >> 8; /* corrimiento de 8 bits necesario*/
printf("\n el valor que me envio mi hijo es: %d", estado);
}
else{ /* código del hijo */
i=i+j;
exit(i); /* termina el hijo y envía el valor de la variable i al padre */
}
}
/*
Programa 3

Programa que hace uso de las llamadas al sistema wait() y exit() para
una comunicación primitiva entre el proceso padre y varios procesos hijos.

Ejemplifica el uso de variables locales y globales para todos los procesos

*/

#include <stdio.h>
#include <stdlib.h>

#define NUM_PROC 5
int I = 0;

void codigo_proc_hijo(int id) /*esta función la ejecuta cada proceso hijo */

{
int i;

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

printf("Proceso %d: i = %d, I = %d\n", id, i, I++);
exit(id);
}

main()
{
int p,
id[NUM_PROC] = {1, 2, 3, 4, 5},
pid,
salida;

for (p = 0; p < NUM_PROC; p++){ /* se crean los procesos hijo */

pid = fork();
if (!pid) {
codigo_proc_hijo(id[p]);
}
}

/* Esta parte solo la ejecuta el proceso padre */

for (p = 0; p < NUM_PROC; p++){
pid = wait (&salida);
printf ("Proceso %d con id = %d terminado \n", pid, salida >>8);
}
}
/*
Programa 4

Programa que hace uso de la llamada al sistema exec() para cambiar el código
del hijo.

Ejemplifica la ejecución de comandos de Unix

*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
int pid;

pid = fork(); /* Se crea un proceso hijo */

if (pid) {
printf ("\n Esperare a que termine mi hijo");
wait(NULL);
printf("\n Ya terminó mi hijo”);
}
else{ /* El código del hijo se cambia por el código del comando “ls” */
execlp("ls", "ls", "-l",(char *)0);
}
}
/*
Programa 5

Programa que hace uso de las llamadas al sistema exec(), pipe(), close() y dup(),
para efectuar una comunicación más amplia.

Ejemplifica la ejecución de comandos de Unix con el uso del pipe

*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
int pid,
pipefd[2];

pipe(pipefd); /*se crea el canal de comunicación */

pid = fork(); /* Se crea el proceso hijo */
if (pid) {
close(0);
close(pipefd[1]);
dup(pipefd[0]);
execlp("wc", "wc", (char*)0); /*cambio de código */
}
else{
close(1);
close(pipefd[0]);
dup(pipefd[1]);
execlp("ls", "ls", "-l",(char *)0); /*cambio de código */
}
}
/*
Programa 6

Programa que hace uso de las llamadas al sistema exec(), pipe() y close(), para
efectuar una comunicación directa.

Ejemplifica el envio de mensajes tipo texto de padre a hijo.

*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
int pid,
pipefd[2];

char mensaje1[20],
mensaje2[20];

pipe(pipefd); /*se crea el canal de comunicación */

pid = fork(); /* se crea el proceso hijo */
if (pid) {
printf("\n Soy el padre, dame mensaje:");
gets(mensaje1);
close(pipefd[0]);
write(pipefd[1], mensaje1, strlen(mensaje1)+1);
}
else{
printf("\n Soy el hijo, ");
close(pipefd[1]);
read(pipefd[0], mensaje2, 20);
printf(" mensaje recibido: %s", mensaje2);
}
}