LinuxSocket 编程 -- UdpServer 与 epoll

最新推荐文章于 2024-08-02 16:22:25 发布
最新推荐文章于 2024-08-02 16:22:25 发布
阅读量779 收藏 4
点赞数
文章标签： udp 网络 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxfx_OT/article/details/127082515
版权

上节回顾
上一节介绍了 UDP server 与 UDP Client 简单的双向 交互。
但是遇到多 Client 与 Server 连接时 UDP Server 就处理不了。
本节介绍 使用 epoll 来实现多连接。

使用udp 与 epoll 结合

与 TCP 不同的是 UDP 需要自己创建新的 socket 而不是 系统接口的accept 返回新的fd。

Server 端代码

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <pthread.h>
#include <assert.h>

#define SO_REUSEPORT    15

#define MAXBUF 10240
#define MAXEPOLLSIZE 100

int flag = 0;
int count = 0;
char buffer[MAXBUF];

int read_data(int sd)
{
    //char recvbuf[MAXBUF + 1];
    int  ret;
    struct sockaddr_in client_addr;
    socklen_t cli_len=sizeof(client_addr);

    bzero(buffer, MAXBUF);
  
    ret = recvfrom(sd, buffer, MAXBUF, 0, (struct sockaddr *)&client_addr, &cli_len);
    //fflush(stdout);

    return ret;
}

int send_data(int sd)
{
   // char sndbuf[MAXBUF + 1];
    int  ret;
    struct sockaddr_in client_addr;
    socklen_t cli_len=sizeof(client_addr);
  
    ret = sendto(sd, buffer, MAXBUF, 0, (struct sockaddr *)&client_addr, cli_len);
    if (ret > 0) {
        printf("send: %s  from  %d\n", buffer, sd);
    } else {
        printf("send err:%s  %d\n", strerror(errno), ret);
      
    }
    return ret;
}



int udp_accept(int sd, struct sockaddr_in my_addr)
{
    int new_sd = -1;
    int ret = 0;
    int reuse = 1;
    char buf[16];
    struct sockaddr_in peer_addr;
    socklen_t cli_len = sizeof(peer_addr);

    ret = recvfrom(sd, buf, 17, 0, (struct sockaddr *)&peer_addr, &cli_len);
    if (ret < 0) {
		return -1;
    }
    buf[ret] ='\0';
    printf("ret: %d, buf: %s\n", ret, buf);

    if ((new_sd = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("child socket");
        exit(1);
    } else {
        printf("%d, parent:%d  new:%d\n",count++, sd, new_sd); //1023
    }

    ret = setsockopt(new_sd, SOL_SOCKET, SO_REUSEADDR, &reuse,sizeof(reuse));
    if (ret) {
        exit(1);
    }

    ret = setsockopt(new_sd, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse));
    if (ret) {
        exit(1);
    }

	//my_addr.sin_port += count;
    ret = bind(new_sd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr));
    if (ret){
        perror("chid bind");
        exit(1);
    } else {
    }

    peer_addr.sin_family = PF_INET;
    //printf("aaa:%s\n", inet_ntoa(peer_addr.sin_addr));
    if (connect(new_sd, (struct sockaddr *) &peer_addr, sizeof(struct sockaddr)) == -1) {
        perror("chid connect");
        exit(1);
    } else {
    }
    char buffer[1024] = {0};
    memset(buffer, 0, 1024);
    sprintf(buffer, "hello from Server");
    sendto(new_sd, buffer, strlen(buffer), 0, (struct sockaddr *) &peer_addr, sizeof(struct sockaddr_in));

out:
    return new_sd;
}

