make sure all vectors are unique_ptr, unorder maps (optimization)

include/llarp/dns.hpp

@@ -9,6 +9,8 @@
 
 #include <sys/socket.h>
 
+#include <llarp/net.hpp> // for llarp::Addr
+
 // dnsc can work over any UDP socket
 // however we can't ignore udp->user
 // we need to be able to reference the request (being a request or response)
@@ -19,9 +21,11 @@ struct dns_tracker
   // uint c_responses;
   uint c_requests;
   // request has to be a pointer
-  std::map< uint, dnsc_answer_request * > client_request;
+  std::unordered_map< uint, std::unique_ptr< dnsc_answer_request > > client_request;
   // FIXME: support multiple dns server contexts
   dnsd_context *dnsd;
+  // rn we need 1 tracker per DNSd and each DNSd needs it's own IP
+  //std::map< llarp::Addr, std::unique_ptr< dnsc_answer_request > > dnsds;
   // std::map< uint, dnsd_question_request * > daemon_request;
 };
 
@@ -67,10 +71,10 @@ struct dns_msg_answer
 struct dns_packet
 {
   struct dns_msg_header *header;
-  std::vector< dns_msg_question * > questions;
-  std::vector< dns_msg_answer * > answers;
-  std::vector< dns_msg_answer * > auth_rrs;
-  std::vector< dns_msg_answer * > additional_rrs;
+  std::vector< std::unique_ptr< dns_msg_question > > questions;
+  std::vector< std::unique_ptr< dns_msg_answer > > answers;
+  std::vector< std::unique_ptr< dns_msg_answer > > auth_rrs;
+  std::vector< std::unique_ptr< dns_msg_answer > > additional_rrs;
 };
 
 extern "C"

include/llarp/dns_iptracker.hpp

@@ -21,16 +21,16 @@ struct ip_range
   uint8_t octet3;
   // FIXME: we're not consecutive
   uint8_t left;
-  std::map< uint8_t, dns_pointer * > used;
+  std::unordered_map< uint8_t, dns_pointer * > used;
 };
 
 struct dns_iptracker
 {
   struct privatesInUse interfaces;
   struct privatesInUse used_privates;
-  std::vector< ip_range * > used_ten_ips;
-  std::vector< ip_range * > used_seven_ips;
-  std::vector< ip_range * > used_nine_ips;
+  std::vector< std::unique_ptr <ip_range> > used_ten_ips;
+  std::vector< std::unique_ptr <ip_range> > used_seven_ips;
+  std::vector< std::unique_ptr <ip_range> > used_nine_ips;
 };
 
 void

llarp/dns_dotlokilookup.cpp

@@ -26,7 +26,7 @@ struct check_query_simple_request
   dnsd_question_request *request;
 };
 
-std::map< std::string, struct dnsd_query_hook_response * >
+std::unordered_map< std::string, struct dnsd_query_hook_response * >
     loki_tld_lookup_cache;
 
 void

llarp/dns_iptracker.cpp

@@ -40,7 +40,8 @@ dns_iptracker_setup(llarp::Addr tunGatewayIp)
                  std::to_string(ip[1]), '.', std::to_string(ip[2]), "].",
                  std::to_string(ip[3]));
 
-  ip_range *range = new ip_range;
+  //ip_range *range = new ip_range;
+  std::unique_ptr<ip_range> range(new ip_range);
   range->octet2   = ip[1];  // 2nd octet
   range->octet3   = ip[2];  // 3rd octet
   // FIXME: look up any static mappings to discount
@@ -56,17 +57,17 @@ dns_iptracker_setup(llarp::Addr tunGatewayIp)
   // FIXME: forcing one and only one range
   if(ip[0] == 10)
   {
-    g_dns_iptracker.used_ten_ips.push_back(range);
+    g_dns_iptracker.used_ten_ips.push_back(std::move(range));
     g_dns_iptracker.used_privates.ten = false;
   }
   else if(ip[0] == 172)
   {
-    g_dns_iptracker.used_seven_ips.push_back(range);
+    g_dns_iptracker.used_seven_ips.push_back(std::move(range));
     g_dns_iptracker.used_privates.oneSeven = false;
   }
   else if(ip[0] == 192)
   {
-    g_dns_iptracker.used_nine_ips.push_back(range);
+    g_dns_iptracker.used_nine_ips.push_back(std::move(range));
     g_dns_iptracker.used_privates.oneNine = false;
   }
   else
