TCP 通信程序示例——实现一个服务器连接多个客户端

tcp_fork

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <signal.h>
#include <sys/wait.h>

// 定义一个类型别名,方便后续使用
typedef struct sockaddr* (SA);

// 信号处理函数,用于处理子进程结束的信号
void handle(int num)
{
    // 等待子进程结束,防止产生僵尸进程
    wait(NULL);
}

int main(int argc, char *argv[])
{
    // 注册信号处理函数,当收到 SIGCHLD 信号时,调用 handle 函数
    signal(SIGCHLD, handle);

    // 创建监听套接字
    int listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        // 如果创建失败,打印错误信息并退出程序
        perror("socket");
        exit(1);
    }

    // 定义服务器地址结构体和客户端地址结构体,并初始化为 0
    struct sockaddr_in ser, cli;
    bzero(&ser, sizeof(ser));
    bzero(&cli, sizeof(cli));

    // 设置服务器地址结构体的参数
    ser.sin_family = AF_INET; // 设置地址族为 IPv4
    ser.sin_port = htons(50000); // 设置端口号为 50000,并转换为网络字节序
    ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址

    // 设置套接字选项,允许地址和端口重用
    int on = 1;
    setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));

    // 将监听套接字与服务器地址绑定
    int ret = bind(listfd, (SA)&ser, sizeof(ser));
    if (-1 == ret)
    {
        // 如果绑定失败,打印错误信息并退出程序
        perror("bind");
        exit(1);
    }

    // 开始监听连接请求,设置排队连接数为 3
    listen(listfd, 3);

    // 客户端地址结构体的长度
    socklen_t len = sizeof(cli);

    while (1)
    {
        // 接受客户端连接请求,返回通讯套接字
        int conn = accept(listfd, (SA)&cli, &len);
        if (-1 == conn)
        {
            // 如果接受连接失败,打印错误信息并继续循环
            perror("accept");
            // exit(1);
            continue;
        }

        // 创建子进程
        pid_t pid = fork();
        if (0 == pid)
        {
            // 子进程执行的代码
            while (1)
            {
                // 关闭监听套接字,因为子进程不需要它
                close(listfd);
                char buf[512] = {0};
                // 从通讯套接字接收数据
                int rd_ret = recv(conn, buf, sizeof(buf), 0);
                if (rd_ret <= 0)
                {
                    // 如果接收数据失败或客户端断开连接,打印提示信息并关闭通讯套接字,退出子进程
                    printf("cli off line\n");
                    close(conn);
                    // break;
                    exit(1);
                }
                // 打印接收到的客户端数据
                printf("cli:%s\n", buf);
                time_t tm;
                // 获取当前时间
                time(&tm);
                // 将客户端数据和时间格式化后存入 buf 中
                sprintf(buf, "%s %s", buf, ctime(&tm));
                // 将 buf 中的数据发送回客户端
                send(conn, buf, strlen(buf), 0);
            }
        }
        else if (pid > 0)
        {
            // 父进程执行的代码,关闭通讯套接字
            close(conn);
        }
        else
        {
            // 如果 fork 失败,打印提示信息并继续循环
            printf("fork");
            continue;
        }
    }
    // 关闭监听套接字
    close(listfd);
    return 0;
}

这段代码实现了一个简单的 TCP 服务器,它在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时,服务器会创建一个子进程来处理与该客户端的通信。子进程会接收客户端发送的数据,并在数据后加上当前时间后发送回客户端。同时,服务器还注册了一个信号处理函数来处理子进程结束的信号,以防止产生僵尸进程。

tcp_pthread

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>

// 定义一个类型别名,方便后续使用
typedef struct sockaddr* (SA);

