C++ tcp::socket类代码示例

ed_key c_netuser::get_public_key_resp(ip::tcp::socket &socket_) {
	DBG_MTX(dbg_mtx, "START");
	assert(socket_.is_open());
	boost::system::error_code ec;

	char header[2];
	DBG_MTX(dbg_mtx, "read header");
    size_t pkresp = socket_.read_some(buffer(header, 2), ec);
    DBG_MTX(dbg_mtx, "pk: " << pkresp << ":[" <<header[0] << header[1] << "]");

	DBG_MTX(dbg_mtx, "read public key size");
    size_t pub_key_size = 4;
    uint32_t key_size = 0;
    size_t recieved_bytes = socket_.read_some(buffer(&key_size, pub_key_size), ec);
    DBG_MTX(dbg_mtx, "size:" << recieved_bytes << ":[" <<key_size << "]");

    assert(recieved_bytes == pub_key_size);

    const std::unique_ptr<unsigned char[]> pub_key_data(new unsigned char[key_size]);

	DBG_MTX(dbg_mtx, "read public key data");
    recieved_bytes = socket_.read_some(buffer(pub_key_data.get(), key_size), ec);
    DBG_MTX(dbg_mtx, "data:" << recieved_bytes << ":[" << ed_key(pub_key_data.get(),recieved_bytes) << "]");
    assert(recieved_bytes == key_size);

    ed_key pub_key(pub_key_data.get(), key_size);
	DBG_MTX(dbg_mtx, "END");
	return pub_key;
}

    ~asio_connection()
    {
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
        socket_.cancel();
#endif
        //socket_.shutdown(socket_base::shutdown_both);
        socket_.close();
    }

void c_netuser::send_public_key_req(ip::tcp::socket &socket_) {
	DBG_MTX(dbg_mtx, "send public key request");
	assert(socket_.is_open());
    boost::system::error_code ec;
    char pubkey_send_req[2] = {'p','k'};
    size_t sendbytes = socket_.write_some(boost::asio::buffer(pubkey_send_req, request_type_size),ec);
    DBG_MTX(dbg_mtx, "pk: " << sendbytes << ":[" << pubkey_send_req[0] <<  pubkey_send_req[1] << "]");

}

void c_netuser::send_coin(ip::tcp::socket &socket_, const std::string &coin_data) {
	DBG_MTX(dbg_mtx, "START");
	assert(socket_.is_open());
    boost::system::error_code ec;
	char header[2] = {'$', 't'};
	socket_.write_some(buffer(header, 2), ec);

	uint32_t coin_data_size = coin_data.size();
	socket_.write_some(buffer(&coin_data_size, 4), ec);

	socket_.write_some(buffer(coin_data), ec);
}

inline void cia_client::do_write(boost::shared_ptr<chat_message> ch_msg)
{
	//BOOST_LOG_SEV(cia_g_logger, Debug) << "当前m_chat_msg_queue队列剩余元素:" << m_chat_msg_queue.Size();
	ptr self = shared_from_this();
	//BOOST_LOG_SEV(cia_g_logger, Debug) << "异步发送的数据为:" << std::endl; //<< ch_msg->m_procbuffer_msg.DebugString();
	//BOOST_LOG_SEV(cia_g_logger, Debug) << "rn id:" << ch_msg->m_procbuffer_msg.transid();
	if (!ch_msg->parse_to_cia_msg())
	{		
		BOOST_LOG_SEV(cia_g_logger, Debug) << "解析待发送的报文出错";
		//m_chat_msg_queue.Put(ch_msg);
		return;
	}
	m_sock_.async_send(boost::asio::buffer(ch_msg->data(), ch_msg->length()),
		[this, self, ch_msg](boost::system::error_code ec, std::size_t /*length*/){		
		if (ec){
			BOOST_LOG_SEV(cia_g_logger, Debug) << "异步发送数据回调函数，检测到异常， 关闭此客户端socket, 错误码" << ec;
			stop();
		}
		else
		{
			//BOOST_LOG_SEV(cia_g_logger, Debug) << "已成功异步发送数据, 数据的transid:" << ch_msg->m_procbuffer_msg.transid();
		}
		//m_chat_msg_queue.Put(ch_msg);
	});
}

    void set_socket_recv_bufsize(int buffer_size)
    {
        boost::asio::socket_base::receive_buffer_size recv_bufsize_option(buffer_size);
        socket_.set_option(recv_bufsize_option);

        //std::cout << "set_socket_recv_buffer_size(): " << buffer_size << " bytes" << std::endl;
    }

    void do_write_some()
    {
        //auto self(this->shared_from_this());
        socket_.async_write_some(boost::asio::buffer(data_, packet_size_),
            [this](const boost::system::error_code & ec, std::size_t bytes_written)
            {
                if (!ec) {
                    // If get a circle of ping-pong, we count the query one time.
                    do_query_counter();

                    if ((uint32_t)bytes_written != packet_size_) {
                        std::cout << "asio_connection::do_write_some(): async_write(), bytes_written = "
                                  << bytes_written << " bytes." << std::endl;
                    }

                    do_read_some();
                }
                else {
                    // Write error log
                    std::cout << "asio_connection::do_write_some() - Error: (code = " << ec.value() << ") "
                              << ec.message().c_str() << std::endl;
                    stop(true);
                }
            }
        );
    }

	void Connect(const std::string& host, uint16 port)
	{
		using namespace std::placeholders;
		_socket.async_connect(ip::tcp::endpoint(ip::address::from_string(host), port)
			, std::bind(&Impl::OnConnected, this, _1));
		
	}

