Esempio n. 1
0
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;
}
Esempio n. 2
0
    ~asio_connection()
    {
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
        socket_.cancel();
#endif
        //socket_.shutdown(socket_base::shutdown_both);
        socket_.close();
    }
Esempio n. 3
0
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] << "]");

}
Esempio n. 4
0
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);
}
Esempio n. 5
0
 virtual void close() {
   if (!closed) closed = 1;
   
   if (clientSocket->is_open()) {
     clientSocket->cancel();
     clientSocket->close();
   }
   
   if (serverSocket.is_open()) {
     serverSocket.cancel();
     serverSocket.close();
   }
 }
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);
	});
}
Esempio n. 7
0
    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;
    }
Esempio n. 8
0
    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);
                }
            }
        );
    }
Esempio n. 9
0
	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));
		
	}
Esempio n. 10
0
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));
  }
}
Esempio n. 11
0
    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();
    }
Esempio n. 12
0
 // 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);
 }
Esempio n. 13
0
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);
}
Esempio n. 14
0
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");
}
Esempio n. 15
0
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
}
Esempio n. 17
0
channel::channel(ip::tcp::socket& input, ip::tcp::socket& output, session& parent_session, const time_duration& input_timeout, bool first_input_stat)
    : input(input)
    , output(output)
    , input_timer(input.io_service())
    , input_timeout(input_timeout)
    , pipe_size(0)
    , parent_session(parent_session)
    , input_handler(boost::bind(&channel::finished_waiting_input, this, placeholders::error(), placeholders::bytes_transferred()))
    , output_handler(boost::bind(&channel::finished_waiting_output,this, placeholders::error(), placeholders::bytes_transferred()))
    , current_state(created)
    , first_input(first_input_stat)
{
    if (pipe2(pipe, O_NONBLOCK) == -1)
    {
        perror("pipe2");
        throw boost::system::errc::make_error_code(static_cast<boost::system::errc::errc_t> (errno));
    }
}
Esempio n. 18
0
 void do_read_some()
 {
     socket_.async_read_some(boost::asio::buffer(data_, packet_size_),
         [this](const boost::system::error_code & ec, std::size_t received_bytes)
         {
             if ((uint32_t)received_bytes != packet_size_) {
                 std::cout << "asio_connection::do_read_some(): async_read(), received_bytes = "
                           << received_bytes << " bytes." << std::endl;
             }
             if (!ec) {
                 // A successful request, can be used to statistic qps
                 do_write_some();
             }
             else {
                 // Write error log
                 std::cout << "asio_connection::do_read_some() - Error: (code = " << ec.value() << ") "
                           << ec.message().c_str() << std::endl;
                 stop(true);
             }
         }
     );
 }
Esempio n. 19
0
 void do_write(ip::tcp::socket & sock, char * buff, size_t size) {
     if ( !started() ) return;
     sock.async_write_some(buffer(buff,size), 
                           MEM_FN3(on_write,ref(sock),_1,_2));
 }
Esempio n. 20
0
 // Destructor
 ~Connection()
 {
   socket.close();
 }
Esempio n. 21
0
 size_t read_complete(ip::tcp::socket & sock, 
                      const error_code & err, size_t bytes) {
     if ( sock.available() > 0) return sock.available();
     return bytes > 0 ? 0 : 1;
 }
Esempio n. 22
0
  virtual void shuttle() {
    serverSocket.async_connect(destination, boost::bind(&RawBridge::handleConnect,
							this,
							Bridge::getSmartPointer(), 
							placeholders::error));      
  }