// 线程函数,用于处理与客户端的通信
void* th(void* arg)
{
    // 将当前线程设置为分离状态,无需主线程进行连接
    pthread_detach(pthread_self());
    int conn =* (int*)arg;
    //sem_post();
    while (1)
    {
        char buf[512] = {0};
        // 从通讯套接字接收数据
        int rd_ret = recv(conn, buf, sizeof(buf), 0);
        if (rd_ret <= 0)
        {
            // 如果接收数据失败或客户端断开连接,打印提示信息并关闭通讯套接字,退出线程
            printf("cli off line\n");
            close(conn);
            break;
        }
        // 打印接收到的客户端数据
        printf("cli:%s\n", buf);
        time_t tm;
        // 获取当前时间
        time(&tm);
        // 将客户端数据和时间格式化后存入 buf 中
        sprintf(buf, "%s %s", buf, ctime(&tm));
        // 将 buf 中的数据发送回客户端
        send(conn, buf, strlen(buf), 0);
    }

    return NULL;
}

int main(int argc, char *argv[])
{
    // 创建监听套接字
    int listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        // 如果创建失败,打印错误信息并退出程序
        perror("socket");
        exit(1);
    }

    // 定义服务器地址结构体和客户端地址结构体,并初始化为 0
    struct sockaddr_in ser, cli;
    bzero(&ser, sizeof(ser));
    bzero(&cli, sizeof(cli));

    // 设置服务器地址结构体的参数
    ser.sin_family = AF_INET; // 设置地址族为 IPv4
    ser.sin_port = htons(50000); // 设置端口号为 50000,并转换为网络字节序
    ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址

    // 设置套接字选项,允许地址和端口重用
    int on = 1;
    setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));

    // 将监听套接字与服务器地址绑定
    int ret = bind(listfd, (SA)&ser, sizeof(ser));
    if (-1 == ret)
    {
        // 如果绑定失败,打印错误信息并退出程序
        perror("bind");
        exit(1);
    }

    // 开始监听连接请求,设置排队连接数为 3
    listen(listfd, 3);

    // 客户端地址结构体的长度
    socklen_t len = sizeof(cli);

    while (1)
    {
        // 接受客户端连接请求,返回通讯套接字
        int conn = accept(listfd, (SA)&cli, &len);
        if (-1 == conn)
        {
            // 如果接受连接失败,打印错误信息并继续循环
            perror("accept");
            // exit(1);
            continue;
        }

        pthread_t tid;
        // 创建一个新线程来处理与客户端的通信
        pthread_create(&tid, NULL, th, &conn);
        //sem_wait();
        // join();
        // 确保 th 中,把 conn 保存到局部变量中
        usleep(1000 * 5);
    }
    // 关闭监听套接字
    close(listfd);
    return 0;
}

这段代码实现了一个多线程的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时,服务器会创建一个新线程来处理与该客户端的通信。每个线程独立地与对应的客户端进行交互,接收客户端发送的数据,并在数据后加上当前时间后发送回客户端。

主要步骤如下:

  1. 创建监听套接字,并设置服务器地址和端口等参数。
  2. 允许地址和端口重用。
  3. 绑定监听套接字到服务器地址。
  4. 开始监听连接请求。
  5. 在循环中,接受客户端连接请求。
  6. 为每个连接创建一个新线程,传入连接套接字的指针作为参数。
  7. 新线程在分离状态下运行,处理与客户端的通信。
  8. 主线程继续接受新的连接请求。

tcp_select

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
/* According to POSIX.1-2001, POSIX.1-2008 */
#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

// 定义一个类型别名,方便后续使用
typedef struct sockaddr* (SA);

