libevent discard

windows client:

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

#include "stdafx.h"

#include <iostream>
#include <assert.h>
#include <string>
#include <stdint.h>
#include <vector>

#include "event2/event.h"
#include "event2/bufferevent.h"
#include "event2/buffer.h"
#include "event2/listener.h"
#include "event2/util.h"

#include "windowsSocket.h" // windows socket init

const char* CONNECT_IP = "192.168.239.150";
const unsigned short CONNECT_PORT = 5000;
const std::string g_message(256, '1');

void WriteCallback(struct bufferevent *bev, void *ctx)
{
	std::cout << "write callback, number:" << g_message.size() << std::endl;
	bufferevent_write(bev, g_message.c_str(), g_message.size());
}

void EventCallback(struct bufferevent *bev, short what, void *ctx)
{
	std::cout << "on event - ";
	if (what & BEV_EVENT_TIMEOUT) {
		std::cout << "time out" << std::endl;
	} else if (what & BEV_EVENT_EOF) {
		std::cout << "connection closed" << std::endl;
	} else if (what & BEV_EVENT_ERROR) {
		std::cout << "event error" << std::endl;
	} else if (what & BEV_EVENT_CONNECTED) {
		std::cout << "connected" << std::endl;
		evutil_make_socket_nonblocking(bufferevent_getfd(bev));
		bufferevent_write(bev, g_message.c_str(), g_message.size());
	} else if (what & BEV_EVENT_READING) {
		std::cout << "reading" << std::endl;
	} else if (what & BEV_EVENT_WRITING) {
		std::cout << "writing" << std::endl;
	} else {
		std::cout << "others" << std::endl;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	WindowsSocket::Startup(2, 2);
	
	struct sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = inet_addr(CONNECT_IP);
	sin.sin_port = htons(CONNECT_PORT);
	
	struct event_base *base = event_base_new();
	struct bufferevent *bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
	bufferevent_setcb(bev, NULL, WriteCallback, EventCallback, NULL);
	bufferevent_enable(bev, EV_WRITE | EV_PERSIST);

	struct evbuffer *output = bufferevent_get_output(bev);
	bufferevent_socket_connect(bev, (sockaddr*)&sin, sizeof(sin));
	event_base_dispatch(base);
	WindowsSocket::Cleanup();
	system("pause");
    return 0;
}

linux server:

#include <iostream>
#include <arpa/inet.h>
#include <time.h>
#include <stdlib.h>

#include <event2/event.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>

void event_cb(struct bufferevent *be, short event, void *val)
{
    std::cout << "event cb - ";
    if (event & BEV_EVENT_TIMEOUT) {
        std::cout << "time out" << std::endl;
    } else if (event & BEV_EVENT_EOF) {
        std::cout << "connection eof" << std::endl;
        goto out;
    } else if (event & BEV_EVENT_ERROR) {
        std::cout << "event error" << std::endl;
        goto out;
    } else if (event & BEV_EVENT_CONNECTED) {
        std::cout << "connected" << std::endl;
    } else if (event & BEV_EVENT_READING) {
        std::cout << "reading" << std::endl;
    } else if (event & BEV_EVENT_WRITING) {
        std::cout << "writing" << std::endl;
    } else {
        std::cout << "others" << std::endl;
    }
    return;
    
out:
    bufferevent_free(be);
}

void read_cb(struct bufferevent *be, void *val)
{
    std::cout << "read_cb" << std::endl;
    struct evbuffer *input = bufferevent_get_input(be);

    if (input) {
        int len = evbuffer_get_length(input);
        evbuffer_drain(input, len);
        std::cout << "drain:" << len << std::endl;
    }
}

void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *addr, int socklen, void *val)
{
    std::cout << "listener_cb, in, fd:"  << fd << std::endl;
    struct event_base *base = evconnlistener_get_base(listener);
    struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    bufferevent_setcb(bev, read_cb, NULL, event_cb, NULL);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);
}

int main()
{
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(0);
    sin.sin_port = htons(5000);

    struct event_base *base = event_base_new();
    struct evconnlistener *listener = evconnlistener_new_bind(base, listener_cb, NULL, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
                                    -1, (struct sockaddr*)&sin, sizeof(sin));

    std::cout << "start..." << std::endl;

    event_base_dispatch(base);
    evconnlistener_free(listener);
    return 0;
}