C/Visual C - Comunicacion mediante pipes

 
Vista:

Comunicacion mediante pipes

Publicado por beamelli (8 intervenciones) el 12/08/2005 11:50:54
Hola, tengo que realizar la comunicación entre dos programas mediante pipes en windows.
Lo primero es crear un programa ( esclavo) que cree dos pipes o tuberias para poder enviar y recibir información entre los dos programas, una vez que tengo creadas las pipes, dado que en windows no podemos usar la funcion fork() para crear un nuevo proceso idéntico, tengo que usar la función spawn o spawnl a la que le paso como argumentos el argumento NO_WAIT, los descriptores , y el nombre del archivo ejecutable del hijo. El problema es que no se si tengo que pasar los descriptores como tal, es decir ( 0 para leer y 1 para escribir ) o si le tengo que pasar donde se va almacenando la informacion a ser leida y escrita. Después cierro los descriptores que sean del hijo y asigno la entrada de este con la la lectura del pipe1 y la salida con la escritura del pipe2.
Después en el nuevo proceso, tengo que cerrar estos descriptores que le llegan como argumento, duplicarlos y asignarselos a la nueva entrada (LEER) Y salida(Escribir) de los pipes. una vez que tengo esto, ya puedo ejecutar el segundo programa.
Espero que podais ayudarme, aunque no se si entendeis lo que quiero explicar, si conoceis más o menos lo que quiero hacer pero teneis una mejor idea, me lo podriais explicar?.
Gracias de todas formas.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

RE:Comunicacion mediante pipes

Publicado por fernando.gomez (1604 intervenciones) el 12/08/2005 18:50:38
No entendí bien, pero se me hace que estás confundiendo conceptos de Linux con Windows. Evidenetemente, fork no existe como tal, y no hay un equivalente exactamente igual.

Para lograr un IPC (Interprocess Communication) en Windows, puedes emplear varios mecanismos (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ipc/base/interprocess_communications.asp). Los más usados son COM y RPC. Debido a que --a diferencia de en Linux-- los Pipes NO SON TRATADOS EXACTAMENTE COMO ARCHIVOS, no son muy adecuados dichos Pipes. Yo me iría por RPC (Remote Procedure Call) o COM (Component Object Model). Sobre Pipes puedes consultar en http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ipc/base/pipes.asp.

Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Comunicacion mediante pipes

Publicado por beamelli (8 intervenciones) el 15/08/2005 10:13:07
A ver si me puedo explicar mejor. Necesito hacer una comunicación entre dos programas mediante pipes en Windows. Para ello creo dos pipes una para transmitir los datos hacia un programa y otra para devolver los datos hacia el otro programa. Una vez que he creado las dos pipes, tengo que crear un nuevo proceso para que abra el segundo programa.

tengo que hacer algo asi, este es el servidor:
#include "stdafx.h"

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h> // to use _pipe function
#include <stdio.h>
#include <stdlib.h> // to use itoa function.
#include <process.h> //to use NO_WAIT argument of spawn function, execl


#define PIPE_READ 0
#define PIPE_WRITE 1

#define pipe(phandles) _pipe(phandles,MAXMESG,O_BINARY)
int p1[2] ; // pipe1
int p2[2] ; // pipe2
int m_in ;
int m_out ;
int state;
int fd1,fd2;

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

char otherProgramm[10] = "Link2.exe" ;
//*create two pipes p1 and p2, return true if the pipes could not be created.

if( _pipe(p1,256,O_TEXT|O_NOINHERIT )==-1 || _pipe(p2,256,O_TEXT|O_NOINHERIT )==-1 ){
return false ;
}

char rpipe[20];
char wpipe[20] ;

itoa( p1[PIPE_READ], rpipe, 10 );
itoa( p2[PIPE_WRITE], wpipe, 10 );

// starting another program
if( (state = spawnl(P_NOWAIT, otherProgramm, rpipe, wpipe, NULL))==-1 )
{
// error closing the pipes
close(p1[PIPE_READ]) ; // close 0
close(p1[PIPE_WRITE]) ; // close 1
close(p2[PIPE_READ]) ; // close 0
close(p2[PIPE_WRITE]) ; // close 1
return false ;
}
m_in = p2[PIPE_READ] ;
m_out = p1[PIPE_WRITE] ;

close(p2[PIPE_WRITE]) ;
close(p1[PIPE_READ]) ;

return true;
}

y luego al crear un proceso tendria que hacer algo asi:


#include "stdafx.h"
#include <stdio.h>
#include <io.h>
#include <process.h>

int fd1,fd2;

