Newsgroup: it.comp.os.linux.development
Titolo: Aprire pipe su stdin e sdout

Ho  necessita`  di aprire  una  coppia  di  pipe (unnamed)  versto  un
programma X  che lancio io (da un  programma in C). Con  le named pipe
non avrei difficolta`,  con le unnamed non riesco a  venirne fuori - e
vorrei usare queste ultime.
-- 
Gian  | main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Uberto|                        David Korn, 1987 ioccc best one liner 
Lauri |-------------------------------------------------------------------
(aka saint) >>Vedere X-Nospam nell'header - See X-Nospam field in Header<<

 vorrei usare queste ultime.
int main(void)
{
   int  fd[2];
   close(0);
   close(1);
   pipe(fd);
   fork() & exec();
}
le pipe dovrebbero occupare i file descriptor dello stdin e dello
stdout. Pertanto il figlio scrivendo sullo stdout dovrebbe mandare
i dati al padre.
Era questo che volevi o ho capito male?
C:\>iao Angelo.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 wrote in message
AP> news:uwuxkg...@mail.eng.it...
AP> le pipe dovrebbero occupare i file descriptor dello stdin e dello
AP> stdout. Pertanto il figlio scrivendo sullo stdout dovrebbe mandare
AP> i dati al padre.
Infatti, ho trovato  un'altro esempio che faceva quasi  la stessa cosa
(non toccava stdin e stout).
Non e`  che mi vengono  chiusi i descrittori  (close on exec() )  ? Ho
provato con scarsi risultati - devo passare dei comandi ad un programma
esterno e leggerne gli output...


 esterno e leggerne gli output...
Mi sembra strano, il flag close-on-exec dovrebbe essere impostato
esplicitamente tramite fcntl. Nell'esempio che ho postato di fcntl
non c'era nemmeno l'ombra :-)
C:\>iao Angelo


> esterno e leggerne gli output...
AP> Mi sembra strano, il flag close-on-exec dovrebbe essere impostato
AP> esplicitamente tramite fcntl. Nell'esempio che ho postato di fcntl
AP> non c'era nemmeno l'ombra :-)
Direi anche io.  Ho trovato un  esempio analogo al tuo in rete, un pdf
con gli  slide di un corso di  CS. Fintanto che non  facevo delle exec
funzionava  tutto. Mi  sa che  continuo a  lavorarci,  magari sparando
delle  fcntl  esplicite  per   _togliere_  il  close-on-exec.  Ho  una
soluzione che funziona con le named pipe, ma richiede codice extra per
la creazione affidabile delle stesse.
Grazie!


 programma per Solaris ma sotto mano ho solo Linux (e Linux != Unix).
Sei sicuro che il programma lanciato con exec non ridiriga l'output
su stderr invece che su stdout?
Perche' non provi a postrae il codice sul ng, magari ne esce fuori
qualcosa di utile (per tutti).


 esterno e leggerne gli output...
Hai provato coi soliti ingredienti? intendo: pipe(), select, write(),
read() e compagnia?
Di solito, quando ho un programma con varie sorgenti di i/o creo dei
tanti buffer circolari quanti sono i canali, e poi scrivo una funzione
che si occupa del loro aggiornamento (select, write, read, ecc.).
Qui c'e' uno spezzone di programma, incompleto e buggato, ma che
potrebbe darti un suggerimento: prende dati da stdin, li da' a sort per
l'ordinamento, e li ritorna su stdout. Praticamente il programma fa solo
il passacarte.  La gestione dei buffer e' primitiva (non sono circolari).
/**********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
char * progname;
void err(char * s)
{
	fprintf(stderr, "%s: %s: %s\n", progname, s, strerror(errno));
	exit(1);
}
int main(int ac, char *av[])
{
	int out[2], in[2], pid, res;
	fd_set infds, outfds;
	struct timeval timeout;
	char inbuf[100];  int inbuf_len;  // buffer stdin-->sort
	char outbuf[100]; int outbuf_len; // buffer sort-->stdout
	/****
	Scopo del programma: ordinare alfabeticamente le righe di ``data''
	e stamparle su stdout. Mi avvalgo del comando ``sort'':
        stdin -----> (inbuf)  out[1] -------> out[0]
                      main                            sort
        stdout <---- (outbuf) in[0] <-------- in[1]
	****/
	progname = av[0];
	if( pipe(out) ) err("pipe()");
	if( pipe(in ) ) err("pipe()");
	pid = fork();
	if( pid < 0 ) err("fork()");
	//
	// FIGLIO (sort):
	//
	if( pid == 0 ){
		close(out[1]);
		close(in[0]);
		if( dup2(out[0], 0) < 0 ) err("dup2(out[0])");
		if( dup2(in[1] , 1) < 0 ) err("dup2(in[1])" );
		if( execl("/bin/sort", "sort", NULL) ) err("exec(sort)");
		/** exit implicito **/
	}
	//
	// PADRE:
	//
	close(out[0]);
	close(in[1]);
	inbuf_len = 0;
	outbuf_len = 0;
	data_end = 0;
	while( 1 ){
		FD_ZERO(&infds);
		FD_ZERO(&outfds);
		/* Strategia per la gestione dei buffer interni del programma: */
		/* - sorveglia solo i canali di out per i quali ho dati;       */
		/* - sorveglia solo i canali di in per i quali ho un buffer vuoto.  */
		if( outbuf_len == 0 )
			FD_SET(in[0],  &infds);  // outbuf vuoto: accetta dati da sort
		else
			FD_SET(1,      &outfds); // outbuf pieno: scarica dati su stdout
		if( inbuf_len == 0 ){
			FD_SET(0,      &infds);  // inbuf vuoto: accetta dati da stdin
		} else
			FD_SET(out[1], &outfds); // inbuf pieno: scarica dati su sort
		timeout.tv_sec = 0;
		timeout.tv_usec = 0;
		res = select(FD_SETSIZE, &infds, &outfds, NULL, &timeout);
		if( res == 0 ){
			// timeout - non ricorre qui
			printf("timeout\n");
		} else if( res == 1 ){
			if( FD_ISSET(0, &infds) ){
				// dati disponibili in stdin o fine file:
				// ...
			}
			if( FD_ISSET(in[0], &infds) ){
				// dati disponibili da sort o fine file:
				// ...
			}
			if( FD_ISSET(1, &outfds) ){
				// stdout pronto a ricevere dati:
				// ...
			}
			if( FD_ISSET(out[1], &outfds) ){
				// sort pronto a ricevere dati:
				// ...
			}
		} else {
			err("select()");
		}
	}
	wait(&res);
	/* v. "man 2 wait" per la diagnostica su "res" */
	exit(0);
}
/**********************************************************************/
Ciao,
// Umberto Salsi
//
// 
http://digilander.iol.it/salsi
  --  GnuPG Key ID = BE2C F6CD 77E9 29AE

 non avrei difficolta`,  
