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);
}
}
