bevBufferevent转发服务器

来源：互联网发布：c2c 源码编辑：程序博客网时间：2024/06/03 20:55

#include <netinet/in.h>
#include <sys/socket.h>
#include <fcntl.h>

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

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

#define MAX_RELAY_LENGTH 65535
#define MAX_MAGIC_ID 65535
#define MAGIC_LEN 16
#define FLAG 1

typedef struct bev_Buffer_ {
   struct bufferevent *bev1;
   struct bufferevent *bev2;
} bev_Buffer_t;
bev_Buffer_t *bevBuffer = NULL;

static pthread_mutex_t lock;
static short int MagicId[MAX_MAGIC_ID] = {0};
static short int client_id = 0;
static short int device_id = 0;

//struct bufferevent内建了两个event(read/write)和对应的缓冲区(struct evbuffer *input, *output)，并提供相应的函数用来操作> 缓冲区(或者直接操作bufferevent)
//接收到数据后，判断是不一样一条消息的结束，结束标志为"over"字符串
static void readcb(struct bufferevent *bev, void *ctx)
{
#if 1
    struct evbuffer *input, *output;
    char *request_line;
    size_t len;
    int count = 0;
    input = bufferevent_get_input(bev);//其实就是取出bufferevent中的input
    output = bufferevent_get_output(bev);//其实就是取出bufferevent中的output

    size_t input_len = evbuffer_get_length(input);
    size_t output_len = evbuffer_get_length(output);

/************read msg from bufferevent***********/
   char msg[MAX_RELAY_LENGTH+1] = {0};
   len = bufferevent_read(bev, msg, sizeof(msg));

/*********get client and device MagicId**********/
if (NULL != strstr(msg,"client")) {
    printf("msg =:%s len =:%d\n",msg,len);
    if (len > MAGIC_LEN) {
      client_id = ntohs(((short int*)msg)[0]);
      if( (bevBuffer+client_id)->bev2 == 0) {
        (bevBuffer+client_id)->bev2 = bev;
        //pthread_mutex_unlock(&lock);//unlock mutex
        printf("client_id come:%d\n",client_id);
      }
      if (device_id == client_id) {
        for(count = 0; count < MAX_MAGIC_ID; count++) {
          if (MagicId[count] == device_id) {
            printf("this magic_id already have\n");
            return;
          } else if (MagicId[count] == 0) {
            MagicId[count] = device_id;
            printf("magic_id is:%d\n",MagicId[count]);
            return;
          }
        }
      }
    } else {
      client_id = ntohs(((short int*)msg)[0]);
      if( (bevBuffer+client_id)->bev2 == 0) {
        (bevBuffer+client_id)->bev2 = bev;
        //pthread_mutex_unlock(&lock);//unlock mutex
        printf("client_id come:%d\n",client_id);
        return;
      }
      if (device_id == client_id) {
        for(count = 0; count < MAX_MAGIC_ID; count++) {
          if (MagicId[count] == device_id) {
            printf("this magic_id already have\n");
            return;
          } else if (MagicId[count] == 0) {
            MagicId[count] = device_id;
            printf("magic_id is:%d\n",MagicId[count]);
            return;
          }
        }
      }
    }
} else if (NULL != strstr(msg,"device")) {
    device_id = ntohs(((short int*)msg)[0]);
    if( (bevBuffer+device_id)->bev1== 0) {
      (bevBuffer+device_id)->bev1 = bev;
      //pthread_mutex_unlock(&lock);//unlock mutex
      printf("device_id come:%d\n",device_id);
      return;
    }
}

/*************match bevbuffer and write**********/
for(count = 0; count < MAX_MAGIC_ID; count++) {
     if (bev == (bevBuffer + MagicId[count])->bev1) {
       if (NULL != (bevBuffer + MagicId[count])->bev2) {
            printf("3# current bev is %d ,bev1 %d to bev2 %d\n",bev,(bevBuffer+MagicId[count])->bev1,(bevBuffer+MagicId[count])->bev2);
        bufferevent_write((bevBuffer + MagicId[count])->bev2, msg, len);
        //pthread_mutex_unlock(&lock);//unlock mutex
        return;
       }
     } else if (bev == (bevBuffer + MagicId[count])->bev2) {
       if (NULL != (bevBuffer + MagicId[count])->bev1) {
            printf("4# current bev is %d bev2 %d to bev1 %d\n",bev,(bevBuffer+MagicId[count])->bev2,(bevBuffer+MagicId[count])->bev1);
        bufferevent_write((bevBuffer + MagicId[count])->bev1, msg, len);
        //pthread_mutex_unlock(&lock);//unlock mutex
        return;
       }
     }
}
#endif

}

