C++ bufferevent_socket_connect函数代码示例

//## int cbufferevent.socket_connect(Sockaddr_in sa);
static KMETHOD cbufferevent_socket_connect(KonohaContext *kctx, KonohaStack *sfp)
{
	kcbufferevent *bev = (kcbufferevent *)sfp[0].asObject;
	kSockaddr_in *sa = (kSockaddr_in *)sfp[1].asObject;
	int ret = bufferevent_socket_connect(bev->bev, (struct sockaddr *)&sa->sockaddr, sizeof sa->sockaddr);
	KReturnUnboxValue(ret);
}

void InitConnectTo(Server *pServer) {

    struct sockaddr_in sa;

    u32 ip;
    inet_aton(pServer->host, &ip);
    sa.sin_addr = *((struct in_addr *) & ip);
    sa.sin_family = AF_INET;
    sa.sin_port = htons(pServer->port);
    bzero(&sa.sin_zero, 8);


    gettimeofday(&tv, NULL);
    printf("InitConnectTo()  [time: %d]\n", tv.tv_sec);

    pServer->poll->status = 1;
    timerclear(&tv);
     tv.tv_usec=pServer->timeout*1000*1000;

    pServer->poll->bev = bufferevent_socket_new(pServer->evConfig.ev_base, -1, BEV_OPT_CLOSE_ON_FREE);
    bufferevent_socket_connect(pServer->poll->bev ,(struct sockaddr *)&sa, sizeof(sa));
    bufferevent_setcb(pServer->poll->bev, OnBufferedRead, OnBufferedWrite, OnBufferedError, pServer);
    bufferevent_enable(pServer->poll->bev, EV_READ|EV_WRITE |EV_TIMEOUT);
    bufferevent_set_timeouts(pServer->poll->bev, &tv, &tv);

}

static void
bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
    void *arg)
{
	struct bufferevent *bev = arg;
	struct bufferevent_private *bev_p =
	    EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
	int r;
	BEV_LOCK(bev);

	bufferevent_unsuspend_write_(bev, BEV_SUSPEND_LOOKUP);
	bufferevent_unsuspend_read_(bev, BEV_SUSPEND_LOOKUP);

	if (result != 0) {
		bev_p->dns_error = result;
		bufferevent_run_eventcb_(bev, BEV_EVENT_ERROR);
		bufferevent_decref_and_unlock_(bev);
		if (ai)
			evutil_freeaddrinfo(ai);
		return;
	}

	/* XXX use the other addrinfos? */
	/* XXX use this return value */
	r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);
	(void)r;
	bufferevent_decref_and_unlock_(bev);
	evutil_freeaddrinfo(ai);
}

int BotMonitor::connect(const InetAddr& serverAddr)
{
	MutexLockConditionGuard lock(this->m_mutex, this->threadType() == TT_multi_thread);
	for (int i = BOT_DATA->m_nAccountIndex; //
			i < BOT_DATA->m_nAccountIndex + BOT_DATA->m_nBotAmout; ++i)
	{
		BotConnection *conn = new BotConnection();
		conn->init(i, this, true);
		bufferevent_socket_connect(conn->bevent(),//
				(struct sockaddr *)&serverAddr.addr_,//
				sizeof(serverAddr.addr_));

		std::string strIndex = convert<std::string>(i);
		std::string strAccount = BOT_DATA->m_strAccountPre + strIndex + "&";

		this->m_connMap.insert(std::make_pair(i, conn));
		GameBot* bot = new GameBot(i, strAccount);
		this->m_botMap.insert(std::make_pair(i, bot));

		int hz = BOT_DATA->m_nConnectHz > 0 ? BOT_DATA->m_nConnectHz : 10;
		usleep(1000000 / hz);
	}

	return 0;
}

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

static void
bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
    void *arg)
{
	struct bufferevent *bev = arg;
	int r;
	BEV_LOCK(bev);

	bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
	bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);

	if (result != 0) {
		/* XXX Communicate the error somehow. */
		_bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
		_bufferevent_decref_and_unlock(bev);
		if (ai)
			evutil_freeaddrinfo(ai);
		return;
	}

	/* XXX use the other addrinfos? */
	r = bufferevent_socket_connect(bev, ai->ai_addr, ai->ai_addrlen);
	_bufferevent_decref_and_unlock(bev);
	evutil_freeaddrinfo(ai);
}

