C++ socket_ptr类代码示例

 // 异步连接回调(带超时)
 void on_async_connect_timed(error_code const& ec, socket_ptr sp
     , endpoint addr, boost::posix_time::time_duration timed)
 {
     if (ec)
     {
         // 错误
         ec_ = ec;
         async_connecting_.reset();
         notify_onconnect();
     }
     else if (sp->lowest_layer().remote_endpoint() == sp->lowest_layer().local_endpoint())
     {
         // 回环假链接, 重试.
         async_connecting_.reset();
         if (!async_connect_timed(addr, timed))
         {
             if (!ec_) ec_ = make_error_code(errc::reconnect_error);
             notify_onconnect();
         }
         return ;
     }
     else
     {
         // 连接成功, 握手
         async_handshake(sp, addr);
     }
 }

void Server::connection(socket_ptr _sock) {
    try {
        CLOG_INFO << "Connection, peer IP: " << _sock->remote_endpoint().address().to_string() << endl;

        Operation op;
        receive(_sock, op);

        if ( op == Operation::CREATE ) {
            Counter(_sock, this);
        }
        else if ( op == Operation::INFO_DEVICE || 
                  op == Operation::LIST_DEVICES || 
                  op == Operation::CMD_STATUS ||
                  op == Operation::READ_DEVICE ) {
            Info(_sock, op, this);
        }
        else {
            send<int>(_sock, (int)Retval::ERROR);
        }                
        _sock->close();
    } 
    catch (exception& e) {
        CLOG_ERROR << "Exception in thread: " << e.what() << endl;
    }
}

 // 异步连接回调
 void on_async_connect(error_code const& ec, socket_ptr sp, endpoint addr)
 {
     if (ec)
     {
         // 错误
         ec_ = ec;
         async_connecting_.reset();
         notify_onconnect();    // 通知连接结果
     }
     else if (sp->lowest_layer().remote_endpoint() == sp->lowest_layer().local_endpoint())
     {
         // 回环假链接, 重试.
         async_connecting_.reset();
         if (!async_connect(addr))
         {
             if (!ec_) ec_ = make_error_code(errc::reconnect_error);
             notify_onconnect();
         }
     }
     else
     {
         // 连接成功, 握手
         async_handshake(sp, addr);
     }
 }

    /// 连接回调
    void tcp_connector::async_connect_handler( boost::system::error_code const& ec
        , socket_ptr pSock, FactoryFunc fact_func, ConnectHandler const& handler
        , options_ptr opts, tcp::resolver::iterator resolver_it )
    {
        tcp_session_ptr ptr;
        boost::system::error_code remote_ec, local_ec;
        if (!ec && pSock->remote_endpoint(remote_ec) != pSock->local_endpoint(local_ec)
            && !remote_ec && !local_ec)
            ptr = fact_func(pSock, session_initialized(session_id(), group_id(), opts));
        else if (tcp::resolver::iterator() != resolver_it)
        {
            boost::system::error_code close_ec;
            pSock->close(close_ec);
            if (close_ec)
                pSock.reset(new socket(m_ios));

            tcp::endpoint endpoint = *resolver_it++;
            pSock->async_connect(endpoint
                , boost::bind(&tcp_connector::async_connect_handler, this, placeholders::error
                , pSock, fact_func, handler, opts, resolver_it ));
            return ;
        }
        
        handler(ptr, ec);
    }

	void Server::disconnected(socket_ptr & socket)
	{
		boost::lock_guard<boost::mutex> lock(sockets_mut_);
		
		mark_container::iterator it = std::find(marks_.begin(), marks_.end(), socket->native_handle());
		if (it == marks_.end())
			marks_.push_back(socket->native_handle());
	}

void disconnectClient(socket_ptr clientSock)
{
	auto position = find(clientList->begin(), clientList->end(), clientSock);
	
	clientSock->shutdown(tcp::socket::shutdown_both);
	clientSock->close();
	
	clientList->erase(position);

	cout << "Client Disconnected! " << clientList->size() << " total clients" << endl;
}

void network_impl::handle_accept(socket_ptr socket)
{
    tcp::endpoint remote_endpoint = socket->remote_endpoint();
    log_debug() << "New incoming connection from "
            << remote_endpoint.address().to_string();
    channel_handle chanid = create_channel(socket);
    kernel_->handle_connect(chanid);
    socket.reset(new tcp::socket(*service()));
    acceptor_->async_accept(*socket,
            std::bind(&network_impl::handle_accept, shared_from_this(), 
                socket));
}

void multicast_communication::market_data_receiver::connect_socket_( socket_ptr& socket, const common::address& to )
{
	using boost::asio::ip::udp;
	using boost::asio::ip::address;
	using boost::asio::ip::multicast::join_group;

	udp::endpoint listen_endpoint( address::from_string( "0.0.0.0" ), to.port() );

	socket->open( listen_endpoint.protocol() );
	socket->set_option( udp::socket::reuse_address( true ) );
	socket->bind( listen_endpoint );
	socket->set_option( join_group( address::from_string( to.ip() ) ) );
}

