pipe "closing" after fclose() - c

Question

int fd[2];
void write_to_pipe(char* str)
{
int file = fd[1];
FILE *stream;
//printf("writing to pipe : %s\n", str);
stream = fdopen(file, "w");
//printf("fdopen returned : %d\n",(int)stream);
fprintf(stream, "%s", str);
fclose(stream);
}
At main() : pipe(fd);
If I call write_to_pipe first then it works perfectly fine.
If the function is called second time then fdopen fails(returns 0).
I assumed the stream/pipe/somthing is closed
What is the safe way to "not close the pipe" and call the function multiple times
Compiler : gcc 6.3.1
p.s.
This read function could have similar problem too.
char* read_from_pipe()
{
int file = fd[0];
static char buf[100];
FILE *stream;
stream = fdopen(file, "r");
read(file,buf,100);
fclose(stream);
return buf;
}

Answer 1

Standard C doesn't know POSIX file descriptors, only FILE * is standard, and fclose() closes the file. This of course implies to do whatever is necessary on the platform to close the file, so in this case, calling close() on the underlying descriptor.
What you should do is just use FILE * wherever appropriate. So if you need a pipe as a backend for your FILE *, fdopen() the file right after creating the pipe. This way, you have your platform-specific code in a single place.
If you happen to need the file descriptor for anything else than closing the pipe, you can use fileno() on the FILE *, but then you have another platform-dependent part in your code.

Answer 2

What is the safe way to "not close the pipe" and call the function multiple times
Don't use fdopen() on the file descriptor:
void write_to_pipe(char* str)
{
write( fd[ 1 ], str, strlen( str ) );
}
or use fdopen() at the same scope as the pipe itself:
int fd[2];
.
.
.
FILE *stream = fdopen( fd[ 1 ] );
.
.
.
void write_to_pipe(char* str)
{
fprintf(stream, "%s", str);
}

Answer 3

You could dup the file descriptor and perform the fdopen on the duplicate.
int write_to_pipe(char* str)
{
int file = dup(fd[1]);
if(0>file)
return -1;
FILE *stream;
//...
}
In any case, your function should probably return an integer so that it could signal possible errors that might occur inside the function.

Answer 4

You are closing the stdout file descriptor, which closes the pipe. Open it once and keep it around until you are finished.

Answer 5

this function:
char* read_from_pipe()
{
int file = fd[0];
static char buf[100];
FILE *stream;
stream = fdopen(file, "r");
read(file,buf,100);
fclose(stream);
return buf;
}
contains several problems.
Suggest writing it similar to:
#define MAX_BUF_LEN 100
char* read_from_pipe()
{
static char buf[ MAX_BUF_LEN +1 ];
ssize_t byteCount = read( fd[0], buf, MAX_BUF_LEN );
if( 0 > byteCount )
{ // an error occurred
perror( "read from pipe failed" );
buf[0] = '\0';
}
else if( 0 == byteCount )
{
fprintf( stderr, "no bytes read\n" );
buf[0] = '\0';
}
else
{
buf[byteCount] = '\0';
}
return buf;
} // end function: read_from_pipe
Note: read() does not terminate the char array, so the code has to do that And the array has to be 1 char longer than the max number of characters ask for in the read() statement.
Note: the syntax for read() wants a int, not FILE* for its' first parameter. Here is the proper syntax:
ssize_t read(int fd, void *buf, size_t count);
this function:
int fd[2];
void write_to_pipe(char* str)
{
int file = fd[1];
FILE *stream;
//printf("writing to pipe : %s\n", str);
stream = fdopen(file, "w");
//printf("fdopen returned : %d\n",(int)stream);
fprintf(stream, "%s", str);
fclose(stream);
}
leaves a lot to be desired.
Suggest something similar to:
int fd[2]; << in file scope, so visible from functions
void write_to_pipe(char* str)
{
//printf("writing to pipe : %s\n", str);
ssize_t bytesWritten = write( fd[1], str, strlen(str) );
if( strlen(str) != bytesWritten )
{
fprintf( stderr, "write to pipe failed to write all bytes\n" );
}
else if( 0 > bytesWritten )
{
perror( "write to pipe failed" );
}
} // end function: write_to_pipe

Answer 6

Duplicate the descriptor and use the duplicate in the fdopen call.