int main(int argc, char** argv)
{
	if(argc < 3)
	{
		printf("please input 2 parameter\n");
		return -1;
	}
	struct event_base* base = event_base_new();
	struct bufferevent* bev = bufferevent_socket_new(base,-1,
			BEV_OPT_CLOSE_ON_FREE);
	struct event* ev_cmd = event_new(base,STDIN_FILENO,
			EV_READ|EV_PERSIST,
			cmd_msg_cb,(void*)bev);
	event_add(ev_cmd,NULL);
	struct sockaddr_in server_addr;
	memset(&server_addr,0,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&server_addr.sin_addr);

	bufferevent_socket_connect(bev,(struct sockaddr*)&server_addr,
			sizeof(server_addr));
	bufferevent_setcb(bev,server_msg_cb,NULL,event_cb,(void*)ev_cmd);
	bufferevent_enable(bev,EV_READ|EV_PERSIST);

	printf("finished\n");
	return 0;
}

// return 0 if there is valid bufferevent
int CBinaryWriter::connect(){
	int ret;
	if( state == CONNECTING || state == CONNECTED ){
		ret = 0;
		goto ret;
	}
	if( be != NULL ){
		bufferevent_free(be);
		be = NULL;
	}
	be =  bufferevent_socket_new((struct event_base *)base, -1, 0);
	if( bufferevent_disable (be, EV_READ) ){
		goto error;
	}
	bufferevent_setcb(be, NULL, NULL, event_cb, this);
	if( bufferevent_socket_connect(be, addr, addr_len) ){
		goto error;
	}
	ret = 0;
	state = CONNECTING;
ret:
	return ret;

error:
	ret = -1;
	if( be != NULL ){
		bufferevent_free(be);
		be = NULL;
	}   
	goto ret;    
}

	void Conn::run()
	{
		if(conn_type & CONN_TYPE_LISTENER)
		{
			this->pEvbase = event_base_new();
			struct evconnlistener* pEvConn = evconnlistener_new_bind(this->pEvbase,
																	OnConnListenerCb,
																	(void*)this,
																	LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
																	-1,
																	(struct sockaddr*)&sAddrIn,
																	sizeof(struct sockaddr_in));

			if(!pEvConn)
			{
				LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
				return;
			}

			LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port));
			evconnlistener_set_error_cb(pEvConn, OnConnListenerErrCb);
			event_base_dispatch(this->pEvbase);
			return;
		}

		if(conn_type & CONN_TYPE_CONNECTER)
		{
			this->pEvbase = event_base_new();
			this->pConnEvBuf = bufferevent_socket_new(this->pEvbase, -1, BEV_OPT_CLOSE_ON_FREE);
			bufferevent_setcb(this->pConnEvBuf, OnReadCbAddr, NULL, OnConnEventCb, (void*)this);

			if(bufferevent_socket_connect(this->pConnEvBuf, (struct sockaddr*)&sAddrIn, sizeof(struct sockaddr_in)) != 0)
			{
				LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
				bufferevent_free(this->pConnEvBuf);
				return;
			}

			LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port));

			struct event* pEvent = NULL;
			evutil_socket_t fd = bufferevent_getfd(this->pConnEvBuf);

			if(fd != -1 && OnTimingCbAddr != NULL)
			{
				pEvent = event_new(this->pEvbase, fd, EV_PERSIST, OnTimingEventCb, (void*)this);
				event_add(pEvent, &this->tv);
			}

			bufferevent_enable(this->pConnEvBuf, EV_READ);
			event_base_dispatch(this->pEvbase);

			if(fd != -1 && OnTimingCbAddr != NULL)
			{
				event_del(pEvent);
			}

			return;
		}
	}

    void connectToServer(const char *address, const char *port,
            EventHandler *pProcessor) {
        sockaddr_in sin = { 0 };

        sin.sin_family = AF_INET;
        sin.sin_port = htons(atoi(port));
        inet_pton(AF_INET, address, &(sin.sin_addr));

        // Investigate: set reuse address and make socket nonblocking?

        bufferevent *bev = bufferevent_socket_new(m_ebase, -1,
                BEV_OPT_CLOSE_ON_FREE);

        bufferevent_setcb(bev, readfn, NULL, errorfn, (void*) pProcessor);
        pProcessor->setContext((Context*) bev);
        setParent(pProcessor);
        if (bufferevent_socket_connect(bev, (struct sockaddr *) &sin,
                sizeof(sin)) < 0) {
            ERROR_OUT("Cannot bind to port %s", port);
            /* Error starting connection */
            bufferevent_free(bev);
            exit(1);
        }

    }

