LinuxC 网络 -- TCP（C/S）多进程服务器demo

阻塞式IO + 多进程：每来一个客户端创建一个进程

nc -- 作为客户端

代码如下

TcpServer.h 文件：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>

#include <netinet/in.h> //描述网络的

#include <ctype.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <poll.h>

#include <fcntl.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>

#define PORT 5555

int tcp_server_create();
void set_nonblock(int cfd);
int read_nonblock(int cfd, char *message, size_t size);
int read_block(int cfd, char *message, size_t size);

TcpServer.c:

#include "tcp_server.h"

void set_nonblock(int cfd)
{
    int flags;
    flags = fcntl(cfd, F_GETFL);
    flags = flags | O_NONBLOCK; // 把 cfd 设置成非阻塞
    fcntl(cfd, F_SETFL, flags);
}

int tcp_server_create()
{
    signal(SIGPIPE, SIG_IGN);

    struct sockaddr_in s_addr;
    struct sockaddr_in c_addr;
    int sockfd;
    int cfd;
    socklen_t c_size;
    int i;

    // 启连接 加 SOCK_NONBLOCK accept 不会阻塞
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error");
        exit(1);
    }
    printf("success socket!\n");

    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    s_addr.sin_family = AF_INET;
    s_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    s_addr.sin_port = htons(PORT);

    if (bind(sockfd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in)) != 0)
    {
        perror("bind error");
        exit(1);
    }

    printf("bind successuful!\n");

    if (listen(sockfd, 20) != 0)
    {
        perror("listen error");
        exit(1);
    }
    printf("listen successuful!\n");

    return sockfd;
}

int read_nonblock(int cfd, char *message, size_t size)
{
    int r_n;
    while (r_n = read(cfd, message, size))
    {
        if (r_n < 0)
        {
            if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
            {
                perror("recv message error");
                exit(1);
            }

            continue;
        }

        if (r_n == 0)
        {
            printf("client is close!\n");
        }
        else
        {
            break;
        }

        return r_n;
    }
}

int read_block(int cfd, char *message, size_t size)
{
    int r_n;
    while (r_n = read(cfd, message, size))
    {
        if (r_n < 0)
        {
            perror("recv message error");
            exit(1);
        }
        if (r_n == 0)
        {
            printf("client is close!\n");
            return r_n;
        }
        else
        {
            break;
        }

        return r_n;
    }
}

fork_main.c

#include "tcp_server.h"  //阻塞式IO + 多进程
void conver_char(char *p)
{
    if (p == NULL)
    {
        return;
    }
    for (; *p != '\0'; p++)
    {
        if (*p >= 'a' && *p <= 'z')
        {
            *p = *p - 'a' + 'A';
        }
    }
}

void child_exit(int sig)
{
    waitpid(-1, NULL, 0);  //-1 ---- 可以等任意子进程， NULL ---- 不用返回状态，0 ---- 阻塞式的等
    printf("child is exit!\n");
}

void child_run(int cfd)
{
    char message[1024];
    while (1)
    {
        memset(message, 0, sizeof(message));
        if (read_block(cfd, message, sizeof(message)) == 0)
        {
            exit(1);
        }
        conver_char(message);
        write(cfd, message, strlen(message));
    }
}

int main(int argc, char const *argv[])
{
    int cfd;
    int sockfd;
    pid_t pid;

    socklen_t c_size;
    struct sockaddr_in s_addr;
    struct sockaddr_in c_addr;

    sockfd = tcp_server_create();
    set_nonblock(sockfd);
    char message[1024];

    signal(SIGCHLD, child_exit); // 子进程退出 会产生SIGCHLD信号

    while (1)
    {
        c_size = sizeof(struct sockaddr_in);
        cfd = accept(sockfd, (struct sockaddr *)&c_addr, &c_size);   // ---- 阻塞式等待新的客户端
        if (cfd < 0)
        {
            if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
            {
                perror("accept error");
                exit(1);
            }

            continue; // 返回while(1)
        }
        printf("info client: ip = %s port = %d\n", inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));

        if ((pid = fork()) < 0)
        {
            perror("fork error!");
            exit(1);
        }
        if (pid == 0)
        {
            // 读已连接客户端的信息 
            child_run(cfd);
        }
        else if (pid > 0) // 父进程专门相应客户端请求
        {
            close(cfd);

            //shutdown --- 会关闭所有的cfd
        }
    }
    return 0;
}

运行结果如下：

TCP + 多进程 进程的优缺点：

优点：

        编程相对简单，不用考虑线程间的数据同步等、服务器健壮。

缺点：

        1、资源消耗大。启动一个进程消耗相对比启动一个线程要消耗大很多，同时在处理很多的连接时候需要启动很多的进程多去处理

        2、系统的进程数限制也需要考虑