hw::trezor::UdpTransport Class Reference

#include <transport.hpp>

Inheritance diagram for hw::trezor::UdpTransport:

Collaboration diagram for hw::trezor::UdpTransport:

Public Member Functions
	UdpTransport (boost::optional< std::string > device_path=boost::none, boost::optional< std::shared_ptr< Protocol > > proto=boost::none)
virtual	~UdpTransport ()=default
bool	ping () override
std::string	get_path () const override
void	enumerate (t_transport_vect &res) override
void	open () override
void	close () override
std::shared_ptr< Transport >	find_debug () override
void	write (const google::protobuf::Message &req) override
void	read (std::shared_ptr< google::protobuf::Message > &msg, messages::MessageType *msg_type=nullptr) override
void	write_chunk (const void *buff, size_t size) override
size_t	read_chunk (void *buff, size_t size) override
std::ostream &	dump (std::ostream &o) const override
Public Member Functions inherited from hw::trezor::Transport
	Transport ()
virtual	~Transport ()=default

Static Public Attributes
static const char *	PATH_PREFIX = "udp:"
static const char *	DEFAULT_HOST = "127.0.0.1"
static const int	DEFAULT_PORT = 21324

Additional Inherited Members
Protected Member Functions inherited from hw::trezor::Transport
virtual bool	pre_open ()
virtual bool	pre_close ()
Protected Attributes inherited from hw::trezor::Transport
long	m_open_counter

Detailed Description

Definition at line 196 of file transport.hpp.

Constructor & Destructor Documentation

UdpTransport()

hw::trezor::UdpTransport::UdpTransport ( boost::optional< std::string > device_path = boost::none, boost::optional< std::shared_ptr< Protocol > > proto = boost::none )

explicit

Definition at line 510 of file transport.cpp.

                                                                           :
      m_io_service(), m_deadline(m_io_service)
  {
    m_device_host = DEFAULT_HOST;
    m_device_port = DEFAULT_PORT;
    const char *env_trezor_path = nullptr;
 
    if (device_path) {
      parse_udp_path(m_device_host, m_device_port, device_path.get());
    } else if ((env_trezor_path = getenv("TREZOR_PATH")) != nullptr && boost::starts_with(env_trezor_path, UdpTransport::PATH_PREFIX)){
      parse_udp_path(m_device_host, m_device_port, std::string(env_trezor_path));
      MDEBUG("Applied TREZOR_PATH: " << m_device_host << ":" << m_device_port);
    } else {
      m_device_host = DEFAULT_HOST;
    }
 
    assert_port_number((uint32_t)m_device_port);
    if (m_device_host != "localhost" && m_device_host != DEFAULT_HOST){
      throw std::invalid_argument("Local endpoint allowed only");
    }
 
    m_proto = proto ? proto.get() : std::make_shared<ProtocolV1>();
  }

~UdpTransport()

virtual hw::trezor::UdpTransport::~UdpTransport ( )

virtualdefault

Member Function Documentation

close()

void hw::trezor::UdpTransport::close ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 601 of file transport.cpp.

                           {
    if (!pre_close()){
      return;
    }
 
    MTRACE("Closing Trezor:UdpTransport");
    if (!m_socket) {
      throw exc::CommunicationException("Socket is already closed");
    }
 
    m_proto->session_end(*this);
    m_socket->close();
    m_socket = nullptr;
  }

Here is the call graph for this function:

dump()

std::ostream & hw::trezor::UdpTransport::dump ( std::ostream & o ) const

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 766 of file transport.cpp.

                                                    {
    return o << "UdpTransport<path=" << get_path()
             << ", socket_alive=" << (m_socket ? "true" : "false")
             << ">";
  }

Here is the call graph for this function:

enumerate()

void hw::trezor::UdpTransport::enumerate ( t_transport_vect & res )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 566 of file transport.cpp.

                                                     {
    std::shared_ptr<UdpTransport> t = std::make_shared<UdpTransport>();
    bool t_works = false;
 
    try{
      t->open();
      t_works = t->ping();
    } catch(...) {
 
    }
    t->close();
    if (t_works){
      res.push_back(t);
    }
  }

Here is the caller graph for this function:

find_debug()

