tuberias - read pipe c

¿Cómo enviar una cadena simple entre dos programas usando tuberías?

Question

Intenté buscar en la red, pero apenas hay recursos. Un pequeño ejemplo sería suficiente.

EDITAR Me refiero a dos programas diferentes de C que se comunican entre sí. Un programa debería enviar "Hola" y el otro debería recibirlo. Algo como eso.

Answer 1

Desde tldp.org/LDP/lpg/node11.html , esto le muestra cómo mover un programa para usar un tubo. Si no desea fork (), puede usar canalizaciones con nombre .

Además, puede obtener el efecto de prog1 | prog2 prog1 | prog2 enviando la salida de prog1 a stdout y leyendo de stdin en prog2 . También puede leer stdin abriendo un archivo llamado /dev/stdin (pero no estoy seguro de la portabilidad de eso).

/*****************************************************************************
 Excerpt from "Linux Programmer''s Guide - Chapter 6"
 (C)opyright 1994-1995, Scott Burkett
 ***************************************************************************** 
 MODULE: pipe.c
 *****************************************************************************/

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

int main(void)
{
        int     fd[2], nbytes;
        pid_t   childpid;
        char    string[] = "Hello, world!/n";
        char    readbuffer[80];

        pipe(fd);

        if((childpid = fork()) == -1)
        {
                perror("fork");
                exit(1);
        }

        if(childpid == 0)
        {
                /* Child process closes up input side of pipe */
                close(fd[0]);

                /* Send "string" through the output side of pipe */
                write(fd[1], string, (strlen(string)+1));
                exit(0);
        }
        else
        {
                /* Parent process closes up output side of pipe */
                close(fd[1]);

                /* Read in a string from the pipe */
                nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
                printf("Received string: %s", readbuffer);
        }

        return(0);
}

Answer 2

Esta respuesta podría ser útil para un futuro miembro de Google.

#include <stdio.h>
#include <unistd.h>

int main(){     
     int p, f;  
     int rw_setup[2];   
     char message[20];      
     p = pipe(rw_setup);    
     if(p < 0){         
        printf("An error occured. Could not create the pipe.");  
        _exit(1);   
     }      
     f = fork();    
     if(f > 0){
        write(rw_setup[1], "Hi from Parent", 15);    
     }  
     else if(f == 0){       
        read(rw_setup[0],message,15);       
        printf("%s %d/n", message, r_return);   
     }  
     else{      
        printf("Could not create the child process");   
     }      
     return 0;

}

here puede encontrar un ejemplo avanzado de llamada de tubería bidireccional.

Answer 3

Lo que un programa escribe en stdout puede ser leído por otro a través de stdin. Entonces, simplemente, usando c, escriba prog1 para imprimir algo usando printf() y prog2 para leer algo usando scanf() . Entonces solo corre

./prog1 | ./prog2

Answer 4

Una tubería regular solo puede conectar dos procesos relacionados. Se crea mediante un proceso y desaparecerá cuando el último proceso lo cierre.

Una tubería con nombre , también llamada FIFO por su comportamiento, se puede usar para conectar dos procesos no relacionados y existe independientemente de los procesos; lo que significa que puede existir incluso si nadie lo está usando. Se crea un FIFO utilizando la función de biblioteca mkfifo() .

Ejemplo

escritor.c

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    int fd;
    char * myfifo = "/tmp/myfifo";

    /* create the FIFO (named pipe) */
    mkfifo(myfifo, 0666);

    /* write "Hi" to the FIFO */
    fd = open(myfifo, O_WRONLY);
    write(fd, "Hi", sizeof("Hi"));
    close(fd);

    /* remove the FIFO */
    unlink(myfifo);

    return 0;
}

reader.c

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

#define MAX_BUF 1024

int main()
{
    int fd;
    char * myfifo = "/tmp/myfifo";
    char buf[MAX_BUF];

    /* open, read, and display the message from the FIFO */
    fd = open(myfifo, O_RDONLY);
    read(fd, buf, MAX_BUF);
    printf("Received: %s/n", buf);
    close(fd);

    return 0;
}

_{Nota: la verificación de errores se omitió en el código anterior por simplicidad.}

Answer 5

primero, haga que el programa 1 escriba la cadena en stdout (como si quisiera que aparezca en la pantalla). luego, el segundo programa debería leer una cadena de stdin, como si un usuario estuviera escribiendo desde un teclado. entonces corres:

programa_1 | programa_2

Answer 6

Aquí hay una muestra :

int main()
{
    char buff[1024] = {0};
    FILE* cvt;
    int status;
    /* Launch converter and open a pipe through which the parent will write to it */
    cvt = popen("converter", "w");
    if (!cvt)
    {
        printf("couldn''t open a pipe; quitting/n");
        exit(1)
    }
    printf("enter Fahrenheit degrees: " );
    fgets(buff, sizeof (buff), stdin); /*read user''s input */
    /* Send expression to converter for evaluation */
    fprintf(cvt, "%s/n", buff);
    fflush(cvt);
    /* Close pipe to converter and wait for it to exit */
    status=pclose(cvt);
    /* Check the exit status of pclose() */
    if (!WIFEXITED(status))
        printf("error on closing the pipe/n");
    return 0;
}

Los pasos importantes en este programa son:

1. La llamada a popen() que establece la asociación entre un proceso hijo y un conducto en el elemento primario.
2. La llamada a fprintf() que usa el conducto como un archivo ordinario para escribir en el stdin del proceso secundario o leer desde su stdout.
3. La llamada a pclose() cierra el conducto y hace que el proceso hijo finalice.

Answer 7

dup2( STDIN_FILENO, newfd )

Y leer:

char reading[ 1025 ];
int fdin = 0, r_control;
if( dup2( STDIN_FILENO, fdin ) < 0 ){
    perror( "dup2(  )" );
    exit( errno );
}
memset( reading, ''/0'', 1025 );
while( ( r_control = read( fdin, reading, 1024 ) ) > 0 ){
    printf( "<%s>", reading );
    memset( reading, ''/0'', 1025 );
}
if( r_control < 0 )
    perror( "read(  )" );    
close( fdin );    

Pero, creo que fcntl puede ser una mejor solución

echo "salut" | code