int main(int argc, char *argv[])
{
    // 创建监听套接字
    int listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        // 如果创建失败,打印错误信息并退出程序
        perror("socket");
        exit(1);
    }

    // 定义服务器地址结构体和客户端地址结构体,并初始化为 0
    struct sockaddr_in ser, cli;
    bzero(&ser, sizeof(ser));
    bzero(&cli, sizeof(cli));

    // 设置服务器地址结构体的参数
    ser.sin_family = AF_INET; // 设置地址族为 IPv4
    ser.sin_port = htons(50000); // 设置端口号为 50000,并转换为网络字节序
    ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址

    // 设置套接字选项,允许地址和端口重用
    int on = 1;
    setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));

    // 将监听套接字与服务器地址绑定
    int ret = bind(listfd, (SA)&ser, sizeof(ser));
    if (-1 == ret)
    {
        // 如果绑定失败,打印错误信息并退出程序
        perror("bind");
        exit(1);
    }

    // 开始监听连接请求,设置排队连接数为 3
    listen(listfd, 3);

    // 客户端地址结构体的长度
    socklen_t len = sizeof(cli);

    // 1. 创建文件描述符集合
    fd_set rd_set, tmp_set;
    FD_ZERO(&rd_set); // 清空读集合
    FD_ZERO(&tmp_set); // 清空临时集合

    // 2. 将监听套接字添加到临时集合
    FD_SET(listfd, &tmp_set);

    // 记录当前最大的文件描述符
    int maxfd = listfd;

    while (1)
    {
        // 复制临时集合到读集合,用于 select 调用
        rd_set = tmp_set;

        // 使用 select 函数监控文件描述符集合中的读事件
        select(maxfd + 1, &rd_set, NULL, NULL, NULL);

        int i = 0;
        // 遍历所有可能的文件描述符
        for (i = 0; i < maxfd + 1; i++)
        {
            // 如果当前文件描述符在读集合中被置位,并且是监听套接字
            if (FD_ISSET(i, &rd_set) && i == listfd)
            {
                // 接受客户端连接请求,返回通讯套接字
                int conn = accept(listfd, (SA)&cli, &len);
                if (-1 == conn)
                {
                    // 如果接受连接失败,打印错误信息并继续循环
                    perror("accept");
                    // exit(1);
                    continue;
                }

                // 将新的连接套接字添加到临时集合
                FD_SET(conn, &tmp_set);

                // 更新最大文件描述符
                if (conn > maxfd)
                    maxfd = conn;
            }
            // 如果当前文件描述符在读集合中被置位,并且不是监听套接字
            if (FD_ISSET(i, &rd_set) && i!= listfd)
            {
                int conn = i;
                char buf[512] = {0};
                // 从通讯套接字接收数据
                int rd_ret = recv(conn, buf, sizeof(buf), 0);
                if (rd_ret <= 0)
                {
                    // 如果接收数据失败或客户端断开连接,从临时集合中清除该套接字,并关闭连接
                    FD_CLR(conn, &tmp_set);
                    close(conn);
                    printf("cli offline\n");
                    break;
                }
                // 打印接收到的客户端数据(注释掉了)
                //printf("cli:%s\n", buf);
                time_t tm;
                // 获取当前时间
                time(&tm);
                // 将客户端数据和时间格式化后存入 buf 中
                sprintf(buf, "%s %s", buf, ctime(&tm));
                // 将 buf 中的数据发送回客户端
                send(conn, buf, strlen(buf), 0);
            }
        }
    }
    // 关闭监听套接字
    close(listfd);
    return 0;
}

这段代码实现了一个基于select函数的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。

主要步骤如下:

  1. 创建监听套接字,并设置服务器地址和端口等参数。
  2. 允许地址和端口重用。
  3. 绑定监听套接字到服务器地址。
  4. 开始监听连接请求。
  5. 创建文件描述符集合,将监听套接字添加到集合中,并记录最大文件描述符。
  6. 在循环中,使用select函数监控文件描述符集合中的读事件。
  7. 如果监听套接字有可读事件,接受客户端连接请求,并将新的连接套接字添加到集合中,更新最大文件描述符。
  8. 如果其他套接字有可读事件,接收数据,处理数据(加上时间戳后发送回客户端),如果连接断开,从集合中清除该套接字并关闭连接。

tcp_epoll

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/epoll.h>

