LibEvent-Demo

// libevent-test.cpp : 定义控制台应用程序的入口点。
//

//#include "stdafx.h"

#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"wsock32.lib")
#pragma comment(lib,"libevent.lib")
#pragma comment(lib,"libevent_core.lib")
#pragma comment(lib,"libevent_extras.lib")


#include <stdio.h>
#include <stdlib.h>
#include <evhttp.h>
#include <event.h>
#include <string.h>
#include "event2/http.h"
#include "event2/event.h"
#include "event2/buffer.h"
#include "event2/bufferevent.h"
#include "event2/bufferevent_compat.h"
#include "event2/http_struct.h"
#include "event2/http_compat.h"
#include "event2/util.h"
#include "event2/listener.h"

#define BUF_MAX 1024*16
#define RESTFUL_URL_KHREALTIMEDATA		"/api/v1/khrealtimedata"
#define RESTFUL_URL_KHQUERYDATA			"/api/v1/khquerydata"
#define RESTFUL_URL_KHINSERT			"/api/v1/khinsert"
#define RESTFUL_URL_KHVARIABLESNUMBER	"/api/v1/khvariablesnumber"
#define RESTFUL_URL_KHVARIABLES			"/api/v1/khvariables"
#define RESTFUL_URL_KHADDTAGS			"/api/v1/khaddtags"
#define RESTFUL_URL_KHDATASAMPLING		"/api/v1/khsamplingdata"
#define RESTFUL_URL_REGISTERCLIENT		"/api/v1/khregisterclient"	//注册客户端
//解析post请求数据
void get_post_message(char *buf, struct evhttp_request *req)
{
	size_t post_size = 0;

	post_size = evbuffer_get_length(req->input_buffer);//获取数据长度
	printf("====line:%d,post len:%d\n",__LINE__,post_size);
	if (post_size <= 0)
	{
		printf("====line:%d,post msg is empty!\n",__LINE__);
		return;
	}
	else
	{
		size_t copy_len = post_size > BUF_MAX ? BUF_MAX : post_size;
		printf("====line:%d,post len:%d, copy_len:%d\n",__LINE__,post_size,copy_len);
		memcpy(buf, evbuffer_pullup(req->input_buffer,-1), copy_len);
		buf[post_size] = '\0';
		printf("====line:%d,post msg:%s\n",__LINE__,buf);
	}
}

//解析http头，主要用于get请求时解析uri和请求参数
char *find_http_header(struct evhttp_request *req,struct evkeyvalq *params,const char *query_char)
{
	if(req == NULL || params == NULL || query_char == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"input params is null.");
		return NULL;
	}

	struct evhttp_uri *decoded = NULL;
	char *query = NULL;	
	char *query_result = NULL;
	const char *path;
	const char *uri = evhttp_request_get_uri(req);//获取请求uri

	if(uri == NULL)
	{
		printf("====line:%d,evhttp_request_get_uri return null\n",__LINE__);
		return NULL;
	}
	else
	{
		printf("====line:%d,Got a GET request for <%s>\n",__LINE__,uri);
	}

	//解码uri
	decoded = evhttp_uri_parse(uri);
	if (!decoded) 
	{
		printf("====line:%d,It's not a good URI. Sending BADREQUEST\n",__LINE__);
		evhttp_send_error(req, HTTP_BADREQUEST, 0);
		return NULL;
	}

	//获取uri中的path部分
	path = evhttp_uri_get_path(decoded);
	if (path == NULL) 
	{
		path = "/";
	}
	else
	{
		printf("====line:%d,path is:%s\n",__LINE__,path);
	}

	//获取uri中的参数部分
	query = (char*)evhttp_uri_get_query(decoded);
	if(query == NULL)
	{
		printf("====line:%d,evhttp_uri_get_query return null\n",__LINE__);
		return NULL;
	}

	//查询指定参数的值
	evhttp_parse_query_str(query, params);			
	query_result = (char*)evhttp_find_header(params, query_char);

	return query_result;
}