future<void> session(ip::tcp::socket s, size_t block_size) {
  vector<char> buf(block_size);
  s.set_option(ip::tcp::no_delay(true));
  for (;;) {
    auto n = co_await async_read_some(s, buffer(buf.data(), block_size));
    n = co_await async_write(s, buffer(buf.data(), n));
  }
}

    int get_socket_recv_bufsize() const
    {
        boost::asio::socket_base::receive_buffer_size recv_bufsize_option;
        socket_.get_option(recv_bufsize_option);

        //std::cout << "receive_buffer_size: " << recv_bufsize_option.value() << " bytes" << std::endl;
        return recv_bufsize_option.value();
    }

 // Constructor
 Connection(std::string server_url)
   : io_service_(), socket(io_service_)
 {
   tcp::resolver resolver(io_service_);
   tcp::resolver::query query(server_url, "4444"); // EDIT PORT NUMBER HERE
   tcp::resolver::iterator iterator = resolver.resolve(query);
   socket.connect(*iterator);
 }

string c_netuser::recv_coin(ip::tcp::socket &socket_) {
	DBG_MTX(dbg_mtx, "START");
	assert(socket_.is_open());
	boost::system::error_code ec;

    size_t recieved_bytes = 0;

	uint32_t coin_size = 0;
	recieved_bytes = socket_.read_some(buffer(&coin_size, 4), ec);
	DBG_MTX(dbg_mtx, "get " << recieved_bytes << " bytes");
	assert(recieved_bytes == 4);

	const std::unique_ptr<char[]> coin_data(new char[coin_size]);

	recieved_bytes = socket_.read_some(buffer(coin_data.get(), coin_size), ec);
	assert(recieved_bytes == coin_size);
	return std::string(coin_data.get(), coin_size);
}

void c_netuser::send_public_key_resp(ip::tcp::socket &socket_) {
	DBG_MTX(dbg_mtx, "START");
	assert(socket_.is_open());
	boost::system::error_code ec;
	char header[2] = {'p', 'k'};
	DBG_MTX(dbg_mtx, "send header");
	socket_.write_some(buffer(header, 2), ec);
	//uint32_t packet_size = ed25519_sizes::pub_key_size;
    ed_key packet = get_public_key();
	uint32_t packet_size = packet.size();
	// TODO send binary data
	DBG_MTX(dbg_mtx,"send public key size" << "[" << packet_size << "]");
    socket_.write_some(boost::asio::buffer(&packet_size, 4), ec);

    DBG_MTX(dbg_mtx,"send public key data" << "[" << packet << "]");
    socket_.write_some(boost::asio::buffer(packet.c_str(), packet_size), ec);
    DBG_MTX(dbg_mtx,"end of sending public key");
}

void c_netuser::server_read(ip::tcp::socket socket_) {
	DBG_MTX(dbg_mtx, "START");
	assert(socket_.is_open());
    boost::system::error_code ec;
    DBG_MTX(dbg_mtx,"server read");
	while (!ec && !m_stop_flag) {
		char header[2] = {0, 0};
		socket_.read_some(buffer(header, 2), ec);
		if (header[0] == 'p' && header[1] == 'k') {
			send_public_key_resp(socket_);
		}
		else if (header[0] == '$' && header[1] == 't') {
			std::string coin_data = recv_coin(socket_);
			recieve_from_packet(coin_data);
		}
	}
	socket_.close();
}

void cia_client::stop()
{
	if (!m_started_) return;
	m_started_ = false;
	m_sock_.close();
	m_deal_ch_msg_group.interrupt_all();

	ptr self = shared_from_this();
	auto it = std::find(clients.begin(), clients.end(), self);
	clients.erase(it);
	BOOST_LOG_SEV(cia_g_logger, Debug) << "客户端socket已经调用stop函数关闭";
	//x m_config_server->set_started(true);	// 为了防止网络情况异常, 造成服务端关闭连接后重置此值为2, 通讯端保证此值为1
}