perchè non le usi?
-- 
Antonello Pasella

 perchè non le usi?
Forse perche' avrebbe difficolta' a spiegare ad un programma
non fatto da lui e di cui probabilmente non ha il sorgente
qual'e' la named pipe da usare?
:-)


 qual'e' la named pipe da usare?
Mi verrebbe da dire programma <  in_pipe > out_pipe, cosi` pensa a tutto
la shell. Ma probabilmente mi sfugge qualcosa.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"Sei l'unica donna della mia vita".
(Adamo)

 vorrei usare queste ultime.
In questo modo a me funziona(magari ti ho frainteso...):
(puo' darsi che trovi qualche errore di trascrizione....)
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
main(){
 
 int fd[2];
 pid_t son; 
 char buffer[128]; 
 pipe(fd); 
 
 
 if(son=fork() == 0){
   close(0);
   dup(fd[0]);
   close(1);
   dup(fd[1]);
 
   /* inserisci la execl con il comando
      che devi utilizzare */
   /*execlp(.................................); */
 }  
 else{
   wait(5);
   read(fd[0], buffer, 128);
 
   /* il buffer dovrebbe essere valorizzato
      con l'output del comando */
 }
return 0;
}
 
Ciao alla prossima.



Eccetera... che roba e' un unnamed/named pipe?
---
Blackstorm
*Con due angeli al seguito*
Datemene uno con un browser testuale, un eroe fuori dal cinema alle tre di
notte. Datemelo che ti accompagni sempre a casa, anche se piove, anche se fa
freddo, anche se un passo più in là finisce il mondo. Datemelo che scriva
lettere belle non a me, e se poi le leggo va be', mica è colpa mia.{Angelus}
[ICQ #116647346]

 
named pipe
---------- 
In computer programming, a named pipe is a method for
passing information from one computer process to other
processes using a pipe or message holding place that is
given a specific name.
Unlike a regular pipe (o unnamed pipe n.d.p.), a named pipe can
be used by processes that do not have to share a common process
origin and the message sent to the named pipe can be read by any
authorized process that knows the name of the named pipe. 
A named pipe is sometimes called a "FIFO" (first in, first out)
because the first data written to the pipe is the first data that
is read from it.
 
http://searchsolaris.techtarget.com/sDefinition/0,,sid12_gci212619,00.html
C:\>iao Angelo
