hw::trezor::BridgeTransport Class Reference

#include <transport.hpp>

Inheritance diagram for hw::trezor::BridgeTransport:

Collaboration diagram for hw::trezor::BridgeTransport:

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

Static Public Attributes
static const char *	PATH_PREFIX = "bridge:"

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 162 of file transport.hpp.

Constructor & Destructor Documentation

BridgeTransport()

hw::trezor::BridgeTransport::BridgeTransport	(	boost::optional< std::string >	device_path = boost::none,
		boost::optional< std::string >	bridge_host = boost::none
	)

Definition at line 315 of file transport.cpp.

                                             :
    m_device_path(device_path),
    m_bridge_host(bridge_host ? bridge_host.get() : DEFAULT_BRIDGE),
    m_response(boost::none),
    m_session(boost::none),
    m_device_info(boost::none)
    {
      const char *env_bridge_port = nullptr;
      if (!bridge_host && (env_bridge_port = getenv("TREZOR_BRIDGE_PORT")) != nullptr)
      {
        uint16_t bridge_port;
        CHECK_AND_ASSERT_THROW_MES(epee::string_tools::get_xtype_from_string(bridge_port, env_bridge_port), "Invalid bridge port: " << env_bridge_port);
        assert_port_number(bridge_port);
 
        m_bridge_host = std::string("127.0.0.1:") + boost::lexical_cast<std::string>(env_bridge_port);
        MDEBUG("Bridge host: " << m_bridge_host);
      }
 
      m_http_client.set_server(m_bridge_host, boost::none, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
    }

Here is the call graph for this function:

~BridgeTransport()

virtual hw::trezor::BridgeTransport::~BridgeTransport ( )

virtualdefault

Member Function Documentation

close()

void hw::trezor::BridgeTransport::close ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 404 of file transport.cpp.

                              {
    if (!pre_close()){
      return;
    }
 
    MTRACE("Closing Trezor:BridgeTransport");
    if (!m_device_path || !m_session){
      throw exc::CommunicationException("Device not open");
    }
 
    std::string uri = "/release/" + m_session.get();
    std::string req;
    json bridge_res;
    bool req_status = invoke_bridge_http(uri, req, bridge_res, m_http_client);
    if (!req_status){
      throw exc::CommunicationException("Failed to release device");
    }
 
    m_session = boost::none;
  }

Here is the call graph for this function:

device_info()

const boost::optional< json > & hw::trezor::BridgeTransport::device_info

(

)

const

Definition at line 476 of file transport.cpp.

                                                                 {
    return m_device_info;
  }

dump()

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

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 480 of file transport.cpp.

                                                       {
    return o << "BridgeTransport<path=" << (m_device_path ? get_path() : "None")
             << ", info=" << (m_device_info ? t_serialize(m_device_info.get()) : "None")
             << ", session=" << (m_session ? m_session.get() : "None")
             << ">";
  }

Here is the call graph for this function:

enumerate()

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

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 347 of file transport.cpp.

                                                        {
    json bridge_res;
    std::string req;
 
    bool req_status = invoke_bridge_http("/enumerate", req, bridge_res, m_http_client);
    if (!req_status){
      throw exc::CommunicationException("Bridge enumeration failed");
    }
 
    for(rapidjson::Value::ConstValueIterator itr = bridge_res.Begin(); itr != bridge_res.End(); ++itr){
      auto element = itr->GetObject();
      auto t = std::make_shared<BridgeTransport>(boost::make_optional(json_get_string(element["path"])));
 
      auto itr_vendor = element.FindMember("vendor");
      auto itr_product = element.FindMember("product");
      if (itr_vendor != element.MemberEnd() && itr_product != element.MemberEnd()
        && itr_vendor->value.IsNumber() && itr_product->value.IsNumber()){
        try {
          const auto id_vendor = (uint16_t) itr_vendor->value.GetUint64();
          const auto id_product = (uint16_t) itr_product->value.GetUint64();
          const auto device_idx = get_device_idx(id_vendor, id_product);
          if (!is_device_supported(device_idx)){
            MDEBUG("Device with idx " << device_idx << " is not supported. Vendor: " << id_vendor << ", product: " << id_product);
            continue;
          }
        } catch(const std::exception &e){
          MERROR("Could not detect vendor & product: " << e.what());
        }
      }
 
      t->m_device_info.emplace();
      t->m_device_info->CopyFrom(*itr, t->m_device_info->GetAllocator());
      res.push_back(t);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_path()

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

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 338 of file transport.cpp.

                                            {
    if (!m_device_path){
      return "";
    }
 
    std::string path(PATH_PREFIX);
    return path + m_device_path.get();
  }

Here is the caller graph for this function:

open()

void hw::trezor::BridgeTransport::open ( )

overridevirtual

Reimplemented from hw::trezor::Transport.

Definition at line 383 of file transport.cpp.

                             {
    if (!pre_open()){
      return;
    }
 
    if (!m_device_path){
      throw exc::CommunicationException("Coud not open, empty device path");
    }
 
    std::string uri = "/acquire/" + m_device_path.get() + "/null";
    std::string req;
    json bridge_res;
    bool req_status = invoke_bridge_http(uri, req, bridge_res, m_http_client);
    if (!req_status){
      throw exc::CommunicationException("Failed to acquire device");
    }
 
    m_session = boost::make_optional(json_get_string(bridge_res["session"]));
    m_open_counter = 1;
  }

Here is the call graph for this function:

read()

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

overridevirtual

Implements hw::trezor::Transport.

Definition at line 448 of file transport.cpp.

                                                                                                       {
    if (!m_response){
      throw exc::CommunicationException("Could not read, no response stored");
    }
 
    std::string bin_data;
    if (!epee::string_tools::parse_hexstr_to_binbuff(m_response.get(), bin_data)){
      throw exc::CommunicationException("Response is not well hexcoded");
    }
 
    uint16_t msg_tag;
    uint32_t msg_len;
    deserialize_message_header(bin_data.c_str(), msg_tag, msg_len);
    if (bin_data.size() != msg_len + 6){
      throw exc::CommunicationException("Response is not well hexcoded");
    }
 
    if (msg_type){
      *msg_type = static_cast<messages::MessageType>(msg_tag);
    }
 
    std::shared_ptr<google::protobuf::Message> msg_wrap(MessageMapper::get_message(msg_tag));
    if (!msg_wrap->ParseFromArray(bin_data.c_str() + 6, msg_len)){
      throw exc::EncodingException("Response is not well hexcoded");
    }
    msg = msg_wrap;
  }

Here is the call graph for this function:

write()

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

overridevirtual

Implements hw::trezor::Transport.

Definition at line 425 of file transport.cpp.

                                                              {
    m_response = boost::none;
 
    const auto msg_size = message_size(req);
    const auto buff_size = serialize_message_buffer_size(msg_size);
 
    std::unique_ptr<uint8_t[]> req_buff(new uint8_t[buff_size]);
    uint8_t * req_buff_raw = req_buff.get();
 
    serialize_message(req, msg_size, req_buff_raw, buff_size);
 
    std::string uri = "/call/" + m_session.get();
    std::string req_hex = epee::to_hex::string(epee::span<const std::uint8_t>(req_buff_raw, buff_size));
    std::string res_hex;
 
    bool req_status = invoke_bridge_http(uri, req_hex, res_hex, m_http_client);
    if (!req_status){
      throw exc::CommunicationException("Call method failed");
    }
 
    m_response = res_hex;
  }

Here is the call graph for this function:

Member Data Documentation

PATH_PREFIX

const char * hw::trezor::BridgeTransport::PATH_PREFIX = "bridge:"

static

Definition at line 170 of file transport.hpp.

---

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

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