Hello,

I was playing with an experimental code on pipe and met with a problem which I don’t understand.

the program reads a file and writes it to one end of pipe and then reads it from another end of pipe.
the buffer for writing pipe is named buf0, and for reading pipe is named buf.
and I found the program does not finish unless sizeof(buf) > sizeof(buf0).
is this a bug or feature of pipe?

Kenji Arisawa

=== BEGIN a.c ===
#include <u.h>
#include <libc.h>

char *argv0;

void
usage(void)
{
        fprint(2,"usage: %s file\n",argv0);
        exits("usage");
}

void
main(int argc, char *argv[])
{
        int fd,pfd[2];
        char buf[256];
        char buf0[256];
        /* need to be sizeof(buf) > sizeof(buf0)
         * but this condition is very curious to me */
        int n;
        char *file;
        argv0 = argv[0];
        argc--;argv++;
        USED(argc);
        if(argv[0] == nil)
                usage();
        file = argv[0];
        fd = open(file,OREAD);
        if(fd < 0)
                sysfatal("no such file");

        if(pipe(pfd) < 0)
                sysfatal("pipe error");
        print("pfd: %d %d\n",pfd[0],pfd[1]);

        while((n = read(fd,buf0,sizeof(buf0))) > 0){
                print("read: %d %s\n",n,file);
                n = write(pfd[1],buf0,n);
                print("write: %d\n",n);
        }
        close(pfd[1]);
        while((n = read(pfd[0],buf,sizeof(buf))) > 0){
                buf[n] = 0;
                print("%d %s\n",n,buf);
        }
        print("%d\n",n);

        exits(nil);
}
=== END a.c ===