//处理get请求
void http_handler_testget_msg(struct evhttp_request *req,void *arg)
{
	if(req == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"input param req is null.");
		return;
	}

	char *sign = NULL;
	char *data = NULL;
	struct evkeyvalq sign_params = {0};
	sign = find_http_header(req,&sign_params,"sign");//获取get请求uri中的sign参数
	if(sign == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"request uri no param sign.");
	}
	else
	{
		printf("====line:%d,get request param: sign=[%s]\n",__LINE__,sign);
	}

	data = find_http_header(req,&sign_params,"data");//获取get请求uri中的data参数
	if(data == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"request uri no param data.");
	}
	else
	{
		printf("====line:%d,get request param: data=[%s]\n",__LINE__,data);
	}
	printf("\n");

	//回响应
	struct evbuffer *retbuff = NULL;
	retbuff = evbuffer_new();
	if(retbuff == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"retbuff is null.");
		return;
	}
	evbuffer_add_printf(retbuff,"Receive get request,Thamks for the request!");
	evhttp_send_reply(req,HTTP_OK,"Client",retbuff);
	evbuffer_free(retbuff);
}

//处理post请求
void http_handler_testpost_msg(struct evhttp_request *req,void *arg)
{
	if(req == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"input param req is null.");
		return;
	}

	char buf[BUF_MAX] = {0};
	get_post_message(buf, req);//获取请求数据，一般是json格式的数据
	if(buf == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"get_post_message return null.");
		return;
	}
	else
	{
		//可以使用json库解析需要的数据
		printf("====line:%d,request data:%s",__LINE__,buf);
	}

	//回响应
	struct evbuffer *retbuff = NULL;
	retbuff = evbuffer_new();
	if(retbuff == NULL)
	{
		printf("====line:%d,%s\n",__LINE__,"retbuff is null.");
		return;
	}
	evbuffer_add_printf(retbuff,"Receive post request,Thamks for the request!");
	evhttp_send_reply(req,HTTP_OK,"Client",retbuff);
	evbuffer_free(retbuff);
}
void generic_handler(struct evhttp_request *req, void *arg)
{
	struct evbuffer *buf = evbuffer_new();
	if(!buf)
	{
		puts("failed to create response buffer \n");
		return;
	}

	evbuffer_add_printf(buf, "Server Responsed. Requested: %s\n", evhttp_request_get_uri(req));
	evhttp_send_reply(req, HTTP_OK, "OK", buf);
	evbuffer_free(buf);
}
int init_win_socket()
{
	WSADATA wsaData;
	if(WSAStartup(MAKEWORD(2,2) , &wsaData) != 0) 
	{
		return -1;
	}
	return 0;
}
///
//             http:对每个事件分别处理					//
///
// int main()
// {
// 
// 	WSADATA wsaData;
// 	if(WSAStartup(MAKEWORD(2,2) , &wsaData) != 0) 
// 	{
// 		return -1;
// 	}
// 	short http_port = 4567;
// 	char *http_addr = "127.0.0.1";
// 
// 	//初始化
// 	event_init();
// 	//启动http服务端
// 	struct evhttp *http_server = evhttp_start(http_addr,http_port);
// 	if(http_server == NULL)
// 	{
// 		printf("====line:%d,%s\n",__LINE__,"http server start failed.");
// 		return -1;
// 	}
// 
// 	//设置请求超时时间(s)
// 	evhttp_set_timeout(http_server,5);
// 	//设置事件处理函数，evhttp_set_cb针对每一个事件(请求)注册一个处理函数，
// 	//区别于evhttp_set_gencb函数，是对所有请求设置一个统一的处理函数
// 	evhttp_set_cb(http_server,RESTFUL_URL_KHQUERYDATA,http_handler_testpost_msg,NULL);
// 	evhttp_set_cb(http_server,"/me/testget",http_handler_testget_msg,NULL);
// 
// 
// 
// 	//循环监听
// 	event_dispatch();
// 	//实际上不会释放，代码不会运行到这一步
// 	evhttp_free(http_server);
// 
// 	return 0;
// }
/
//				http：对所有请求统一由一个函数处理													//

