///// MODELOS OPERATIVOS /////

/* Modelo 1 */

/ PADRE /

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

#define NOMBRE "hijoputa"

#define PERMISOS 0644

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

int num_hijos = argc - 2;
int i;
int pid;
int fd;
int status;
char c;
/*
if(argc < 3){
printf("Error en la linea de ordenes\n");
return EXIT_FAILURE;
}//if*/
if((mkfifo(argv[1], PERMISOS)) != 0){
printf("Error en la creacion de la tuberia\n");
return EXIT_FAILURE;
}//if

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

switch(fork()){
case -1:
printf("Error en la creacion del hijo\n");
continue;
case 0:
if(execl(NOMBRE,NOMBRE, argv[1], argv[i+2],NULL) == -1){
fprintf(stderr, "Error en la ejecucion\n");
}//if
break;
}//switch
}//for

if((fd = open(argv[1], O_RDONLY)) == -1){

fprintf(stderr, "Error al abrir la tuberia\n");
return EXIT_FAILURE;
}//if

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

if((pid=wait(&status)) == -1){
printf("Error en la espera\n");
continue;
}//if

if((read(fd, &c, sizeof(c))) == -1){

fprintf(stderr, "Error al leer de la tuberia");
 continue;
}//if
printf("Fin proceso %d, con el caracter %c y un estado %d\n",
pid,c,status);
}//for

unlink(argv[1]);

printf("El proceso padre ha acabado\n");

return EXIT_SUCCESS;
}//main

/ HIJO /
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

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

int c;

if(argc != 2){
printf("Error en la linea de ordenes\n");
return EXIT_FAILURE;
}
c = argv[2][0];
printf("Caracter %c\n",c);

printf("El proceso hijo ha acabado %d\n", getpid());

return EXIT_SUCCESS;
}

/* Modelo 2 */

/ PADRE /

#define _POSIX_SOURCE /* Elimina el warning en declaracion de kill () */

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

#define MAXHIJOS 100 /* No de procesos hijos a crear */

#define NOMBREHIJO "hijo" /* Nombre del programa hijo */
#define MAXBUFFER 256 /* No de procesos hijos a crear */

void finalizarProcesos();

pid_t pids[MAXHIJOS];

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

int fd;
int n;
char buffer[MAXBUFFER];
int c;

int numerohijos;
 int i,j;
int pid;

if(argc < 2){

fprintf(stderr, "Error en el numero de argumentos\n");
return EXIT_FAILURE;
}//if

if((fd = mkfifo(argv[1],0644))!=0){
fprintf(stderr, "Error en la creacion de la tuberia\n");
return EXIT_FAILURE;
}//if

numerohijos = argc - 2;

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

switch(pids[i]=fork()){
case -1:
fprintf(stderr, "Error en la creacion de un proceso
hijo\n");
finalizarProcesos();
break;
case 0:
if(execl(NOMBREHIJO, NOMBREHIJO, argv[1], *++argv, NULL) ==
-1){
fprintf(stderr, "Error al ejecutar un proceso
hijo\n");
return EXIT_FAILURE;
}//if
break;
}//switch
}//for

for(i = 0; i <numerohijos;i++){
if(pids[i]!=0){
if(kill(pids[i],SIGINT) == -1){
fprintf(stderr, "Error al enviar la seal\n");
}//if2
else{

printf("El proceso %d, ha finalizado\n",pids[i]);

}
}//if
}//for
unlink(argv[1]);
return EXIT_SUCCESS;
}//main

void finalizarProcesos(void){
int i;

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

if(pids[i]!=0){
if(kill(pids[i],SIGINT) == -1){
fprintf(stderr, "Error al enviar la seal\n");
}//if
}//if
}//for
}//funcion

/ HIJO /

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

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

int fd;
int pid;
int i;
char n;

if(argc != 3){
fprintf(stderr, "Error en la linea de argumentos132151\n");
return EXIT_FAILURE;
}//if

if((fd = open(argv[1], O_WRONLY)) == -1){

fprintf(stderr, "Error al abrir la tuberia");
return EXIT_FAILURE;
}//if

n = argv[2][0];

if((write(fd, &n, sizeof(n))) == -1){

fprintf(stderr, "Error al escribir en la tuberia\n");
return EXIT_FAILURE;
}//if
return EXIT_SUCCESS;
}//main

/* Modelo 3 */

/ PADRE /

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

#define NOMBRE "wc"

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

