You are not checking for errors, and you are not using a return value from read(2)

that tells you how many characters are returned. This is weird as it is the source of an unsynchronized server and client. I rewrote your code so that it doesn't work (although I don't check the return value write(2)

, which should fail when pipes are broken --- when killing the server or client). It remains as complete as exercise for you.

Focus on how null terminated strings are handled by the call printf(3)

by specifying the length of the formatted string "%.*s"

(this is a trick to avoid putting the final \0

in a buffer (which should be checked if you are reading before sizeof buf

instead of sizeof buf - 1

.

server.c

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

#define F(fmt) __FILE__":%d:%s: " fmt, __LINE__, __func__

/* file scope to share with at_exit() call */
static const char myfifo[] = "/tmp/client_to_server_fifo";
static const char myfifo2[] = "/tmp/server_to_client_fifo";

void rm_fifos(void)
{
    printf(F("deleting fifo \"%s\"\n"), myfifo);
    unlink(myfifo);
    printf(F("deleting fifo2 \"%s\"\n"), myfifo2);
    unlink(myfifo2);
}

int main()
{
    int client_to_server;
    int server_to_client;
    int res;

    char buf[BUFSIZ];

    /* create the FIFO (named pipe) */
    printf(F("creating fifo \"%s\"\n"), myfifo);
    res = mkfifo(myfifo, 0666 | O_EXCL); /* O_EXCL guarantees that no second instance is created while this is running */
    if (res < 0) {
            fprintf(stderr,
                    F("%s: %s(errno=%d)\n"),
                    myfifo, strerror(errno), errno);
            exit(EXIT_FAILURE);
    }
    printf(F("creating fifo \"%s\"\n"), myfifo);
    res = mkfifo(myfifo2, 0666 | O_EXCL);
    if (res < 0) {
            fprintf(stderr,
                    F("%s: %s(errno=%d)\n"),
                    myfifo2, strerror(errno), errno);
            unlink(myfifo); /* we successfuly created it */
            exit(EXIT_FAILURE);
    }

    atexit(rm_fifos);

    /* open, read, and display the message from the FIFO */
    client_to_server = open(myfifo, O_RDONLY);
    if (client_to_server < 0) {
            fprintf(stderr,
                    F("%s: open: %s(errno=%d)\n"),
                    myfifo, strerror(errno), errno);
            exit(EXIT_FAILURE);
    }

    server_to_client = open(myfifo2, O_WRONLY);
    if (server_to_client < 0) {
            fprintf(stderr,
                    F("%s: open: %s(errno=%d)\n"),
                    myfifo2, strerror(errno), errno);
            exit(EXIT_FAILURE);
    }

    printf(F("Server ON bufsize=%d.\n"), BUFSIZ);

    while (1) {
            ssize_t n = read(client_to_server, buf, BUFSIZ);
            if (n < 0) {
                    fprintf(stderr,
                            F("%s: read: %s(errno = %d)\n"),
                            myfifo, strerror(errno), errno);
                    exit(EXIT_FAILURE);
            }
            if (n == 0) break;  /* EOF on input */

            printf("Received: [%.*s]\n", n, buf);
            printf("Sending back...\n");
            write(server_to_client, buf, n); /* very important to write just the n read chars, and not more */

            /* no need to clean buf from any data */
    }

    close(client_to_server);
    close(server_to_client);

    /* no need to unlink, as this was prepared in the atexit() library call */
    return 0;
}

      

        
        
        
      

    

client.c

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

#define F(fmt) __FILE__ ":%d:%s: " fmt, __LINE__, __func__

int main()
{
    int client_to_server;
    char *myfifo = "/tmp/client_to_server_fifo";
    int server_to_client;
    char *myfifo2 = "/tmp/server_to_client_fifo";

    char str[BUFSIZ];

    /* write str to the FIFO */
    client_to_server = open(myfifo, O_WRONLY);
    if (client_to_server < 0) {
            fprintf(stderr,
                    F("%s: %s(errno = %d)\n"),
                    myfifo, strerror(errno), errno);
            exit(EXIT_FAILURE);
    }
    server_to_client = open(myfifo2, O_RDONLY);
    if (server_to_client < 0) {
            fprintf(stderr,
                    F("%s: %s(errno = %d)\n"),
                    myfifo2, strerror(errno), errno);
            exit(EXIT_FAILURE);
    }

    char buf1[30] = "str1";
    char buf1_length = strlen(buf1);
    char buf2[30] = "str2";
    char buf2_length = strlen(buf2);

    while(1) {

            ssize_t n;
            //write first string
            write(client_to_server, buf1, buf1_length);
            n = read(server_to_client, str, sizeof(str));
            if (n < 0) {
                    fprintf(stderr,
                            F("%s: %s(errno = %d)\n"),
                            myfifo2, strerror(errno), errno);
                    exit(EXIT_FAILURE);
            }
            if (n == 0) break;

            printf("...received from the server: %.*s\n", n, str);

            /* NO NEED TO CLEAN THE BUFFER */

            //write second string
            write(client_to_server, buf2, buf2_length);
    }

    close(client_to_server);
    close(server_to_client);

    return 0;
}