#!/bin/bash
(nc -kl 192.168.2.100 2222) >> /tmp/myfifo &      # /tmp/myfifo is a named pipe
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done ) < /tmp/myfifo &

. script_test

nc 192.168.2.100 2222

nc -lk 192.168.2.100 2222

./script_test

#!/bin/bash
(nc -kl 192.168.2.100 2222) >> /tmp/myfifo &      # /tmp/myfifo is a named pipe
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done ) < /tmp/myfifo

#!/bin/bash
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done ) < /tmp/myfifo &
(nc -kl 192.168.2.100 2222) >> /tmp/myfifo &      # /tmp/myfifo is a named pipe

#!/bin/bash
(nc -kl 192.168.2.100 2222) >> /tmp/myfifo & disown     # /tmp/myfifo is a named pipe
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done ) < /tmp/myfifo & disown

#!/bin/bash
(nc -kl 192.168.2.100 2222) >> /tmp/myfifo &      # /tmp/myfifo is a named pipe
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done ) < /tmp/myfifo &
# according to bash manpage wait without arguments waits for all child processes
wait
# the next line was never reached in my tests
echo "The End"

#!/bin/bash

# This worked for me

(nc -dkl 127.0.0.1 2222) >> /tmp/myfifo &      # /tmp/myfifo is a named pipe
nc_pid=$!
( while true; do read in; if [ "$in" == "" ]; then continue; fi; echo "$in"; done) < /tmp/myfifo &
cat_fifo_pid=$!

trap 'kill $nc_pid $cat_fifo_pid' SIGTERM SIGINT

wait

#!/bin/bash

nc -d -l 127.0.0.1 2222 &
wait

#define _POSIX_C_SOURCE 1

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/select.h>


static void die_if(int cond, const char* name) {
    if (cond) {
        perror(name);
        exit(EXIT_FAILURE);
    }
}

/* return 1 on EOF, 0 otherwise */
static int send_from_to(int from_fd, int to_fd) {
    unsigned char* buffer[4096];

    int nread = read(from_fd, buffer, sizeof buffer);
    die_if(nread < 0, "read");
    if (nread == 0) return 1;

    int nwrote = write(to_fd, buffer, nread);
    die_if(nwrote < 0, "write");
    if (nwrote != nread) fprintf(stderr, "TODO: handle partial write\n");

    return 0;
}

static void send_recv_loop(int sockfd) {

    fd_set read_fds;

    for (;;) {
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);
        FD_SET(sockfd, &read_fds);

        int ready_fds = select(sockfd+1, &read_fds, NULL, NULL, NULL);
        die_if(ready_fds < 0, "select");

        if (FD_ISSET(STDIN_FILENO, &read_fds)) {
            if (send_from_to(STDIN_FILENO, sockfd)) {
                fprintf(stderr, "EOF on stdin\n");
                exit(EXIT_SUCCESS);
            }
        }

        if (FD_ISSET(sockfd, &read_fds)) {
            if (send_from_to(sockfd, STDOUT_FILENO)) {
                fprintf(stderr, "EOF on socket\n");
                break;
            }
        }
    }
}


int main(int argc, char** argv) {
    int server_mode = 0;
    int i = 1;
    int failed;

    if (argc > 1
        && (strcmp(argv[i], "-l") == 0 ||
            strcmp(argv[i], "-kl") == 0 ||
            strcmp(argv[i], "-lk") == 0))
    {
        server_mode = 1;
        i++;
    }

    if (argc < i + 2) {
        fprintf(stderr, "Usage: [-lk] <host> <port>\n");
        exit(EXIT_FAILURE);
    }

    const char* host = argv[i++];
    const char* port = argv[i++];

    struct addrinfo* ainfo = NULL;

    struct addrinfo hints;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    failed = getaddrinfo(host, port, NULL, &ainfo);
    if (failed) {
        fprintf(stderr, "getaddrinfo(%s, %s): %s\n",
            host, port, gai_strerror(failed));
        exit(EXIT_FAILURE);
    }

    int listen_fd = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
    die_if(listen_fd < 0, "socket");

    if (server_mode) {
        int truth = 1;
        failed = setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,
            &truth, sizeof truth);
        die_if(failed, "setsockopt");

        failed = bind(listen_fd, ainfo->ai_addr, ainfo->ai_addrlen);
        die_if(failed, "bind");

        for (;;) {
            failed = listen(listen_fd, 1);
            die_if(failed, "listen");

            int sockfd = accept(listen_fd, NULL, NULL);
            die_if(sockfd < 0, "accept");

            send_recv_loop(sockfd);
        }
    } else {
        failed = connect(listen_fd, ainfo->ai_addr, ainfo->ai_addrlen);
        die_if(failed, "connect");

        send_recv_loop(listen_fd);
    }

    return 0;
}