Короткий ответ: клиент и сервер получают «str2\0str1\0», но печатают только до первого \0, то есть «str2».

Длинный ответ на стороне клиента, который вы отправляете не только строки «str1» и «str2», но и завершающий NUL:

write(client_to_server, buf1, sizeof(buf1));

Здесь sizeof возвращает длину строки плюс завершающий NUL.

Теперь серверная часть. Вы читаете до BUFSIZ байт. Поэтому, если клиент достаточно быстр, чтобы отправить несколько строк, то есть «str2\0str1\0», вы прочитаете все строки за один раз. Чтобы исправить это, вы должны принять во внимание то, что возвращает чтение, то есть:

ssize_t ret = read(client_to_server, buf, BUFSIZ);
printf("Received: size %zd\n", ret); // print the size
fwrite(buf, 1, ret, stdout); // print the buffer with NULs
write(server_to_client,buf,ret); // write back just the data you actually received

Вы не проверяете наличие ошибок и не используете возвращаемое значение из read(2), которое говорит, сколько символов возвращается при чтении. Это странно, так как это источник несинхронизированного сервера и клиента. Я переписал ваш код таким образом, что он не дает сбоев (хотя я не проверяю возвращаемое значение write(2), которое должно давать сбой при разрыве каналов --- при убийстве сервера или клиента). Вам остается выполнить это, как упражнение.

Сосредоточьтесь на том, как строки, не заканчивающиеся нулем, обрабатываются вызовом printf(3), указав длину строки в формате "%.*s" (это уловка, позволяющая избежать помещения конечного \0 в буфер (который следует проверять, если вы читаете до sizeof buf вместо 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;
}

клиент.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;
}