libevent

 

/*服务器端++++++++++++++++++++++++++++++++++++*/

 #include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h>
#include<iostream>
using namespace std;
typedef struct _ConnectStat {
    struct event*  ev;
}ConnectStat;
void accept_connection(int fd, short events, void* arg);
void do_echo_request(int fd, short events, void *arg);
void do_echo_response(int fd, short events, void *arg);
struct event_base* base;

int main(int argc, char** argv)
{
        int listener = socket(AF_INET, SOCK_STREAM, 0);
        struct sockaddr_in sin;
        sin.sin_family = AF_INET;
        sin.sin_addr.s_addr = 0;
        sin.sin_port = htons(80);

        bind(listener, (struct sockaddr *)&sin, sizeof(sin));
        listen(listener, 5);
        base = event_base_new();
        struct event* ev_listen = event_new(base, listener,
        EV_READ | EV_PERSIST,
        accept_connection, NULL);
        event_add(ev_listen, NULL);
        event_base_dispatch(base);
        return 0;
}
 

void  accept_connection(int fd, short events, void* arg)
{
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int sockfd = accept(fd, (struct sockaddr*)&client, &len);
    struct event *ev = event_new(NULL, -1, 0, NULL, NULL);
    ConnectStat *    stat = (ConnectStat *)malloc(sizeof(ConnectStat));
    stat->ev = ev;
    event_assign(ev, base, sockfd, EV_READ,
        do_echo_request, (void*)stat);
    event_add(ev, NULL);
}


void do_echo_request(int fd, short events, void *arg)
{
    ConnectStat *stat = (ConnectStat *)arg;
    struct event *ev = stat->ev;
    char a[1024];
    int len = read(fd, a, 1024);
    if (a[0]=='q') {
        event_free(ev);
        close(fd);
        free(stat);
        return;
    }
    a[len] = '\0';
    cout << a << endl;
    event_set(ev, fd, EV_WRITE, do_echo_response, (void*)stat);
    ev->ev_base = base;
    event_add(ev, NULL);
}

void do_echo_response(int fd, short events, void *arg) {
    ConnectStat * stat = (ConnectStat *)(arg);
    struct event * ev = stat->ev;
    char *a = "laozicao \n \0";
    int _s = write(fd, a, strlen(a));
    if (_s > 0)
    {
        printf("write successfully.\n");
    }
    event_set(ev, fd, EV_READ, do_echo_request, (void*)stat);
    ev->ev_base = base;
    event_add(ev, NULL);
    return;
}

/*客户端*+++++++++++++++++++++++++++++  */

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<errno.h>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<event.h>
#include<event2/util.h>
#include<iostream>
using namespace std;

void cmd_read_data(int fd, short events, void* arg);
void socket_read_data(int fd, short events, void *arg);

int main()
{ 
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(80);
    inet_aton("192.168.203.128", &server_addr.sin_addr);
    int sockfd = socket(PF_INET, SOCK_STREAM, 0);
    connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    struct event_base* base = event_base_new();
    struct event *ev_sockfd = event_new(base, sockfd,
        EV_READ | EV_PERSIST,
        socket_read_data, NULL);
    event_add(ev_sockfd, NULL);
    struct event* ev_cmd = event_new(base, STDIN_FILENO,
        //STDIN_FILENO 标准输入
        EV_READ | EV_PERSIST, cmd_read_data,
        (void*)&sockfd);
    event_add(ev_cmd, NULL);
    event_base_dispatch(base);
    return 0;
}


void cmd_read_data(int fd, short events, void* arg)
{
    char msg[1024];
    int ret = read(fd, msg, sizeof(msg) - 1);
    int sockfd = *((int*)arg);
    if (msg[ret - 1] == '\n')
    {
        msg[ret - 1] = '\0';
    }  
    write(sockfd, msg, ret);
}


void socket_read_data(int fd, short events, void *arg)
{
    char msg[1024];
    int len = read(fd, msg, sizeof(msg) - 1);
    msg[len] = '\0';
    cout << msg << endl;
}

/****************************************************************************************/