// 定义一个类型别名,方便后续使用
typedef struct sockaddr* (SA);

// 向 epoll 实例添加文件描述符的函数
int add_fd(int epfd, int fd)
{
    struct epoll_event ev;
    ev.events = EPOLLIN; // 关注读事件
    ev.data.fd = fd;
    int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    if (-1 == ret)
    {
        perror("add fd");
    }
    return ret;
}

// 从 epoll 实例删除文件描述符的函数
int del_fd(int epfd, int fd)
{
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = fd;
    int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
    if (-1 == ret)
    {
        perror("add fd");
    }
    return ret;
}

int main(int argc, char *argv[])
{
    // 创建监听套接字
    int listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        // 如果创建失败,打印错误信息并退出程序
        perror("socket");
        exit(1);
    }

    // 定义服务器地址结构体和客户端地址结构体,并初始化为 0
    struct sockaddr_in ser, cli;
    bzero(&ser, sizeof(ser));
    bzero(&cli, sizeof(cli));

    // 设置服务器地址结构体的参数
    ser.sin_family = AF_INET; // 设置地址族为 IPv4
    ser.sin_port = htons(50000); // 设置端口号为 50000,并转换为网络字节序
    ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址

    // 设置套接字选项,允许地址和端口重用
    int on = 1;
    setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));

    // 将监听套接字与服务器地址绑定
    int ret = bind(listfd, (SA)&ser, sizeof(ser));
    if (-1 == ret)
    {
        // 如果绑定失败,打印错误信息并退出程序
        perror("bind");
        exit(1);
    }

    // 开始监听连接请求,设置排队连接数为 3
    listen(listfd, 3);

    // 客户端地址结构体的长度
    socklen_t len = sizeof(cli);

    struct epoll_event rev[10] = {0};
    // 1. 创建 epoll 实例
    int epfd = epoll_create(10);
    if (-1 == epfd)
    {
        // 如果创建失败,打印错误信息并返回
        perror("epoll_create");
        return 1;
    }
    // 2. 将监听套接字添加到 epoll 实例
    add_fd(epfd, listfd);

    while (1)
    {
        // 3. 等待事件发生
        int ep_ret = epoll_wait(epfd, rev, 10, -1);
        int i = 0;
        // 4. 查找有事件的文件描述符并处理
        for (i = 0; i < ep_ret; i++)
        {
            if (rev[i].data.fd == listfd)
            {
                // 如果是监听套接字有事件,表示有新的连接请求
                int conn = accept(listfd, (SA)&cli, &len);
                if (-1 == conn)
                {
                    // 如果接受连接失败,打印错误信息并继续循环
                    perror("accept");
                    continue;
                }
                // 将新的连接套接字添加到 epoll 实例
                add_fd(epfd, conn);
            }
            else
            {
                int conn = rev[i].data.fd;
                char buf[512] = {0};
                // 从连接套接字接收数据
                int rd_ret = recv(conn, buf, sizeof(buf), 0);
                if (rd_ret <= 0)
                {
                    // 如果接收数据失败或客户端断开连接,从 epoll 实例中删除该套接字,并关闭连接
                    del_fd(epfd, conn);
                    close(conn);
                    break;
                }
                time_t tm;
                // 获取当前时间
                time(&tm);
                // 将客户端数据和时间格式化后存入 buf 中
                sprintf(buf, "%s %s", buf, ctime(&tm));
                // 将 buf 中的数据发送回客户端
                send(conn, buf, strlen(buf), 0);
            }
        }
    }
    // 关闭监听套接字
    close(listfd);
    return 0;
}

这段代码实现了一个基于epoll的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。

