Merge remote-tracking branch 'dgoulet/ticket40009_045_01'

scripts/maint/rename_c_identifier.py

@@ -239,7 +239,7 @@ def main(argv):
         print("I require an even number of identifiers.", file=sys.stderr)
         return 1
 
-    if any_uncommitted_changes():
+    if args.commit and any_uncommitted_changes():
         print("Uncommitted changes found. Not running.", file=sys.stderr)
         return 1
 

src/app/config/resolve_addr.c

@@ -568,8 +568,26 @@ find_my_address(const or_options_t *options, int family, int warn_severity,
   return true;
 }
 
-/** Return true iff <b>addr</b> is judged to be on the same network as us, or
- * on a private network.
+/** @brief: Return true iff the given addr is judged to be local to our
+ * resolved address.
+ *
+ * This function is used to tell whether another address is 'remote' enough
+ * that we can trust it when it tells us that we are reachable, or that we
+ * have a certain address."
+ *
+ * The criterion to learn if the address is local are the following:
+ *
+ *    1. Internal address.
+ *    2. If EnforceDistinctSubnets is set then it is never local.
+ *    3. Network mask is compared. IPv4: /24 and IPv6 /48. This is different
+ *       from the path selection that looks at /16 and /32 because we only
+ *       want to learn here if the address is considered to come from the
+ *       Internet basically.
+ *
+ * @param addr The address to test if local and also test against our resovled
+ *             address.
+ *
+ * @return True iff address is considered local or else False.
  */
 MOCK_IMPL(bool,
 is_local_to_resolve_addr, (const tor_addr_t *addr))
@@ -589,10 +607,6 @@ is_local_to_resolve_addr, (const tor_addr_t *addr))
 
   switch (family) {
   case AF_INET:
-    /* XXX: Why is this /24 and not /16 which the rest of tor does? Unknown
-     * reasons at the moment highlighted in ticket #40009. Because of that, we
-     * can't use addrs_in_same_network_family(). */
-
     /* It's possible that this next check will hit before the first time
      * find_my_address actually succeeds. For clients, it is likely that
      * find_my_address will never be called at all. In those cases,

src/feature/client/entrynodes.c

@@ -1554,7 +1554,7 @@ guard_in_node_family(const entry_guard_t *guard, const node_t *node)
     if (get_options()->EnforceDistinctSubnets && guard->bridge_addr) {
       tor_addr_t node_addr;
       node_get_addr(node, &node_addr);
-      if (addrs_in_same_network_family(&node_addr,
+      if (router_addrs_in_same_network(&node_addr,
                                        &guard->bridge_addr->addr)) {
         return 1;
       }

src/feature/nodelist/nodelist.c

@@ -2034,7 +2034,7 @@ nodelist_refresh_countries(void)
 /** Return true iff router1 and router2 have similar enough network addresses
  * that we should treat them as being in the same family */
 int
-addrs_in_same_network_family(const tor_addr_t *a1,
+router_addrs_in_same_network(const tor_addr_t *a1,
                              const tor_addr_t *a2)
 {
   if (tor_addr_is_null(a1) || tor_addr_is_null(a2))
@@ -2150,8 +2150,8 @@ nodes_in_same_family(const node_t *node1, const node_t *node2)
     node_get_pref_ipv6_orport(node1, &ap6_1);
     node_get_pref_ipv6_orport(node2, &ap6_2);
 
-    if (addrs_in_same_network_family(&a1, &a2) ||
-        addrs_in_same_network_family(&ap6_1.addr, &ap6_2.addr))
+    if (router_addrs_in_same_network(&a1, &a2) ||
+        router_addrs_in_same_network(&ap6_1.addr, &ap6_2.addr))
       return 1;
   }
 
@@ -2209,8 +2209,8 @@ nodelist_add_node_and_family(smartlist_t *sl, const node_t *node)
       tor_addr_port_t ap6;
       node_get_addr(node2, &a);
       node_get_pref_ipv6_orport(node2, &ap6);
-      if (addrs_in_same_network_family(&a, &node_addr) ||
-          addrs_in_same_network_family(&ap6.addr, &node_ap6.addr))
+      if (router_addrs_in_same_network(&a, &node_addr) ||
+          router_addrs_in_same_network(&ap6.addr, &node_ap6.addr))
         smartlist_add(sl, (void*)node2);
     } SMARTLIST_FOREACH_END(node2);
   }

src/feature/nodelist/nodelist.h

@@ -128,7 +128,7 @@ int node_is_unreliable(const node_t *router, int need_uptime,
 int router_exit_policy_all_nodes_reject(const tor_addr_t *addr, uint16_t port,
                                         int need_uptime);
 void router_set_status(const char *digest, int up);
-int addrs_in_same_network_family(const tor_addr_t *a1,
+int router_addrs_in_same_network(const tor_addr_t *a1,
                                  const tor_addr_t *a2);
 
 /** router_have_minimum_dir_info tests to see if we have enough

src/test/test_address.c

@@ -1152,23 +1152,23 @@ test_address_tor_addr_in_same_network_family(void *ignored)
 
   tor_addr_parse(&a, "8.8.8.8");
   tor_addr_parse(&b, "8.8.4.4");
-  tt_int_op(addrs_in_same_network_family(&a, &b), OP_EQ, 1);
+  tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 1);
 
   tor_addr_parse(&a, "8.8.8.8");
   tor_addr_parse(&b, "1.1.1.1");
-  tt_int_op(addrs_in_same_network_family(&a, &b), OP_EQ, 0);
+  tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0);
 
   tor_addr_parse(&a, "8.8.8.8");
   tor_addr_parse(&b, "2001:4860:4860::8844");
-  tt_int_op(addrs_in_same_network_family(&a, &b), OP_EQ, 0);
+  tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0);
 
   tor_addr_parse(&a, "2001:4860:4860::8888");
   tor_addr_parse(&b, "2001:4860:4860::8844");
-  tt_int_op(addrs_in_same_network_family(&a, &b), OP_EQ, 1);
+  tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 1);
 
   tor_addr_parse(&a, "2001:4860:4860::8888");
   tor_addr_parse(&b, "2001:470:20::2");
-  tt_int_op(addrs_in_same_network_family(&a, &b), OP_EQ, 0);
+  tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0);
 
  done:
   return;