Beispiel #1
0
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;
}
Beispiel #2
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);
}
Beispiel #3
0
    /**
     * コンストラクタ
     *
     * @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;
    }
Beispiel #4
0
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)));
		}
	}
}
Beispiel #5
0
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));
}
Beispiel #6
0
	/* 
	 * 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);
}
Beispiel #8
0
	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;
	}
Beispiel #9
0
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;
}
Beispiel #10
0
	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;
}
Beispiel #12
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);
}
Beispiel #13
0
Datei: telex.c Projekt: ewust/fox
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);
}
Beispiel #14
0
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));
}
Beispiel #15
0
// 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
    );
}
Beispiel #16
0
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);
}
Beispiel #18
0
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);
}
Beispiel #19
0
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++;
}
Beispiel #20
0
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);
}
Beispiel #21
0
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);
    }
    
}
Beispiel #22
0
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;
}
Beispiel #24
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;
  }
}
Beispiel #26
0
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;
}
Beispiel #27
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));
}
Beispiel #29
0
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);
}
Beispiel #30
0
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);
}