一个Linux下的TCP服务2

最新推荐文章于 2024-08-11 18:26:55 发布
最新推荐文章于 2024-08-11 18:26:55 发布
阅读量191 收藏
点赞数
文章标签： linux epoll socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_cppcoder/article/details/109107981
版权
该博客介绍了如何利用epoll的ET模式和多路复用技术优化Linux下的TCP服务。代码示例展示了如何创建服务器和客户端，通过编译参数控制服务端或客户端行为，并能指定客户端数量。程序处理包括连接、读写和错误处理等功能，实现了高效的数据交换。
摘要由CSDN通过智能技术生成

        为了优化 <一个Linux下的TCP服务1> 的效率, 本篇用epoll多路IO复用技术, 并设置ET模式, 文件名为epoll.c.

        该文件不仅包含了服务端代码, 还包含客户端代码, 这可以通过编译参数COMPILE_SERVER来控制. 同时可以指定客户端数量, 具体代码如下:

// epoll.c

#include <sys/epoll.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>

int setNonblock(int fd) 
{
        int flags = 0;
        if ((flags = fcntl(fd, F_GETFL)) == -1) 
        {
                return -1;
        }
                
        flags |= O_NONBLOCK;
        if (fcntl(fd, F_SETFL, flags) == -1) 
        {
                return -1;
        }
        return 0;
}

int addFD(int efd, int fd, int mode)
{
        struct epoll_event event;
        event.events = mode;
        event.data.fd = fd;
        return epoll_ctl(efd, EPOLL_CTL_ADD, fd, &event);
}

int epollETAdd(int efd, int fd, int mode)
{
        return setNonblock(fd) | addFD(efd, fd, mode);      
}

void epollETDel(int efd, int fd)
{
        close(fd);
        epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
}

void epollETModifyMode(int efd, int fd, int mode)
{
        struct epoll_event event;
        event.events = mode;
        event.data.fd = fd;
        epoll_ctl(efd, EPOLL_CTL_MOD, fd, &event);
}

void connFunc(int efd, int fd)
{
        int connFD = accept(fd, NULL, NULL);
        if (connFD == -1) 
        {
                return;
        }
        epollETAdd(efd, connFD, EPOLLIN | EPOLLET);
}

void readFunc(int efd, int fd)
{
        char buf[32];
        memset(buf, 0x00, sizeof(buf));

        int readLen = read(fd, buf, sizeof(buf));
        if (readLen == -1)
        {
                if (errno == EAGAIN)
                {}
                else
                {
                        printf("Something wrong with read.\n");
                        epollETDel(efd, fd);
                }
                return;
        }
        else if (readLen == 0) 
        {
                printf("Remote unregister.\n");
                epollETDel(efd, fd);
                return;
        }

#ifndef COMPILE_SERVER
        printf("Client recv msg: %s\n", buf);
#else 
        printf("Server recv msg: %s\n", buf);
#endif
        epollETModifyMode(efd, fd, EPOLLOUT | EPOLLET);
}

void writeFunc(int efd, int fd)
{
        char *buf;
#ifndef COMPILE_SERVER
        buf = "ping";
        printf("Client write msg: %s\n", buf);
#else
        buf = "pong";
        printf("Server write msg: %s\n", buf);
#endif
        write(fd, buf, strlen(buf));
        epollETModifyMode(efd, fd, EPOLLIN | EPOLLET);        
}

void errFunc(int efd, int fd)
{
        printf("Something wrong with epoll_wait.\n");
        epollETDel(efd, fd);        
}

int binding(char *ip, int port, int sfd)
{
        struct sockaddr_in addr;
        memset(&addr, 0x00, sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip);
        return bind(sfd, (struct sockaddr*)(void*)(&addr), sizeof(struct sockaddr_in));
}

int connecting(char *ip, int port, int sfd)
{
        struct sockaddr_in addr;
        memset(&addr, 0x00, sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip);
        return connect(sfd, (struct sockaddr*)(void*)(&addr), sizeof(struct sockaddr_in));
}

int socketing(char *ip, int port)
{
        int sfd = 0, val = 0;
        if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        {
                printf("socket, errMsg: %s.\n", strerror(errno));
                return -1;
        }

#ifndef COMPILE_SERVER
        if (connecting(ip, port, sfd) == -1)
        {
                printf("connecting failed.\n");
                goto FAIELD;                
        }
#else
        if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int)) == -1)
        {
                printf("set SO_REUSEADDR failed, errMsg: %s.\n", strerror(errno));
                goto FAIELD;         
        }

        if (binding(ip, port, sfd) == -1)
        {
                printf("bind failed, errMsg: %s.\n", strerror(errno));
                goto FAIELD;
        }

        if (listen(sfd, 512) == -1)
        {
                printf("listen failed, errMsg: %s.\n", strerror(errno));
                goto FAIELD; 
        }
#endif

        return sfd;