static void bevBuffer_reset(struct bufferevent *bev)
{
   int i = 0;
   for(; i < MAX_MAGIC_ID; i++)
   {
       if((bevBuffer + MagicId[i])->bev1 == bev)
       {
      printf("#1->i :%d bev1 :%d bev2 :%d magic_id :%d reset\n",i,(bevBuffer + MagicId[i])->bev1,(bevBuffer + MagicId[i])->bev2,MagicId[i]);
      /*********reset bevBuffer with magicid****************/
           (bevBuffer + MagicId[i])->bev1 = 0;
           (bevBuffer + MagicId[i])->bev2 = 0;
      MagicId[i] = 0;
           return;
       }

       if((bevBuffer + MagicId[i])->bev2 == bev)
       {
      printf("#2->i :%d bev2 :%d bev1 :%d magic_id :%d reset\n",i,(bevBuffer + MagicId[i])->bev2,(bevBuffer + MagicId[i])->bev1,MagicId[i]);
      /*********reset bevBuffer with magicid****************/
           (bevBuffer + MagicId[i])->bev1 = 0;
           (bevBuffer + MagicId[i])->bev2 = 0;
      MagicId[i] = 0;
           return;
       }
   }
}

static void errorcb(struct bufferevent *bev, short error, void *ctx)
{
    if (error & BEV_EVENT_EOF)
    {
        /* connection has been closed, do any clean up here */
        printf("connection closed\n");
    }
    else if (error & BEV_EVENT_ERROR)
    {
        /* check errno to see what error occurred */
        printf("some other error\n");
    }
    else if (error & BEV_EVENT_TIMEOUT)
    {
        /* must be a timeout event handle, handle it */
        printf("Timed out\n");
    }

    bevBuffer_reset(bev);

    bufferevent_free(bev);
    printf("errorcb done\n");
}

static void do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = (struct event_base *)arg;
    //struct sockaddr_storage ss;
    struct sockaddr_in ss;
    socklen_t slen = sizeof(ss);
    evutil_socket_t fd;
    //int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0)
    {
        perror("accept");
    }
    else if (fd > FD_SETSIZE)
    {
        close(fd);
    }
    else
    {

        printf("\n\naccept:<IP>:%s<Port>:%d\n",inet_ntoa(ss.sin_addr),ntohs(ss.sin_port));
        struct bufferevent *bev;
        evutil_make_socket_nonblocking(fd);

        //使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base
        //BEV_OPT_CLOSE_ON_FREE表示释放bufferevent时关闭底层传输端口。这将关闭底层套接字，释放底层bufferevent等。
        bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

        bevBuffer_reset(bev);
        //设置读写对应的回调函数

        printf("readcb start\n");
        //mutex lock
        //pthread_mutex_lock(&lock);

        bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);

        printf("readcb done\n");
        //bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);


        //启用读写事件,其实是调用了event_add将相应读写事件加入事件监听队列poll。正如文档所说，如果相应事件不置为true，bufferevent是不会读写数据的
        bufferevent_enable(bev, EV_READ|EV_WRITE);
        //printf("event enable\n");
    }
}

void run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new();
    if (!base)
        return; /*XXXerr*/

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    //sin.sin_addr.s_addr = htonl(INADDR_ANY);
    //sin.sin_port = htons(8800);
    sin.sin_port = htons(11440);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        return;
    }
if (listen(listener, 16)<0)
    {
        perror("listen");
        return;
    }

       bevBuffer = malloc(MAX_MAGIC_ID*sizeof(bev_Buffer_t));
       memset(bevBuffer, 0, MAX_MAGIC_ID*sizeof(bev_Buffer_t));
    //mutex lock by ycs
    //pthread_mutex_init(&lock,NULL);

       printf("start listen \n");
    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
       printf("event dispatch\n");
}