void Client::inboundLoop(socket_ptr sock, string_ptr prompt) {
    int sizeBufRd = 0;
    char buff[1024] = {0};
    
    while( true){
        if( sock->available()){
            sizeBufRd = sock->read_some( buffer( buff, sizeInput));
            string_ptr msg( new string( buff, sizeBufRd));
            pMsgQueue->push( msg);
        }
        
//        boost::this_thread::sleep( boost::posix_time::millisec(100));
    }
}

        // 超时回调
        void on_overtime(error_code const& ec, socket_ptr sp, errc error_enum)
        {
            if (ec)
                return ;

            // 超时了
            error_code lec;
            sp->lowest_layer().cancel(lec);
            sp->lowest_layer().shutdown(socket_base::shutdown_both, lec);
            sp->lowest_layer().close(lec);
            async_connecting_.reset();
            ec_ = make_error_code(error_enum);
            notify_onconnect();
        }

void writeLoop(socket_ptr sock, string_ptr prompt)
{
    char inputBuf[inputSize] = {0};

    for(;;)
    {
        //cin.getline(inputBuf, inputSize);
        //inputMsg = *prompt + (string)inputBuf + '\n';
	mainMutex.lock();
	
	
        if(!sendMessage.empty())
        {
		sendMessage = *prompt + sendMessage;
		cout << sendMessage << sendMessage.empty() << endl;
            //sock->write_some(buffer(inputMsg, inputSize));
		sock->write_some(buffer(sendMessage, inputSize));
        }

        if(sendMessage.find("exit") != string::npos){
            mainMutex.unlock();
		exit(1);
	}
        sendMessage.clear();
	memset(inputBuf,0,inputSize);
	mainMutex.unlock();
	boost::this_thread::sleep( boost::posix_time::millisec(500));
    }
}

/*****************************************************************************
*   fiber function per server connection
*****************************************************************************/
void session( socket_ptr sock) {
    try {
        for (;;) {
            char data[max_length];
            boost::system::error_code ec;
            std::size_t length = sock->async_read_some(
                    boost::asio::buffer( data),
                    boost::fibers::asio::yield[ec]);
            if ( ec == boost::asio::error::eof) {
                break; //connection closed cleanly by peer
            } else if ( ec) {
                throw boost::system::system_error( ec); //some other error
            }
            print( tag(), ": handled: ", std::string(data, length));
            boost::asio::async_write(
                    * sock,
                    boost::asio::buffer( data, length),
                    boost::fibers::asio::yield[ec]);
            if ( ec == boost::asio::error::eof) {
                break; //connection closed cleanly by peer
            } else if ( ec) {
                throw boost::system::system_error( ec); //some other error
            }
        }
        print( tag(), ": connection closed");
    } catch ( std::exception const& ex) {
        print( tag(), ": caught exception : ", ex.what());
    }
}

void writeLoop(socket_ptr sock, string_ptr prompt)
{
    string inputMsg;
    int i = 1;
    for(;;)
    {
        inputMsg = *prompt;

        mainMutex.lock();
        if(!sendMessage.empty())
        {
            cerr << "Message sent:" << sendMessage <<":\n";
            inputMsg += sendMessage;
            sock->write_some(buffer(inputMsg, inputSize));
            //sendMessage.clear();
            if(i==10)
            {
                sendMessage.clear();
                i=1;
            }else
                ++i;

        }
        mainMutex.unlock();
        if(inputMsg.find("exit") != string::npos)
            return;
        inputMsg.clear();
        boost::this_thread::sleep( boost::posix_time::millisec(1000));
    }
}

void session(socket_ptr sock)
{
	for (;;)
	{
		char data[max_length];
		::memset(data, 0, max_length);

		boost::system::error_code error;
		size_t length = sock->read_some(boost::asio::buffer(data), error);
		if (error == boost::asio::error::eof)
			break; // Connection closed cleanly by peer.
		else if (error)
			throw boost::system::system_error(error); // Some other error.

		// boost::asio::write(*sock, boost::asio::buffer(data, length));

		for (int i = 0; i < g_clinets.size(); ++i)
		{
			boost::asio::write(*g_clinets[i], boost::asio::buffer(data, length));
		}

		std::cout << "Client Data is :";
		std::cout.write(data, length);
		std::cout << "\n";
	}
}

static int ReadLine(socket_ptr sock, std::string &tmp)
{
	boost::system::error_code ec;
	boost::asio::streambuf response;

	try {
		SOCKET native_sock = sock->native();
		int result = SOCKET_ERROR;

		if (INVALID_SOCKET != native_sock)
		{
			DWORD tv=2000;
			result = setsockopt(native_sock, SOL_SOCKET, SO_RCVTIMEO, (char *) &tv,sizeof(DWORD) );
			// result should be zero
		}
		size_t len = boost::asio::read_until(*sock, response, "\n", ec);
		if(len==0)
			return -1;

		if(ec)
			throw boost::system::system_error(ec); // 
		if (ec == boost::asio::error::eof)
			throw boost::system::system_error(ec); // 

		std::istream response_stream(&response);
		getline(response_stream, tmp);
	}
	catch(std::exception & e) 
	{ 
		std::cout<< "ReadLine  Exception " << e.what() << "\n";
		return -1;
	}
	return tmp.size();
}