int main(int argc, char **argv)
{
    int listener, kdpfd, nfds, n, curfds,new_sd;
    socklen_t len;
    struct sockaddr_in my_addr, their_addr;
    unsigned int port;
    struct epoll_event ev;
    struct epoll_event events[MAXEPOLLSIZE];
    int opt = 1;
    int ret = 0;

    port = 1234;
  
    if ((listener = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("socket");
        exit(1);
    } else {
        printf("socket OK:%d\n",listener);
    }

    ret = setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    if (ret) {
        exit(1);
    }

    ret = setsockopt(listener, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    if (ret) {
        exit(1);
    }

	int flags = fcntl(listener, F_GETFL, 0);
	flags |= O_NONBLOCK;
	fcntl(listener, F_SETFL, flags);
  
    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = PF_INET;
    my_addr.sin_port = htons(port);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1) {
        perror("bind");
        exit(1);
    } else {
        printf("IP bind OK\n");
    }
	
    kdpfd = epoll_create(MAXEPOLLSIZE);

    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = listener;

    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0) {
        fprintf(stderr, "epoll set insertion error: fd=%dn", listener);
        return -1;
    } else {
        printf("ep add OK\n");
    }
    printf("================\n");
    while (1) {
            nfds = epoll_wait(kdpfd, events, 10000, -1);
            if (nfds == -1) {
                perror("epoll_wait");
                break;
            }
      
            for (n = 0; n < nfds; ++n) {
                if (events[n].data.fd == listener) {             
                struct epoll_event child_ev;
				    while (1) {
	                        new_sd = udp_accept(listener, my_addr);
					        if (new_sd == -1) break;
	                        child_ev.events = EPOLLIN;
	                        child_ev.data.fd = new_sd;
	                        if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_sd, &child_ev) < 0) {
	                            fprintf(stderr, "epoll set insertion error: fd=%dn", new_sd);
	                            return -1;
	                        }

				        }
                } else if(events[n].events == EPOLLIN){
                    struct epoll_event child_ev;
                    ret = read_data(events[n].data.fd);
                    if (ret > 0) {
                        new_sd = events[n].data.fd;
                        child_ev.events = EPOLLOUT;
                        child_ev.data.fd = new_sd;
                        if (epoll_ctl(kdpfd, EPOLL_CTL_MOD, new_sd, &child_ev) < 0) {
                            fprintf(stderr, "epoll set insertion error: fd=%dn", new_sd);
                            return -1;
                        }
                        printf("read[%d]: %s  from  %d\n", ret, buffer, new_sd);
                    } else if(ret == 0){
                        printf("read err:%s  %d\n", strerror(errno), ret);
                        close(new_sd);
                    }
                
            }else if(events[n].events == EPOLLOUT){
                struct epoll_event child_ev;
                new_sd = events[n].data.fd;
                ret = send_data(new_sd);
                child_ev.events = EPOLLIN;
	            child_ev.data.fd = new_sd;
	            if (epoll_ctl(kdpfd, EPOLL_CTL_MOD, new_sd, &child_ev) < 0) {
	                fprintf(stderr, "epoll set insertion error: fd=%dn", new_sd);
	                 return -1;
	                }
            }
        }
    }
    close(listener);
    return 0;
}

client 端代码

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


int main(int argc, char * argv[])
{
    int socketFd;
    int  Port = 1234;
    int ret = 0;
    struct sockaddr_in peer_Addr;
    socklen_t server_len=sizeof(peer_Addr);
    peer_Addr.sin_family = PF_INET;
    peer_Addr.sin_port = htons(Port);
    peer_Addr.sin_addr.s_addr = inet_addr("172.26.197.253");
    
    if ((socketFd = socket(PF_INET, SOCK_DGRAM| SOCK_CLOEXEC, 0)) == -1) {
        perror("child socket");
        exit(1);
    } 
    if (connect(socketFd, (struct sockaddr *) &peer_Addr, sizeof(struct sockaddr)) == -1) {
        perror("chid connect");
        exit(1);
    }
    char buffer[1024] = {0};
    memset(buffer, 0, 1024);
    sprintf(buffer, "hello from client");
    sendto(socketFd, buffer, strlen(buffer), 0, (struct sockaddr *) &peer_Addr, sizeof(struct sockaddr_in));
    ret = recvfrom(socketFd, buffer,1024, 0, (struct sockaddr *)&peer_Addr, &server_len);
    if (ret > 0) {
        printf("read[%d]: %s  fd:%d\n", ret, buffer, socketFd);
        } else {
           printf("read err:%s  %d\n", strerror(errno), ret);
      
    }
    memset(buffer, 0, 1024);
    while(1)
    {

        char buffer[1024] = {0};
        memset(buffer, 0, 1024);
        //sprintf(buffer, "hello from client");
        printf("input send data:\n");
        scanf("%s",buffer); 
        sendto(socketFd, buffer, strlen(buffer), 0, (struct sockaddr *) &peer_Addr, sizeof(struct sockaddr_in));
        memset(buffer, 0, 1024);
        printf("=============\n");
        ret = recvfrom(socketFd, buffer,1024, 0, (struct sockaddr *)&peer_Addr, &server_len);
        if (ret > 0) {
        printf("read[%d]: %s  fd:%d\n", ret, buffer, socketFd);
        } else {
           printf("read err:%s  %d\n", strerror(errno), ret);
      
        }
    }
   
    close(socketFd);
    return 0;
}