主要步骤如下:

  1. 创建监听套接字,并设置服务器地址和端口等参数。
  2. 允许地址和端口重用。
  3. 绑定监听套接字到服务器地址。
  4. 开始监听连接请求。
  5. 创建epoll实例。
  6. 将监听套接字添加到epoll实例中。
  7. 在循环中,使用epoll_wait等待事件发生。
  8. 当有事件发生时,检查是监听套接字还是连接套接字的事件。如果是监听套接字的事件,接受新的连接请求,并将新的连接套接字添加到epoll实例中。如果是连接套接字的事件,接收数据,处理数据(加上时间戳后发送回客户端),如果连接断开,从epoll实例中删除该套接字并关闭连接。

服务端

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/time.h>

// 定义一个类型别名,方便后续使用
typedef struct sockaddr* (SA);

int main(int argc, char *argv[])
{
    // 创建客户端套接字
    int conn = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == conn)
    {
        // 如果创建失败,打印错误信息并退出程序
        perror("socket");
        exit(1);
    }

    // 定义服务器地址结构体,并初始化为 0
    struct sockaddr_in ser;
    bzero(&ser, sizeof(ser));
    // 设置地址族为 IPv4
    ser.sin_family = AF_INET;
    // 设置端口号为 50000,并转换为网络字节序
    ser.sin_port = htons(50000);
    // 设置服务器 IP 地址为本地回环地址
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 连接到服务器
    int ret = connect(conn, (SA)&ser, sizeof(ser));
    if (-1 == ret)
    {
        // 如果连接失败,打印错误信息并退出程序
        perror("connect");
        exit(1);
    }

    int i = 5;
    // 设置超时时间结构体
    struct timeval tv;
    tv.tv_sec = 3;  // 秒数为 3
    tv.tv_usec = 0; // 微秒数为 0
    // 设置套接字接收超时时间
    setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 

    while (1)
    {
        // 发送数据给服务器
        char buf[512]="hello,this tcp test";
        send(conn, buf, strlen(buf), 0);
        bzero(buf, sizeof(buf));
        // 从服务器接收数据
        int ret = recv(conn, buf, sizeof(buf), 0);
        if (ret == 0)
        {
            // 如果接收返回 0,表示服务器关闭连接
            printf("ser close\n");
            break;
        }
        if (ret <= 0)
        {
            // 如果接收返回小于等于 0,表示接收失败或超时
            printf("time out,contineu\n");
        }
        // 打印接收到的服务器数据
        printf("ser:%s\n", buf);
        // 睡眠 1 秒
        sleep(1);
    }
    // 关闭客户端套接字
    close(conn);
    return 0;
}

这段代码实现了一个简单的 TCP 客户端。它连接到本地回环地址的 50000 端口上的服务器,发送数据并接收服务器的响应。同时,设置了接收超时时间为 3 秒,如果在 3 秒内没有接收到数据,就会打印超时信息并继续循环。客户端会不断发送数据、接收响应并打印,直到服务器关闭连接。

相关推荐
FeelTouch Labs9 分钟前
Netty实现WebSocket Server是否开启压缩深度分析
网络·websocket·网络协议
霍格沃兹测试开发学社测试人社区15 分钟前
软件测试学习笔记丨Flask操作数据库-数据库和表的管理
软件测试·笔记·测试开发·学习·flask
今天我又学废了31 分钟前
Scala学习记录,List
学习
颇有几分姿色37 分钟前
深入理解 Linux 内存管理:free 命令详解
linux·运维·服务器
王俊山IT1 小时前
C++学习笔记----10、模块、头文件及各种主题(一)---- 模块(5)
开发语言·c++·笔记·学习
AndyFrank1 小时前
mac crontab 不能使用问题简记
linux·运维·macos
筱源源1 小时前
Kafka-linux环境部署
linux·kafka
千天夜2 小时前
使用UDP协议传输视频流!(分片、缓存)
python·网络协议·udp·视频流
EricWang13582 小时前
[OS] 项目三-2-proc.c: exit(int status)
服务器·c语言·前端
我是谁??2 小时前
C/C++使用AddressSanitizer检测内存错误
c语言·c++