epoll测试实例

C++ Code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXEVENTS 64

static int
make_socket_non_blocking (int sfd)
{
    int flags, s;

flags = fcntl (sfd, F_GETFL, 0);
    if (flags == -1)
    {
        perror ("fcntl");
        return -1;
    }

flags |= O_NONBLOCK;
    s = fcntl (sfd, F_SETFL, flags);
    if (s == -1)
    {
        perror ("fcntl");
        return -1;
    }

return 0;
}

static int
create_and_bind (char *port)
{
    struct addrinfo hints;
    struct addrinfo *result, *rp;
    int s, sfd;

memset (&hints, 0, sizeof (struct addrinfo));
    hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
    hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
    hints.ai_flags = AI_PASSIVE;     /* All interfaces */

s = getaddrinfo (NULL, port, &hints, &result);
    if (s != 0)
    {
        fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
        return -1;
    }

for (rp = result; rp != NULL; rp = rp->ai_next)
    {
        sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (sfd == -1)
        {
            continue;
        }

s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
        if (s == 0)
        {
            /* We managed to bind successfully! */
            break;
        }

close (sfd);
    }

if (rp == NULL)
    {
        fprintf (stderr, "Could not bind\n");
        return -1;
    }

freeaddrinfo (result);

return sfd;
}