buffevent  事件

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h>
#include <iostream>
using namespace std;

#define BUFLEN  1024

typedef struct _ConnectStat {
    struct bufferevent* bev;
}ConnectStat;


void accept_connection(int fd, short events, void* arg);
//

void do_echo_request(struct bufferevent* bev, void* arg);
//read

void event_cb(struct bufferevent *bev, short event, void *arg);
//error

struct event_base* base;

int main( )
{
 
     int listener = socket(AF_INET, SOCK_STREAM, 0);
     struct sockaddr_in sin;
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = 0;
     sin.sin_port = htons(80);
    
     bind(listener, (struct sockaddr *)&sin, sizeof(sin));
     listen(listener, 5);
    
 
     base = event_base_new();

       struct event* ev_listen = event_new
     (base, listener, EV_READ | EV_PERSIST,
     accept_connection, base);

     event_add(ev_listen, NULL);
     event_base_dispatch(base);
     return 0;
}


void  accept_connection(int fd, short events, void* arg)
{
 
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int sockfd = accept(fd, (struct sockaddr*)&client, &len);
    
    struct event_base* base = (struct event_base*)arg;


    struct bufferevent* bev = bufferevent_socket_new(base,
        sockfd, BEV_OPT_CLOSE_ON_FREE);
    
 
    bufferevent_setcb(bev, do_echo_request, NULL, event_cb, NULL);
                     //bufferevent  readcb  writecb error   data
    //更改bufferevent的回调函数。 将会堵塞
 
    bufferevent_enable(bev, EV_READ | EV_PERSIST);
    //启用bufferevent。
}


void do_echo_request(struct bufferevent* bev, void* arg)
{
    cout << "aaaaaaaaaaaa" << endl;
 
    char a[1024];

    size_t len = bufferevent_read(bev, a, 1024);

    a[len] = '\0';
    cout << a << endl;

    bufferevent_write(bev, a, strlen(a));

}


void event_cb(struct bufferevent *bev, short event, void *arg)
{
    cout << "error " << endl;
    bufferevent_free(bev);
}

/***************************************************************************************************************/

libevent  的终极版

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include<event2/listener.h>
#include <assert.h>

#include<iostream>
using namespace std;

typedef struct _ConnectStat {
    struct bufferevent* bev;
}ConnectStat;

 
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sock, int socklen, void *arg);

 
void do_echo_request(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
 
struct event_base* base;

int main(int argc, char** argv)
{
    struct sockaddr_in sin;
    memset(&sin, 0, sizeof(struct sockaddr_in));
    sin.sin_family = AF_INET;
    sin.sin_port = htons(80);
    sin.sin_addr.s_addr = 0;

    base = event_base_new();

    struct evconnlistener *listener
        = evconnlistener_new_bind(base, listener_cb, base,
            LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,
            10, (struct sockaddr*)&sin,
            sizeof(struct sockaddr_in));

    event_base_dispatch(base);
    cout << "aaaaaa" << endl;
    evconnlistener_free(listener);
    event_base_free(base);

    return 0;

}


void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sock, int socklen, void *arg)
   //
{
    cout << "客户端的sock" << fd <<endl;
    cout << "socklen " << socklen <<endl;
    struct event_base *base = (struct event_base*)arg;

    struct bufferevent *bev = bufferevent_socket_new(base, fd,
        BEV_OPT_CLOSE_ON_FREE);
 
    ConnectStat * stat = (ConnectStat *)malloc(sizeof(ConnectStat));
    memset(stat, '\0', sizeof(ConnectStat));
    stat->bev = bev;

    bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

}

void do_echo_request(struct bufferevent* bev, void* arg)
{
    ConnectStat *stat = (ConnectStat *)arg;
    char a[1024];
    size_t len = bufferevent_read(bev, a, 1024);
    a[len] = '\0';
    cout << a << endl;
    bufferevent_write(bev, a, strlen(a));
}


void event_cb(struct bufferevent *bev, short event, void *arg)
{
    cout << "error" << endl;
    ConnectStat *stat = (ConnectStat *)arg;
    bufferevent_free(bev);
    free(stat);
}