int main(int argc, char **argv)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1. #include <netinet/in.h>
2. #include <sys/socket.h>
3. #include <fcntl.h>
5. #include <event2/event.h>
6. #include <event2/buffer.h>
7. #include <event2/bufferevent.h>
9. #include <assert.h>
10. #include <unistd.h>
11. #include <string.h>
12. #include <stdlib.h>
13. #include <stdio.h>
14. #include <errno.h>
16. void do_read(evutil_socket_t fd, short events, void *arg);
18. //struct bufferevent内建了两个event(read/write)和对应的缓冲区(struct evbuffer *input, *output)，并提供相应的函数用来操作>
19. 缓冲区(或者直接操作bufferevent)
20. //接收到数据后，判断是不一样一条消息的结束，结束标志为"over"字符串
21. void readcb(struct bufferevent *bev, void *ctx)
22. {
23. printf("called readcb!\n");
24. struct evbuffer *input, *output;
25. char *request_line;
26. size_t len;
27. input = bufferevent_get_input(bev);//其实就是取出bufferevent中的input
28. output = bufferevent_get_output(bev);//其实就是取出bufferevent中的output
30. size_t input_len = evbuffer_get_length(input);
31. printf("input_len: %d\n", input_len);
32. size_t output_len = evbuffer_get_length(output);
33. printf("output_len: %d\n", output_len);
35. while(1)
36. {
37. request_line = evbuffer_readln(input, &len, EVBUFFER_EOL_CRLF);//从evbuffer前面取出一行，用一个新分配的空字符结束
38. 的字符串返回这一行,EVBUFFER_EOL_CRLF表示行尾是一个可选的回车，后随一个换行符
39. if(NULL == request_line)
40. {
41. printf("The first line has not arrived yet.\n");
42. free(request_line);//之所以要进行free是因为 line = mm_malloc(n_to_copy+1))，在这里进行了malloc
43. break;
44. }
45. else
46. <span style="white-space: pre;"> </span>{
47. printf("Get one line date: %s\n", request_line);
48. if(strstr(request_line, "over") != NULL)//用于判断是不是一条消息的结束
49. {
50. char *response = "Response ok! Hello Client!\r\n";
51. evbuffer_add(output, response, strlen(response));//Adds data to an event buffer
52. printf("服务端接收一条数据完成，回复客户端一条消息: %s\n", response);
53. free(request_line);
54. break;
55. }
56. }
57. free(request_line);
58. }
60. size_t input_len1 = evbuffer_get_length(input);
61. printf("input_len1: %d\n", input_len1);
62. size_t output_len1 = evbuffer_get_length(output);
63. printf("output_len1: %d\n\n", output_len1);
64. }
66. void errorcb(struct bufferevent *bev, short error, void *ctx)
67. {
68. if (error & BEV_EVENT_EOF)
69. {
70. /* connection has been closed, do any clean up here */
71. printf("connection closed\n");
72. }
73. else if (error & BEV_EVENT_ERROR)
74. {
75. /* check errno to see what error occurred */
76. printf("some other error\n");
77. }
78. else if (error & BEV_EVENT_TIMEOUT)
79. {
80. /* must be a timeout event handle, handle it */
81. printf("Timed out\n");
82. }
83. bufferevent_free(bev);
84. }
86. void do_accept(evutil_socket_t listener, short event, void *arg)
87. {
88. struct event_base *base = arg;
89. struct sockaddr_storage ss;
90. socklen_t slen = sizeof(ss);
91. int fd = accept(listener, (struct sockaddr*)&ss, &slen);
92. if (fd < 0)
93. {
94. perror("accept");
95. }
96. else if (fd > FD_SETSIZE)
97. {
98. close(fd);
99. }
100. else
101. {
102. struct bufferevent *bev;
103. evutil_make_socket_nonblocking(fd);
105. //使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base
106. ////BEV_OPT_CLOSE_ON_FREE表示释放bufferevent时关闭底层传输端口。这将关闭底层套接字，释放底层bufferevent等。
107. bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
109. //设置读写对应的回调函数
110. bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);
111. // bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);
113. //启用读写事件,其实是调用了event_add将相应读写事件加入事件监听队列poll。正如文档所说，如果相应事件不置为true，buf
114. ferevent是不会读写数据的
115. bufferevent_enable(bev, EV_READ|EV_WRITE);
116. }
117. }
119. void run(void)
120. {
121. evutil_socket_t listener;
122. struct sockaddr_in sin;
123. struct event_base *base;
124. struct event *listener_event;
126. base = event_base_new();
127. if (!base)
128. return; /*XXXerr*/
130. sin.sin_family = AF_INET;
131. sin.sin_addr.s_addr = 0;
132. sin.sin_port = htons(8000);
134. listener = socket(AF_INET, SOCK_STREAM, 0);
135. evutil_make_socket_nonblocking(listener);
137. #ifndef WIN32
138. {
139. int one = 1;
140. setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
141. }
142. #endif
144. if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)
145. {
146. perror("bind");
147. return;
148. }
149. if (listen(listener, 16)<0)
150. {
151. perror("listen");
152. return;
153. }
155. listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
156. /*XXX check it */
157. event_add(listener_event, NULL);
159. event_base_dispatch(base);
160. }
162. int main(int argc, char **argv)
163. {
164. setvbuf(stdout, NULL, _IONBF, 0);
166. run();
167. return 0;
168. }

0 0