Прием многих входящих соединений по TCP

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/time.h>
#include <locale.h>
 
/* константы */
#define LISTEN_PORT    12345
#define LISTEN_BACKLOG 8
static int listen_sock;
/* ====================200================================================== */
/* обработчик SIGCHLD                                                     */
/* ====================================================================== */
void sigchld_handler(int signum)
{
    int pid, status, old_errno;
 
    /* сохранить текущее значение errno */
    old_errno = errno;
 
    /* обработка всех завершившихся на текущий момент процессов */
    while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
 
        /* обработка возможной ошибки */
        /* ignore ECHILD because we can get it when atexit() with waitpid() */
        /* was set and race between two waitpid()'s occur */
        if (pid == -1) {
            if (errno != ECHILD) {
                perror("waitpid");
                exit(EXIT_FAILURE);
            }
            break;
        }
 
        /* printf() в обработчике сигнала - плохо */
//        print_status(pid, status);
    }
 
    /* восстановить старое значение errno */
    errno = old_errno;
}
 
/* ====================================================================== */
/* обработчик SIGINT                                                      */
/* см. документацию libc, Signal Handling,                                */
/* Defining Handlers, Termination in Handler                              */
/* ====================================================================== */
void sigint_handler(int s)
{
 
    /* закрыть сокет без проверки результата т.к. сигнал может поступить */
    /* повторно когда сокет уже закрыт но выполнение еще не завершилось  */
    (void) close(listen_sock);
 
    /* printf() в обработчике сигнала - плохо */
    printf("выполнение завершается в связи с получением SIGINT\n");
 
    /* восстановить реакцию на сигнал по умолчанию (завершение) */
    /* и повторить отправку сигнала (таким образом, в статусе   */
    /* завершения, который получит родительский процесс, будет  */
    /* видно, по какой причине (получение сигнала) завершился   */
    /* текущий процесс                                          */
    signal(s, SIG_DFL);
    raise(s);
}
 
int main(int argc, char *argv[])
{
    //int listen_sock;
    int accept_sock;
    struct sockaddr_in listen_name, accept_name;
    socklen_t accept_len;
    struct sigaction sa;
    int pid;
    struct timeval t;
    struct tm *tmp;
    char buffer[1024];
    int len;
    int n;
 
    /* установить обработчик сигнала SIGCHLD */
    /* We're only interested in children that have terminated, not ones */
    /* which have been stopped (eg user pressing control-Z at terminal) */
    sigemptyset(&sa.sa_mask);
    sa.sa_handler = sigchld_handler;
    sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }
 
    /* установить обработчик сигнала SIGINT */
    sigemptyset(&sa.sa_mask);
    sa.sa_handler = sigint_handler;
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }
 
 
 
    /* Создать сокет, семейство протоколов Internet, с соединением */
    /* Протокол выбирается автоматически (TCP) */
    if ((listen_sock = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
    }
 
    /* Заполнить структуру данных с адресом сокета */
    /* Сокет будет привязан ко всем доступным интерфейсам */
    /* и номеру порта LISTEN_PORT */
    memset(&listen_name, 0, sizeof(listen_name));
    listen_name.sin_family = AF_INET;
    listen_name.sin_addr.s_addr = htonl(INADDR_ANY);
    listen_name.sin_port = htons(LISTEN_PORT);
 
    /* Назначить сокету адрес из только что заполненной */
    /* структуры данных listen_name */
    if (bind(listen_sock, (struct sockaddr *) (&listen_name),
         sizeof(struct sockaddr_in)) == -1) {
    perror("bind");
    exit(EXIT_FAILURE);
    }
 
    /* Включить прием входящих соединений */
    /* Максимальная длина очереди входящих соединений - LISTEN_BACKLOG */
    if (listen(listen_sock, LISTEN_BACKLOG) == -1) {
    perror("listen");
    exit(EXIT_FAILURE);
    }
    while(1) {
    /* Принимать соединения */
    /* Завершение работы программы - по сигналу SIGINT */
    /* (в обработчике сигнала SIGINT) или при ошибке accept() */
    accept_len = sizeof(accept_name);
    printf("для завершения работы нажмите Ctrl-C\n");
    while ((accept_sock = accept(listen_sock,
                 (struct sockaddr *) (&accept_name),
                 &accept_len)) != -1) {
 
    /* вывод сведений о поступившем соединении */
    printf("принято входящее соединение с адреса %s порта %d\n",
           inet_ntoa(accept_name.sin_addr),
           ntohs(accept_name.sin_port));
 
    /* порождение процесса, в котором будет обрабатываться */
    /* поступившее соединение */
    switch (pid = fork()) {
 
        /* потомок */
        case 0://???????????????????????????????????????????? 
 
        /* сокет для приема входящих соединений в потомке не нужен */
        if (close(listen_sock) == -1) {
        perror("close");
        exit(EXIT_FAILURE);
        }
        /* Вывод на экран принятого сообщения */
        while(0 <(n = read(accept_sock, buffer, 1024))) {
 
        if (write(STDOUT_FILENO, buffer, n) != n) {
            fprintf(stderr, "Ошибка записи: %s\n",
                strerror(errno));
            exit(EXIT_FAILURE);
        }
        }
        if(n==0){printf("Coединение закрыто!\n");}
        exit(EXIT_SUCCESS);
        /* недостижимо */
        break;
 
        /* ошибка */
    case -1:
        perror("fork");
        exit(EXIT_FAILURE);
        /* тоже недостижимо */
        break;
 
        /* родитель */
    default:
        printf("порожден процесс с идентификатором %d\n", pid);
    }
 
    /* закрыть сокет поступившего соединения */
    /* т.к. в родителе он не нужен */
    if (close(accept_sock) == -1) {
        perror("close");
        exit(EXIT_FAILURE);
    }
    }
 }
    /* выход из цикла возможен только при ошибке accept() */
    /* вывести сообщение об ошибке, закрыть сокет, созданный */
    /* для приема входящих соединений и завершить работу */
    perror("accept");
    if (close(listen_sock) == -1) {
    perror("close");
    exit(EXIT_FAILURE);
    }
    return 1;
 
    /* После завершения данного процесса порожденные им процессы */
    /* (по одному на каждое соединение) останутся сиротами (orphans) */
    /* и станут детьми корневого процесса с process id 1 (init) */
}