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); }
void CTcpHandler::TcpConnect(CCommand *pCmd) { NsqLogPrintf(LOG_DEBUG, "TcpConnect\n"); CTcpConnectCommand *pConnectCmd = dynamic_cast<CTcpConnectCommand *>(pCmd); m_strHost = pConnectCmd->m_strHost; m_iPort = pConnectCmd->m_iPort; sockaddr_in sAddr; memset(&sAddr, 0, sizeof(sockaddr_in)); sAddr.sin_addr.s_addr = inet_addr(pConnectCmd->m_strHost.c_str()); sAddr.sin_port = htons(pConnectCmd->m_iPort); sAddr.sin_family = AF_INET; CNetThread *pThread = dynamic_cast<CNetThread *>(GetThread()); m_pBufevt = bufferevent_socket_new(pThread->GetEventBase(), -1, BEV_OPT_THREADSAFE); int32_t iRet = bufferevent_socket_connect(m_pBufevt, (sockaddr*)&sAddr, sizeof(sockaddr_in)); if (iRet != 0) { OnError(errno); return ; } 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); SetTimeout(); }
int MTCLink::Connect() { fFD = socket(AF_INET, SOCK_STREAM, 0); if (fFD <= 0){ lprintf("Error opening a new socket for sbc connection!\n"); throw "Error opening a new socket\n"; } struct sockaddr_in sbc_addr; memset(&sbc_addr,'\0',sizeof(sbc_addr)); sbc_addr.sin_family = AF_INET; inet_pton(AF_INET, SBC_SERVER, &sbc_addr.sin_addr.s_addr); sbc_addr.sin_port = htons(SBC_PORT); // make the connection if (connect(fFD,(struct sockaddr*) &sbc_addr,sizeof(sbc_addr))<0){ close(fFD); lprintf("Problem connecting to sbc socket!\n"); throw "Problem connecting to socket\n"; } int32_t test_word = 0x000DCBA; int n = write(fFD,(char*)&test_word,4); fConnected = 1; fBev = bufferevent_socket_new(evBase,fFD,BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE); bufferevent_setwatermark(fBev, EV_READ, 0, 0); bufferevent_setcb(fBev,&GenericLink::RecvCallbackHandler,&GenericLink::SentCallbackHandler,&GenericLink::EventCallbackHandler,this); bufferevent_enable(fBev,EV_READ | EV_WRITE); lprintf("Connected to SBC!\n"); return 0; }
static void GuNET_Server_Client_onConnect(evutil_socket_t fd, short event, void * serv) { GuNET_Server_Client_t * client; GuNET_Server_t * server = (GuNET_Server_t *) serv; struct sockaddr_storage ss; #ifdef _WIN32 int slen = sizeof(ss); #else socklen_t slen = sizeof(ss); #endif struct bufferevent * bev; int clientfd = accept(fd, (struct sockaddr *) &ss, &slen); if (clientfd < 0) { } else if (clientfd > FD_SETSIZE) { if (OUTPUTERROR) fprintf(stderr, "[GuNET_Server] clientfd > FD_SETSIZE"); evutil_closesocket(clientfd); return; } else { client = malloc(sizeof(GuNET_Server_Client_t)); if (!client) { if (OUTPUTERROR) fprintf(stderr, "[GuNET_Server] Failed to malloc for new client."); evutil_closesocket(clientfd); return; } evutil_make_socket_nonblocking(clientfd); bev = bufferevent_socket_new(server->base, clientfd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { if (OUTPUTERROR) fprintf(stderr, "[GuNET_Server] Failed to malloc bufferevent."); free(client); evutil_closesocket(clientfd); return; } bufferevent_setcb(bev, GuNET_Server_Client_onRead, NULL, GuNET_Server_Client_onError, serv); bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE); bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST); client->fd = clientfd; client->bev = bev; client->server = server; client->length = 0; client->key = NULL; client->userdata = server->userdata; client->next = NULL; client->prev = GuNET_Server_getLastClient(server); if (!client->prev) server->clients = client; else client->prev->next = client; if (server->onConnect) server->onConnect(client, client->userdata); } }
void on_accept(evutil_socket_t listener, short event, void *arg) { /* if we've hit max connections, refuse the connection */ if (!inc_and_check_connections()) { /* @todo: refuse the connection */ close(listener); return; } struct event_base *base = arg; struct sockaddr_storage ss; /*drizzle_con_st *connection = NULL;*/ socklen_t slen = sizeof(ss); printf("accepting\n"); int fd = accept(listener, (struct sockaddr*)&ss, &slen); if (fd < 0) { perror("accept"); } else if (fd > FD_SETSIZE) { close(fd); } else { struct bufferevent *bev; evutil_make_socket_nonblocking(fd); bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, readcb, NULL, errorcb, NULL); bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE); bufferevent_enable(bev, EV_READ|EV_WRITE); } }
static void readcb(struct bufferevent *bev, void *ctx) { struct bufferevent *partner = ctx; struct evbuffer *src, *dst; size_t len; src = bufferevent_get_input(bev); len = evbuffer_get_length(src); if (!partner) { evbuffer_drain(src, len); return; } dst = bufferevent_get_output(partner); evbuffer_add_buffer(dst, src); if (evbuffer_get_length(dst) >= MAX_OUTPUT) { /* We're giving the other side data faster than it can * pass it on. Stop reading here until we have drained the * other side to MAX_OUTPUT/2 bytes. */ bufferevent_setcb(partner, readcb, drained_writecb, eventcb, bev); bufferevent_setwatermark(partner, EV_WRITE, MAX_OUTPUT/2, MAX_OUTPUT); bufferevent_disable(bev, EV_READ); } }
static void readcbout(struct bufferevent *bev_out, void *ctx_in) { struct bufferevent *partner_in = ctx_in; struct evbuffer *src, *dst; size_t len; src = bufferevent_get_input(bev_out); len = evbuffer_get_length(src); if (!partner_in) { fprintf(stderr, "partner_in == NULL"); evbuffer_drain(src, len); return; } dst = bufferevent_get_output(partner_in); evbuffer_add_buffer(dst, src); if (evbuffer_get_length(dst) >= MAX_OUTPUT_C2P) { /* We're giving the other side data faster than it can * pass it on. Stop reading here until we have drained the * other side to MAX_OUTPUT_C2P/2 bytes. */ fprintf(stderr, "adjust the wartermark of <client-proxy>\n"); bufferevent_setcb(partner_in, readcbin, drained_writecbin, eventcbin, bev_out); bufferevent_setwatermark(partner_in, EV_WRITE, MAX_OUTPUT_C2P/2, MAX_OUTPUT_C2P); bufferevent_disable(bev_out, EV_READ); } }
/** * 回调函数会接受三个参数 * listener 注册的fd * event 注册的事件 * arg 注册时的参数 */ void DoAccept(evutil_socket_t nListenSock, short event, void *pArg) { // 获取链接的fd struct sockaddr_storage oAddr; socklen_t nAddrLen = sizeof(oAddr); int nConnSock = accept(nListenSock, (struct sockaddr*)&oAddr, &nAddrLen); if (nConnSock < 0) { perror("accept"); } else if (nConnSock > FD_SETSIZE) { close(nConnSock); } else { evutil_make_socket_nonblocking(nConnSock); // 设置为非堵塞的socket // 获取传入的参数——event base,自对象在DoAccpet中穿件,用于存放所有的fd struct event_base *pEventBase = (struct event_base*)pArg; // 创建一个缓冲事件,缓冲事件,顾名思义,就是当数据缓冲到一定程度,才触发,而不是只要有数据就触发 struct bufferevent* pBuffEnt = bufferevent_socket_new(pEventBase, nConnSock, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(pBuffEnt, ReadCallBack, NULL, ErrorCallBack, NULL); // “程度”通过高/低水位来设定 bufferevent_setwatermark(pBuffEnt, EV_READ, 0, MAX_LINE); // 必须调用这句,否则enabled == false bufferevent_enable(pBuffEnt, EV_READ|EV_WRITE); } }
static ad_conn_t *conn_new(ad_server_t *server, struct bufferevent *buffer) { if (server == NULL || buffer == NULL) { return NULL; } // Create a new connection container. ad_conn_t *conn = NEW_OBJECT(ad_conn_t); if (conn == NULL) return NULL; // Initialize with default values. conn->server = server; conn->buffer = buffer; conn->in = bufferevent_get_input(buffer); conn->out = bufferevent_get_output(buffer); conn_reset(conn); // Bind callback bufferevent_setcb(buffer, conn_read_cb, conn_write_cb, conn_event_cb, (void *)conn); bufferevent_setwatermark(buffer, EV_WRITE, 0, 0); bufferevent_enable(buffer, EV_WRITE); bufferevent_enable(buffer, EV_READ); // Run callbacks with AD_EVENT_INIT event. conn->status = call_hooks(AD_EVENT_INIT | AD_EVENT_WRITE, conn); return conn; }
void MessageManager::DoAccept(evutil_socket_t listener, short event, void *arg) { struct CallbackArg *cbArg = (struct CallbackArg *)arg; struct sockaddr_storage ss; socklen_t slen = sizeof(ss); int fd = accept(listener, (struct sockaddr*)&ss, &slen); if(fd < 0) { LOG(ERROR, "Failed to connect to UI", "accept: " + string(strerror(errno))); } else { struct bufferevent *bev; evutil_make_socket_nonblocking(fd); bev = bufferevent_socket_new(cbArg->m_base, fd, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE); if(bev == NULL) { LOG(ERROR, "Failed to connect to UI: socket_new", ""); return; } bufferevent_setcb(bev, MessageDispatcher, NULL, ErrorDispatcher, cbArg); bufferevent_setwatermark(bev, EV_READ, 0, 0); if(bufferevent_enable(bev, EV_READ|EV_WRITE) == -1) { LOG(ERROR, "Failed to connect to UI: bufferevent_enable", ""); return; } //Create the socket within the messaging subsystem //MessageManager::Instance().StartSocket(fd); //Start the callback thread for this new connection cbArg->m_callback->StartServerCallbackThread(fd, bev); } }
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 enbaled by default, so the underlying evbuffer writecb will be called when dispatch. * evbuffer writecb FOUND that there is no data to be sent, return. * evbuffer writecb is not persisted. (If persisted, evbuffer writecb will be called again and agian, see event_write * So there is no pending event in base, base will exit. */ bufferevent_setcb(p_event, NULL, event_output, buff_ev_cb, p_base); /* write data to evbuffer, So when evbuffer cb FOUND there is data, send it out. * And, call the bufferevent cb based on water mark. */ bufferevent_write (p_event, "nisssssssssdssssssssa", 20); /* * normally, If evbuffer cb send data, FOUND that : the left data len is < 10, then bufferevent writecb * will be invoked to tell ME. * hey, there almost no data!! */ bufferevent_setwatermark(p_event, EV_WRITE, 10, -1); sleep (10); event_base_dispatch(p_base); return 0; }
static void test_bufferevent_watermarks_impl(int use_pair) { struct bufferevent *bev1 = NULL, *bev2 = NULL; char buffer[65000]; int i; test_ok = 0; if (use_pair) { struct bufferevent *pair[2]; tt_assert(0 == bufferevent_pair_new(NULL, 0, pair)); bev1 = pair[0]; bev2 = pair[1]; bufferevent_setcb(bev1, NULL, wm_writecb, errorcb, NULL); bufferevent_setcb(bev2, wm_readcb, NULL, errorcb, NULL); } else { bev1 = bufferevent_new(pair[0], NULL, wm_writecb, wm_errorcb, NULL); bev2 = bufferevent_new(pair[1], wm_readcb, NULL, wm_errorcb, NULL); } bufferevent_disable(bev1, EV_READ); bufferevent_enable(bev2, EV_READ); for (i = 0; i < sizeof(buffer); i++) buffer[i] = (char)i; /* limit the reading on the receiving bufferevent */ bufferevent_setwatermark(bev2, EV_READ, 10, 20); /* Tell the sending bufferevent not to notify us till it's down to 100 bytes. */ bufferevent_setwatermark(bev1, EV_WRITE, 100, 2000); bufferevent_write(bev1, buffer, sizeof(buffer)); event_dispatch(); tt_int_op(test_ok, ==, 2); /* The write callback drained all the data from outbuf, so we * should have removed the write event... */ tt_assert(!event_pending(&bev2->ev_write, EV_WRITE, NULL)); end: bufferevent_free(bev1); bufferevent_free(bev2); }
static void drained_writecb (struct bufferevent *bev, void *ctx) { struct bufferevent * partner = getpartner (bev, (pcallback_info) ctx); bufferevent_setcb (bev, readcb, NULL, eventcb, partner); bufferevent_setwatermark (bev, EV_WRITE, 0, 0); if (partner) bufferevent_enable (partner, EV_READ); }
static int buffer_event_set_write_watermarks(lua_State* L) { int low, high; le_bufferevent* ev = buffer_event_get(L, 1); if(!ev->ev) return 0; low = lua_tonumber(L, 2); high = lua_tonumber(L, 3); bufferevent_setwatermark(ev->ev, EV_WRITE, low, high); return 0; }
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 ClientImpl::initiateAuthentication(PendingConnection* pc, struct bufferevent *bev)throw (voltdb::LibEventException) { logMessage(ClientLogger::DEBUG, "ClientImpl::initiateAuthentication"); FreeBEVOnFailure protector(bev); bufferevent_setwatermark( bev, EV_READ, 4, HIGH_WATERMARK); bufferevent_setwatermark( bev, EV_WRITE, 8192, 262144); if (bufferevent_enable(bev, EV_READ)) { throw voltdb::LibEventException(); } AuthenticationRequest authRequest( m_username, "database", m_passwordHash, m_hashScheme ); ScopedByteBuffer bb(authRequest.getSerializedSize()); authRequest.serializeTo(&bb); struct evbuffer *evbuf = bufferevent_get_output(bev); if (evbuffer_add( evbuf, bb.bytes(), static_cast<size_t>(bb.remaining()))) { throw voltdb::LibEventException(); } protector.success(); }
void socks_flush(struct socks_data *data) { struct evbuffer *buf; buf = bufferevent_get_output(data->bev); if (evbuffer_get_length(buf)) { bufferevent_disable(data->bev, EV_READ); bufferevent_setwatermark(data->bev, EV_WRITE, 0, 16384); bufferevent_setcb(data->bev, NULL, socks_flush_fin, socks_request_error, data); } else socks_flush_fin(data->bev, data); }
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); }
void pipe_join(struct tcp_pcb *pcb, struct bufferevent *bev) { struct pipe_data *data; data = calloc(1, sizeof(*data)); data->bev = bev; data->pcb = pcb; tcp_arg(data->pcb, data); tcp_err(data->pcb, pipe_tcp_err); tcp_recv(data->pcb, pipe_tcp_recv); tcp_sent(data->pcb, pipe_tcp_sent); bufferevent_setwatermark(data->bev, EV_READ, 1, 262144); bufferevent_setwatermark(data->bev, EV_WRITE, 8192, 262144); bufferevent_setcb(data->bev, pipe_bev_readable, pipe_bev_writable, pipe_bev_error, data); bufferevent_enable(data->bev, EV_READ); bufferevent_set_timeouts(data->bev, NULL, NULL); pipe_bev_readable(data->bev, data); }
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); }
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); }
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; }
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 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 pipe_bev_flush(struct pipe_data *data) { struct evbuffer *buf; buf = bufferevent_get_output(data->bev); if (evbuffer_get_length(buf)) { bufferevent_disable(data->bev, EV_READ); bufferevent_setwatermark(data->bev, EV_WRITE, 0, 262144); bufferevent_setcb(data->bev, NULL, pipe_bev_flush_fin, pipe_bev_err_kill, data); } else { bufferevent_free(data->bev); free(data); } }
static void accept_tcp_channel(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *_) { assert(address->sa_family == AF_INET); struct sockaddr_in *ipv4 = (struct sockaddr_in *) address; char buffer[INET_ADDRSTRLEN]; debug( "tcp channel: from %s", inet_ntop(AF_INET, &(ipv4->sin_addr), buffer, INET_ADDRSTRLEN)); if( ipv4->sin_family != context.control_address.sin_family || memcmp( &ipv4->sin_addr, &context.control_address.sin_addr, sizeof(ipv4->sin_addr))) { debug("tcp channel: invalid source address!"); close(fd); return; } int32_t one = 1; setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); struct bufferevent *bev = bufferevent_socket_new( context.events, fd, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS); if(!bev) { perror("bufferevent_socket_new"); event_base_loopexit(context.events, NULL); return; } bufferevent_setwatermark(bev, EV_READ, 0, BUFFER_LIMIT); bufferevent_setcb( bev, authenticate_tcp_channel, NULL, error_on_tcp_channel, NULL); bufferevent_enable(bev, EV_READ | EV_WRITE); }
void client_start_stream(Client *cl) { struct bufferevent *bev = cl->client.bufev; cl->authenticated = true; bufferevent_disable(bev, EV_READ | EV_WRITE); bufferevent_settimeout(bev, SOCKS_IO_TIMEOUT, SOCKS_IO_TIMEOUT); bufferevent_setwatermark(bev, EV_READ, 0, SOCKS_STREAM_BUFSIZ); bufferevent_setcb(bev, on_client_read_stream, on_client_write, on_client_event, cl); bufferevent_enable(bev, EV_READ | EV_WRITE); /* there is still data available in the buffer, call next callback */ if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev))) on_client_read_stream(bev, cl); }
void LibEventMain::errorfn(bufferevent *bev, short int error, void *arg) { INFO_OUT("Errorfn: %x\n", error); if (error & BEV_EVENT_CONNECTED) { bufferevent_setwatermark(bev, EV_READ, 0, max_buff); bufferevent_enable(bev, EV_READ | EV_WRITE); EventHandler *p = (EventHandler *) arg; if (p) { p->enable(); } } // if error & BEV_EVENT_EOF, BEV_EVENT_ERROR, BEV_EVENT_TIMEOUT if ((error & BEV_EVENT_ERROR) || (error & BEV_EVENT_EOF) || (error & BEV_EVENT_TIMEOUT)) { bufferevent_free(bev); } }
static void drained_writecb(struct bufferevent *bev, void *ctx) { ssh_session_t *session = ctx; struct bufferevent *partner = session->owner_ptr; printf("2----------------------------------------\r\n"); /* We were choking the other side until we drained our outbuf a bit. * Now it seems drained. */ bufferevent_setcb(bev, data_read_handler, NULL, event_error_handler, ctx); bufferevent_setwatermark(bev, EV_WRITE, 0, 0); if (partner) { bufferevent_enable(partner, EV_READ); } }