FAIELD:
        close(sfd);
        return -1;
}

int Server(char *ip, int port)
{
        int epollFD = 0, sockFD = 0;
        struct epoll_event activeEvents[1024];

        if ((epollFD = epoll_create(1024)) == -1)
        {
                return -1; 
        }

        if ((sockFD = socketing(ip, port)) == -1)
        {
                close(epollFD);
                return -1;
        }

        if (epollETAdd(epollFD, sockFD, EPOLLIN | EPOLLET) == -1)
        {
                close(epollFD);
                close(sockFD);
                return -1;                 
        }
        printf("Epoll server start success.\n");

        for(;;)
        {
                int count = epoll_wait(epollFD, activeEvents, 1024, -1);
                if (count == -1) 
                {
                        printf("epoll_wait failed, errMsg: %s.\n", strerror(errno));
                        continue;
                }

                for (int index = 0; index < count; ++index) 
                {
                        int tmpFD = activeEvents[index].data.fd;
                        if (tmpFD == sockFD) 
                        {
                                connFunc(epollFD, tmpFD);
                        }
                        else if(activeEvents[index].events & EPOLLIN)
                        {
                                readFunc(epollFD, tmpFD);
                        }
                        else if (activeEvents[index].events & EPOLLOUT)
                        {
                                writeFunc(epollFD, tmpFD);
                        }
                        else 
                        {
                                errFunc(epollFD, tmpFD);
                        }
                }
        }

        close(epollFD);
        close(sockFD);
        return 0;
}

int Client(char *ip, int port, int nums)
{
        int epollFD = 0, sockFD = 0;
        struct epoll_event activeEvents[1024];

        if ((epollFD = epoll_create(1024)) == -1)
        {
                return -1; 
        }

        for (int i = 0; i < nums; ++i)
        {
                if ((sockFD = socketing(ip, port)) == -1)
                {
                        close(epollFD);
                        return -1;
                }

                if (epollETAdd(epollFD, sockFD, EPOLLOUT | EPOLLET) == -1)
                {
                        close(epollFD);
                        close(sockFD);
                        return -1;                 
                }
        }
        printf("Epoll client start success.\n");

        for(;;)
        {
                int count = epoll_wait(epollFD, activeEvents, 1024, -1);
                if (count == -1) 
                {
                        printf("epoll_wait failed, errMsg: %s.\n", strerror(errno));
                        continue;
                }

                for (int index = 0; index < count; ++index) 
                {
                        int tmpFD = activeEvents[index].data.fd;
                        if(activeEvents[index].events & EPOLLIN)
                        {
                                readFunc(epollFD, tmpFD);
                        }
                        else if (activeEvents[index].events & EPOLLOUT)
                        {
                                writeFunc(epollFD, tmpFD);
                        }
                        else 
                        {
                                errFunc(epollFD, tmpFD);
                        }
                }
        }

        close(epollFD);
        close(sockFD);
        return 0;
}

int main(int argc, char *argv[])
{

#ifndef COMPILE_SERVER
        if (argc != 4)
        {
                printf("argc != 4; [client: ./a.out ip port nums]\n");
                return -1;
        }
        Client(argv[1], atoi(argv[2]), atoi(argv[3]));
#else 
        if (argc != 3)
        {
                printf("argc != 3; [server: ./a.out ip port]\n");
                return -1;
        }
        Server(argv[1], atoi(argv[2]));
#endif

        return 0;
}

        先编译epoll_server, 编译并启动, 命令如下:

   gcc epoll.c -o epoll_server -DCOMPILE_SERVER -std=c99

   ./epoll_server 127.0.0.1 6688

        再编译epoll_client, 编译并启动, 命令如下:

   gcc epoll.c -o epoll_client -std=c99

   ./epoll_client 127.0.0.1 6688 1024

        因为是在同一台机器, 所有有2048个ESTABLISHED, 结果如下, :

