以下代码在vs 2010编译通过,使用的libevent版本是:libevent-2.0.22,win7环境测试通过。

服务器实现:

1 流程图:

2 代码:

// my_telnet.cpp : Defines the entry point for the console application.
// #include "stdafx.h" #include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h> #ifndef WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
# include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif #include "event2/bufferevent.h"
#include "event2/buffer.h"
#include "event2/listener.h"
#include "event2/util.h"
#include "event2/event.h"
#include "event2/util.h" #include <WinSock2.h>
//#include "MySimpleLog.h" static const int PORT = ; //读取一行输入并返回
static void conn_readcb(struct bufferevent *bev, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("conn_readcb!\n"); //只有读到一行完整行才进行处理 所以这里需要检查缓冲区是否存在换行符
//如果存在才往下走
struct evbuffer *input = bufferevent_get_input(bev);
struct evbuffer_ptr ptrInput;
if ((ptrInput = evbuffer_search(input , "\n", , NULL)).pos == -)
{
return;
} char line[] = {};
int nRead = ; //已读取字节数
int nExpect = ptrInput.pos + ; //期望读取的字节数 //把这一行读取出来(如果大于1024则需要分次读取)
while (nRead < nExpect)
{
int nLeft = nExpect - nRead;
int nReadOnce = min(nLeft, sizeof(line) - ); int n = bufferevent_read(bev, line, nReadOnce);
if (n <= )
{
//MY_SIMPLE_LOG_ERROR("expect to read %d bytes,but get %d.", nReadOnce, n);
break;
}
line[n] = '\0';
//把待发送数据添加到发送缓冲中,这里不会立即发送数据,要等conn_readcb返回后才会发送的
bufferevent_write(bev, line, n);
nRead += nReadOnce;
//MY_SIMPLE_LOG_DEBUG("n = %d nRead = %d nExpect = %d! line = [%s]", n, nRead, nExpect, line);
} //启动写事件,发送缓冲内容 //写事件是默认开启的,这里不需要额外设置
//bufferevent_enable(bev, EV_WRITE | EV_PERSIST); //为避免粘包,这里要判断缓冲里面是否还有剩余数据,如果有要特别处理
//这是因为libevent是边缘触发的,而不是水平触发
if (evbuffer_get_length(input) != )
{
//本来是想直接激活读事件
//但是发现要访问bufferevent未公开的成员,就不这样搞了
//event_active(&(bev->ev_read), EV_READ, 1);
conn_readcb(bev, user_data);
}
} static void conn_writecb(struct bufferevent *bev, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("conn_writecb!");
struct evbuffer *output = bufferevent_get_output(bev);
if (evbuffer_get_length(output) == )
{
//MY_SIMPLE_LOG_DEBUG("buffer writed\n");
//bufferevent_free(bev);
}
} static void conn_writecb_once(struct bufferevent *bev, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("conn_writecb_once!");
struct evbuffer *output = bufferevent_get_output(bev);
if (evbuffer_get_length(output) == )
{
//MY_SIMPLE_LOG_DEBUG("flushed free\n");
bufferevent_free(bev);
}
} static void conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("conn_eventcb!\n"); //判断是因为什么原因调用了此函数
if (events & BEV_EVENT_EOF)
{
//MY_SIMPLE_LOG_DEBUG("Connection closed.\n");
}
else if (events & BEV_EVENT_ERROR)
{
//MY_SIMPLE_LOG_DEBUG("Got an error on the connection: %s\n",
// strerror(errno));/*XXX win32*/
}
else if ((events & BEV_EVENT_TIMEOUT) && (events & BEV_EVENT_READING))
{
//发生读超时 //超时事件发生时,会禁止相应读/写事件,需要重新注册
//这里由于业务逻辑上认为超时就要关闭socket,就没必要这样做了
//bufferevent_enable(bev, EV_READ | EV_PERSIST); //发送一个超时消息给客户端,然后就关闭bufferevent
const char time_out_msg[] = "time out!\n";
//MY_SIMPLE_LOG_INFOR(time_out_msg);
int n = bufferevent_write(bev, time_out_msg, sizeof(time_out_msg) - );
//MY_SIMPLE_LOG_DEBUG("bufferevent_write ret %d send %d", n, int(sizeof(time_out_msg) - 1));
// 据说这个版本bufferevent_flush没实现 实测总是返回0
// n = bufferevent_flush(bev, EV_WRITE, BEV_FINISHED);
// //MY_SIMPLE_LOG_DEBUG("bufferevent_flush ret %d", n); //等写完超时信息就退出
bufferevent_setcb(bev, NULL, conn_writecb_once, NULL, user_data);
return;
}
/* None of the other events can happen here, since we haven't enabled
* timeouts */
bufferevent_free(bev);
} //ctrl + c处理函数
static void signal_cb(evutil_socket_t sig, short events, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("signal_cb!\n"); printf("to exit in 2 seconds.\n");
struct event_base *base = (struct event_base *)user_data;
struct timeval delay = { , }; //MY_SIMPLE_LOG_DEBUG("Caught an interrupt signal; exiting cleanly in two seconds.\n"); event_base_loopexit(base, &delay);
} //新连接到来处理函数
static void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *sa, int socklen, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("listener_cb!\n");
struct event_base *base = (struct event_base *)user_data;
struct bufferevent *bev; //将该连接设置成非阻塞
evutil_make_socket_nonblocking(fd);
//BEV_OPT_CLOSE_ON_FREE参数让bufferevent被删除时会自动清理对应的socket
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!bev)
{
//MY_SIMPLE_LOG_ERROR("Error constructing bufferevent!");
event_base_loopbreak(base);
return;
}
//MY_SIMPLE_LOG_DEBUG("new connect!\n"); //开始设置各个事件的回调函数
//最后一个参数是各个回调函数的user_data 这里不需要用到,填NULL
//除了读写事件外,其它很多事件都是会回调conn_eventcb
bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, NULL); //EV_PERSIST不设置的话读事件只会触发一次
bufferevent_enable(bev, EV_READ | EV_PERSIST);
//默认情况下bufferevent自动监听可读事件,如有需要可以关闭
//关闭的情况下bufferevent_write调用后,不会真正往socket写,只保留在缓冲区
//bufferevent_disable(bev, EV_WRITE);
struct timeval delay = { , };
//读超时10秒 写超时无限
bufferevent_set_timeouts(bev, &delay, NULL);
} /*
基本流程:
1 新建event_base
2 生成监听socket
3 将
*/
int main(int argc, char **argv)
{
struct event_base *base;
struct evconnlistener *listener;
struct event *signal_event; struct sockaddr_in sin; #ifdef WIN32
WSADATA wsa_data;
WSAStartup(0x0201, &wsa_data);
#endif //MY_SIMPLE_LOG_INIT(//MY_SIMPLE_LOG_LEVEL_DEBUG); //初始化event_base 这个是全局唯一的
base = event_base_new();
if (!base)
{
//MY_SIMPLE_LOG_ERROR("Could not initialize libevent!\n");
return ;
}
//MY_SIMPLE_LOG_DEBUG("all inited"); //往event_base新增一个event,监听连接事件
memset(&sin, , sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT); listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -,
(struct sockaddr*)&sin,
sizeof(sin)); if (!listener)
{
//MY_SIMPLE_LOG_ERROR("Could not create a listener!\n");
event_base_free(base);
return ;
}
//MY_SIMPLE_LOG_INFOR("listener created"); //evutil_make_socket_nonblocking(listener); //监听socket不应该设置成非阻塞
//监听ctrl+c信号
signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base); if (!signal_event || event_add(signal_event, NULL)<)
{
//MY_SIMPLE_LOG_ERROR("Could not create/add a signal event!\n");
evconnlistener_free(listener);
event_base_free(base);
return ;
}
//MY_SIMPLE_LOG_INFOR("signal_event created"); //MY_SIMPLE_LOG_INFOR("beging to dispatch");
printf("beging to dispatch...\n");
//开始监听连接 这是一个内置循环的函数 event_base_loopexit函数调用才会返回
event_base_dispatch(base);
//MY_SIMPLE_LOG_INFOR("end dispatch\n"); //清理资源
evconnlistener_free(listener);
event_free(signal_event);
event_base_free(base); //MY_SIMPLE_LOG_DEBUG("done\n");
return ;
}