bool TorControlConnection::Connect(const std::string &target, const ConnectionCB& _connected, const ConnectionCB&  _disconnected)
{
    if (b_conn)
        Disconnect();
    // Parse target address:port
    struct sockaddr_storage connect_to_addr;
    int connect_to_addrlen = sizeof(connect_to_addr);
    if (evutil_parse_sockaddr_port(target.c_str(),
        (struct sockaddr*)&connect_to_addr, &connect_to_addrlen)<0) {
        LogPrintf("tor: Error parsing socket address %s\n", target);
        return false;
    }

    // Create a new socket, set up callbacks and enable notification bits
    b_conn = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
    if (!b_conn)
        return false;
    bufferevent_setcb(b_conn, TorControlConnection::readcb, NULL, TorControlConnection::eventcb, this);
    bufferevent_enable(b_conn, EV_READ|EV_WRITE);
    this->connected = _connected;
    this->disconnected = _disconnected;

    // Finally, connect to target
    if (bufferevent_socket_connect(b_conn, (struct sockaddr*)&connect_to_addr, connect_to_addrlen) < 0) {
        LogPrintf("tor: Error connecting to address %s\n", target);
        return false;
    }
    return true;
}

int main(int argc, char **argv)
{
    struct sockaddr_in serv_addr;
    struct event_base *base;
    struct bufferevent *bev, *bev_stdout;
    int i, addr_len = sizeof serv_addr;
    struct timeval timeout = {1, 0};
    
    base = event_base_new();
    if (evutil_parse_sockaddr_port("127.0.0.1:8200", (struct sockaddr *)&serv_addr, &addr_len)) {
        printf("evutil_parse_sockaddr_port");
        exit(1);
    }


    for (i = 0; i < 10; i++) {

        bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
        bufferevent_setcb(bev, readcb, writecb, eventcb, NULL);
        bufferevent_enable(bev, EV_READ | EV_WRITE);
        bufferevent_set_timeouts(bev, &timeout, &timeout);
        evbuffer_add_printf(bufferevent_get_output(bev), websocket_request);

        if (bufferevent_socket_connect(bev, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
            bufferevent_free(bev);
            printf("bufferevent_socket_connect");
            exit(1);
        }
    }

    event_base_dispatch(base);
}

bufferevent * connect_by_ipport(const char * ip_port)
{
	bufferevent * bev =NULL;
	do 
	{
		struct sockaddr saddr;
		int saddr_len =sizeof(saddr);
		if(0!=evutil_parse_sockaddr_port(ip_port, &saddr, &saddr_len))
		{
			printf("evutil_parse_sockaddr_port failed! \n");
			break;
		}

		bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
		int rt =bufferevent_socket_connect(bev,(struct sockaddr *)&saddr, sizeof(saddr));
		if ( rt!= 0) {
				bufferevent_free(bev);
				break;
		}
		bufferevent_setcb(bev, readcb, writecb, eventcb, NULL);
		bufferevent_enable(bev, EV_READ|EV_WRITE);

	} while (0);
	return bev;
}

static void go_connecting(int fd, short what, void *arg)
{
	CONNECTOR *cr = (CONNECTOR *)arg;
	bufferevent_socket_connect(cr->bev, cr->sa, cr->socklen);
	PUTS("bufferevent_socket_connect %s", __FUNCTION__);

}

    /**
     * Redisサーバへ接続
     *
     * @access public
     * @return bool
     */
    bool rediscli::connection() {
        struct sockaddr *address;
        int length;

        if (port >= 1 && port <= 65535) {
            struct sockaddr_in sin;
            bzero(&sin, sizeof(sin));
            sin.sin_family = AF_INET;
            sin.sin_addr.s_addr = inet_addr(listen.c_str());
            sin.sin_port = htons(port);
            
            address = (struct sockaddr *)&sin;
            length  = sizeof(sin);
        } else {
            struct sockaddr_un sun;
            bzero(&sun, sizeof(sun));
            sun.sun_family = AF_LOCAL;
            strcpy(sun.sun_path, listen.c_str());

            address = (struct sockaddr *)&sun;
            length  = sizeof(sun);
        }


        if (bufferevent_socket_connect(bev, address, length) < 0) {
            log::error("Could not connect a redis server!");
            return false;
        }

        return true;
    }