static void listen_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *arg) { struct event_base *base = arg; struct bufferevent *bev; const char s[] = TEST_STR; bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_write(bev, s, sizeof(s)); bufferevent_setcb(bev, NULL, sender_writecb, sender_errorcb, NULL); bufferevent_enable(bev, EV_WRITE); }
void tty_start_tty(struct tty *tty) { struct termios tio; int mode; if (tty->fd == -1) return; if ((mode = fcntl(tty->fd, F_GETFL)) == -1) fatal("fcntl failed"); if (fcntl(tty->fd, F_SETFL, mode|O_NONBLOCK) == -1) fatal("fcntl failed"); bufferevent_enable(tty->event, EV_READ|EV_WRITE); if (tcgetattr(tty->fd, &tty->tio) != 0) fatal("tcgetattr failed"); memcpy(&tio, &tty->tio, sizeof tio); tio.c_iflag &= ~(IXON|IXOFF|ICRNL|INLCR|IGNCR|IMAXBEL|ISTRIP); tio.c_iflag |= IGNBRK; tio.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONLRET); tio.c_lflag &= ~(IEXTEN|ICANON|ECHO|ECHOE|ECHONL|ECHOCTL| ECHOPRT|ECHOKE|ECHOCTL|ISIG); tio.c_cc[VMIN] = 1; tio.c_cc[VTIME] = 0; if (tcsetattr(tty->fd, TCSANOW, &tio) != 0) fatal("tcsetattr failed"); tcflush(tty->fd, TCIOFLUSH); tty_putcode(tty, TTYC_SMCUP); tty_putcode(tty, TTYC_SGR0); memcpy(&tty->cell, &grid_default_cell, sizeof tty->cell); tty_putcode(tty, TTYC_RMKX); tty_putcode(tty, TTYC_ENACS); tty_putcode(tty, TTYC_CLEAR); tty_putcode(tty, TTYC_CNORM); if (tty_term_has(tty->term, TTYC_KMOUS)) tty_puts(tty, "\033[?1000l"); tty->cx = UINT_MAX; tty->cy = UINT_MAX; tty->rlower = UINT_MAX; tty->rupper = UINT_MAX; tty->mode = MODE_CURSOR; tty->flags |= TTY_STARTED; }
static void drained_writecb(struct bufferevent *bev, void *ctx) { struct bufferevent *partner = ctx; /* We were choking the other side until we drained our outbuf a bit. * Now it seems drained. */ bufferevent_setcb(bev, readcb, NULL, eventcb, partner); bufferevent_setwatermark(bev, EV_WRITE, 0, 0); if (partner) bufferevent_enable(partner, EV_READ); }
void on_accept(int fd,short,void* arg){ struct event_base* base = reinterpret_cast<struct event_base*>(arg); struct sockaddr_in peer_addr; memset(&peer_addr,0,sizeof(peer_addr)); socklen_t len=0; int clientfd = accept(fd,(struct sockaddr*)&peer_addr,&len); evutil_make_socket_nonblocking(clientfd); auto bv = bufferevent_socket_new(base,clientfd,BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bv,readcb,writecb,eventcb,base); bufferevent_enable(bv,EV_READ ); }
void chldreadcb(struct bufferevent *b, void *arg) { char *line, *sp, *ap; int n, i, total, nprocs = *(int *)arg; if((line=evbuffer_readline(b->input)) != nil){ sp = line; if((ap = strsep(&sp, "\t")) == nil) panic("report error\n"); n = atoi(ap); if(n - nreport > NBUFFER) panic("a process fell too far behind\n"); n %= NBUFFER; for(i=0; i<params.nbuckets + 3 && (ap=strsep(&sp, "\t")) != nil; i++) reportbuf[n][i] += atoi(ap); if(++nreportbuf[n] >= nprocs){ /* Timestamp it. */ printf("%d\t",(int)time(nil)); for(i = 0; i < params.nbuckets + 3; i++) printf("%d\t", reportbuf[n][i]); /* Compute the total rate of succesful requests. */ total = 0; for(i=3; i<params.nbuckets+1; i++) total += reportbuf[n][i]; printf("%d\n", mkrate(&lastreporttv, total)); /* Aggregate. */ counts.errors += reportbuf[n][0]; counts.timeouts += reportbuf[n][1]; counts.closes += reportbuf[n][2]; for(i=0; i<params.nbuckets; i++){ counts.successes += reportbuf[n][i + 3]; counts.counters[i] += reportbuf[n][i + 3]; } /* Clear it. Advance nreport. */ memset(reportbuf[n], 0,(params.nbuckets + 3) * sizeof(int)); nreportbuf[n] = 0; nreport++; } free(line); } bufferevent_enable(b, EV_READ); }
static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) { /* We got a new connection! Set up a bufferevent for it. */ struct event_base *base = evconnlistener_get_base(listener); struct bufferevent *bev = bufferevent_socket_new( base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL); bufferevent_enable(bev, EV_READ|EV_WRITE); }
static void network_listen_callback(int listen_fd, short events, void *arg) { int fd = KSOCK_svr_accept(listen_fd); struct bufferevent *bufev; printf("fd %d conn...\n", fd); bufev = bufferevent_new(fd, network_read_callback, NULL, network_error_callback, (void *)fd); bufferevent_enable(bufev, EV_READ); }
static void accept_conn_callback( struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *context) { struct event_base *base = evconnlistener_get_base(listener); struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL); bufferevent_enable(bev, EV_READ | EV_WRITE); }
void BaseServer::listener_callback(struct evconnlistener *listener, int fd, struct sockaddr *sa, int socklen, void *arg) { event_base *base = (event_base*)arg; struct bufferevent* bev = bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE); assert(bev); bufferevent_setwatermark(bev,EV_READ,0,0); bufferevent_setwatermark(bev,EV_WRITE,0,0); bufferevent_setcb(bev,read_callback,write_callback,NULL,NULL); bufferevent_enable(bev,EV_READ); }
struct bufferevent* red_connect_relay(struct sockaddr_in *addr, evbuffercb writecb, everrorcb errorcb, void *cbarg) { struct bufferevent *retval = NULL; int on = 1; int relay_fd = -1; int error; relay_fd = socket(AF_INET, SOCK_STREAM, 0); if (relay_fd == -1) { log_errno(LOG_ERR, "socket"); goto fail; } error = fcntl_nonblock(relay_fd); if (error) { log_errno(LOG_ERR, "fcntl"); goto fail; } error = setsockopt(relay_fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)); if (error) { log_errno(LOG_WARNING, "setsockopt"); goto fail; } error = connect(relay_fd, (struct sockaddr*)addr, sizeof(*addr)); if (error && errno != EINPROGRESS) { log_errno(LOG_NOTICE, "connect"); goto fail; } retval = bufferevent_new(relay_fd, NULL, writecb, errorcb, cbarg); if (!retval) { log_errno(LOG_ERR, "bufferevent_new"); goto fail; } error = bufferevent_enable(retval, EV_WRITE); // we wait for connection... if (error) { log_errno(LOG_ERR, "bufferevent_enable"); goto fail; } return retval; fail: if (relay_fd != -1) redsocks_close(relay_fd); if (retval) bufferevent_free(retval); return NULL; }
static void drone_rampup_timer_cb(evutil_socket_t fd, short what, void *arg) { struct job *job = arg; Drone__JobRequest *request = job->request; struct session *session; struct bufferevent *bev; struct sockaddr_in echo_sin; struct timeval timeout; u_int64_t sessions; u_int64_t i; if (job->client == NULL) return; if ((request->sessions - job->cur_sessions) > request->rampup_sessions) sessions = request->rampup_sessions; else sessions = request->sessions - job->cur_sessions; memset(&echo_sin, 0, sizeof(echo_sin)); echo_sin.sin_family = AF_INET; echo_sin.sin_addr.s_addr = htonl(request->ipv4); echo_sin.sin_port = htons(request->port); for (i = 0; i < sessions; i++) { bev = bufferevent_socket_new(job->client->base, -1, BEV_OPT_CLOSE_ON_FREE); session = malloc(sizeof(struct session)); bufferevent_setcb(bev, drone_read_cb, NULL, drone_event_cb, session); bufferevent_enable(bev, EV_READ | EV_WRITE); timeout.tv_sec = request->timeout; timeout.tv_usec = 0; bufferevent_set_timeouts(bev, NULL, &timeout); if (bufferevent_socket_connect(bev, (struct sockaddr *) &echo_sin, sizeof(echo_sin)) < 0) { bufferevent_free(bev); free(session); perror("Error during connection"); return; } session->job = job; session->bev = bev; session->remaining_data = 0; job->sessions[job->cur_sessions] = session; job->cur_sessions++; } }
static void newconn(struct evconnlistener *lev, evutil_socket_t sock, struct sockaddr *cli, int socklen, void *raw) { server *serv = raw; session *sess; printf("New client\n"); sess = calloc(1, sizeof(*sess)); if(sess) { sess->serv = serv; sess->S.build_stream = buildstream; sess->S.cleanup = &cleanup_session; /* periodic timer */ sess->pingtimer = event_new(serv->base, -1, EV_PERSIST, pingconn, sess); assert(sess->pingtimer); sess->S.bev = bufferevent_socket_new(serv->base, sock, BEV_OPT_CLOSE_ON_FREE); if(sess->S.bev) { h2session_setup_bev(&sess->S); bufferevent_enable(sess->S.bev, EV_READ); if(prepare_h2_session(sess)) { bufferevent_free(sess->S.bev); free(sess); printf("Client failed\n"); return; } else { nghttp2_settings_entry iv[] = { {NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 100}, {NGHTTP2_SETTINGS_ENABLE_PUSH, 0} }; int rv; if ((rv=nghttp2_submit_settings(sess->S.h2sess, NGHTTP2_FLAG_NONE, iv, ARRLEN(iv))) || (rv=nghttp2_session_send(sess->S.h2sess))) { printf("submit error: %s", nghttp2_strerror(rv)); cleanup_session(&sess->S); } else { const struct timeval itvl = {5,0}; printf("Connection ready\n"); evtimer_add(sess->pingtimer, &itvl); } } } } if(!sess || !sess->S.bev) { fprintf(stderr, "No memory\n"); free(sess); close(sock); return; } }
static void drained_writecbout(struct bufferevent *bev_out, void *ctx_in) { fprintf(stderr, "drained_writecbout adjust the wartermark of <proxy->server>\n"); struct bufferevent *partner_in = ctx_in; /* We were choking the other side until we drained our outbuf a bit. * Now it seems drained. */ bufferevent_setcb(bev_out, readcbout, NULL, eventcbout, partner_in); bufferevent_setwatermark(bev_out, EV_WRITE, 0, 0); if (partner_in) bufferevent_enable(partner_in, EV_READ); }
/* Send a byte to the server. */ static void client_event_cb(struct bufferevent *bev, short events, void *ctx) { if (events & BEV_EVENT_CONNECTED) { unsigned char tmp = 'A'; bufferevent_write(bev, &tmp, 1); } else if (events & BEV_EVENT_ERROR) { puts("Client socket got error!"); exit(2); } bufferevent_enable(bev, EV_READ); }
static void watcher_new_conn(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *vctx) { struct watcher_ctx *ctx = vctx; struct bufferevent *bev; ctx->refcount++; bev = bufferevent_socket_new(ctx->event_base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, NULL, NULL, watcher_conn_closed, vctx); bufferevent_enable(bev, EV_READ | EV_WRITE); }
void http_makeconnect(struct bufferevent *bev, struct argument *arg) { extern struct addr *socks_dst_addr; ip_addr_t address; socks_resolveaddress("www.google.com", &address); evbuffer_add_printf(EVBUFFER_OUTPUT(bev), "CONNECT %s:80 HTTP/1.0\r\n" "\r\n", addr_ntoa(socks_dst_addr), SSHUSERAGENT); bufferevent_enable(bev, EV_WRITE); }
static void drained_writecbin(struct bufferevent *bev_in, void *ctx_out) { fprintf(stderr, "drained_writecbin adjust the wartermark of <client-proxy>\n"); struct bufferevent *partner_out= ctx_out; /* We were choking the other side until we drained our outbuf a bit. * Now it seems drained. */ bufferevent_setcb(bev_in, readcbin, NULL, eventcbin, partner_out); bufferevent_setwatermark(bev_in, EV_WRITE, 0, 0); if (partner_out) bufferevent_enable(partner_out, EV_READ); }
static void direct_relay_readcb_helper(redsocks_client *client, struct bufferevent *from, struct bufferevent *to) { if (EVBUFFER_LENGTH(to->output) < to->wm_write.high) { if (bufferevent_write_buffer(to, from->input) == -1) redsocks_log_errno(client, LOG_ERR, "bufferevent_write_buffer"); if (bufferevent_enable(from, EV_READ) == -1) redsocks_log_errno(client, LOG_ERR, "bufferevent_enable"); } else { if (bufferevent_disable(from, EV_READ) == -1) redsocks_log_errno(client, LOG_ERR, "bufferevent_disable"); } }
static void socks_request_cb(struct bufferevent *bev, void *ctx) { struct socks_data *data = ctx; if (evbuffer_get_length(bufferevent_get_input(bev)) < data->req_len) { bufferevent_enable(bev, EV_READ); bufferevent_setwatermark(bev, EV_READ, data->req_len, 2048); bufferevent_setcb(bev, socks_request_cb, NULL, socks_request_error, ctx); } else data->req_cb(ctx); }
int Server::psub(struct evhttp_request *req){ bufferevent_enable(req->evcon->bufev, EV_READ); PresenceSubscriber *psub = new PresenceSubscriber(); psub->req = req; psub->serv = this; psubs.push_back(psub); log_info("%s:%d psub, psubs: %d", req->remote_host, req->remote_port, psubs.size); evhttp_send_reply_start(req, HTTP_OK, "OK"); evhttp_connection_set_closecb(req->evcon, on_psub_disconnect, psub); return 0; }
static int create_control_socket_event(struct event_base * base, control_thread_context_t * context, struct bufferevent ** control_event) { struct bufferevent * new_event = NULL; int sock_fd = -1; struct timeval read_timeout = { 0 }; /* Get the connection's socket */ if (IDEVICE_E_SUCCESS != idevice_connection_get_fd(context->control_connection, &sock_fd)) { error("ERROR: Failed to get the socket for the reverse proxy's control connection\n"); goto cleanup; } /* libevent needs sockets to be non-blocking */ if (0 != evutil_make_socket_nonblocking(sock_fd)) { error("ERROR: Failed to make the reverse proxy's control socket non-blocking\n"); goto cleanup; } /* Create a new bufferevent for the control socket */ new_event = bufferevent_socket_new(base, sock_fd, 0); if (NULL == new_event) { error("ERROR: Failed to initialize the reverse proxy's control socket\n"); goto cleanup; } /* Init the new bufferevent */ bufferevent_setcb(new_event, rproxy_control_read_cb, NULL, rproxy_control_event_cb, (void*)context); read_timeout.tv_sec = CONTROL_RECV_TIMEOUT; read_timeout.tv_usec = 0; bufferevent_set_timeouts(new_event, &read_timeout, NULL); /* Each control message is a 32bit unsigned int, so tell libevent to call * our read callback only when there is enough data */ bufferevent_setwatermark(new_event, EV_READ, sizeof(uint32_t), 0); /* Enable both read & write events */ if (0 != bufferevent_enable(new_event, EV_READ | EV_WRITE)) { error("ERROR: Failed to enable the proxy's control socket\n"); goto cleanup; } *control_event = new_event; return 0; cleanup: if (new_event) { bufferevent_free(new_event); } return -1; }
int main () { int sockfd; struct bufferevent *p_event; struct sockaddr_in addr; ff = fopen("/tmp/log", "w"); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(PORT); if (inet_pton(AF_INET, SVRADDR, &addr.sin_addr) <= 0) { printf("inet_pton"); exit(1); } if ((p_base = event_base_new()) == NULL) { printf("event_base_new "); return 1; } /* we do not need invoke socket function to create socket */ if ((p_event = bufferevent_socket_new(p_base, -1, BEV_OPT_CLOSE_ON_FREE)) == NULL) { printf("bufferevent_socket_new "); return 1; } /* client actually connecte to server at this time. */ if ((sockfd = bufferevent_socket_connect(p_event, (struct sockaddr *) &addr, sizeof(addr))) < 0) { printf("bufferevent_socket_connect "); return 1; } /* EV_WRITE is default enabled, EV_READ is default disabled */ /* So If we disable READ, evbuffer callback will not be added to base (read and write) */ bufferevent_setcb(p_event, buff_input_cb, NULL, eventcb, p_base); bufferevent_enable(p_event, EV_WRITE); /* edge-triggered */ /* default read low-water mark is 0. */ /* default read high-water mark is unlimited. */ /* If the underlying data received over 20, remove the READ event from base */ bufferevent_setwatermark(p_event, EV_READ, 10, 20); event_base_dispatch(p_base); return 0; }
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) { struct event_base *base = (event_base*)user_data; struct bufferevent *bev; bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { std::cout << "Error constructing bufferevent!\n"; event_base_loopbreak(base); return; } bufferevent_setcb(bev, conn_readcb, NULL, conn_eventcb, NULL); int res = bufferevent_enable(bev, EV_READ); }
static void on_accept(struct evconnlistener* l, evutil_socket_t* fd, struct sockaddr* addr, int socklen, void *arg) { struct tcp_receiver* r = arg; struct event_base* b = evconnlistener_get_base(l); struct bufferevent *bev = bufferevent_socket_new(b, fd, BEV_OPT_CLOSE_ON_FREE); /*设置读事件函数和错误函数*/ bufferevent_setcb(bev, on_read, NULL, on_error, arg); /*设置监视的socket事件*/ bufferevent_enable(bev, EV_READ|EV_WRITE); /*添加到事件管理器中*/ carray_push_back(r->bevs, bev); paxos_log_info("Accepted connection from %s:%d", inet_ntoa(((struct sockaddr_in*)addr)->sin_addr), ntohs(((struct sockaddr_in*)addr)->sin_port)); }
static void authenticate_tcp_channel(struct bufferevent *bev, void *_) { debug("tcp channel: authentication reading data"); struct evbuffer *input = bufferevent_get_input(bev); size_t len = evbuffer_get_length(input); size_t wanted = sizeof(struct MessageResponse); if(len < wanted) return; debug("tcp channel: authentication checking message"); struct MessageResponse *res = (struct MessageResponse *) evbuffer_pullup(input, wanted); if(res->type != RESPONSE) { debug( "tcp channel: invalid authentication message %s", message_get_type_string((struct Message *) res)); bufferevent_free(bev); return; } union Channel *current = find_channel(&res->response); if(!current) { debug("tcp channel: authentication failed"); bufferevent_free(bev); return; } evbuffer_drain(input, wanted); debug("tcp channel: authenticated"); assert(current->base.proto == IPPROTO_TCP); current->tcp.channel_buffers = bev; bufferevent_setcb( current->tcp.peer_buffers, read_tcp_peer, NULL, error_on_tcp_peer, current); bufferevent_enable(current->tcp.peer_buffers, EV_READ | EV_WRITE); bufferevent_setcb( bev, read_tcp_channel, NULL, error_on_tcp_channel, current); read_tcp_channel(bev, current); }
static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) { log_debug("New client connection"); struct event_base *base = evconnlistener_get_base(listener); struct bufferevent *bev = bufferevent_socket_new( base, fd, BEV_OPT_CLOSE_ON_FREE); struct conn_client *client = conn_alloc_client(bev); bufferevent_setcb(bev, read_cb, write_cb, event_cb, client); bufferevent_enable(bev, EV_READ|EV_WRITE); }
void chldreadcb(struct bufferevent *b, void *arg) { char *line, *sp, *ap; int n, i, nprocs = *(int *)arg; if((line=evbuffer_readline(b->input)) != nil){ sp = line; if((ap = strsep(&sp, "\t")) == nil) panic("report error\n"); n = atoi(ap); if(n - nreport > NBUFFER) panic("a process fell too far behind\n"); n %= NBUFFER; for(i=0; i<params.nbuckets + num_cols && (ap=strsep(&sp, "\t")) != nil; i++) reportbuf[n][i] += atoi(ap); if(++nreportbuf[n] >= nprocs){ /* Timestamp it. */ printf("%d\t",(int)time(nil)); for(i = 0; i < params.nbuckets + num_cols; i++) printf("%d\t", reportbuf[n][i]); printf("%ld\n", mkrate(&lastreporttv, reportbuf[n][0])); reset_time(&lastreporttv); /* Aggregate. */ counts.conn_successes += reportbuf[n][0]; counts.conn_errors += reportbuf[n][1]; counts.conn_timeouts += reportbuf[n][2]; counts.conn_closes += reportbuf[n][3]; counts.http_successes += reportbuf[n][4]; counts.http_errors += reportbuf[n][5]; for(i=0; i<params.nbuckets; i++) counts.counters[i] += reportbuf[n][i + num_cols]; /* Clear it. Advance nreport. */ memset(reportbuf[n], 0,(params.nbuckets + num_cols) * sizeof(int)); nreportbuf[n] = 0; nreport++; } free(line); } bufferevent_enable(b, EV_READ); }
void CTcpHandler::TcpAdd(CCommand *pCmd) { CTcpAddCommand *pConnectCmd = dynamic_cast<CTcpAddCommand *>(pCmd); CEventThread *pThread = dynamic_cast<CEventThread *>(GetThread()); m_pBufevt = bufferevent_socket_new(pThread->GetEventBase(), pConnectCmd->m_iFd, BEV_OPT_THREADSAFE); bufferevent_setcb(m_pBufevt, CNetThread::OnStaticRead, CNetThread::OnStaticWrite, CNetThread::OnStaticError, this); bufferevent_enable(m_pBufevt, EV_READ|EV_PERSIST|EV_ET); bufferevent_setwatermark(m_pBufevt, EV_READ, OnRead(NULL, 0), 0); OnConnect(); //告诉listen线程 SetTimeout(); }
static void socks_accept(struct evconnlistener *evl, evutil_socket_t new_fd, struct sockaddr *addr, int socklen, void *ctx) { struct event_base *base = evconnlistener_get_base(evl); struct bufferevent *bev; LWIP_DEBUGF(SOCKS_DEBUG, ("%s: Accepting socks connection\n", __func__)); bev = bufferevent_socket_new(base, new_fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, socks_version, NULL, socks_error, ctx); bufferevent_setwatermark(bev, EV_READ, 1, 2048); bufferevent_enable(bev, EV_READ|EV_WRITE); }
void NFCNet::listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) { //怕你们重了 NFCNet* pNet = (NFCNet*)user_data; bool bClose = pNet->CloseNetObject(fd); if (bClose) { //error return; } if (pNet->mmObject.size() >= pNet->mnMaxConnect) { //应该T掉,拒绝 return; } struct event_base *base = pNet->base; //创建一个基于socket的bufferevent struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { //应该T掉,拒绝 fprintf(stderr, "Error constructing bufferevent!"); //event_base_loopbreak(base); return; } //我获得一个新连接。为其创建一个bufferevent--FD需要管理 struct sockaddr_in* pSin = (sockaddr_in*)sa; NetObject* pObject = new NetObject(pNet, fd, *pSin, bev); pObject->GetNet()->AddNetObject(fd, pObject); //为bufferevent设置各种回调 bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, (void*)pObject); //开启bufferevent的读写 bufferevent_enable(bev, EV_READ|EV_WRITE); //模拟客户端已连接事件 conn_eventcb(bev, BEV_EVENT_CONNECTED, (void*)pObject); ////////////////////////////////////////////////////////////////////////// struct timeval tv; /* 设置读超时120秒, 可做为心跳机制, 120秒没收到消息就T */ tv.tv_sec = 120; tv.tv_usec = 0; bufferevent_set_timeouts(bev, &tv, NULL); }