客户端实现:

客户端实现较简单,就不附流程图了,直接贴代码

// my_telnet.cpp : Defines the entry point for the console application.
// #include "stdafx.h" #include <string.h>
#include <errno.h>
#include <stdio.h>
#include <io.h>
#include <signal.h> #ifndef WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
# include <arpa/inet.h>
# endif
#include <sys/socket.h>
#else
#include <Ws2tcpip.h>
#endif #include "event2/bufferevent.h"
#include "event2/buffer.h"
#include "event2/listener.h"
#include "event2/util.h"
#include "event2/event.h"
#include "event2/util.h"
#include <WinSock2.h>
#include <conio.h> // _kbhit(), _getch()
//#include "MySimpleLog.h"
#include <assert.h>
static const int PORT = ; int tcp_connect_server(const char* server_ip, int port); void cmd_msg_cb(int fd, short events, void* arg);
void server_msg_cb(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
void signal_cb(evutil_socket_t sig, short events, void *user_data); typedef struct
{
struct bufferevent* bev;
struct evbuffer *buf;
}MyTelnetParam; int main(int argc, char** argv)
{
if( argc < )
{
//两个参数依次是服务器端的IP地址、端口号
fprintf(stderr, "please input 2 parameter\n");
return -;
} #ifdef WIN32
WSADATA wsa_data;
WSAStartup(0x0201, &wsa_data);
#endif //MY_SIMPLE_LOG_INIT(//MY_SIMPLE_LOG_LEVEL_DEBUG); struct event_base *base = event_base_new(); //创建bufferevent 暂时不设置对应的socket
struct bufferevent* bev = bufferevent_socket_new(base, -,
BEV_OPT_CLOSE_ON_FREE);
assert(bev != NULL);
/*
//监听终端输入事件 这是linux的做法 win上面不能这样玩
struct event* ev_cmd = event_new(base, _fileno(stdin),
EV_READ | EV_PERSIST,
cmd_msg_cb, (void*)bev); event_add(ev_cmd, NULL);
*/
struct evbuffer *buf = evbuffer_new();
assert(buf != NULL);
MyTelnetParam param = {bev, buf}; //监听终端输入事件 用超时事件 这里不用evtimer_new 因为那个事件只能触发一次
struct event *ev_cmd = event_new(base, -, EV_PERSIST, cmd_msg_cb, (void *)&param);
assert(event_new != NULL);
//每100微秒检测一次键盘输入情况 如果有输入则读取输入并发送给服务器
//时间太短CPU占用太高,太长用户感觉有延迟
struct timeval wait_time = {, };
event_add(ev_cmd, &wait_time); //监听ctrl+c信号
struct event *signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
assert(signal_event != NULL);
event_add(signal_event, NULL); //服务器ip信息初始化
struct sockaddr_in server_addr;
memset(&server_addr, , sizeof(server_addr) );
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(atoi(argv[]));
//inet_aton(argv[1], &server_addr.sin_addr);
server_addr.sin_addr.s_addr = inet_addr(argv[]); //连接服务器,并将socket设置到bufferevent
bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
sizeof(server_addr)); bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, NULL);
bufferevent_enable(bev, EV_READ | EV_PERSIST); event_base_dispatch(base);
//这将自动close套接字和free读写缓冲区
bufferevent_free(bev);
event_free(ev_cmd);
event_free(signal_event);
evbuffer_free(buf);
event_base_free(base); #ifdef WIN32
WSACleanup();
#endif //MY_SIMPLE_LOG_DEBUG("finished \n");
return ;
} void cmd_msg_cb(int fd, short events, void* arg)
{
MyTelnetParam *param = (MyTelnetParam *)arg;
struct bufferevent *bev = param->bev;
struct evbuffer *buf = param->buf; //如果有键盘输入,则读取一个字符 如果不加这判断直接getch有可能会阻塞回调
if (_kbhit())
{
char cInput = EOF;
do
{
//读取键盘输入并回显 不用getchar 因为getchar要等用户按回车才能获取
int nInput = (char) _getch();
cInput = (char) nInput;
evbuffer_add(buf, &cInput, ); //这里最好用putch 不用putchar 因为有时是读取到非可视化字符,如方向键
putch(nInput); //读满一行就先返回 同时换行
if (cInput == '\r')
{
//实际测试发现,按回车时用getch只能读取到一次按键\r
cInput = '\n';
evbuffer_add(buf, &cInput, );
putch(cInput);
break;
}
} while (_kbhit()); //将buf整理成连续的内存
//size_t nLen = evbuffer_get_length(buf);
//evbuffer_pullup(buf, nLen); //往socket输出读取到的字节并移除buf现有字节
bufferevent_write_buffer(bev, buf);
evbuffer_drain(buf, evbuffer_get_length(buf));
}
} //ctrl + c处理函数
static void signal_cb(evutil_socket_t sig, short events, void *user_data)
{
//MY_SIMPLE_LOG_DEBUG("signal_cb!\n"); printf("to exit in 2 seconds.\n");
struct event_base *base = (struct event_base *)user_data;
struct timeval delay = { , }; //MY_SIMPLE_LOG_DEBUG("Caught an interrupt signal; exiting cleanly in two seconds.\n"); event_base_loopexit(base, &delay);
} void server_msg_cb(struct bufferevent* bev, void* arg)
{
char msg[ * ]; size_t len = bufferevent_read(bev, msg, sizeof(msg) - );
msg[len] = '\0'; printf("recv %d:[%s]\n", (int)len, msg);
} void event_cb(struct bufferevent *bev, short event, void *arg)
{
if (event & BEV_EVENT_EOF)
printf("connection closed\n");
else if (event & BEV_EVENT_ERROR)
printf("some other error\n");
else if( event & BEV_EVENT_CONNECTED)
{
printf("the client has connected to server\n");
return ;
} // 不等目前队列中所有回调事件完成,立即退出循环
// 如果等待回调事件完成再退出要用event_base_loopexit
// 这里不能用event_base_loopexit 不然如果用户操作太快,cmd_msg_cb会报错
event_base_loopbreak(bufferevent_get_base(bev));
}

