Foro de elhacker.net

Hola! queria saber si existe alguna forma para comunicar dos procesos hijo en C, intercambiando informacion entre ellos una vez ejecutados.

Gracias de ante mano

Si estás en un sistema tipo Unix, utilizar tuberías puede ser una opción.

El procedimiento sería crear las tuberías desde el padre, crear los hijos, cerrar las tuberías en el padre y como los hijos heredan los descriptores de ficheros del padre, que estos  utilicen como entrada y/o salida las tuberías. que el padre tenía abiertas en el momento de crear los hijos.

dup2 y pipe son las funciones usadas para ello.

En un sistema Windows no sabría decirte.

Primeramente gracias por la respeusta Akai. Efectivamente, estoy en un sistema Unix, me había planteado utilizar sockets porque nunca antes usé tuberias, pero quizá sea una opción mas eficiente la de las tuberías. ¿podrias ponerme un ejemplo a nivel de código donde se utilicen estas ideas que me pones?

Gracias de ante mano!

Si, esto sería un pequeño shell de una práctica de la facultad donde se utiliza esto:

Esto crea tantos hijos como ordenes hay, y luego cada hijo hace hace un exec para cambiarse por el programa que realmente nos interesa poner en su lugar.

Esto se plantea como que el shell crea 2 hijos cuando tu le pides ejecutar "ls -la | grep root"

el primer hijo se hace un exec a "ls -la" y el segundo a "grep root"

	for(i=0;i<nordenes;i++){
		forkpid=fork();
		if(forkpid==0){
			redirigir_entrada(i);
			redirigir_salida(i);
			cerrar_fd();
			if(-1==execvp(ordenes[i],args[i]))
				exit(-1);
		}
		else if(forkpid==-1){
			return ERROR;
		}
		else{
 
		}
	}
	cerrar_fd();

Pero antes de ese código se preparan los canales de esta forma:
cmdfd es una estructura que contiene dos enteros, infd y outfd.

for(i=0;i<ncmd-1;i++){
        pipe(fds);
        cmdfd[i].outfd=fds[1];
        cmdfd[i+1].infd=fds[0];
    }

Para las órdenes que haya, se crean n-1 tuberias.

(revisa la referencia de pipe y dup2)

y redirigir la entrada o salida sería esto:

int redirigir_entrada(int i){
    if(cmdfd[i].infd!=0){ //evitar redirigir la entrada estándar sobre si misma, perdida de tiempo.
        if(-1!=dup2(cmdfd[i].infd,0))
            return OK;
        return ERROR;
        }
    return OK;
}
 
int redirigir_salida(int i){
	if(cmdfd[i].outfd!=1){ //evitar redirigir la salida estándar sobre si misma, perdida de tiempo
		if(-1!=dup2(cmdfd[i].outfd,1))
			return OK;
		return ERROR;
	}
    return OK;
}
int cerrar_fd(){
    int i; 
    for(i=3;i<=nds+2;i++){ //nds +2 es el numero del último descriptor de fichero activo.
        close(i);
        }
    return OK;
}
 

Posiblemente encuentres por ahí un código más claro, pero lo básico es:

Preparar canales
Crear hijos
Cerrar canales del padre si no se tiene que comunicar con los hijos
Que los hijos se redirijan las entradas / salidas y cerrar los descriptores sobrantes
A correr.

EDIT: editados los comentarios del código.