std::shared_ptr< Transport > hw::trezor::UdpTransport::find_debug ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 616 of file transport.cpp.

                                                    {
#ifdef WITH_TREZOR_DEBUGGING
    std::shared_ptr<UdpTransport> t = std::make_shared<UdpTransport>();
    t->m_proto = std::make_shared<ProtocolV1>();
    t->m_device_host = m_device_host;
    t->m_device_port = m_device_port + 1;
    return t;
#else
    MINFO("Debug link is disabled in production");
    return nullptr;
#endif
  }

get_path()

std::string hw::trezor::UdpTransport::get_path ( ) const

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 535 of file transport.cpp.

                                         {
    std::string path(PATH_PREFIX);
    return path + m_device_host + ":" + std::to_string(m_device_port);
  }

Here is the caller graph for this function:

open()

void hw::trezor::UdpTransport::open ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 582 of file transport.cpp.

                          {
    if (!pre_open()){
      return;
    }
 
    udp::resolver resolver(m_io_service);
    udp::resolver::query query(udp::v4(), m_device_host, std::to_string(m_device_port));
    m_endpoint = *resolver.resolve(query);
 
    m_socket.reset(new udp::socket(m_io_service));
    m_socket->open(udp::v4());
 
    m_deadline.expires_at(boost::posix_time::pos_infin);
    check_deadline();
 
    m_proto->session_begin(*this);
    m_open_counter = 1;
  }

Here is the call graph for this function:

ping()

bool hw::trezor::UdpTransport::ping ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 546 of file transport.cpp.

                         {
    return ping_int();
  }

read()

void hw::trezor::UdpTransport::read ( std::shared_ptr< google::protobuf::Message > & msg, messages::MessageType * msg_type = nullptr )

overridevirtual

Implements hw::trezor::Transport.

Definition at line 729 of file transport.cpp.

                                                                                                    {
    m_proto->read(*this, msg, msg_type);
  }

read_chunk()

size_t hw::trezor::UdpTransport::read_chunk ( void * buff, size_t size )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 642 of file transport.cpp.

                                                         {
    require_socket();
    if (size < 64){
      throw std::invalid_argument("Buffer too small");
    }
 
    ssize_t len;
    while(true) {
      try {
        boost::system::error_code ec;
        len = receive(buff, size, &ec, true);
        if (ec == boost::asio::error::operation_aborted) {
          continue;
        } else if (ec) {
          throw exc::CommunicationException(std::string("Comm error: ") + ec.message());
        }
 
        if (len != 64) {
          throw exc::CommunicationException("Invalid chunk size");
        }
 
        break;
 
      } catch(exc::CommunicationException const& e){
        throw;
      } catch(std::exception const& e){
        MWARNING("Error reading chunk, reason: " << e.what());
        throw exc::CommunicationException(std::string("Chunk read error: ") + std::string(e.what()));
      }
    }
 
    return static_cast<size_t>(len);
  }

Here is the call graph for this function:

write()

void hw::trezor::UdpTransport::write ( const google::protobuf::Message & req )

overridevirtual

Implements hw::trezor::Transport.

Definition at line 725 of file transport.cpp.

                                                           {
    m_proto->write(*this, req);
  }

write_chunk()

void hw::trezor::UdpTransport::write_chunk ( const void * buff, size_t size )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 629 of file transport.cpp.

                                                              {
    require_socket();
 
    if (size != 64){
      throw exc::CommunicationException("Invalid chunk size");
    }
 
    auto written = m_socket->send_to(boost::asio::buffer(buff, size), m_endpoint);
    if (size != written){
      throw exc::CommunicationException("Could not send the whole chunk");
    }
  }

Member Data Documentation

DEFAULT_HOST

const char * hw::trezor::UdpTransport::DEFAULT_HOST = "127.0.0.1"

static

Definition at line 206 of file transport.hpp.

DEFAULT_PORT

const int hw::trezor::UdpTransport::DEFAULT_PORT = 21324

static

Definition at line 207 of file transport.hpp.

PATH_PREFIX

const char * hw::trezor::UdpTransport::PATH_PREFIX = "udp:"

static

Definition at line 205 of file transport.hpp.

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device_trezor/trezor/transport.hpp
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device_trezor/trezor/transport.cpp