我不买vip
关注
linux下的tcp服务器
03-22
linux下的TCP协议及使用，关于套接字的创建，及高并发服务器的创建
如何测试Linux下tcp最大连接数限制详解
01-11
前言 关于TCP服务器最大并发连接数有一种误解就是“因为端口号上限为65535,所以TCP服务器理论上的可承载的最大并发连接数也是...这个测试主要是想搞明白Linux下哪些参数配置限制了连接数的最大值，上限是多少。 一、先
一个Linux下的TCP服务1
c_cppcoder的博客
08-31 590
有几点设置: 1, 设置了端口重复使用 2, 设置了FD阻塞 3, 每一个TCP请求都会开启一个线程去读FD 4, 每个FD都设置了5秒的超时时间, 如果5秒还没有数据, 则回收相关资源退出 代码如下: #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <sys/time.h> #include <errno.h&
Linux应用——TCP通信
最新发布
m0_56399733的博客
08-11 1079
TCP三次握手，四次挥手，滑动窗口相关知识，利用TCP实现多线程、多进程通信，状态转变以及半关闭与端口复用知识。
Linux TCP服务器
bianyuke
12-01 1759
一、TCP编程框架    TCP网络包括服务器(server)和客户端(client)两种模式。                    二、Linux下TCP编程流程      根据系统给出API接口，根据上面流程，很容易写出一个简单的TCP应用程序。      TCP服务模式API使用流程：            创建socket()套接字            绑定bind(
Linux下使用TCP协议完成一个简单的client-service通信
ZHUANHzzz的博客
08-27 1033
TCP CS 通信实现
【Linux】之 TCP服务器与客户端
qq_40408365的博客
03-17 888
一、TCP服务器的特点 面向连接，可靠传输，字节流服务（适用安全性高，信息质量要求高的传输：文件传输） 先连接再传输。 数据传输灵活。 缺点：传输速度较低，数据可能粘包。 二、TCP服务器的建立流程 socket -> bind -> listen -> connect -> accept -> recv/send -> close 可以看出TCP连...
TCP.rar_LINUX TCP _linux 服务器_tcp linux_tcp 服务器
09-23
总的来说，这个资源包是学习TCP在Linux服务器环境下应用的宝贵材料。它可以帮助开发者理解TCP连接的生命周期，学习如何使用套接字API编写服务器和客户端程序，以及掌握TCP的可靠性机制。通过实践这些示例，你将能够...
linux下TCP通讯助手
06-30
里面为deb文件，直接双击即可安装。或者通过指令： sudo dpkg -i **.deb 如果安装后点击软件无反应，则需要在终端执行： sudo apt-get install libqtgui4:amd64
linux设备tcpreplay安装
06-17
在Linux设备上安装tcpreplay包回放工具
【Linux | 网络编程】TCP的服务端（守护进程） + 客户端
上上谦. 的博客
10-03 3538
上一节，我们用了udp写了一个服务端和客户端之间通信的代码，只要函数了解认识到位，上手编写是很容易的。本章我们开始编写tcp的服务端和客户端之前通信的代码，要认识一批新的接口，并将我们之前学习的系统知识加进来，做到融会贯通…
linux下2个检查tcp连接的命令
01-10
1 检测web服务器的链接数量及状态： netstat -ant|awk '{print $5 \t $6}'|grep ::ffff:|sed -e 's/::ffff://' -e 's/:[0-9]*//' |sort|uniq -c| sort -rn|head -10 结果： 122 125.162.71.199 TIME_WAIT 99 79.119.125.43 TIME_WAIT 81 125.167.243.77 TIME_WAIT 75 110.137.106.75 TIME_WAIT 29 118.97.140.166 TIME_WAIT 29 115.192.
Linux下TCP协议客户端和服务器之间的通信
weixin_50490512的博客
12-19 1105
Linux下TCP协议客户端和服务器之间的通信，
linux系统实现tcp协议通讯
weixin_49180881的博客
03-16 718
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
Linux环境 创建TCP协议实现服务端和客户端聊天
m0_46278216的博客
05-23 335
【代码】Linux环境 创建TCP协议实现服务端和客户端聊天。
Linux 基于 TCP 协议的简单服务器-客户端应用
Han同学
04-16 1197
Linux 基于 TCP 协议的简单服务器-客户端应用
【Linux】Tcp服务器的三种与客户端通信方法及守护进程化
Sxy_wspsby的博客
07-22 1233
在上一篇文章中，我们实现了Tcp服务器，但是为了演示多进程和多线程的效果，我们将服务器与客户通通信写成了一下死循环，导致只要有一个用户没有和服务器通信完毕其他用户就都无法和服务器通信，这也体现了单进程面对网络时的一些不足，下面我们用多进程，多线程，线程池来解决这个问题。本篇文章中最重要的是网络知识与系统知识融合在一起，就比如多进程版和多线程版中多进程需要关闭两次文件描述符而多线程只需要一次，要理解这些概念就必须知道进程和线程的概念，所以网络的学习很考验系统的基本功。
Linux高性能服务器编程--第1篇 TCP/IP协议详解 笔记
weixin_57950256的博客
04-08 890
TCP模块的另一个任务是提高网络利用率，降低丢包率，保证网络资源对每条数据流的公平性，这就是所谓的拥塞控制。拥塞控制的最终受控变量是发送端向网络一次连续写入（收到其中第一个数据的确认前）的数据量，我们称为SWND（Send Window，发送窗口）。报文段的数据部分的最大长度称为SMSS（Sender Maximum Segment Size，发送者最大段大小），其值一般等于MSS。
Linux循环TCP服务器实现与详解
循环服务是服务器在处理完一个连接后，继续等待下一个连接，而并发服务则会为每个新连接创建一个新的进程或线程来处理。 循环TCP服务端程序的核心在于其不断接收和处理客户端连接的循环结构。以下是一些关键步骤和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值