代码调试

启动 Server

qifei@QF:~/udp_server_concurrent$ ./udp_server 
socket OK:3
IP bind OK
ep add OK
================
ret: 17, buf: hello from client
0, parent:3  new:5
read[3]: 122  from  5
send: 122  from  5

启动Client 发送 hello client 并接收 服务端返回的 hello server
手动输入要发送的数据，立刻收到服务端返回同样的消息

qifei@QF:~/udp_server_concurrent$ ./client 
read[17]: hello from Server  fd:3
input send data:
122
read[1024]: 122  fd:3
input send data:

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习:
服务器高级架构体系：
https://ke.qq.com/course/417774?flowToken=1010783

wxfx_OT
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux高并发网络编程开发——epoll-udp
Alliswell_WP
07-08 1296
在学习Linux高并发网络编程开发总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-Linux系统编程-第13天（epoll-udp） 目录：一、学习目标二、复习1、通过gdb定位段错误的位置2、TCP状态转换复习三、epoll1、epoll相关的函数介绍和工作流程2、epoll模型伪代码3、epoll模型代码实现4、epoll三种工作模式5...
epoll介绍以及epoll 实现udp server
qq_37657601的博客
02-16 1590
Abstract epoll是Linux内核为处理大批量句柄而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本， 它能显著减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。 简介: epoll是Linux下多路复用IO接口select/poll的增强版本， 它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率， 因为： 它会复用文件...
Linux Socket编程 -- UDP Server 与 Client
wxfx_OT的博客
09-19 1657
UDP simple server
Linux网络编程---UDP服务器
qq_51647149的博客
04-29 2354
UDP通信与TCP通信的对比及实现、网络/本地套接字通信的对比
linux网络编程-epoll多路复用
xiyangxiaoguo的博客
12-04 853
client.cpp -->client server.cpp -->server 在server中使用epoll来进行多路复用 client.cpp #include <stdlib.h> #include <stdio.h> #include <errno.h> #include <string.h> #include <string> #include <unistd.h> #include <net.
网络socket编程--epoll 模型原理详解以及实例
$好记性还是要多记录$
05-18 3848
1.简介 Linux I/O多路复用技术在比较多的TCP网络服务器中有使用，即比较多的用到select函数。Linux 2.6内核中有提高网络I/O性能的新方法，即epoll 。 epoll是什么？按照man手册的说法是为处理大批量句柄而作了改进的poll。要使用epoll只需要以下的三个系统函数调用： epoll_create(2)，epoll_ctl(2)，epoll_wait(2)。 ...
linux中epoll+socket实战
Blueeyedboy521的博客
05-15 1710
在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内核来扩大这个数目，但这似乎并不治本。TCP接收到事件时会回调触发epoll_wait 中事件第一个参数就是前面函数的返回值。
端口监听与epoll理论 - Linux C++网络编程（二十二）
生活需要深度
05-01 698
一：监听端口 （1.1）开启监听端口 二：epoll技术简介 （2.1）epoll概述 (1)I/O多路复用：epoll就是一种典型的I/O多路复用技术:epoll技术的最大特点是支持高并发； 传统多路复用技术select,poll，在并发量达到1000-2000，性能就会明显下降； epoll,kquene(freebsd) epoll，从linux内核2.6引入的，2.6之前是没有的； (2)epoll和kquene技术类似：单独一台计算机支撑少则数万，多则数十上百万并发连接的核心技
网络socket编程--多路复用
King_的博客
02-19 1713
一、五种网络I/O模型 1.什么是I/O IO在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。 比如你打开浏览器，访问新浪首页，浏览器这个程序就需要通过网络IO获取新浪的网页。浏览器首先会发送数据给新浪服务器，告诉它我想要首页的HTML，这个动作是往外发数据，叫Output，随后新浪服务器把网页发过来，这个动作是从外面接收数据，叫Input。所以，通常，程序完成IO操作会有
socket_linux-socket网络编程详解_
10-01
在Linux Socket编程中，我们需要定义服务器和客户端的网络地址，这通常使用`struct sockaddr_in`结构体完成。包含IP地址和端口号。 ```c struct sockaddr_in server; server.sin_family = AF_INET; server.sin_addr...
udp -socket编程
10-10
**UDP套接字编程** 是在Linux系统中实现网络通信的一种方式。以下是关于UDP套接字编程的一些关键知识点： 1. **套接字创建**：在Linux中，通过调用`socket()`函数创建一个套接字。对于UDP，应选择`PF_INET`（表示...
linux网络编程-源代码&课件.zip
11-08
讲义通常会详细解释Linux网络编程的基本概念，如套接字（socket）接口，它是应用程序与网络协议栈之间的接口。套接字API允许开发者创建、绑定、监听和接受来自网络的连接，以及发送和接收数据。讲义可能还会涵盖IP...
0.2-chat-epoll.zip
05-22
它们通常都是基于socket编程实现，使用TCP或UDP协议，可能涉及到网络编程中的各种概念，如套接字的创建、绑定、监听、连接、读写操作等。 在实际的聊天程序中，可能会使用到线程或者进程来处理并发连接，epoll的...
Linux网络编程socket编程学习
05-09
自学Linux网络编程关于socket的编写，包括 server.c 和 client.c 的编写；很详细的介绍了网络套接字socket的C/S模型TCP协议的服务器端和客户端的程序函数以及编写过程；重点介绍多路I/O转接服务器的实现，包括select...
网安科班精选！爱荷华大学教授的网络安全零基础入门教程！
互联网架构小马的博客
07-31 622
网络就像一把双刃剑，给我们的生活、交流、工作和发展带来了便利，但同时也给信息安全以及个人隐私带来了威胁。网络和信息安全问题不仅影响了网络的普及和应用，还关系到企国家、军队、企业的信息安全和社会的经济安全，让人又爱又恨。今天给大家分享的这份手册，主要从网络漏洞、协议和安全解决方案等方面来探讨网络安全问题。我们把网络看成是不安全和安全的源头，通过分析网络漏洞、探测、攻击和减少攻击的方法，来研究不同的网络协议。
未知攻焉知防：从攻击者视角看网络安全的“攻守之道”
科技云报道
08-01 390
基于独特的“动态安全+AI”技术思想，瑞数信息综合运用自动化攻击保护、0day防护、多源低频防护、多维度分层分级对抗等多种安全防护策略和手段，还推出瑞数WAAP超融合平台，支持WAF、Bots防护、0day攻击防护、应用DDoS防护、API安全防护等多项安全产品单独或联合部署，能够覆盖Web、移动App、H5、API及IoT全应用渠道，提供多层级的联动防御机制，令企业在各类复杂的环境中，都可以轻松实现应用安全一体化防御。其次，由于供应链数量众多，类型错综复杂，导致安全难以做到统一管理，供应链风险与日俱增。
【Vulnhub系列】Vulnhub Connect-The-Dots 靶场渗透（原创）
最新发布
Lusen的博客
08-02 553
Vulnhub系列Connect-The-Dots靶场做题记录
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 594
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值