int main(int argc, char* argv[])
{
#ifdef WIN32
	init_win_socket();
#endif

	short          http_port = 4567;
	char          *http_addr = "127.0.0.1";

	struct event_base * base = event_base_new();

	struct evhttp * http_server = evhttp_new(base);
	if(!http_server)
	{
		return -1;
	}

	int ret = evhttp_bind_socket(http_server,http_addr,http_port);
	if(ret!=0)
	{
		return -1;
	}

	evhttp_set_gencb(http_server, generic_handler, NULL);

	printf("http server start OK! \n");

	event_base_dispatch(base);

	evhttp_free(http_server);

	WSACleanup();
	return 0;
}
//
//					服务端程序demo
//
// #include <stdio.h>
// #include <time.h>
// 
// #include <event2/bufferevent.h>
// #include <event2/buffer.h>
// #include <event2/listener.h>
// #include <event2/util.h>
// #include <event2/event.h>
// 
// const int PORT = 2500;
// const int BUFFER_SIZE = 1024;
// 
// void listener_cb(struct evconnlistener *, evutil_socket_t,
// struct sockaddr *, int socklen, void *);
// void conn_writecb(struct bufferevent *, void *);
// void conn_readcb(struct bufferevent *, void *);
// void conn_eventcb(struct bufferevent *, short, void *);
// void delay(int ms);
// 
// int main(int argc, char **argv)
// {
// 	printf("I am server\n");
// #ifdef WIN32
// 	WSAData wsaData;
// 	WSAStartup(MAKEWORD(2, 0), &wsaData);
// #endif
// 	struct sockaddr_in sin;
// 	memset(&sin, 0, sizeof(sin));
// 	sin.sin_family = AF_INET;
// 	sin.sin_port = htons(PORT);
// 
// 	struct evconnlistener *listener;
// 	struct event_base *base = event_base_new();
// 	if (!base)
// 	{
// 		printf("Could not initialize libevent\n");
// 		return 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)
// 	{
// 		printf("Could not create a listener\n");
// 		return 1;
// 	}
// 
// 	event_base_dispatch(base);
// 	evconnlistener_free(listener);
// 	event_base_free(base);
// 
// 	printf("done\n");
// 	return 0;
// }
// 
// void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,struct sockaddr *sa, int socklen, void *user_data)
// {
// 	printf("Detect an connection\n");
// 	struct event_base *base = (struct event_base *)user_data;
// 	struct bufferevent *bev;
// 
// 	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
// 	if (!bev)
// 	{
// 		printf("Could not create a bufferevent\n");
// 		event_base_loopbreak(base);
// 		return;
// 	}
// 	bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, NULL);
// 	bufferevent_enable(bev, EV_READ|EV_WRITE);
// 	//服务器监听到连接时，给客户端发送第一条消息
// 	char *reply_msg = "I receive a message from server";
// 	bufferevent_write(bev, reply_msg, strlen(reply_msg));
// }
// 
// //conn_writecwritecb函数将在bufferevent中的output evbuffer缓冲区发送完成后被调用。
// //此时evbuffer_get_length(output) = 0，说明output evbuffer缓冲区被清空。
// //假设发现有10000条记录要发送出去，1次发送10000条将占用大量内存，所以，我们要分批发送
// //先发送100条数据，假设每条数据为1024字节bufferevent_write(bev,buf,1024 *100);
// //系统在这100条记录发送完成后将调用conn_writecbb回调函数,然后在该函数中循环发送剩下的
// //数据
// void conn_writecb(struct bufferevent *bev, void *user_data)
// {
// 	//    struct evbuffer *output = bufferevent_get_output(bev);
// 	//    if (evbuffer_get_length(output) == 0)
// 	//    {
// 	//        printf("Output evbuffer is flushed\n");
// 	//        bufferevent_free(bev);
// 	//    }
// 	//delay 1 second
// 	delay(1000);
// 	static int msg_num = 1;
// 	char reply_msg[1000] = {'\0'};
// 	char *str = "I receive a message from server ";
// 	memcpy(reply_msg,str,strlen(str));
// 	sprintf(reply_msg+strlen(str),"%d",msg_num);
// 	bufferevent_write(bev, reply_msg, strlen(reply_msg));
// 	msg_num++;
// }
// 
// void conn_readcb(struct bufferevent *bev, void *user_data)
// {
// 	struct evbuffer *input =bufferevent_get_input(bev);
// 	size_t sz=evbuffer_get_length(input);
// 	if (sz > 0)
// 	{
// 		char msg[BUFFER_SIZE] = {'\0'};
// 		bufferevent_read(bev, msg, sz);
// 		printf("%s\n", msg);
// 	}
// }
// 
// void conn_eventcb(struct bufferevent *bev, short events, void *user_data)
// {
// 	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);
// }
// 
// void delay(int ms)
// {
// 	clock_t start = clock();
// 	while(clock() - start < ms);
// }