tools::dns_utils Namespace Reference

Functions
std::string	address_from_txt_record (const std::string &s)
std::vector< std::string >	addresses_from_url (const std::string &url, bool &dnssec_valid)
	gets a electroneum address from the TXT record of a DNS entry
std::string	get_account_address_as_str_from_url (const std::string &url, bool &dnssec_valid, std::function< std::string(const std::string &, const std::vector< std::string > &, bool)> dns_confirm)
bool	load_txt_records_from_dns (std::vector< std::string > &good_records, const std::vector< std::string > &dns_urls, std::string type)
std::vector< std::string >	parse_dns_public (const char *s)

Function Documentation

address_from_txt_record()

std::string tools::dns_utils::address_from_txt_record

(

const std::string &

s

)

Definition at line 411 of file dns_utils.cpp.

{
  // make sure the txt record has "oa1:etn" and find it
  auto pos = s.find("oa1:etn");
  if (pos == std::string::npos)
    return {};
  // search from there to find "recipient_address="
  pos = s.find("recipient_address=", pos);
  if (pos == std::string::npos)
    return {};
  pos += 18; // move past "recipient_address="
  // find the next semicolon
  auto pos2 = s.find(";", pos);
  if (pos2 != std::string::npos)
  {
    // length of address == 98, we can at least validate that much here
    if (pos2 - pos == 98)
    {
      return s.substr(pos, 98);
    }
    else if (pos2 - pos == 109) // length of address == 109 --> integrated address
    {
      return s.substr(pos, 109);
    }
  }
  return {};
}

Here is the caller graph for this function:

addresses_from_url()

std::vector< std::string > tools::dns_utils::addresses_from_url	(	const std::string &	url,
		bool &	dnssec_valid )

gets a electroneum address from the TXT record of a DNS entry

gets the electroneum address from the TXT record of the DNS entry associated with <url>. If this lookup fails, or the TXT record does not contain an ETN address in the correct format, returns an empty string. <dnssec_valid> will be set true or false according to whether or not the DNS query passes DNSSEC validation.

Parameters

url	the url to look up
dnssec_valid	return-by-reference for DNSSEC status of query

Returns

a electroneum address (as a string) or an empty string

Definition at line 452 of file dns_utils.cpp.

{
  std::vector<std::string> addresses;
  // get txt records
  bool dnssec_available, dnssec_isvalid;
  std::string oa_addr = DNSResolver::instance().get_dns_format_from_oa_address(url);
  auto records = DNSResolver::instance().get_txt_record(oa_addr, dnssec_available, dnssec_isvalid);
 
  // TODO: update this to allow for conveying that dnssec was not available
  if (dnssec_available && dnssec_isvalid)
  {
    dnssec_valid = true;
  }
  else dnssec_valid = false;
 
  // for each txt record, try to find a electroneum address in it.
  for (auto& rec : records)
  {
    std::string addr = address_from_txt_record(rec);
    if (addr.size())
    {
      addresses.push_back(addr);
    }
  }
  return addresses;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_account_address_as_str_from_url()

std::string tools::dns_utils::get_account_address_as_str_from_url	(	const std::string &	url,
		bool &	dnssec_valid,
		std::function< std::string(const std::string &, const std::vector< std::string > &, bool)>	dns_confirm )

Definition at line 479 of file dns_utils.cpp.

{
  // attempt to get address from dns query
  auto addresses = addresses_from_url(url, dnssec_valid);
  if (addresses.empty())
  {
    LOG_ERROR("wrong address: " << url);
    return {};
  }
  return dns_confirm(url, addresses, dnssec_valid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_txt_records_from_dns()

bool tools::dns_utils::load_txt_records_from_dns	(	std::vector< std::string > &	good_records,
		const std::vector< std::string > &	dns_urls,
		std::string	type )

Definition at line 515 of file dns_utils.cpp.

{
  // Prevent infinite recursion when distributing
  if (dns_urls.empty()) return false;
 
  std::vector<std::vector<std::string> > records;
  records.resize(dns_urls.size());
 
  size_t first_index = crypto::rand_idx(dns_urls.size());
 
  // send all requests in parallel
  std::deque<bool> avail(dns_urls.size(), false), valid(dns_urls.size(), false);
  tools::threadpool& tpool = tools::threadpool::getInstance();
  tools::threadpool::waiter waiter;
  for (size_t n = 0; n < dns_urls.size(); ++n)
  {
    tpool.submit(&waiter,[n, dns_urls, &records, &avail, &valid](){
      records[n] = tools::DNSResolver::instance().get_txt_record(dns_urls[n], avail[n], valid[n]); 
    });
  }
  waiter.wait(&tpool);
 
  size_t cur_index = first_index;
  do
  {
    const std::string &url = dns_urls[cur_index];
    if (!avail[cur_index])
    {
      records[cur_index].clear();
      LOG_PRINT_L2("DNSSEC not available for " << type << " at URL: " << url << ", skipping.");
    }
    if (!valid[cur_index])
    {
      records[cur_index].clear();
      LOG_PRINT_L2("DNSSEC validation failed for " << type << " at URL: " << url << ", skipping.");
    }
 
    cur_index++;
    if (cur_index == dns_urls.size())
    {
      cur_index = 0;
    }
  } while (cur_index != first_index);
 
  size_t num_valid_records = 0;
 
  for( const auto& record_set : records)
  {
    if (record_set.size() != 0)
    {
      num_valid_records++;
    }
  }
 
  if (num_valid_records < 2)
  {
    LOG_PRINT_L1("WARNING: no two valid ElectroneumPulse DNS " << type << " records were received, only " << num_valid_records);
    return false;
  }
 
  int good_records_index = -1;
  for (size_t i = 0; i < records.size() - 1; ++i)
  {
    if (records[i].size() == 0) continue;
 
    for (size_t j = i + 1; j < records.size(); ++j)
    {
      if (dns_records_match(records[i], records[j]))
      {
        good_records_index = i;
        break;
      }
    }
    if (good_records_index >= 0) break;
  }
 
  if (good_records_index < 0)
  {
    LOG_PRINT_L1("WARNING: no two ElectroneumPulse DNS " << type << " records matched");
    return false;
  }
 
  good_records = records[good_records_index];
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_dns_public()

std::vector< std::string > tools::dns_utils::parse_dns_public

(

const char *

s

)

Definition at line 601 of file dns_utils.cpp.

{
  unsigned ip0, ip1, ip2, ip3;
  char c;
  std::vector<std::string> dns_public_addr;
  if (!strcmp(s, "tcp"))
  {
    for (size_t i = 0; i < sizeof(DEFAULT_DNS_PUBLIC_ADDR) / sizeof(DEFAULT_DNS_PUBLIC_ADDR[0]); ++i)
      dns_public_addr.push_back(DEFAULT_DNS_PUBLIC_ADDR[i]);
    LOG_PRINT_L0("Using default public DNS server(s): " << boost::join(dns_public_addr, ", ") << " (TCP)");
  }
  else if (sscanf(s, "tcp://%u.%u.%u.%u%c", &ip0, &ip1, &ip2, &ip3, &c) == 4)
  {
    if (ip0 > 255 || ip1 > 255 || ip2 > 255 || ip3 > 255)
    {
      MERROR("Invalid IP: " << s << ", using default");
    }
    else
    {
      dns_public_addr.push_back(std::string(s + strlen("tcp://")));
    }
  }
  else
  {
    MERROR("Invalid DNS_PUBLIC contents, ignored");
  }
  return dns_public_addr;
}

Here is the caller graph for this function: