Libevent库
作用
开源的库、提高了开发效率
封装了socket通信
封装了IO多路转接
精简，专注于网络，性能高
事件驱动形式
过程：
1、事件的底层处理框架
一个函数
2、消息循环
一个函数
3、创建事件
不带缓冲区—event
几个函数
带缓冲区 ----bufferevent
几个函数
4、资源释放
几个函数
事件处理框架-event_base
1、
在使用libevent函数之前需要分配一个或者多个event_base结构体。每个结event_base结构体持有一个事件集合，可以检测以确定哪个事件是激活的。
相当于epoll红黑树的树根
底座
抽象层，完成对event_base的封装
每个event_base都有一种用于检测哪种事件已经就绪的"方法"
event_base结构体如下：
struct eventop{
const char *name;
void *(init)(struct event_base *);//初始化
int (*add)(void *,struct event *);//注册事件
int (*del)(void *,struct event *);//删除事件
....
};
...
...
2、
–创建event_base
struct event_base base = event_base_new(void);*
失败返回NULL
–释放event_base
event_base_free(struct event_base*base);
–循环监听base对应的事件，等待条件满足
event_base_dispatch
3、
–查看event_base封装的后端
const char** event_get_supported_methods(void);
char* str[];
const char* event_base_get_method(const struct event_base *base);
–event_base和fork
子进程创建成功之后，父进程可以继续使用event_base
子进程中需要继续使用event_base需要重新进程初始化
int event_reint(struct event_base*base);
使用套路
1、创建一个事件处理框架 event_base_new(void) 其中有消息循环但要自己启动
2、创建一个事件
3、事件添加到事件处理框架上
4、开始事件循环
5、释放资源
-释放event_base
event_base_free(struct event_base* base);
事件循环 – event_loop
一旦有一个已经注册了某件事件的event_base,就需要让libevent等待事件并且通知事件的发生
#define EVLOOP_ONCE 0X01
事件只会被触发一次
事件没有被触发，阻塞等
#define EVLOOP_NONBLOCK 0X02
非阻塞等方式去做事件检测
不关心事件是否触发了
#define EVLOOP_NO_EXIT_ON_EMPTY 0X04
没有事件的时候，也不推出轮询检测
1、 int event_base_loop(struct event_base*base,int flags);
a.正常退出返回0，失败退出返回-1
2、 int event_base_dispatch(struct event_base*base);
等同于没有设置标志位的 event_base_loop()
将一直运行，直到没有已经注册的事件了 或者调用了event_base_loopbreak()或者event_base_loopexit()为止。
3、循环停止
返回值:成功0 失败-1
struct timeval{
long tv_sec;
long tv_usec;
};
如果event_base 当前正在执行激活时间的回调，他将在执行完当前正在处理的事件后立即退出
int event_base_loopexit(
struct event_base*base,
const struct timeval* tv
);
让event_base立即退出循环
int event_base_loopbreak(struct event_base*base);
事件创建–event
1、创建新事件
#define EV_TIMEOUT 0X01 //已经废弃
#define EV_READ 0X02
#define EV_WRITE 0X04
#define EV_SIGNAL 0X08
#define EV_PERSIST 0X10 //持续模式
#define EV_ET 0X20 //边沿模式
typefef void(*event_callback_fn)(evutil socket_t,short,void*);
struct event*event_new(
struct event_base*base;
evutil_socket_t fd //文件描述符--int 传到回调的fd
short what //传到回调的 short
event_callback_fn cb //事件的处理动作
void*arg //传到回调的参数
);
调用event_new()函数之后，新事件处于已经初始化和非未决状态
1、非未决
没有资格被处理
2、未决
有资格被处理但是还没有被处理
2、释放事件
void event_free(struct event *event);
3、设置未决事件
构造事件之后，将其添加到event_base 之前实际上是不能对其做任何操作的。使用event_add()将事件添加到event_base,非未决事件->未决事件。
int event_add(
struct event*ev,
const struct timeval *tv
);
-tv
NULL：事件被处罚，对应的回调被调用
tv = {0,100}，如果设置的事件
在改时间段内检测的事件没被触发，事件到达之后，回调函数还是会被调用
函数调用成功返回0，失败返回-1
4、设置非未决
int event_del(struct evnet*ev);
对已经初始化的事件调用event_del()将使其成为非未决和非激活的，如果事件不是为觉得或者激活的，调用将没有效果。成功时，函数返回0，失败时，返回-1
##事件的状态转换
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-222rj9CQ-1600939606704)(C:\Users\AJIM\Desktop\C++\事件)]
数据缓存区 -Bufferevent
1、event2/bufferevent.h
2、bufferevent理解:
是libevent为IO缓冲区操作提供一种通用的机制
bufferevent由一个底层的传输端口(如套接字)，一个读取缓冲区和一个写入缓冲区组成
与通常的事件在底层传输窗口已经就绪，可以读取或者写入的时候执行回调，不同的是，bufferevent在读取或者写入足够量的数据之后调用用户提供的回调
3、回调–缓冲区对应的操作
每个bufferevent有两个数据相关的回调
一个读取回调
从底层传输端口读取了任意量的数据之后，会调用读取回调(默认)
一个写入回调
输出缓冲区中足够量的数据被清空到底层传输端口后写入回调会被调用(默认)
使用bufferevent
1、创建基于套接字的bufferevent
可以使用bufferevent_socket_new()创建基于套接字的bufferevent
struct bufferevent*bufferevent_socket_new(
struct event_base*base,
evutil_socket_t fd,
enum bufferevent_options options
);
options: BEV_OPT_CLOSE_ON_FREE
释放bufferevent时关闭顶层传输端口。这将关闭底层套接字，释放底层buffevent等
参考手册page53 --bufferevent的选项标志
struct bufferevent 也是一个event
成功时函数返回一个bufferevent,失败时则返回NULL
2、在bufferevent上启动链接
int bufferevent_socket_connect(
struct bufferevent *bev,
struct sockaddr*address,--server ip 和 port
int addrlen
);
address 和 addrlen参数跟标准调用connect()的参数相同。如果还没有为bufferevent设置套接字，调用函数将为其分配一个新的流套接字，并且设置为非阻塞的。
如果已经为bufferevent设置套接字，套用bufferevent_socket_connect()将告知libevent套接字还未连接，直到连接成功之前不应该对其进行读取或者写入操作
连接完成之前可以向输出缓冲区添加数据
3、释放bufferevent操作
void bufferevent_free(struct bufferevent*bev);
这个函数释放bufferevent
4、bufferevent读写缓冲区写回调操作
typedef void(*bufferevent_data_cb)(
struct bufferevent *bev,
void *ctx
);
typedef vood(*bufferevent_event_cb)(
struct bufferevent* bev,
short events,
void *ctx
)
events参数：
EV_EVENT_READING：读取操作时发生某事件，具体时哪种事件看其他标志
BEV_EVENT_WRITING:写入操作时发生某事件，具体时哪种事件请看其他标志。
BEV_EVENT_ERROR:操作时发生错误。关于错误的更多信息，请调用EVUTIL_SOCKET_ERROR()。
BEV_EVENT_TIMEOUT：发生超时。
BEV_EVENT_EOF:遇到文件结束指示
BEV_EVENT_CONNECTED:请求连接过程已经完成
实现客户端时可以判断
void bufferevent_setcb(
struct bufferevent*bufev,
bufferevent_data_cb readcb,
--在读回调中读数据
--bufferevent_read()
bufferevent_data_cb writecb,
--NULL
bufferevent_event_cb eventcb,
--NULL
void *cbarg
);
5、禁用、启动缓冲区
禁用之后，对应的回调也就不会被调用了
void bufferevent_enable(
struct bufferevent *bufev,
short events
);
void bufferevent_disable(
struct bufferevent*bufev,
short events
);
short bufferevent_get_enabled(
struct bufferevent* bufev
);
可以启动或者禁用buffevent上的EV_READ、EV_WRITE或者EV_READ|EV_WRITE事件。没有启动读取或者写入事件时，bufferevent将不会试图进行数据读取或者写入。
6、操作bufferevent中的数据
向bufferevent的输出缓冲区添加数据
int bufferevent_write(
struct buffevent*bufev,
const void*data,
size_t size
);
从bufferevent的输入缓冲区移除数据
size_t bufferevent_read(
struct bufferevent* bufev,
void *data,
size_t size
);
链接监听器–evconnlistener
1、创建和释放evconnlistener
typedef void(*evconnlistener_cb)(
struct evconnlistener* listener,
evutil_socket_t sock,
用于通信的文件描述符
struct sockaddr*addr,
客户端的IP和端口信息
int len,
void *prt
外部传进来的数据
);
struct evconnlistener* evconnlistner_new(
struct event_base* base,
evconnlistener_cb cb,
void* ptr,
unsigned flags,
int backlog,
evutil_socket_t fd
);
参数flags:
参考手册--page99-100[可识别的标志]
LEV_OPT_CLOSE_ON_FREE
LEV_OPT_REUSEABLE
struct econnlistener* evonnlistener_new_bind(
struct event_base*base,
evconnlistener_cb cb, ---接受连接之后，用户要做的操作
void *ptr,//给回调传参
unsigned flags,
int backlog,
----1：使用默认的最大值
const struct sockaddr*sa
---- 服务器的IP和端口信息
int socklen);
两个evconnlistener_new*()函数都分配和返回一个新的连接监听器对象。连接监听器使用event_base来得说什么时候在给定得监听套接字上有新的TCP连接。新的连接到达时，监听器调用你给的回调函数
void evconnlistener_free(struct evconnlistener*lev);
2、启动和禁用 evconnlistener
*int evconnlistener_disable(struct evconnlistener lev);
*int evconnlistener_enable(struct evconnlistener lev);
这两个函数暂时禁止或者重新允许监听新连接
3、调整evconnlistener的回调函数
void evconnlistener_set_cb(
struct evconnlistener*lev,
evconnlistener_cb cb,
void *arg
);
函数调整evconnlistener的回调函数和其参数
重要的函数总结
必须需要掌握的函数：
--创建event_base
struct event_base*event_base_new(void);
失败返回NULL
--释放event_base
event_base_free(struct event_base*base);
--事件创建----（分为有缓冲区和无缓冲区）
------没有缓冲区
struct event*event_new();
int event_add(
struct event*ev,
const struct timeval *tv
);
--释放事件：
void event_free(struct event*event);
--开始事件循环：
int event_base_dispatch(struct event_base*base);
=========================套接字通信==========================
1、创建带缓冲区的事件
struct bufferevnet*bufferevent_socket_new(
struct event_base*base,
evutil_socket_t fd,
enum bufferevent_options options
);
给读写缓冲区设置回调
void bufferevent_setcb(
sturct bufferevent*bufev,
bufferevent_data_cb readcb,
bufferevent_data_cb writecb,
bufferevent_event_cb eventcb,
void *cbarg
);
void bufferevent_enable(
struct bufferevnet*bufev,
short events
);
默认ev_write 时enable
ev_read是关闭的
2、套接字通信，客户端连接服务器
int bufferevent_socket_connect(
struct bufferevent *bev,
struct sockaddr*address, --server ip 和 port
int addrlen
);
3、服务端用的函数
创建监听的套接字
绑定
监听
接受连接请求
struct evconnlistener *evconnlistener_new_bind(
struct event_base*base,
evconnlisten_cb cb,
void *ptr,
unsigned flags,
int backlog,
const struct sockaddr *sa,
int socklen
);
4、操作bufferevent中的数据
向bufferevent的输出缓冲区中添加数据
int bufferevnet_write(
struct bufferevnet*bufev,
const void* data,
size_t size
);
从bufferevent的输入缓冲区移除数据
size_t bufferevent_read(
struct bufferevnet*bufev,
void *data,
size_t size
);
例子：HTTP的简单实现
main.c
#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <event2/bufferevent.h>
#include <event2/listener.h>
#include <event2/event.h>
#include "libevent_http.h"
int main(int argc, char **argv)
{
if(argc < 3)
{
printf("./event_http port path\n");
return -1;
}
if(chdir(argv[2]) < 0) {
printf("dir is not exists: %s\n", argv[2]);
perror("chdir err:");
return -1;
}
struct event_base *base;
struct evconnlistener *listener;
struct event *signal_event;
struct sockaddr_in sin;
base = event_base_new();
if (!base)
{
fprintf(stderr, "Could not initialize libevent!\n");
return 1;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(atoi(argv[1]));
// 创建监听的套接字，绑定，监听，接受连接请求
listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener)
{
fprintf(stderr, "Could not create a listener!\n");
return 1;
}
// 创建信号事件, 捕捉并处理
signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
if (!signal_event || event_add(signal_event, NULL)<0)
{
fprintf(stderr, "Could not create/add a signal event!\n");
return 1;
}
// 事件循环
event_base_dispatch(base);
evconnlistener_free(listener);
event_free(signal_event);
event_base_free(base);
printf("done\n");
return 0;
}
libevent_http.h
#ifndef _LIBEVENT_HTTP_H
#define _LIBEVENT_HTTP_H
#include <event2/event.h>
void conn_eventcb(struct bufferevent *bev, short events, void *user_data);
void conn_readcb(struct bufferevent *bev, void *user_data);
const char *get_file_type(char *name);
int hexit(char c);
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *sa, int socklen, void *user_data);
int response_http(struct bufferevent *bev, const char *method, char *path);
int send_dir(struct bufferevent *bev,const char *dirname);
int send_error(struct bufferevent *bev);
int send_file_to_http(const char *filename, struct bufferevent *bev);
int send_header(struct bufferevent *bev, int no, const char* desp, const char *type, long len);
void signal_cb(evutil_socket_t sig, short events, void *user_data);
void strdecode(char *to, char *from);
void strencode(char* to, size_t tosize, const char* from);
#endif
libevent_http.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <string.h>
#include <dirent.h>
#include <time.h>
#include <signal.h>
#include <ctype.h>
#include <errno.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include "libevent_http.h"
#define _HTTP_CLOSE_ "Connection: close\r\n"
int response_http(struct bufferevent *bev, const char *method, char *path)
{
if(strcasecmp("GET", method) == 0){
//get method ...
strdecode(path, path);
char *pf = &path[1];
if(strcmp(path, "/") == 0 || strcmp(path, "/.") == 0)
{
pf="./";
}
printf("***** http Request Resource Path = %s, pf = %s\n", path, pf);
struct stat sb;
if(stat(pf,&sb) < 0)
{
perror("open file err:");
send_error(bev);
return -1;
}
if(S_ISDIR(sb.st_mode))//处理目录
{
//应该显示目录列表
send_header(bev, 200, "OK", get_file_type(".html"), -1);
send_dir(bev, pf);
}
else //处理文件
{
send_header(bev, 200, "OK", get_file_type(pf), sb.st_size);
send_file_to_http(pf, bev);
}
}
return 0;
}
/*
*charset=iso-8859-1 西欧的编码，说明网站采用的编码是英文；
*charset=gb2312 说明网站采用的编码是简体中文；
*charset=utf-8 代表世界通用的语言编码；
* 可以用到中文、韩文、日文等世界上所有语言编码上
*charset=euc-kr 说明网站采用的编码是韩文；
*charset=big5 说明网站采用的编码是繁体中文；
*
*以下是依据传递进来的文件名，使用后缀判断是何种文件类型
*将对应的文件类型按照http定义的关键字发送回去
*/
const char *get_file_type(char *name)
{
char* dot;
dot = strrchr(name, '.'); //自右向左查找‘.’字符;如不存在返回NULL
if (dot == (char*)0)
return "text/plain; charset=utf-8";
if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0)
return "text/html; charset=utf-8";
if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0)
return "image/jpeg";
if (strcmp(dot, ".gif") == 0)
return "image/gif";
if (strcmp(dot, ".png") == 0)
return "image/png";
if (strcmp(dot, ".css") == 0)
return "text/css";
if (strcmp(dot, ".au") == 0)
return "audio/basic";
if (strcmp( dot, ".wav") == 0)
return "audio/wav";
if (strcmp(dot, ".avi") == 0)
return "video/x-msvideo";
if (strcmp(dot, ".mov") == 0 || strcmp(dot, ".qt") == 0)
return "video/quicktime";
if (strcmp(dot, ".mpeg") == 0 || strcmp(dot, ".mpe") == 0)
return "video/mpeg";
if (strcmp(dot, ".vrml") == 0 || strcmp(dot, ".wrl") == 0)
return "model/vrml";
if (strcmp(dot, ".midi") == 0 || strcmp(dot, ".mid") == 0)
return "audio/midi";
if (strcmp(dot, ".mp3") == 0)
return "audio/mpeg";
if (strcmp(dot, ".ogg") == 0)
return "application/ogg";
if (strcmp(dot, ".pac") == 0)
return "application/x-ns-proxy-autoconfig";
return "text/plain; charset=utf-8";
}
int send_file_to_http(const char *filename, struct bufferevent *bev)
{
int fd = open(filename, O_RDONLY);
int ret = 0;
char buf[4096] = {0};
while( (ret = read(fd, buf, sizeof(buf)) ) )
{
bufferevent_write(bev, buf, ret);
memset(buf, 0, ret);
}
close(fd);
return 0;
}
int send_header(struct bufferevent *bev, int no, const char* desp, const char *type, long len)
{
char buf[256]={0};
sprintf(buf, "HTTP/1.1 %d %s\r\n", no, desp);
//HTTP/1.1 200 OK\r\n
bufferevent_write(bev, buf, strlen(buf));
// 文件类型
sprintf(buf, "Content-Type:%s\r\n", type);
bufferevent_write(bev, buf, strlen(buf));
// 文件大小
sprintf(buf, "Content-Length:%ld\r\n", len);
bufferevent_write(bev, buf, strlen(buf));
// Connection: close
bufferevent_write(bev, _HTTP_CLOSE_, strlen(_HTTP_CLOSE_));
//send \r\n
bufferevent_write(bev, "\r\n", 2);
return 0;
}
int send_error(struct bufferevent *bev)
{
send_header(bev,404, "File Not Found", "text/html", -1);
send_file_to_http("404.html", bev);
return 0;
}
int send_dir(struct bufferevent *bev,const char *dirname)
{
char encoded_name[1024];
char path[1024];
char timestr[64];
struct stat sb;
struct dirent **dirinfo;
char buf[4096] = {0};
sprintf(buf, "<html><head><meta charset=\"utf-8\"><title>%s</title></head>", dirname);
sprintf(buf+strlen(buf), "<body><h1>当前目录：%s</h1><table>", dirname);
//添加目录内容
int num = scandir(dirname, &dirinfo, NULL, alphasort);
for(int i=0; i<num; ++i)
{
// 编码
strencode(encoded_name, sizeof(encoded_name), dirinfo[i]->d_name);
sprintf(path, "%s%s", dirname, dirinfo[i]->d_name);
printf("############# path = %s\n", path);
if (lstat(path, &sb) < 0)
{
sprintf(buf+strlen(buf),
"<tr><td><a href=\"%s\">%s</a></td></tr>\n",
encoded_name, dirinfo[i]->d_name);
}
else
{
strftime(timestr, sizeof(timestr),
" %d %b %Y %H:%M", localtime(&sb.st_mtime));
if(S_ISDIR(sb.st_mode))
{
sprintf(buf+strlen(buf),
"<tr><td><a href=\"%s/\">%s/</a></td><td>%s</td><td>%ld</td></tr>\n",
encoded_name, dirinfo[i]->d_name, timestr, sb.st_size);
}
else
{
sprintf(buf+strlen(buf),
"<tr><td><a href=\"%s\">%s</a></td><td>%s</td><td>%ld</td></tr>\n",
encoded_name, dirinfo[i]->d_name, timestr, sb.st_size);
}
}
bufferevent_write(bev, buf, strlen(buf));
memset(buf, 0, sizeof(buf));
}
sprintf(buf+strlen(buf), "</table></body></html>");
bufferevent_write(bev, buf, strlen(buf));
printf("################# Dir Read OK !!!!!!!!!!!!!!\n");
return 0;
}
void conn_readcb(struct bufferevent *bev, void *user_data)
{
printf("******************** begin call %s.........\n",__FUNCTION__);
char buf[4096]={0};
char method[50], path[4096], protocol[32];
bufferevent_read(bev, buf, sizeof(buf));
printf("buf[%s]\n", buf);
sscanf(buf, "%[^ ] %[^ ] %[^ \r\n]", method, path, protocol);
printf("method[%s], path[%s], protocol[%s]\n", method, path, protocol);
if(strcasecmp(method, "GET") == 0)
{
response_http(bev, method, path);
}
printf("******************** end call %s.........\n", __FUNCTION__);
}
void conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
printf("******************** begin call %s.........\n", __FUNCTION__);
if (events & BEV_EVENT_EOF)
{
printf("Connection closed.\n");
}
else if (events & BEV_EVENT_ERROR)
{
printf("Got an error on the connection: %s\n",
strerror(errno));
}
bufferevent_free(bev);
printf("******************** end call %s.........\n", __FUNCTION__);
}
void signal_cb(evutil_socket_t sig, short events, void *user_data)
{
struct event_base *base = user_data;
struct timeval delay = { 1, 0 };
printf("Caught an interrupt signal; exiting cleanly in one seconds.\n");
event_base_loopexit(base, &delay);
}
void listener_cb(struct evconnlistener *listener,
evutil_socket_t fd,struct sockaddr *sa, int socklen, void *user_data)
{
printf("******************** begin call-------%s\n",__FUNCTION__);
struct event_base *base = user_data;
struct bufferevent *bev;
printf("fd is %d\n",fd);
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!bev)
{
fprintf(stderr, "Error constructing bufferevent!");
event_base_loopbreak(base);
return;
}
bufferevent_flush(bev, EV_READ | EV_WRITE, BEV_NORMAL);
bufferevent_setcb(bev, conn_readcb, NULL, conn_eventcb, NULL);
bufferevent_enable(bev, EV_READ | EV_WRITE);
printf("******************** end call-------%s\n",__FUNCTION__);
}
/*
* 这里的内容是处理%20之类的东西！是"解码"过程。
* %20 URL编码中的‘ ’(space)
* %21 '!' %22 '"' %23 '#' %24 '$'
* %25 '%' %26 '&' %27 ''' %28 '('......
* 相关知识html中的‘ ’(space)是 
*/
void strdecode(char *to, char *from)
{
for ( ; *from != '\0'; ++to, ++from)
{
if (from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
{
// 依次判断from中 %20 三个字符
*to = hexit(from[1])*16 + hexit(from[2]);
// 移过已经处理的两个字符(%21指针指向1),表达式3的++from还会再向后移一个字符
from += 2;
}
else
{
*to = *from;
}
}
*to = '\0';
}
//16进制数转化为10进制, return 0不会出现
int hexit(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
return 0;
}
// "编码"，用作回写浏览器的时候，将除字母数字及/_.-~以外的字符转义后回写。
// strencode(encoded_name, sizeof(encoded_name), name);
void strencode(char* to, size_t tosize, const char* from)
{
int tolen;
for (tolen = 0; *from != '\0' && tolen + 4 < tosize; ++from)
{
if (isalnum(*from) || strchr("/_.-~", *from) != (char*)0)
{
*to = *from;
++to;
++tolen;
}
else
{
sprintf(to, "%%%02x", (int) *from & 0xff);
to += 3;
tolen += 3;
}
}
*to = '\0';
}
248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