int
main (int argc, char *argv[])
{
    int sfd, s;
    int efd;
    struct epoll_event event;
    struct epoll_event *events;

if (argc != 2)
    {
        fprintf (stderr, "Usage: %s [port]\n", argv[0]);
        exit (EXIT_FAILURE);
    }

sfd = create_and_bind (argv[1]);
    if (sfd == -1)
    {
        abort ();
    }

s = make_socket_non_blocking (sfd);
    if (s == -1)
    {
        abort ();
    }

s = listen (sfd, SOMAXCONN);
    if (s == -1)
    {
        perror ("listen");
        abort ();
    }

efd = epoll_create1 (0);
    if (efd == -1)
    {
        perror ("epoll_create");
        abort ();
    }

event.data.fd = sfd;
    event.events = EPOLLIN | EPOLLET;
    s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
    if (s == -1)
    {
        perror ("epoll_ctl");
        abort ();
    }

/* Buffer where events are returned */
    events = calloc (MAXEVENTS, sizeof event);

/* The event loop */
    while (1)
    {
        int n, i;

n = epoll_wait (efd, events, MAXEVENTS, -1);
        for (i = 0; i < n; i++)
        {
            if ((events[i].events & EPOLLERR) ||
                    (events[i].events & EPOLLHUP) ||
                    (!(events[i].events & EPOLLIN)))
            {
                /* An error has occured on this fd, or the socket is not
                   ready for reading (why were we notified then?) */
                fprintf (stderr, "epoll error\n");
                close (events[i].data.fd);
                continue;
            }

else if (sfd == events[i].data.fd)
            {
                /* We have a notification on the listening socket, which
                   means one or more incoming connections. */
                while (1)
                {
                    struct sockaddr in_addr;
                    socklen_t in_len;
                    int infd;
                    char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

in_len = sizeof in_addr;
                    infd = accept (sfd, &in_addr, &in_len);
                    if (infd == -1)
                    {
                        if ((errno == EAGAIN) ||
                                (errno == EWOULDBLOCK))
                        {
                            /* We have processed all incoming
                               connections. */
                            break;
                        }
                        else
                        {
                            perror ("accept");
                            break;
                        }
                    }

s = getnameinfo (&in_addr, in_len,
                                     hbuf, sizeof hbuf,
                                     sbuf, sizeof sbuf,
                                     NI_NUMERICHOST | NI_NUMERICSERV);
                    if (s == 0)
                    {
                        printf("Accepted connection on descriptor %d "
                               "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

/* Make the incoming socket non-blocking and add it to the
                       list of fds to monitor. */
                    s = make_socket_non_blocking (infd);
                    if (s == -1)
                    {
                        abort ();
                    }

event.data.fd = infd;
                    event.events = EPOLLIN | EPOLLET;
                    s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                    if (s == -1)
                    {
                        perror ("epoll_ctl");
                        abort ();
                    }
                }
                continue;
            }
            else
            {
                /* We have data on the fd waiting to be read. Read and
                   display it. We must read whatever data is available
                   completely, as we are running in edge-triggered mode
                   and won‘t get a notification again for the same
                   data. */
                int done = 0;

while (1)
                {
                    ssize_t count;
                    char buf[512];

count = read (events[i].data.fd, buf, sizeof buf);
                    if (count == -1)
                    {
                        /* If errno == EAGAIN, that means we have read all
                           data. So go back to the main loop. */
                        if (errno != EAGAIN)
                        {
                            perror ("read");
                            done = 1;
                        }
                        break;
                    }
                    else if (count == 0)
                    {
                        /* End of file. The remote has closed the
                           connection. */
                        done = 1;
                        break;
                    }

/* Write the buffer to standard output */
                    s = write (1, buf, count);
                    if (s == -1)
                    {
                        perror ("write");
                        abort ();
                    }
                }

if (done)
                {
                    printf ("Closed connection on descriptor %d\n",
                            events[i].data.fd);

/* Closing the descriptor will make epoll remove it
                       from the set of descriptors which are monitored. */
                    close (events[i].data.fd);
                }
            }
        }
    }

free (events);

close (sfd);

return EXIT_SUCCESS;
}

具体函数介绍请参考:https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/

运行结果:

服务器端:

客户端:

时间: 2024-11-10 02:05:29

epoll测试实例的相关文章

epoll模型实例

一.epoll概述 epoll是linux下的一个系统调用,用来监听大量文件描述符并对其上的触发事件进行处理.它是select/poll的增强版本,也是linux下多路复用io最常用的接口.要理解epoll是什么,首先得清楚什么是多路复用io.用户进行io操作需要经过内核,而如果所请求的io目前不满足条件(如需要从标准输入读取数据,而用户还未输入),这个时候内核就会让应用程序陷入等待,即阻塞状态.个人理解,io复用技术就是通过特定接口,将这种阻塞进行了转移,转嫁到了如select/poll/ep

Loadrunner经典测试实例

Loadrunner经典测试实例 原文地址:https://www.cnblogs.com/guaimao123/p/7779244.html

postman测试实例--断言

让我们来看看postman测试的一些例子. 其中大部分是作为内部postman片段. 大多数测试是为单行的JavaScript语句一样简单. 只要你想一个请求,你可以有很多的测试. 注意:一个响应已从服务器接收后测试脚本运行. 测试实例 1.设置环境变量postman.setEnvironmentVariable("key", "value"); 例子: postman.setEnvironmentVariable("url", "ht

Confluence 6 从生产环境中恢复一个测试实例

请参考 Restoring a Test Instance from Production 页面中的内容获得更多完整的说明. 很多 Confluence 的管理员将会使用生产实例运行完整数据和服务的 Confluence 服务器,同时还会设置一个测试实例来测试升级等.在这种情况下,你的 Confluence 可以回运行 2 个不同的版本,而且也是非常常见的.这个文档将会知道你如何拷贝生产环境中的数据到一个测试实例中,同时测试环境的版本和生产环境中的版本还有可能是不同的. 在开始这个操作指南之前,

微服务架构 - 离线部署k8s平台并部署测试实例

一般在公司部署或者真实环境部署k8s平台,很有可能是内网环境,也即意味着是无法连接互联网的环境,这时就需要离线部署k8s平台.在此整理离线部署k8s的步骤,分享给大家,有什么不足之处,欢迎指正. 1.准备环境 这次离线部署k8s的版本为v1.10.1,同时docker的版本为17.12.0-ce,不过本文章不介绍如何离线部署docker,如果大家要看的话,可以看本人之前写的文章<CentOS7离线部署docker> 本人准备的环境是3台虚拟机,也即1台master节点,2个node节点,ip及

[原]我在Windows环境下的首个Libevent测试实例

libevent对Windows环境也有很好的支持,不过初次学习和编译libevent简单实例,总是有一些陌生感的,只有成功编译并测试了一个实例,才会有恍然大悟的感觉.下面将要讲到的一个实例是我从网上抄过来的,原创文章地址为:http://www.felix021.com/blog/read.php?2068,表示感谢! 在给出我的第一个测试成功的例子代码之前,简要介绍一下libevent入门的基本知识.原文中作者有一段话是这样的: “基本的socket编程是阻塞/同步的,每个操作除非已经完成或

LoadRunner11 压力测试实例笔记

最近在学习用loadrunner做web性能测试,简单记录一下一个自学实例流程. 1.录制测试脚本 (1).打开LR11,点击create/edit Script来打开VUgen (2).点击新建 (3).选择协议类型,点击create (4).开始录制弹窗中设置要目标url,这里用http://mail.163.com为例,点击ok (5).因之前登陆保存了缓存,这里可以直接跳过登陆,录制发送邮件的流程 填写邮件内容,收件人.主题.内容等,点击发送 发送成功页面 停止录制,查看生成的脚本. 2

【框架】[Hibernate]构架知识点详解入门与测试实例

转载请注明出处:http://blog.csdn.net/qq_26525215 本文源自[大学之旅_谙忆的博客] Hibernate介绍: Hibernate是一个开放源码的.非常优秀.成熟的O/R Mapping框架.它提供了强大.高性能的Java对象和关系数据的持久化和查询功能. O/R Mapping 对象关系映射(Object Relational Mapping,简称ORM)技术,是通过使用描述对象和数据库之间映射的元数据,将Java程序中的对象自动持久化到关系数据库中. 对象和关系

Apache-AB压力测试实例

一 AB背景介绍 Apache附带的压力测试工具apache bench--简称ab,非常容易使用,并且完全可以摸你各种条件对Web服务器发起测试请求.ab可以直接在Web服务器本地发起测试请求,这对于需要了解服务器的处理性能至关重要,因为它不包括数据的网络传输时间以及用户PC本地的计算时间. ab is a tool for benchmarking your Apache Hypertext Transfer Protocol (HTTP) server. It is designed to