用libevent实现的echo服务器及telnet客户端的更多相关文章

  1. 使用node新建一个socket服务器连接Telnet客户端并且进行输入的显示

    最近在看node的socket,这个很有趣,这个可以很清晰的得到网络http请求的一个过程.首先我们需要一个Telnet的客户端,node(博主为8.0+版本) Telnet客户端的开启过程 有的系统 ...

  2. Linux下的echo服务器

    epoll模式下的echo服务器,忘记从哪个网页上粘贴过来的了,学习一下 /* * main.cc * * Created on: 2009-11-30 * Author: liheyuan * De ...

  3. netty入坑第一步:了解netty和编写简单的Echo服务器和客户端

    早期java API通过原生socket产生所谓的"blocking",大致过程是这样 这种的特点是每次只能处理一个请求,如果要实现多个请求并行,就还要分配一个新的线程来给每个客户 ...

  4. boost::asio实现一个echo服务器

    以前使用ACE实现Server框架,但是觉得太笨重,决定采用boost.asio来写服务器程序: 1.服务器构建在linux上面:当然也可以在windows下运行 2.io部分采用非阻塞模式.业务逻辑 ...

  5. 域名可以解析(ping域名可以获取正确ip),服务器本地telnet 域名+端口 无法连接,通过建立本地虚拟域名指定的方法解决该问题

    环境: 服务器A,网管已为A开通外网ip,且设置有映射域名:假如内网ip为172.16.2.6.外网ip为123.123.123.123.域名为test.sstest.com 现象: 服务器A,tel ...

  6. 网络编程-echo服务器

    代码: #coding="utf-8" #name=echo服务器 from socket import * #1.创建套接字 udpSocket = socket(AF_INET ...

  7. Linux网络编程--多线程实现echo服务器与客户端“一对多”功能,是网络编程的“Hello World!”

    在linux平台下,用多线程实现echo服务器与客户端“一对多”(即是一台服务器可以响应多个客户端的请求).本人写了个demo,和大家一起分享,有不足的地方,请多多指教,我是壮壮熊. 编译时,在后面加 ...

  8. 基于EPOLL模型的局域网聊天室和Echo服务器

    一.EPOLL的优点 在Linux中,select/poll/epoll是I/O多路复用的三种方式,epoll是Linux系统上独有的高效率I/O多路复用方式,区别于select/poll.先说sel ...

  9. 关于telnet协议的研究以及用java进行封装实现自己的telnet客户端(转)

    最近在做一个远程控制的模块,其中用到了telnet协议,开始用的是apache-net包的telnetclient,但发现问题不少,比较慢,还有就是判断是否read完毕的问题.后来经过讨论打算实现自己 ...

随机推荐

  1. Page Object设计模式(项目整体结构)

    1. 什么是框架 1.1 定义: 框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件(类)及构件(类)实例间交互的方法. 1.2 为什么要搭建自动化测试框架 自动化测试的开发, ...

  2. [转]JOGL安装

    本章介绍了设置环境以使用JOGL使用不同的集成开发环境(IDE),在您的系统上. 安装JOGL 对于JOGL安装,需要有以下系统要求: 系统要求 第一个要求是要在机器上安装Java Developme ...

  3. HDU 2088 Box of Bricks(脑洞)

    传送门: http://acm.hdu.edu.cn/showproblem.php?pid=2088 Box of Bricks Time Limit: 1000/1000 MS (Java/Oth ...

  4. 分享一个在js中判断数据是undefined,NaN,null,的技巧

    教大家如何在js中判断一个值是否是undefined,null,NaN,以及如何单独判断 平常开发过程中大家可能遇到一种问题,就是取页面某个值的时候获取不到这个var就是undefined了,如果是数 ...

  5. percona数据库监控工具的安装部署

    Percona Monitoring and Management 安装 PMM是一个开源,免费的mysql管理监控平台,他可以用来分析mysql,mariadb和mongodb的服务器性能. 安装步 ...

  6. vue的声明式渲染

    声明式渲染 答:2018-8-23声明式渲染是vue对数据进行操作的模式,也叫做响应式渲染当dom节点上绑定了vue的对象的属性时,如果这个属性发生了改变,无需你进行其它的操作,页面上的数据会自动发生 ...

  7. 怎么将oracle的sql文件转换成mysql的sql文件

    怎么将sql文件导入PowerDesigner中的方法(将oracle的sql文件转换成mysql的sql文件)呢? 怎么将xx.sql文件的数据库结构导入powerdesigner 的方法呢? 现讲 ...

  8. 纯js轮播图练习-2,js+css旋转木马层叠轮播

    基于css3的新属性,加上js的操作,让现在js轮播图花样越来越多. 而现在出现的旋转木马层叠轮播的轮播图样式,却是得到了很多人都喜爱和投入使用. 尤其是在各大软件中,频繁的出现在大家的眼里,在web ...

  9. 【Spark】Spark2.x版的新特性

    一.API 1. 出现新的上下文接口:SparkSession,统一了SQLContext和HiveContext,并且为SparkSession开发了新的流式调用的configuration API ...

  10. MySQL的JOIN用法

    JOIN的含义就如英文单词“join”一样,连接两张表,大致分为内连接,外连接,右连接,左连接,自然连接.这里描述先甩出一张用烂了的图,然后插入测试数据. CREATE TABLE t_blog( i ...