1 files changed, 56 insertions, 114 deletions

diff --git a/src/feature/relay/relay_find_addr.c b/src/feature/relay/relay_find_addr.c
index 16d0a4733b..48f28b182a 100644
--- a/src/feature/relay/relay_find_addr.c
+++ b/src/feature/relay/relay_find_addr.c
@@ -20,29 +20,12 @@
 #include "feature/relay/router.h"
 #include "feature/relay/routermode.h"
 
-/** The most recently guessed value of our IP address, based on directory
- * headers. */
-static tor_addr_t last_guessed_ip = TOR_ADDR_NULL;
-
-/** We failed to resolve our address locally, but we'd like to build
- * a descriptor and publish / test reachability. If we have a guess
- * about our address based on directory headers, answer it and return
- * 0; else return -1. */
-static int
-router_guess_address_from_dir_headers(uint32_t *guess)
-{
-  if (!tor_addr_is_null(&last_guessed_ip)) {
-    *guess = tor_addr_to_ipv4h(&last_guessed_ip);
-    return 0;
-  }
-  return -1;
-}
-
 /** Consider the address suggestion suggested_addr as a possible one to use as
  * our address.
  *
- * This is called when a valid NETINFO cell is recevied containing a candidate
- * for our address.
+ * This is called when a valid NETINFO cell is received containing a candidate
+ * for our address or when a directory sends us back the X-Your-Address-Is
+ * header.
  *
  * The suggested address is ignored if it does NOT come from a trusted source.
  * At the moment, we only look a trusted directory authorities.
@@ -51,6 +34,9 @@ router_guess_address_from_dir_headers(uint32_t *guess)
  * given peer_addr which is the address from the endpoint that sent the
  * NETINFO cell.
  *
+ * The identity_digest is NULL if this is an address suggested by a directory
+ * since this is a plaintext connection.
+ *
  * The suggested address is set in our suggested address cache if everything
  * passes. */
 void