int main(int argc, char* argv[])
{
// Preparing the redirection of stdin and stdout
// assign the file descriptor f1 to the standar input. fd1 = p1[READ]
close( 0 ); /*** slave - stdin ***/
sscanf(argv[1],"%d",&fd1);
dup2(fd1, 0);

// assign the file descriptor f2 to the standar output. fd2 = p1[WRITE]
close( 1 ); /*** slave - stdout ***/
sscanf(argv[1],"%d",&fd2);
dup2(fd2, 1);

/*
// assign the file descriptor f2 to the standar error fd2 = p1[WRITE]
close( 2 ); // slave - stderr
if( dup2(fd2, 2) == -1 )
myerror(6) ;
*/

fprintf(stderr, "Starting the program Link2.exe\n");
fflush(stderr);

execl( "Singular.exe","Singular.exe", NULL );
return true;

El problema es que yo tengo el primer codigo fuente "link.cpp" y al crear un nuevo proceso, no se si tengo que hacer otro programa "link.cpp" que luego a su vez llame al programa que deseo abrir, o simplemente poner un else y así si al hacer el spawn() no da error, ejecuta el código del hijo. de esta forma:

#include "stdafx.h"

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h> // to use _pipe function
#include <stdio.h>
#include <stdlib.h> // to use itoa function.
#include <process.h> //to use NO_WAIT argument of spawn function, execl


#define PIPE_READ 0
#define PIPE_WRITE 1

#define pipe(phandles) _pipe(phandles,MAXMESG,O_BINARY)
int p1[2] ; // pipe1
int p2[2] ; // pipe2
int m_in ;
int m_out ;
int state;
int fd1,fd2;

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

char otherProgramm[10] = "singular.exe" ;
//*create two pipes p1 and p2, return true if the pipes could not be created.

if( _pipe(p1,256,O_TEXT|O_NOINHERIT )==-1 || _pipe(p2,256,O_TEXT|O_NOINHERIT )==-1 ){
return false ;
}

char rpipe[20];
char wpipe[20] ;

itoa( p1[PIPE_READ], rpipe, 10 );
itoa( p2[PIPE_WRITE], wpipe, 10 );

// starting another program
if( (state = spawnl(P_NOWAIT, otherProgramm, rpipe, wpipe, NULL))==-1 )
{
// error closing the pipes
close(p1[PIPE_READ]) ; // close 0
close(p1[PIPE_WRITE]) ; // close 1
close(p2[PIPE_READ]) ; // close 0
close(p2[PIPE_WRITE]) ; // close 1
return false ;
}
else
{
// Preparing the redirection of stdin and stdout
// assign the file descriptor f1 to the standar input. fd1 = p1[READ]
close( 0 ); /*** slave - stdin ***/
sscanf(argv[1],"%d",&fd1);
dup2(fd1, 0);

// assign the file descriptor f2 to the standar output. fd2 = p1[WRITE]
close( 1 ); /*** slave - stdout ***/
sscanf(argv[1],"%d",&fd2);
dup2(fd2, 1);

/*
close( 2 ); // slave - stderr
if( dup2(fd2, 2) == -1 )
myerror(6) ;
*/

fprintf(stderr, "Starting the program Link2.exe\n");
fflush(stderr);

execl( "Singular.exe","Singular.exe", NULL );
}
m_in = p2[PIPE_READ] ;
m_out = p1[PIPE_WRITE] ;

close(p2[PIPE_WRITE]) ;
close(p1[PIPE_READ]) ;

return true;
}

te pongo aqui una breve explicacion por si lo entiendes mejor:

// Handling pipes under Windows
//
// The following is code fragment which starts another programm
// with spawnl and communcates via pipes with this programm
// This is just a frame of code (taken and slightly modified from
// another bigger project). So it is not directly tested in this way
// but the important technical components are demonstrated
// Syntactically everything should be fine.

#define MAXMESG 0x1000
#define PIPE_READ 0
#define PIPE_WRITE 1

#define pipe(phandles) _pipe(phandles,MAXMESG,O_BINARY)
int p1[2] ; // pipe1
int p2[2] ; // pipe2
int m_in ;
int m_out ;

/**
* the init() function creates a child process and prepares it
* for pipe communication. The pipe communication
* is as follows:
*
* --------- ---------
* | THIS | | OTHER |
* | 1 0 0 1 | | 0 1 1 0 |
* --------- ---------
* v ^ ^ v ^ v v ^
* | | | | ------- | | | |
* | | | *======>| pipe1 |>======* | | |
* | | *-CLOSED-<| |<-CLOSED-* | |
* | | ------- | |
* | | | |
* | | ------ | |
* | *==========<| pipe2 |<==========* |
* *-CLOSED----->| |>--CLOSED----*
* -------
*
* THIS process uses pipe2[0] for reading and pipe1[1] for writing.
* Therefore the OTHER programm must use pipe2[1] for writing and
* pipe1[0] for reading. This means in THIS process the channels
* pipe2[1] and pipe1[0] must be closed and in the OTHER process
* the channels pipe2[0] and pipe1[1] must be closed.

El problema es que haga como lo haga siempre me dan errores y no sé como hacerlo
Espero que me entiendas y puedas ayudarme.
gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Comunicacion mediante pipes

Publicado por SuperIndio (1 intervención) el 11/12/2018 17:13:26
No señor con pipes no lo vas a logra... lo que tenes que usar es SHERD MEMORY

escribi de un lado y lees del otro

busca shmget() shmat() sino avisame tengo una buen ejemplo entre los ciber-arapos de mi 486 DX II
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar