mms::message_transporter Class Reference

#include <message_transporter.h>

Public Member Functions
	message_transporter ()
void	set_options (const std::string &bitmessage_address, const epee::wipeable_string &bitmessage_login)
bool	send_message (const transport_message &message)
bool	receive_messages (const std::vector< std::string > &destination_transport_addresses, std::vector< transport_message > &messages)
bool	delete_message (const std::string &transport_id)
void	stop ()
std::string	derive_transport_address (const std::string &seed)
std::string	derive_and_receive_transport_address (const std::string &seed)
bool	delete_transport_address (const std::string &transport_address)

Detailed Description

Definition at line 83 of file message_transporter.h.

Constructor & Destructor Documentation

message_transporter()

mms::message_transporter::message_transporter

(

)

Definition at line 83 of file message_transporter.cpp.

{
  m_run = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

delete_message()

bool mms::message_transporter::delete_message

(

const std::string &

transport_id

)

Definition at line 184 of file message_transporter.cpp.

{
  std::string request;
  start_xml_rpc_cmd(request, "trashMessage");
  add_xml_rpc_string_param(request, transport_id);
  end_xml_rpc_cmd(request);
  std::string answer;
  post_request(request, answer);
  return true;
}

delete_transport_address()

bool mms::message_transporter::delete_transport_address

(

const std::string &

transport_address

)

Definition at line 232 of file message_transporter.cpp.

{
  std::string request;
  start_xml_rpc_cmd(request, "deleteAddress");
  add_xml_rpc_string_param(request, transport_address);
  end_xml_rpc_cmd(request);
  std::string answer;
  return post_request(request, answer);
}

derive_and_receive_transport_address()

std::string mms::message_transporter::derive_and_receive_transport_address

(

const std::string &

seed

)

Definition at line 214 of file message_transporter.cpp.

{
  // We need to call both "get_deterministic_address" AND "createDeterministicAddresses"
  // because we won't get back the address from the latter call if it exists already
  std::string address = derive_transport_address(seed);
 
  std::string request;
  start_xml_rpc_cmd(request, "createDeterministicAddresses");
  add_xml_rpc_base64_param(request, seed);
  add_xml_rpc_integer_param(request, 1);  // numberOfAddresses
  add_xml_rpc_integer_param(request, 4);  // addressVersionNumber
  end_xml_rpc_cmd(request);
  std::string answer;
  post_request(request, answer);
 
  return address;
}

Here is the call graph for this function:

derive_transport_address()

std::string mms::message_transporter::derive_transport_address

(

const std::string &

seed

)

Definition at line 198 of file message_transporter.cpp.

{
  std::string request;
  start_xml_rpc_cmd(request, "getDeterministicAddress");
  add_xml_rpc_base64_param(request, seed);
  add_xml_rpc_integer_param(request, 4);  // addressVersionNumber
  add_xml_rpc_integer_param(request, 1);  // streamNumber
  end_xml_rpc_cmd(request);
  std::string answer;
  post_request(request, answer);
  std::string address = get_str_between_tags(answer, "<string>", "</string>");
  return address;
}

Here is the caller graph for this function:

receive_messages()

bool mms::message_transporter::receive_messages	(	const std::vector< std::string > &	destination_transport_addresses,
		std::vector< transport_message > &	messages )

Definition at line 102 of file message_transporter.cpp.

{
  // The message body of the Bitmessage message is basically the transport message, as JSON (and nothing more).
  // Weeding out other, non-MMS messages is done in a simple way: If it deserializes without error, it's an MMS message
  // That JSON is Base64-encoded by the MMS because the Electroneum epee JSON serializer does not escape anything and happily
  // includes even 0 (NUL) in strings, which might confuse Bitmessage or at least display confusingly in the client.
  // There is yet another Base64-encoding of course as part of the Bitmessage API for the message body parameter
  // The Bitmessage API call "getAllInboxMessages" gives back a JSON array with all the messages (despite using
  // XML-RPC for the calls, and not JSON-RPC ...)
  m_run.store(true, std::memory_order_relaxed);
  std::string request;
  start_xml_rpc_cmd(request, "getAllInboxMessages");
  end_xml_rpc_cmd(request);
  std::string answer;
  post_request(request, answer);
 
  std::string json = get_str_between_tags(answer, "<string>", "</string>");
  bitmessage_rpc::inbox_messages_response bitmessage_res;
  if (!epee::serialization::load_t_from_json(bitmessage_res, json))
  {
    MERROR("Failed to deserialize messages");
    return true;
  }
  size_t size = bitmessage_res.inboxMessages.size();
  messages.clear();
 
  for (size_t i = 0; i < size; ++i)
  {
    if (!m_run.load(std::memory_order_relaxed))
    {
      // Stop was called, don't waste time processing any more messages
      return false;
    }
    const bitmessage_rpc::message_info &message_info = bitmessage_res.inboxMessages[i];
    if (std::find(destination_transport_addresses.begin(), destination_transport_addresses.end(), message_info.toAddress) != destination_transport_addresses.end())
    {
      transport_message message;
      bool is_mms_message = false;
      try
      {
        // First Base64-decoding: The message body is Base64 in the Bitmessage API
        std::string message_body = epee::string_encoding::base64_decode(message_info.message);
        // Second Base64-decoding: The MMS uses Base64 to hide non-textual data in its JSON from Bitmessage
        json = epee::string_encoding::base64_decode(message_body);
        if (!epee::serialization::load_t_from_json(message, json))
          MERROR("Failed to deserialize message");
        else
          is_mms_message = true;
      }
      catch(const std::exception& e)
      {
      }
      if (is_mms_message)
      {
        message.transport_id = message_info.msgid;
        messages.push_back(message);
      }
    }
  }
 
  return true;
}

Here is the call graph for this function:

send_message()

bool mms::message_transporter::send_message

(

const transport_message &

message

)

Definition at line 166 of file message_transporter.cpp.

{
  // <toAddress> <fromAddress> <subject> <message> [encodingType [TTL]]
  std::string request;
  start_xml_rpc_cmd(request, "sendMessage");
  add_xml_rpc_string_param(request, message.destination_transport_address);
  add_xml_rpc_string_param(request, message.source_transport_address);
  add_xml_rpc_base64_param(request, message.subject);
  std::string json = epee::serialization::store_t_to_json(message);
  std::string message_body = epee::string_encoding::base64_encode(json);  // See comment in "receive_message" about reason for (double-)Base64 encoding
  add_xml_rpc_base64_param(request, message_body);
  add_xml_rpc_integer_param(request, 2);
  end_xml_rpc_cmd(request);
  std::string answer;
  post_request(request, answer);
  return true;
}

Here is the call graph for this function:

set_options()

void mms::message_transporter::set_options	(	const std::string &	bitmessage_address,
		const epee::wipeable_string &	bitmessage_login )

Definition at line 88 of file message_transporter.cpp.

{
  m_bitmessage_url = bitmessage_address;
  epee::net_utils::http::url_content address_parts{};
  epee::net_utils::parse_url(m_bitmessage_url, address_parts);
  if (address_parts.port == 0)
  {
    address_parts.port = PYBITMESSAGE_DEFAULT_API_PORT;
  }
  m_bitmessage_login = bitmessage_login;
 
  m_http_client.set_server(address_parts.host, std::to_string(address_parts.port), boost::none);
}

Here is the call graph for this function:

stop()

void mms::message_transporter::stop ( )

inline

Definition at line 92 of file message_transporter.h.

{ m_run.store(false, std::memory_order_relaxed); }

---

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/wallet/message_transporter.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/wallet/message_transporter.cpp