Crear un proceso que leer por el terminal el nombre de un programa

(orden Unix) y seguidamente lo ejecutara. El programa a ejecutar debe

residir en el directorio /bin y no debe necesitar ningn parmetro (p. ej.
Ls, date, time, cd, pwd...). No se debe de ejecutar un programa hasta que
el anterior haya acabado. El proceso terminara cuando se introduzca la
cadena salir.

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

int main()
{
char var[20];
int x;
printf("\nIniciando....\n");
while(1)
{
printf("\nEl hijo realiza lo siguiente\n");
printf("\nEl comando a ejecutar: ");
scanf("%s",var);
if(0==strcmp(var,"salir"))
{
printf("\n");
exit(0);
}

x=fork();
if(x==0)
{
sleep(1);

execlp(var,var,NULL);
exit(0);
}

else
{
wait(NULL);
printf("\nHola soy el padre\n");
printf("Saliendo....\n");

}
}
La ejecucin del programa lo podemos ver en la siguiente captura.

Y como podemos ver al ingresar SALIR termina el proceso.

Implementar un programa que cree un proceso hijo, y que ambos

procesos, tanto padre como hijo, impriman sus identificadores por
pantalla. Luego modifquelo para que el proceso padre espere a que
finalice el proceso hijo. Introduzca una espera en el proceso hijo mediante
una llamada a sleep ().

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

int main()
{
int n,ID;
n=fork();
if(n==0)
{
printf("\nSOY EL HIJO\n");
ID = getpid();
printf("\nID del Hijo:%d\n",ID);
sleep(3);

}
else
{
 wait(NULL);
printf("\nSOY EL PADRE\n");
ID = getpid();
printf("\nID del Padre: %d\n",ID);
}
}

La ejecucin del programa lo podemos ver en la siguiente captura.

Implementar un programa que cree un proceso hijo y que el proceso hijo

ejecute la orden wc. El padre debe esperar hasta la finalizacin del
proceso hijo para finalizar

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

int main()

if(fork()==0)
{
if(execlp("wc", "wc","-l","arch1",NULL) == -1)
perror("");
exit(0);
}
else
{
wait(NULL);
puts("Fin del programa");
}
return 0;
El archivo llamado arch1 contiene lo siguiente:

La ejecucin del programa lo podemos ver en la siguiente captura.

Crea un proceso hijo que despliegue en pantalla un mensaje

cualquiera y su PPID, en cambio el proceso padre imprimir en
pantalla su PID y el PID del proceso hijo. El proceso padre, deber
esperar por la finalizacin del proceso hijo, para evitar que ste se
quede zombie. Para ello, utiliza la llamada al sistema wait (), que
recibe en la variable status el estado en que el proceso hijo
finaliz.

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

int main()
{
int n,estado,p;
pid_t id2;
pid_t id1;

n=fork();
if(n==0)
{
printf("\nEL PROCESO HIJO\n");
id2 = getppid();
printf("\nEl PPID del Hijo es:%d\n",id2);

}
else
{

p=wait(&estado);
printf("\nEL PROCESO PADRE\n");
id1= getpid();
printf("\nMi PID del Padre es: %d\n",id1);
id2=getpid();
printf("El PID del Hijo es: %d\n",p);
 }
return 0;
}

La ejecucin del programa lo podemos ver en la siguiente captura.

El proceso hijo ejecutar el cdigo del ejecutable PROG, el cual recibe

dos parmetros de entrada, el nombre bajo el que se ejecutar el
proceso hijo (``nombre'') y el segundo es el parmetro ``-b''. Para que
la lista se d por terminada habr que especificar el parmetro NULL.
PROG imprime en pantalla la lista de argumentos recibidos:

#include <stdio.h>
int main(int argc, char *argv[]) {
int i = 0;
for (i = 0; i < argc; i++) printf(``\nArgumento [%d]: %s'', i, argv[i]);
exit(0); }

El programa es el siguiente

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

int n;

n=fork( );
if(n = = 0)
{
char *var[3];
args[0]=PROG
args[1]=-b;
args[2]= NULL;
 execvp(var[0], var);
}
else
{

wait(NULL);
}

Escriba un programa que genere 2 procesos hijos. Uno de ellos desplegara

por pantalla la hora y el otro ejecutara un Shell script cualquiera.
Escriba el programa sin el uso de wait con objeto de no tomar en cuenta
la sincronizacin. Al final el padre deber desplegar en pantalla lo
siguienteFIN...soy el Padre, mi PID es:. Explique el resultado.
Modifique el programa de forma que el padre espere a la terminacin de
los hijos.

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

int main()
{
int ID;
if(fork()==0)
{
execv("/bin/date",0);
}
sleep(2);
if(fork()==0)
{
execlp("./arch2","arch2",0);
}
sleep(2);
ID=getpid();
printf("FIN ..... Soy el padre mi PID es %d\n",ID);
return 0;
}

El archivo llamado arch2 contiene lo siguiente

La ejecucin del programa lo podemos ver en la siguiente captura.

 Escriba un programa donde se muestre un proceso principal que
crea 5 hijos a los que se les pasa un cdigo identificador y espera
hasta su terminacin. Cada hijo deber escribir su PID, su PPID, su
UID y GID. Cada hijo ejecuta un bucle donde se escribe 5 veces por
la salida estndar un mensaje que muestra su cdigo identificador
id, el valor de la variable local i junto con el valor de la variable
global I. Porque cada proceso imprime tanto i como I con valores
entre 0 y 5? Si I es una variable global...porque no incrementa su
valor cada vez que un proceso hijo la modifica? Utilice wait para
sincronizar.

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
int n,v=0,id1,id2;
while (v<=5)
{
n=fork();
if(n==0)
{
printf("\nHijo %d creado\n",v);
id1=getpid();
printf("\nEl PID es: %d",id1);
id2=getppid();
printf("\nEl PPID es: %d",id2);
printf("\nEl UID es: %d",getuid());
printf("\nEl GID es: %d",getgid());
}
else
{
wait(NULL);
printf("Padre\n");
}

v++;
}
return 0;
}