int Connector::reConnect() { if(m_bev){ bufferevent_free(m_bev); } m_bev = bufferevent_socket_new(m_base, -1, BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE); if(m_bev == NULL){ printf("Connector::registerToService fail, create bufferevent fail"); return -1; } bufferevent_setcb(m_bev, NULL, NULL, Connector::conn_eventcb, (void*)this); bufferevent_socket_connect(m_bev, (struct sockaddr *)&m_server_sin, sizeof(m_server_sin)); return 0; }
static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) { struct stat *stat = 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, stat); bufferevent_enable(bev, EV_READ|EV_WRITE); bufferevent_priority_set(bev, 2); }
/** * コンストラクタ * * @access public * @param struct event_base *base * @param string _listen * @param int _port */ rediscli::rediscli(struct event_base *base, std::string _listen, int _port) { event_assign(&timeout, base, -1, EV_PERSIST, timeoutcb, this); bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); if (!bev) { log::error("Could not initialize bufferevent_socket_new!"); return ; } bufferevent_setcb(bev, NULL, NULL, eventcb, this); bufferevent_disable(bev, EV_READ | EV_WRITE); connected = false; listen = _listen; port = _port; }
static void irc_dnscb(int result, char type, int count, int ttl, void *addresses, void *arg) { Server *s = (Server *)arg; if(result == DNS_ERR_NONE) { if(type == DNS_IPv4_A) { struct sockaddr_in addr; addr.sin_addr.s_addr = ((in_addr_t *)addresses)[0]; addr.sin_port = htons(s->port); addr.sin_family = AF_INET; s->state = Server::Connecting; if(s->buf) DEBUGF(bufferevent_free(s->buf)); DEBUGF(s->buf = bufferevent_socket_new(s->client->base, -1, BEV_OPT_CLOSE_ON_FREE)); DEBUGF(bufferevent_setcb(s->buf, irc_readcb, irc_writecb, irc_eventcb, s)); DEBUGF(bufferevent_socket_connect(s->buf, (sockaddr *)&addr, sizeof(struct sockaddr_in))); } } }
static void smtp_listener_cb(struct evconnlistener *listener, evutil_socket_t fd ,struct sockaddr *sa, int socklen, void *user_data) { struct event_base* base = user_data; struct bufferevent* bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { ERROR("Error constructing bufferevent!"); event_base_loopbreak(base); return; } struct email* email = new_email(); email->bev = bev; bufferevent_setcb(bev, smtp_conn_readcb, NULL, smtp_conn_eventcb, email); bufferevent_enable(bev, EV_READ); bufferevent_write(bev, _220_HELLO, strlen(_220_HELLO)); }
/* * Constructs a new IRC client on top of hte specified socket and event base. */ irc_client::irc_client (server &srv, struct event_base *evbase, int sock) : srv (srv), log (srv.get_logger ()) { this->evbase = evbase; this->sock = sock; this->bufev = bufferevent_socket_new (evbase, sock, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb (this->bufev, &hCraft::irc_client::handle_read, &hCraft::irc_client::handle_write, &hCraft::irc_client::handle_event, this); bufferevent_enable (this->bufev, EV_READ | EV_WRITE); this->total_read = 0; this->fail = false; this->connected = false; }
static void accept_tcp_peer( struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *relay_listener) { assert(address->sa_family == AF_INET); struct sockaddr_in *ipv4 = (struct sockaddr_in *) address; char buffer[INET_ADDRSTRLEN]; debug( "tcp peer: from %s", inet_ntop(AF_INET, &(ipv4->sin_addr), buffer, INET_ADDRSTRLEN)); 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); struct RelayListener *relay = (struct RelayListener *) relay_listener; union Channel *channel = request_channel(relay->proto, relay->port); if(!channel) { debug("tcp peer: no channels left!"); bufferevent_free(bev); return; } channel->tcp.peer_buffers = bev; bufferevent_setcb( bev, NULL, NULL, error_on_tcp_peer, channel); }
Bool HawkGateThread::StartSession(SOCKET hSocket, const SocketAddr& sAddr) { //套接字有效 if (hSocket == INVALID_SOCKET) return false; //创建缓存事件 bufferevent* pEvent = bufferevent_socket_new((event_base*)m_pBase, hSocket, BEV_OPT_CLOSE_ON_FREE); if (!pEvent) return false; //创建会话 Session* pSession = AllocSession(hSocket, sAddr); if (!pSession) { bufferevent_free(pEvent); return false; } pSession->Event = pEvent; //设置回调 bufferevent_setcb(pEvent, hawk_GateSessionRead, hawk_GateSessionWrite, hawk_GateSessionError, pSession); //设置读超时, 可做为心跳机制 Int32 iTimeout = m_pGateway->GetSessionTimeout(); if (iTimeout > 0) { struct timeval tv; tv.tv_sec = iTimeout / 1000; tv.tv_usec = (iTimeout % 1000) * 1000; bufferevent_set_timeouts(pEvent, &tv, NULL); } //开启读写事件 bufferevent_enable(pEvent, EV_READ | EV_WRITE); //添加到会话列表 m_mSession[pSession->Sid] = pSession; //调用性能监视器 if (m_pGateway->GetProfiler()) m_pGateway->GetProfiler()->RegConnect(true); //添加日志 HawkFmtLog("SessionStart, Sid: %u, Address: %s", pSession->Sid, pSession->Addr->ToString().c_str()); return true; }
void TierClientConnectionReconnect(TierClientConnectionRef me){ if(me->logReconnectMessage) { TCLOG("trying to reconnect"); me->logReconnectMessage = NO; } if(me->be != NULL) bufferevent_free(me->be); me->be = bufferevent_socket_new(me->eventLoop, -1, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(me->be, readCBWrapper, writeCBWrapper, eventCBWrapper, me); bufferevent_enable(me->be, EV_READ|EV_WRITE); bufferevent_socket_connect_hostname(me->be, me->dnsBase, AF_UNSPEC, CO(me->host), me->port); me->isConnecting = YES; }
void Conn::OnConnListenerCb(struct evconnlistener *evListener, evutil_socket_t evSocket, struct sockaddr *pAddrIn, int socklen, void *arg) { LOG_DEBUG("New connecter !"); char addr[64]; memset(addr, 0, socklen); struct sockaddr_in* sIn = (struct sockaddr_in*)pAddrIn; evutil_inet_ntop(AF_INET, (void*)&sIn->sin_addr, addr, socklen); LOG_DEBUG("Peer IP is " << addr); Conn *cn = (Conn*)arg; cn->connAddr.assign(addr, strlen(addr)); struct bufferevent* pEvBuf = bufferevent_socket_new(cn->pEvbase, evSocket, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(pEvBuf, cn->OnReadCbAddr, NULL, cn->OnConnEventCb, (void*)cn); bufferevent_enable(pEvBuf, EV_READ); }
int main () { int sockfd; struct bufferevent *p_event; struct sockaddr_in addr; 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); } evthread_use_pthreads(); 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 | BEV_OPT_THREADSAFE)) == NULL) { printf("bufferevent_socket_new "); return 1; } g_bev = p_event; /* 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, buff_ev_cb, p_base); bufferevent_enable(p_event, EV_READ | EV_WRITE); event_base_dispatch(p_base); return 0; }
static void nbd_old_conn(struct evconnlistener *conn, evutil_socket_t sock, struct sockaddr *addr, int len, void * handle) { struct event_base* eb = evconnlistener_get_base(conn); struct bufferevent* bev = bufferevent_socket_new(eb, sock, BEV_OPT_CLOSE_ON_FREE); struct evbuffer* out = bufferevent_get_output(bev); struct nbd_old_handshake hdr = { .magic = htobe64(GAMMARAY_NBD_MAGIC), .protocol = htobe64(GAMMARAY_NBD_OLD_PROTOCOL), .size = htobe64( ((struct nbd_handle*) handle)->size), .flags = htobe32(NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_TRIM), .zeros = {0} }; struct nbd_client* client = (struct nbd_client*) malloc(sizeof(struct nbd_client)); client->handle = handle; client->state = NBD_DATA_PUSHING; client->socket = sock; client->write_count = 0; client->write_bytes = 0; client->buf = NULL; bufferevent_setcb(bev, &nbd_client_handler, NULL, &nbd_ev_handler, client); evbuffer_add(out, &hdr, sizeof(hdr)); bufferevent_enable(bev, EV_READ|EV_WRITE); } static void nbd_event_error(struct evconnlistener* conn, void* ptr) { struct event_base* eb = evconnlistener_get_base(conn); event_base_loopexit(eb, NULL); } void nbd_run_loop(struct nbd_handle* handle) { event_base_dispatch(handle->eb); }
void telex_accept_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) { struct telex_state *state = ctx; struct bufferevent *bev = bufferevent_socket_new( state->base, fd, BEV_OPT_CLOSE_ON_FREE); struct sockaddr_in *sin = (struct sockaddr_in *)address; char src_ip[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &sin->sin_addr.s_addr, src_ip, INET_ADDRSTRLEN); LogDebug(state->name, "%s:%d connected", src_ip, ntohs(sin->sin_port)); bufferevent_setcb(bev, telex_read_cb, NULL, telex_error_cb, state); bufferevent_enable(bev, EV_READ); }
static void accept_connection_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *addr, int sock_len, void *arg) { /* При обработке запроса нового соединения необходимо создать для него объект bufferevent */ std::cerr << "accepted from: " << int2ipv4(((struct sockaddr_in*)addr)->sin_addr.s_addr) << std::endl; struct event_base *base = evconnlistener_get_base(listener); struct bufferevent *buf_ev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(buf_ev, echo_read_cb, NULL, echo_event_cb, NULL); bufferevent_enable(buf_ev, (EV_READ | EV_WRITE)); }
// connect to the remote server static void s3http_client_connect (S3HttpClient *http) { int port; AppConf *conf; if (http->connection_state == S3C_connecting) return; conf = application_get_conf (http->app); if (http->bev) bufferevent_free (http->bev); http->bev = bufferevent_socket_new (http->evbase, -1, 0); if (!http->bev) { LOG_err (HTTP_LOG, "Failed to create HTTP object!"); } // XXX: // bufferevent_set_timeouts (http->bev, port = evhttp_uri_get_port (http->http_uri); // if no port is specified, libevent returns -1 if (port == -1) { port = conf->http_port; } LOG_debug (HTTP_LOG, "Connecting to %s:%d .. %p", evhttp_uri_get_host (http->http_uri), port, http ); http->connection_state = S3C_connecting; bufferevent_enable (http->bev, EV_WRITE); bufferevent_setcb (http->bev, NULL, NULL, s3http_client_connection_event_cb, http ); bufferevent_socket_connect_hostname (http->bev, http->dns_base, AF_UNSPEC, evhttp_uri_get_host (http->http_uri), port ); }
static void echo_listenercb(struct evconnlistener *listener, evutil_socket_t newsock, struct sockaddr *sourceaddr, int socklen, void *ctx) { struct event_base *base = ctx; int flags = BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE; struct bufferevent *bev; bev = bufferevent_socket_new(base, newsock, flags); bufferevent_setcb(bev, echo_readcb, echo_writecb, echo_eventcb, NULL); if (conn_bucket_cfg) bufferevent_set_rate_limit(bev, conn_bucket_cfg); if (ratelim_group) bufferevent_add_to_rate_limit_group(bev, ratelim_group); ++n_echo_conns_open; bufferevent_enable(bev, EV_READ|EV_WRITE); }
static void accept_control(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *_) { assert(address->sa_family == AF_INET); memcpy(&context.control_address, address, sizeof(context.control_address)); char buffer[INET_ADDRSTRLEN]; debug( "control: from %s", inet_ntop( AF_INET, &context.control_address.sin_addr, buffer, INET_ADDRSTRLEN)); int32_t one = 1; setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); context.control_buffers = bufferevent_socket_new( context.events, fd, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS); if(!context.control_buffers) { perror("bufferevent_socket_new"); event_base_loopexit(context.events, NULL); return; } bufferevent_setcb( context.control_buffers, authenticate_control, NULL, error_on_control, NULL); bufferevent_setwatermark( context.control_buffers, EV_READ, sizeof(struct Message), BUFFER_LIMIT); bufferevent_enable(context.control_buffers, EV_READ | EV_WRITE); // disable new connections while authenticating evconnlistener_set_cb(listener, NULL, NULL); setup_control(context.control_buffers); }
void cache_init_packet_from_server() { socklen_t len; struct bufferevent *bev; struct bev_arg *bev_arg; struct destination *destination=first_destination; struct sockaddr *s; bev = bufferevent_socket_new(event_base, -1, BEV_OPT_CLOSE_ON_FREE); bev_arg=malloc(sizeof (struct bev_arg)); bev_arg->type=BEV_CACHE; bev_arg->bev=bev; bev_arg->remote=NULL; /* set callback functions and argument */ bufferevent_setcb(bev, cache_mysql_init_packet_read_callback, NULL, cache_mysql_init_packet_event_callback, (void *)bev_arg); /* read buffer 64kb */ bufferevent_setwatermark(bev, EV_READ, 0, INPUT_BUFFER_LIMIT); if (destination->s[0] == SOCKET_TCP) { s = (struct sockaddr *) &destination->sin; len = destination->addrlen; } else { s = (struct sockaddr *) &destination->sun; len = destination->addrlen; } /* event_callback() will be called after nonblock connect() return */ if (bufferevent_socket_connect(bev, s, len)==-1) { bufferevent_free(bev); free(bev_arg); } struct linger l; l.l_onoff=1; l.l_linger=0; setsockopt(bufferevent_getfd(bev), SOL_SOCKET, SO_LINGER, (void *) &l, sizeof (l)); bufferevent_enable(bev, EV_READ); }
void new_connection(struct config *conf) { struct conn_state *st = calloc(1, sizeof(struct conn_state)); st->state = WAIT_HELLO; st->conf = conf; st->sock = socket(AF_INET, SOCK_STREAM, 0); int optval = 1; setsockopt(st->sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); evutil_make_socket_nonblocking(st->sock); struct bufferevent *bev; bev = bufferevent_socket_new(conf->base, st->sock, BEV_OPT_CLOSE_ON_FREE); // TODO: error check struct timeval read_to; read_to.tv_sec = TIMEOUT_SECS; read_to.tv_usec = 0; bufferevent_set_timeouts(bev, &read_to, &read_to); st->bev = bev; // Generate client random generate_nonce(conf, st->nonce); generate_client_random(conf->prev_block_hash, conf->merkle_root, st->nonce, st->client_random); // Generte client hello and send it uint8_t *client_hello; size_t client_hello_len = make_client_hello(st->client_random, &client_hello); evbuffer_add(bufferevent_get_output(bev), client_hello, client_hello_len); free(client_hello); bufferevent_setcb(bev, readcb, NULL, eventcb, st); // TODO: error check bufferevent_enable(bev, EV_READ | EV_WRITE); if (bufferevent_socket_connect(bev, (struct sockaddr *)&conf->sin, sizeof(conf->sin)) < 0) { perror("socket connected failed: "); printf("Run `sudo sysctl -w net.ipv4.tcp_tw_recycle=1`\n"); cleanup(st); } conf->num_connections++; }
static void accept_incoming (evutil_socket_t efd, short what, void *arg) { vlogprintf (E_WARNING, "Accepting incoming connection\n"); socklen_t clilen = 0; struct sockaddr_in cli_addr; int fd = accept (efd, (struct sockaddr *)&cli_addr, &clilen); assert (fd >= 0); struct bufferevent *bev = bufferevent_socket_new (TLS->ev_base, fd, 0); struct in_ev *e = malloc (sizeof (*e)); e->bev = bev; e->refcnt = 1; e->in_buf_pos = 0; e->error = 0; e->fd = fd; bufferevent_setcb (bev, read_incoming, 0, event_incoming, e); bufferevent_enable (bev, EV_READ | EV_WRITE); }
void TcpListener::OnAcceptCallabck( evconnlistener* listener, evutil_socket_t fd, sockaddr* addr, int socklen ) { struct event_base *base = evconnlistener_get_base(listener_); struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE | BEV_OPT_DEFER_CALLBACKS | BEV_OPT_UNLOCK_CALLBACKS); std::shared_ptr<TcpClient> client(new TcpClient(bev, GetWeakPtr())); clients_.push_back(client); if (acceptCallback_) { acceptCallback_(client); } }
int ctrl_init(struct switch_cfg *_cfg) { static struct event *ev_int; cfg = _cfg; cfg->ctrl_running = 1; jlog(L_NOTICE, "Control initializing..."); if ((base = event_base_new()) == NULL) { jlog(L_ERROR, "event_base_new failed"); goto out; } if ((ev_int = evsignal_new(base, SIGHUP, sighandler, NULL)) == NULL) { jlog(L_ERROR, "evsignal_new failed"); goto out; } if (event_add(ev_int, NULL) < 0) { jlog(L_ERROR, "event_add failed"); goto out; } if (new_peer() == -1) { jlog(L_ERROR, "new_peer failed"); } bufev_pipe = bufferevent_socket_new(base, pipefd[0], BEV_OPT_CLOSE_ON_FREE); bufferevent_enable(bufev_pipe, EV_READ|EV_WRITE); bufferevent_setcb(bufev_pipe, pipe_read_cb, NULL, pipe_event_cb, NULL); event_base_dispatch(base); if (bufev_sock != NULL) { bufferevent_free(bufev_sock); } event_base_free(base); return 0; out: event_base_free(base); return -1; }
int main(void) { struct event_base *base; struct bufferevent *bev; struct sockaddr_in sin; // epoll_create1 base = event_base_new(); memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */ sin.sin_port = htons(8876); /* Port 9876*/ // struct bufferevent *bufferevent_socket_new( // struct event_base *base, // evutil_socket_t fd, // enum bufferevent_options options); // The base is an event_base, and options is a bitmask of bufferevent options (BEV_OPT_CLOSE_ON_FREE, etc). The fd argument is an optional file descriptor for a socket. You can set fd to -1 if you want to set the file descriptor later. // bufferevent_socket_new 只是分配内存 没有系统调用 bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); //void bufferevent_setcb(struct bufferevent *bufev, // bufferevent_data_cb readcb, bufferevent_data_cb writecb, // bufferevent_event_cb eventcb, void *cbarg); //bufferevent_setcb(bev, NULL, NULL, eventcb, NULL); bufferevent_setcb(bev, NULL, NULL, eventcb, "hello"); if (bufferevent_socket_connect(bev, (struct sockaddr *)&sin, sizeof(sin)) < 0) { /* Error starting connection */ // 连接不能马上建立的时候 应该添加到写事件中 fprintf(stderr, "Connect failed.\n"); bufferevent_free(bev); return -1; } // epoll_wait event_base_dispatch(base); pause(); return 0; }
/* * Client events. */ int v4c_cli_run(struct event_base *base, domid_t domid, unsigned long port) { struct sockaddr_v4v sa = { .sa_family = AF_V4V, .sa_addr = { .domain = domid, .port = port }, }; int rc; assert(!server); assert(!input); server = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); if (!server) { rc = EVUTIL_SOCKET_ERROR(); WRN("Failed to open socket (%s).", evutil_socket_error_to_string(rc)); return -rc; } rc = bufferevent_socket_connect(server, (struct sockaddr*)&sa, sizeof (sa)); if (rc) { rc = EVUTIL_SOCKET_ERROR(); WRN("Failed to connect socket (%s).", evutil_socket_error_to_string(rc)); bufferevent_free(server); return -rc; } bufferevent_setcb(server, v4c_cli_recv, NULL, v4c_cli_event, NULL); bufferevent_enable(server, EV_READ | EV_WRITE); input = v4c_stdin_ev_new(base, server); if (!input) { bufferevent_free(server); } event_base_dispatch(base); event_free(input); /* v4c_cli_event will call bufferevent_free(server). */ return 0; }
tcpConnectStatus TcpTransport::connect(const string &strServerURL, int timeOutMillisecs /* = 3000 */) { string hostName; short portNumber; if (!UtilAll::SplitURL(strServerURL, hostName, portNumber)) { return e_connectFail; } boost::lock_guard<boost::mutex> lock(m_socketLock); struct sockaddr_in sin; memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = inet_addr(hostName.c_str()); sin.sin_port = htons(portNumber); m_eventBase = event_base_new(); m_bufferEvent = bufferevent_socket_new( m_eventBase, -1, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE); bufferevent_setcb(m_bufferEvent, readNextMessageIntCallback, NULL, eventcb, this); bufferevent_enable(m_bufferEvent, EV_READ | EV_WRITE); bufferevent_setwatermark(m_bufferEvent, EV_READ, 4, 0); setTcpConnectStatus(e_connectWaitResponse); if (bufferevent_socket_connect(m_bufferEvent, (struct sockaddr *)&sin, sizeof(sin)) < 0) { LOG_INFO("connect to fd:%d failed", bufferevent_getfd(m_bufferEvent)); setTcpConnectStatus(e_connectFail); freeBufferEvent(); return e_connectFail; } else { int fd = bufferevent_getfd(m_bufferEvent); LOG_INFO("try to connect to fd:%d, addr:%s", fd, (hostName.c_str())); /*struct timeval timeout; timeout.tv_sec = timeOutMillisecs/1000; timeout.tv_usec = 0; struct event* evtimeout = evtimer_new(m_eventBase, timeoutcb, this); evtimer_add(evtimeout, &timeout);*/ evthread_make_base_notifiable(m_eventBase); m_ReadDatathread = new boost::thread(boost::bind(&TcpTransport::runThread, this)); return e_connectWaitResponse; } }
static int launch_request(void) { evutil_socket_t sock; struct sockaddr_in sin; struct bufferevent *b; struct request_info *ri; memset(&sin, 0, sizeof(sin)); ++total_n_launched; sin.sin_family = AF_INET; sin.sin_addr.s_addr = htonl(0x7f000001); sin.sin_port = htons(8080); if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) return -1; if (evutil_make_socket_nonblocking(sock) < 0) { evutil_closesocket(sock); return -1; } frob_socket(sock); if (connect(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0) { int e = evutil_socket_geterror(sock); if (! EVUTIL_ERR_CONNECT_RETRIABLE(e)) { evutil_closesocket(sock); return -1; } } ri = malloc(sizeof(*ri)); ri->n_read = 0; evutil_gettimeofday(&ri->started, NULL); b = bufferevent_socket_new(base, sock, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(b, readcb, NULL, errorcb, ri); bufferevent_enable(b, EV_READ|EV_WRITE); evbuffer_add_printf(bufferevent_get_output(b), "GET %s HTTP/1.0\r\n\r\n", resource); return 0; }
static void cbAcceptSocket(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) { struct event_base *base = evconnlistener_get_base(listener); struct bufferevent *bev; bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { perror("Error constructing bufferevent!"); event_base_loopbreak(base); exit(1); } bufferevent_setcb(bev, cbReadSocket, NULL, cbErrorSocket, NULL); bufferevent_enable(bev, EV_READ); eventarg.output_socket = bufferevent_get_output(bev); printf("client_socket is %d:\n",fd); }
static 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) { fprintf(stderr, "Error constructing bufferevent!"); event_base_loopbreak(base); return; } bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL); bufferevent_enable(bev, EV_WRITE); bufferevent_disable(bev, EV_READ); bufferevent_write(bev, MESSAGE, strlen(MESSAGE)); }
static void listen_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) { struct imap_driver *driver = user_data; struct event_base *base = driver->base; struct bufferevent* bev; bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); if (!bev) { skeeter_log(LOG_CRIT, "Could not acquire bufferevent!"); event_base_loopbreak(base); return; } bufferevent_write(bev, "* CAPABILITY IMAP4rev1 STARTTLS" CRLF, 33); skeeter_log(LOG_INFO, "A new connection established"); imap_driver_install(bev, driver); }
void CBareConnection::BareConnect(const event_type<event_base>& base, int bev_opts, evutil_socket_t socket, sockaddr* addr, int addrlen, const timeval& connTimeout) { assert(!m_bev); assert(addr != nullptr); assert(addrlen > 0); m_bev = event_type<bufferevent>(bufferevent_socket_new(base, socket, bev_opts)); int ret; ret = bufferevent_disable(m_bev, EV_READ | EV_WRITE); assert(ret == 0); (void)ret; ret = bufferevent_set_timeouts(m_bev, &connTimeout, &connTimeout); assert(ret == 0); (void)ret; bufferevent_setcb(m_bev, nullptr, nullptr, conn_event, this); bufferevent_socket_connect(m_bev, addr, addrlen); }