@@ -62,7 +48,6 @@ relay_address_new_suggestion(const tor_addr_t *suggested_addr,
 
   tor_assert(suggested_addr);
   tor_assert(peer_addr);
-  tor_assert(identity_digest);
 
   /* Non server should just ignore this suggestion. Clients don't need to
    * learn their address let alone cache it. */
@@ -73,7 +58,7 @@ relay_address_new_suggestion(const tor_addr_t *suggested_addr,
   /* Is the peer a trusted source? Ignore anything coming from non trusted
    * source. In this case, we only look at trusted directory authorities. */
   if (!router_addr_is_trusted_dir(peer_addr) ||
-      !router_digest_is_trusted_dir(identity_digest)) {
+      (identity_digest && !router_digest_is_trusted_dir(identity_digest))) {
     return;
   }
 
@@ -95,110 +80,67 @@ relay_address_new_suggestion(const tor_addr_t *suggested_addr,
   resolved_addr_set_suggested(suggested_addr);
 }
 
-/** A directory server <b>d_conn</b> told us our IP address is
- * <b>suggestion</b>.
- * If this address is different from the one we think we are now, and
- * if our computer doesn't actually know its IP address, then switch. */
-void
-router_new_address_suggestion(const char *suggestion,
-                              const dir_connection_t *d_conn)
+/** Find our address to be published in our descriptor. Three places are
+ * looked at:
+ *
+ *    1. Resolved cache. Populated by find_my_address() during the relay
+ *       periodic event that attempts to learn if our address has changed.
+ *
+ *    2. If flags is set with RELAY_FIND_ADDR_CACHE_ONLY, only the resolved
+ *       and suggested cache are looked at. No address discovery will be done.
+ *
+ *    3. Finally, if all fails, use the suggested address cache which is
+ *       populated by the NETINFO cell content or HTTP header from a
+ *       directory.
+ *
+ * Return true on success and addr_out contains the address to use for the
+ * given family. On failure to find the address, false is returned and
+ * addr_out is set to an AF_UNSPEC address. */
+MOCK_IMPL(bool,
+relay_find_addr_to_publish, (const or_options_t *options, int family,
+                             int flags, tor_addr_t *addr_out))
 {
-  tor_addr_t addr, my_addr, last_resolved_addr;
-  const or_options_t *options = get_options();
-
-  /* first, learn what the IP address actually is */
-  if (tor_addr_parse(&addr, suggestion) == -1) {
-    log_debug(LD_DIR, "Malformed X-Your-Address-Is header %s. Ignoring.",
-              escaped(suggestion));
-    return;
-  }
+  tor_assert(options);
+  tor_assert(addr_out);
 
-  log_debug(LD_DIR, "Got X-Your-Address-Is: %s.", suggestion);
+  tor_addr_make_unspec(addr_out);
 
-  if (!server_mode(options)) {
-    tor_addr_copy(&last_guessed_ip, &addr);
-    return;
+  /* First, check our resolved address cache. It should contain the address
+   * we've discovered from the periodic relay event. */
+  resolved_addr_get_last(family, addr_out);
+  if (!tor_addr_is_null(addr_out)) {
+    goto found;
   }
 
-  /* XXXX ipv6 */
-  resolved_addr_get_last(AF_INET, &last_resolved_addr);
-  if (!tor_addr_is_null(&last_resolved_addr)) {
-    /* Lets use this one. */
-    tor_addr_copy(&last_guessed_ip, &last_resolved_addr);
-    return;
+  /* Second, attempt to find our address. The following can do a DNS resolve
+   * thus only do it when the no cache only flag is flipped. */
+  if (!(flags & RELAY_FIND_ADDR_CACHE_ONLY)) {
+    if (find_my_address(options, family, LOG_INFO, addr_out, NULL, NULL)) {
+      goto found;
+    }
   }
 
-  /* Attempt to find our address. */
-  if (find_my_address(options, AF_INET, LOG_INFO, &my_addr, NULL, NULL)) {
-    /* We're all set -- we already know our address. Great. */
-    tor_addr_copy(&last_guessed_ip, &my_addr); /* store it in case we
-                                                  need it later */
-    return;
+  /* Third, consider address from our suggestion cache. */
+  resolved_addr_get_suggested(family, addr_out);
+  if (!tor_addr_is_null(addr_out)) {
+    goto found;
   }
 
-  /* Consider the suggestion from the directory. */
-  if (tor_addr_is_internal(&addr, 0)) {
-    /* Don't believe anybody who says our IP is, say, 127.0.0.1. */
-    return;
-  }
-  if (tor_addr_eq(&d_conn->base_.addr, &addr)) {
-    /* Don't believe anybody who says our IP is their IP. */
-    log_debug(LD_DIR, "A directory server told us our IP address is %s, "
-              "but they are just reporting their own IP address. Ignoring.",
-              suggestion);
-    return;
-  }
+  /* No publishable address was found. */
+  return false;
 
-  /* Okay.  We can't resolve our own address, and X-Your-Address-Is is giving
-   * us an answer different from what we had the last time we managed to
-   * resolve it. */
-  if (!tor_addr_eq(&last_guessed_ip, &addr)) {
-    control_event_server_status(LOG_NOTICE,
-                                "EXTERNAL_ADDRESS ADDRESS=%s METHOD=DIRSERV",
-                                suggestion);
-    log_addr_has_changed(LOG_NOTICE, &last_guessed_ip, &addr,
-                         d_conn->base_.address);
-    ip_address_changed(0);
-    tor_addr_copy(&last_guessed_ip, &addr); /* router_rebuild_descriptor()
-                                               will fetch it */
-  }
+ found:
+  return true;
 }
 
-/** Make a current best guess at our address, either because
- * it's configured in torrc, or because we've learned it from
- * dirserver headers. Place the answer in *<b>addr</b> and return
- * 0 on success, else return -1 if we have no guess.
+/** Return true iff this relay has an address set for the given family.
  *
- * If <b>cache_only</b> is true, just return any cached answers, and
- * don't try to get any new answers.
- */
-MOCK_IMPL(int,
-router_pick_published_address, (const or_options_t *options, uint32_t *addr,
-                                int cache_only))
+ * This only checks the caches so it will not trigger a full discovery of the
+ * address. */
+bool
+relay_has_address_set(int family)
 {
-  tor_addr_t last_resolved_addr;
-
-  /* First, check the cached output from find_my_address(). */
-  resolved_addr_get_last(AF_INET, &last_resolved_addr);
-  if (!tor_addr_is_null(&last_resolved_addr)) {
-    *addr = tor_addr_to_ipv4h(&last_resolved_addr);
-    return 0;
-  }
-
-  /* Second, consider doing a resolve attempt right here. */
-  if (!cache_only) {
-    tor_addr_t my_addr;
-    if (find_my_address(options, AF_INET, LOG_INFO, &my_addr, NULL, NULL)) {
-      log_info(LD_CONFIG,"Success: chose address '%s'.", fmt_addr(&my_addr));
-      *addr = tor_addr_to_ipv4h(&my_addr);
-      return 0;
-    }
-  }
-
-  /* Third, check the cached output from router_new_address_suggestion(). */
-  if (router_guess_address_from_dir_headers(addr) >= 0)
-    return 0;
-
-  /* We have no useful cached answers. Return failure. */
-  return -1;
+  tor_addr_t addr;
+  return relay_find_addr_to_publish(get_options(), family,
+                                    RELAY_FIND_ADDR_CACHE_ONLY, &addr);
 }