int i;
int pid;
 int status;

if(argc<2){
fprintf(stderr, "Error en la linea de ordenes\n");
return EXIT_FAILURE;
}

for(i = 0; i < argc-1; i++){

switch(fork()){
case -1:
fprintf(stderr, "Error en la creacion del hijo\n");
return EXIT_FAILURE;
case 0:
printf("Se va a crear el con pid %d\n");
if(execlp(NOMBRE, NOMBRE, argv[i+1],NULL) != 0){
fprintf(stderr, "Error al crear el hijo \n");
continue;
}//if
break;
}
}
for(i = 0; i < argc -1; i++){
pid = wait(&status);
if(pid==-1){
fprintf(stderr, "\n", );
}
}
}//main

/* Modelo 4 */

/ PADRE /

/*padre.c - Crea procesos hijos y espera su finalizacion*/

#define _POSIX_SOURCE /* Elimina el warning en declaracion de kill () */
#include <sys/types .h>
#include <unistd .h>
#include <stdlib .h>
#include <stdio .h>
#include <signal .h>
#include <wait.h>

#define NUM_HIJOS 5 /* No de procesos hijos a crear */

#define NOMBREHIJO "hijo" /* Nombre del programa hijo */

void FinalizarProcesos();

void Manejador(int num);

pid_t pids[NUM_HIJOS]; /* Tabla de procesos hijos */

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

int i, j;
int pid ;
/* Tratamiento de la linea de ordenes */
if (argc != 2) {
fprintf(stderr , "Error en el numero de argumentos\n");
exit(EXIT_FAILURE) ;
}
 /* Tratamiento de la seal */
if (signal(SIGINT, Manejador) == SIG_ERR) {
fprintf(stderr, "Error en la manipulacion de la seal\n");
exit(EXIT_FAILURE) ;
}

/*Creacion de los procesos hijos*/

for (i=0; i<NUM_HIJOS; i++) {
switch(pids[i] = fork()){ /* Se guarda el pid en la tabla de procesos */
case -1:
fprintf(stderr, "Error en la creacion del proceso hijo\n");
FinalizarProcesos();
break;
case 0:
if(execl(NOMBREHIJO, NOMBREHIJO, argv[i], NULL)==-1){
fprintf(stderr, "Error en la ejecucion del proceso hijo\n");
exit(EXIT_FAILURE);
}
break;
}
}

/* Espera a la finalizacion de los procesos hijos */

for (i = 0; i < NUM_HIJOS; i++) {
pid = wait(NULL);
for (j = 0; j < NUM_HIJOS; j++) {
if (pid == pids[j]) {
printf ("[Proceso padre] el proceso %d ha terminado\n" , pid );
pids [ j ] = 0; /* 0 para indicar que no existe el proceso */
}
}
}
printf("[Proceso padre] finaliza\n"); return EXIT_SUCCESS;
return EXIT_SUCCESS
}

/* FianlizarProcesos: Termina todos los procesos hijos vivos */

void FinalizarProcesos (void) {
int i;

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

if (pids[i] != 0) { /* Solo se mata los procesos hijos vivos */
if (kill(pids[i], SIGINT) == 1) {
fprintf(stderr , "Error al enviar una seal\n");
}
}
}

/* Manejador: Manejador de la seal */

void Manejador (int num) {
FinalizarProcesos();
printf("[Proceso padre] finaliza\n");
exit(EXIT_SUCCESS);
}

/ HIJO /

/* hijo .c Espera durmiendo el tiempo indicado y finaliza */

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

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

int seg_espera; /* Segundos a esperar durmiendo */
int seg_maximo; /* No maximo de segundos*/
/* Tratamiento de la linea de ordenes */
if (argc != 2) {
fprintf(stderr , "Error en el numero de return EXIT_FAILURE\n");
return EXIT_FAILURE;
}
if ((seg_maximo = atoi(argv[1])) <= 0) {
fprintf(stderr , "Error en el argumento return EXIT_FAILURE\n");
return EXIT_FAILURE;
}

/* Espera un no de segundos aleatorio y finaliza */

srand((int)getpid()); /* Inicializa la secuencia aleatoria */
seg_espera = 1 + (rand() %seg_maximo);
printf ("[Proceso %d] duerme %d segundos\n" , getpid(), seg_espera);
sleep (seg_espera);
printf ("[Proceso %d] finaliza\n" , getpid ());

return EXIT_SUCCESS;
}