实现并发 回声服务器

#include <bits/stdc++.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/socket.h>
using namespace std;
const int BUF_SIZE = 1024;
void error_handing(char *messages);
void read_childproc(int sig);
int main(int argc, char *argv[])
{

    if (argc != 2)
    {
        cout << "Usage : " << argv[0] << " <IP> <port>" << endl;
        exit(1);
    }
    char messages[BUF_SIZE];
    int serv_sock, clnt_sock, state;
    struct sockaddr_in serv_adr, clnt_adr;

    pid_t pid;
    struct sigaction act;
    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    state = sigaction(SIGCHLD, &act, 0);

    serv_sock = socket(PF_INET, SOCK_STREAM, 0);

    if (serv_sock == -1)
    {
        error_handing("sock() error!");
    }

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
    {
        error_handing("bind() error");
    }
    if (listen(serv_sock, 5) == -1)
    {
        error_handing("listen() error");
    }
    else
    {
        puts("Connect.....");
    }
    socklen_t clnt_adr_sz = sizeof(clnt_adr);
    int str_len;
    for (int i = 0; i < 5; i++)
    {
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        if (clnt_sock == -1)
        {
            continue;
        }
        else
        {
            puts("new client connected...");
        }
        pid = fork();
        if (pid == -1)
        {
            close(clnt_sock);
            continue;
        }
        if (pid == 0) /*子进程运行区域*/
        {
            close(serv_sock);
            while ((str_len = read(clnt_sock, messages, BUF_SIZE)) != 0)
                write(clnt_sock, messages, str_len);

            close(clnt_sock);
            puts("client disconnected...");
            return 0;
        }
        else
        {
            close(clnt_sock);
        }
    }
    close(serv_sock);
    return 0;
}
void error_handing(char *messages)
{
    cout << messages << endl;
    exit(1);
}
void read_childproc(int sig)
{
    pid_t pid;
    int status;
    pid = waitpid(-1, &status, WNOHANG);
    cout << "removed proc id : " << pid << endl;
    return;
}      

#include <bits/stdc++.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
using namespace std;
const int BUF_SIZE = 1024;
void error_handing(char *messages);
void read_routine(int sock, char *buf);
void write_routine(int sock, char *buf);
//int fds[2];
int main(int argc, char *argv[])
{
    char buf[BUF_SIZE];
    if (argc != 3)
    {
        cout << "Usage : " << argv[0] << " <IP> <port>" << endl;
        exit(1);
    }
    int sock;
    sock = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serv_adr;
    if (sock == -1)
    {
        error_handing("socket() error");
    }

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));

    if (connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
    {
        error_handing("connect() error");
    }
    else
    {
        puts("connect.....");
    }
    //pipe(fds);
    pid_t pid = fork();
    if (pid == 0)
    {
        write_routine(sock, buf);
    }
    else
    {
        read_routine(sock, buf);
    }
    close(sock);

    return 0;
}
void error_handing(char *messages)
{
    cout << messages << endl;
    exit(1);
}
void read_routine(int sock, char *buf)
{

    //cout << str_len << endl;
    while (1)
    {
        int str_len = read(sock, buf, BUF_SIZE);
        if (str_len == 0)
            return;
        buf[str_len] = 0;

        cout << "Output :" << buf << endl;
    }
}
void write_routine(int sock, char *buf)
{
    while (1)
    {
        //cout << "Please Input buf:" << endl;
        cin >> buf;

        if (!strcmp(buf, "q") || !strcmp(buf, "Q"))
        {
            shutdown(sock, SHUT_WR);
            return;
        }
        write(sock, buf, strlen(buf));
    }
}