@@ -77,7 +78,7 @@ dns_iptracker_setup(llarp::Addr tunGatewayIp)
 }
 
 inline struct dns_pointer *
-dns_iptracker_allocate_range(struct ip_range *range, uint8_t first)
+dns_iptracker_allocate_range(std::unique_ptr<ip_range> &range, uint8_t first)
 {
   // we have an IP
   llarp::LogDebug("Range has ", (unsigned int)range->left, " ips left");
@@ -95,7 +96,7 @@ dns_iptracker_allocate_range(struct ip_range *range, uint8_t first)
 }
 
 struct dns_pointer *
-dns_iptracker_check_range(std::vector< ip_range * > &ranges, uint8_t first)
+dns_iptracker_check_range(std::vector< std::unique_ptr<ip_range> > &ranges, uint8_t first)
 {
   // tens not all used up
   if(ranges.size())
@@ -119,7 +120,7 @@ dns_iptracker_check_range(std::vector< ip_range * > &ranges, uint8_t first)
   else
   {
     // create one
-    auto new_range    = new ip_range;
+    std::unique_ptr<ip_range> new_range;
     new_range->octet2 = 0;
     switch(first)
     {
@@ -138,7 +139,7 @@ dns_iptracker_check_range(std::vector< ip_range * > &ranges, uint8_t first)
     new_range->octet3 = 0;  // FIXME: counter (0-255)
     // CHECK: planning a /24 but maybe that's too wide for broadcasts
     new_range->left = 252;  // 0 is net, 1 is gw, 255 is broadcast
-    ranges.push_back(new_range);
+    ranges.push_back(std::move(new_range));
     // don't need to check if we're out since this is fresh range
     return dns_iptracker_allocate_range(new_range, first);
   }

llarp/dnsc.cpp

@@ -126,7 +126,7 @@ answer_request_alloc(struct dnsc_context *dnsc, void *sock, const char *url,
   uint16_t id          = ++tracker->c_requests;
   if(id == 65535)
     id = 0;
-  tracker->client_request[id] = request;
+  tracker->client_request[id] = std::unique_ptr<dnsc_answer_request>(request);
 
   dns_query *dns_packet = build_dns_packet(
       (char *)request->question.name.c_str(), id, request->question.type);
@@ -134,6 +134,7 @@ answer_request_alloc(struct dnsc_context *dnsc, void *sock, const char *url,
   return dns_packet;
 }
 
+// FIXME: make first a std_unique
 /// generic dnsc handler
 void
 generic_handle_dnsc_recvfrom(dnsc_answer_request *request,
@@ -486,8 +487,7 @@ raw_resolve_host(struct dnsc_context *dnsc, const char *url,
 
   // if we sent this out, then there's an id
   struct dns_tracker *tracker         = (struct dns_tracker *)dnsc->tracker;
-  struct dnsc_answer_request *request = tracker->client_request[hdr->id];
-  generic_handle_dnsc_recvfrom(request, nullptr, castBuf, size);
+  generic_handle_dnsc_recvfrom(tracker->client_request[hdr->id].get(), nullptr, castBuf, size);
 }
 
 /// intermediate udp_io handler
@@ -504,7 +504,7 @@ llarp_handle_dnsc_recvfrom(struct llarp_udp_io *udp,
 
   // if we sent this out, then there's an id
   struct dns_tracker *tracker         = (struct dns_tracker *)udp->user;
-  struct dnsc_answer_request *request = tracker->client_request[hdr->id];
+  struct dnsc_answer_request *request = tracker->client_request[hdr->id].get();
 
   // sometimes we'll get double responses
   if(request)
@@ -588,18 +588,18 @@ llarp_host_resolved(dnsc_answer_request *request)
   dns_tracker *tracker = (dns_tracker *)request->context->tracker;
   auto val             = std::find_if(
       tracker->client_request.begin(), tracker->client_request.end(),
-      [request](const std::pair< uint, dnsc_answer_request * > &element) {
-        return element.second == request;
+                                      [request](std::pair<const uint, std::unique_ptr < dnsc_answer_request > > &element) {
+        return element.second.get() == request;
       });
   if(val != tracker->client_request.end())
   {
-    tracker->client_request[val->first] = nullptr;
+    tracker->client_request[val->first].reset();
   }
   else
   {
     llarp::LogWarn("Couldn't disable ", request);
   }
-  delete request;
+  //delete request;
 }
 
 bool