Replace several C identifiers for ticket 18106.

We used to have a single boolean, "FascistFirewall".  Ages ago, in
tickets #17840 and #9067, we added an improved "ReachableAddresses"
mechanism.  It's time to rename related identifiers in the code for
consistency.  This closes #18106.

This is an automated commit, generated by this command:

./scripts/maint/rename_c_identifier.py \
        fascist_firewall_allows_address reachable_addr_allows \
        fascist_firewall_use_ipv6 reachable_addr_use_ipv6 \
        fascist_firewall_prefer_ipv6_impl reachable_addr_prefer_ipv6_impl \
        fascist_firewall_prefer_ipv6_orport reachable_addr_prefer_ipv6_orport \
        fascist_firewall_prefer_ipv6_dirport reachable_addr_prefer_ipv6_dirport \
        fascist_firewall_allows_address_addr reachable_addr_allows_addr \
        fascist_firewall_allows_address_ap reachable_addr_allows_ap \
        fascist_firewall_allows_base reachable_addr_allows_base \
        fascist_firewall_allows_ri_impl reachable_addr_allows_ri_impl \
        fascist_firewall_allows_rs_impl reachable_addr_allows_rs_impl \
        fascist_firewall_allows_rs reachable_addr_allows_rs \
        fascist_firewall_allows_md_impl reachable_addr_allows_md_impl \
        fascist_firewall_allows_node reachable_addr_allows_node \
        fascist_firewall_allows_dir_server reachable_addr_allows_dir_server \
        fascist_firewall_choose_address_impl reachable_addr_choose_impl \
        fascist_firewall_choose_address reachable_addr_choose \
        fascist_firewall_choose_address_base reachable_addr_choose_base \
        fascist_firewall_choose_address_rs reachable_addr_choose_from_rs \
        fascist_firewall_choose_address_ls reachable_addr_choose_from_ls \
        fascist_firewall_choose_address_node reachable_addr_choose_from_node \
        fascist_firewall_choose_address_dir_server reachable_addr_choose_from_dir_server

1 files changed, 70 insertions, 70 deletions

diff --git a/src/core/or/policies.c b/src/core/or/policies.c
index 020eb0a152..0dc440cc96 100644
--- a/src/core/or/policies.c
+++ b/src/core/or/policies.c
@@ -311,7 +311,7 @@ parse_reachable_addresses(void)
                    "ReachableAddresses, ReachableORAddresses, or "
                    "ReachableDirAddresses reject all IPv4 addresses. "
                    "Tor will not connect using IPv4.");
-    } else if (fascist_firewall_use_ipv6(options)
+    } else if (reachable_addr_use_ipv6(options)
        && (policy_is_reject_star(reachable_or_addr_policy, AF_INET6, 0)
          || policy_is_reject_star(reachable_dir_addr_policy, AF_INET6, 0))) {
           log_warn(LD_CONFIG, "You have configured tor to use or prefer IPv6 "
@@ -399,12 +399,12 @@ addr_policy_permits_tor_addr(const tor_addr_t *addr, uint16_t port,
  *    - if ClientUseIPv4 is 0, or
  *      if pref_only and pref_ipv6 are both true;
  *  - return false for all IPv6 addresses:
- *    - if fascist_firewall_use_ipv6() is 0, or
+ *    - if reachable_addr_use_ipv6() is 0, or
  *    - if pref_only is true and pref_ipv6 is false.
  *
  * Return false if addr is NULL or tor_addr_is_null(), or if port is 0. */
 STATIC int
-fascist_firewall_allows_address(const tor_addr_t *addr,
+reachable_addr_allows(const tor_addr_t *addr,
                                 uint16_t port,
                                 smartlist_t *firewall_policy,
                                 int pref_only, int pref_ipv6)
@@ -427,7 +427,7 @@ fascist_firewall_allows_address(const tor_addr_t *addr,
   /* Clients and Servers won't use IPv6 unless it's enabled (and in most
    * cases, IPv6 must also be preferred before it will be used). */
   if (tor_addr_family(addr) == AF_INET6 &&
-      (!fascist_firewall_use_ipv6(options) || (pref_only && !pref_ipv6))) {
+      (!reachable_addr_use_ipv6(options) || (pref_only && !pref_ipv6))) {
     return 0;
   }
 
@@ -443,7 +443,7 @@ fascist_firewall_allows_address(const tor_addr_t *addr,
  * port: it supports bridge client per-node IPv6 preferences.
  */
 int
-fascist_firewall_use_ipv6(const or_options_t *options)
+reachable_addr_use_ipv6(const or_options_t *options)
 {
   /* Clients use IPv6 if it's set, or they use bridges, or they don't use
    * IPv4, or they prefer it.
@@ -458,7 +458,7 @@ fascist_firewall_use_ipv6(const or_options_t *options)
  * If we're unsure, return -1, otherwise, return 1 for IPv6 and 0 for IPv4.
  */
 static int
-fascist_firewall_prefer_ipv6_impl(const or_options_t *options)
+reachable_addr_prefer_ipv6_impl(const or_options_t *options)
 {
   /*
    Cheap implementation of config options ClientUseIPv4 & ClientUseIPv6 --
@@ -466,7 +466,7 @@ fascist_firewall_prefer_ipv6_impl(const or_options_t *options)
    If IPv4 is disabled, use IPv6.
    */
 
-  if (server_mode(options) || !fascist_firewall_use_ipv6(options)) {
+  if (server_mode(options) || !reachable_addr_use_ipv6(options)) {
     return 0;
   }
 
@@ -482,9 +482,9 @@ fascist_firewall_prefer_ipv6_impl(const or_options_t *options)
  * per-node IPv6 preferences.
  */
 int
-fascist_firewall_prefer_ipv6_orport(const or_options_t *options)
+reachable_addr_prefer_ipv6_orport(const or_options_t *options)
 {
-  int pref_ipv6 = fascist_firewall_prefer_ipv6_impl(options);
+  int pref_ipv6 = reachable_addr_prefer_ipv6_impl(options);
 
   if (pref_ipv6 >= 0) {
     return pref_ipv6;
@@ -504,9 +504,9 @@ fascist_firewall_prefer_ipv6_orport(const or_options_t *options)
  * preferences. There's no reason to use it instead of this function.)
  */
 int
-fascist_firewall_prefer_ipv6_dirport(const or_options_t *options)
+reachable_addr_prefer_ipv6_dirport(const or_options_t *options)
 {
-  int pref_ipv6 = fascist_firewall_prefer_ipv6_impl(options);
+  int pref_ipv6 = reachable_addr_prefer_ipv6_impl(options);
 
   if (pref_ipv6 >= 0) {
     return pref_ipv6;
@@ -528,16 +528,16 @@ fascist_firewall_prefer_ipv6_dirport(const or_options_t *options)
  * If pref_only is false, ignore pref_ipv6, and return true if addr is allowed.
  */
 int
-fascist_firewall_allows_address_addr(const tor_addr_t *addr, uint16_t port,
+reachable_addr_allows_addr(const tor_addr_t *addr, uint16_t port,
                                      firewall_connection_t fw_connection,
                                      int pref_only, int pref_ipv6)
 {
   if (fw_connection == FIREWALL_OR_CONNECTION) {
-    return fascist_firewall_allows_address(addr, port,
+    return reachable_addr_allows(addr, port,
                                reachable_or_addr_policy,
                                pref_only, pref_ipv6);
   } else if (fw_connection == FIREWALL_DIR_CONNECTION) {
-    return fascist_firewall_allows_address(addr, port,
+    return reachable_addr_allows(addr, port,
                                reachable_dir_addr_policy,
                                pref_only, pref_ipv6);
   } else {
@@ -550,15 +550,15 @@ fascist_firewall_allows_address_addr(const tor_addr_t *addr, uint16_t port,
 /** Return true iff we think our firewall will let us make a connection to
  * addr:port (ap). Uses ReachableORAddresses or ReachableDirAddresses based on
  * fw_connection.
- * pref_only and pref_ipv6 work as in fascist_firewall_allows_address_addr().
+ * pref_only and pref_ipv6 work as in reachable_addr_allows_addr().
  */
 static int
-fascist_firewall_allows_address_ap(const tor_addr_port_t *ap,
+reachable_addr_allows_ap(const tor_addr_port_t *ap,
                                    firewall_connection_t fw_connection,
                                    int pref_only, int pref_ipv6)
 {
   tor_assert(ap);
-  return fascist_firewall_allows_address_addr(&ap->addr, ap->port,
+  return reachable_addr_allows_addr(&ap->addr, ap->port,
                                               fw_connection, pref_only,
                                               pref_ipv6);
 }
@@ -567,17 +567,17 @@ fascist_firewall_allows_address_ap(const tor_addr_port_t *ap,
  * ipv4h_addr/ipv6_addr. Uses ipv4_orport/ipv6_orport/ReachableORAddresses or
  * ipv4_dirport/ipv6_dirport/ReachableDirAddresses based on IPv4/IPv6 and
  * <b>fw_connection</b>.
- * pref_only and pref_ipv6 work as in fascist_firewall_allows_address_addr().
+ * pref_only and pref_ipv6 work as in reachable_addr_allows_addr().
  */
 static int
-fascist_firewall_allows_base(const tor_addr_t *ipv4_addr, uint16_t ipv4_orport,
+reachable_addr_allows_base(const tor_addr_t *ipv4_addr, uint16_t ipv4_orport,
                              uint16_t ipv4_dirport,
                              const tor_addr_t *ipv6_addr, uint16_t ipv6_orport,
                              uint16_t ipv6_dirport,
                              firewall_connection_t fw_connection,
                              int pref_only, int pref_ipv6)
 {
-  if (fascist_firewall_allows_address_addr(ipv4_addr,
+  if (reachable_addr_allows_addr(ipv4_addr,
                                       (fw_connection == FIREWALL_OR_CONNECTION
                                        ? ipv4_orport
                                        : ipv4_dirport),
@@ -586,7 +586,7 @@ fascist_firewall_allows_base(const tor_addr_t *ipv4_addr, uint16_t ipv4_orport,
     return 1;
   }
 
-  if (fascist_firewall_allows_address_addr(ipv6_addr,
+  if (reachable_addr_allows_addr(ipv6_addr,
                                       (fw_connection == FIREWALL_OR_CONNECTION
                                        ? ipv6_orport
                                        : ipv6_dirport),
@@ -598,9 +598,9 @@ fascist_firewall_allows_base(const tor_addr_t *ipv4_addr, uint16_t ipv4_orport,
   return 0;
 }
 
-/** Like fascist_firewall_allows_base(), but takes ri. */
+/** Like reachable_addr_allows_base(), but takes ri. */
 static int
-fascist_firewall_allows_ri_impl(const routerinfo_t *ri,
+reachable_addr_allows_ri_impl(const routerinfo_t *ri,
                                 firewall_connection_t fw_connection,
                                 int pref_only, int pref_ipv6)
 {
@@ -609,15 +609,15 @@ fascist_firewall_allows_ri_impl(const routerinfo_t *ri,
   }
 
   /* Assume IPv4 and IPv6 DirPorts are the same */
-  return fascist_firewall_allows_base(&ri->ipv4_addr, ri->ipv4_orport,
+  return reachable_addr_allows_base(&ri->ipv4_addr, ri->ipv4_orport,
                                       ri->ipv4_dirport, &ri->ipv6_addr,
                                       ri->ipv6_orport, ri->ipv4_dirport,
                                       fw_connection, pref_only, pref_ipv6);
 }
 
-/** Like fascist_firewall_allows_rs, but takes pref_ipv6. */
+/** Like reachable_addr_allows_rs, but takes pref_ipv6. */
 static int
-fascist_firewall_allows_rs_impl(const routerstatus_t *rs,
+reachable_addr_allows_rs_impl(const routerstatus_t *rs,
                                 firewall_connection_t fw_connection,
                                 int pref_only, int pref_ipv6)
 {
@@ -626,20 +626,20 @@ fascist_firewall_allows_rs_impl(const routerstatus_t *rs,
   }
 
   /* Assume IPv4 and IPv6 DirPorts are the same */
-  return fascist_firewall_allows_base(&rs->ipv4_addr, rs->ipv4_orport,
+  return reachable_addr_allows_base(&rs->ipv4_addr, rs->ipv4_orport,
                                       rs->ipv4_dirport, &rs->ipv6_addr,
                                       rs->ipv6_orport, rs->ipv4_dirport,
                                       fw_connection, pref_only, pref_ipv6);
 }
 
-/** Like fascist_firewall_allows_base(), but takes rs.
+/** Like reachable_addr_allows_base(), but takes rs.
  * When rs is a fake_status from a dir_server_t, it can have a reachable
  * address, even when the corresponding node does not.
  * nodes can be missing addresses when there's no consensus (IPv4 and IPv6),
  * or when there is a microdescriptor consensus, but no microdescriptors
  * (microdescriptors have IPv6, the microdesc consensus does not). */
 int
-fascist_firewall_allows_rs(const routerstatus_t *rs,
+reachable_addr_allows_rs(const routerstatus_t *rs,
                            firewall_connection_t fw_connection, int pref_only)
 {
   if (!rs) {
@@ -650,20 +650,20 @@ fascist_firewall_allows_rs(const routerstatus_t *rs,
    * generic IPv6 preference instead. */
   const or_options_t *options = get_options();
   int pref_ipv6 = (fw_connection == FIREWALL_OR_CONNECTION
-                   ? fascist_firewall_prefer_ipv6_orport(options)
-                   : fascist_firewall_prefer_ipv6_dirport(options));
+                   ? reachable_addr_prefer_ipv6_orport(options)
+                   : reachable_addr_prefer_ipv6_dirport(options));
 
-  return fascist_firewall_allows_rs_impl(rs, fw_connection, pref_only,
+  return reachable_addr_allows_rs_impl(rs, fw_connection, pref_only,
                                          pref_ipv6);
 }
 
 /** Return true iff we think our firewall will let us make a connection to
  * ipv6_addr:ipv6_orport based on ReachableORAddresses.
  * If <b>fw_connection</b> is FIREWALL_DIR_CONNECTION, returns 0.
- * pref_only and pref_ipv6 work as in fascist_firewall_allows_address_addr().
+ * pref_only and pref_ipv6 work as in reachable_addr_allows_addr().
  */
 static int
-fascist_firewall_allows_md_impl(const microdesc_t *md,
+reachable_addr_allows_md_impl(const microdesc_t *md,
                                 firewall_connection_t fw_connection,
                                 int pref_only, int pref_ipv6)
 {
@@ -677,15 +677,15 @@ fascist_firewall_allows_md_impl(const microdesc_t *md,
   }
 
   /* Also can't check IPv4, doesn't have that either */
-  return fascist_firewall_allows_address_addr(&md->ipv6_addr, md->ipv6_orport,
+  return reachable_addr_allows_addr(&md->ipv6_addr, md->ipv6_orport,
                                               fw_connection, pref_only,
                                               pref_ipv6);
 }
 
-/** Like fascist_firewall_allows_base(), but takes node, and looks up pref_ipv6
+/** Like reachable_addr_allows_base(), but takes node, and looks up pref_ipv6
  * from node_ipv6_or/dir_preferred(). */
 int
-fascist_firewall_allows_node(const node_t *node,
+reachable_addr_allows_node(const node_t *node,
                              firewall_connection_t fw_connection,
                              int pref_only)
 {
@@ -701,15 +701,15 @@ fascist_firewall_allows_node(const node_t *node,
 
   /* Sometimes, the rs is missing the IPv6 address info, and we need to go
    * all the way to the md */
-  if (node->ri && fascist_firewall_allows_ri_impl(node->ri, fw_connection,
+  if (node->ri && reachable_addr_allows_ri_impl(node->ri, fw_connection,
                                                   pref_only, pref_ipv6)) {
     return 1;
-  } else if (node->rs && fascist_firewall_allows_rs_impl(node->rs,
+  } else if (node->rs && reachable_addr_allows_rs_impl(node->rs,
                                                          fw_connection,
                                                          pref_only,
                                                          pref_ipv6)) {
     return 1;
-  } else if (node->md && fascist_firewall_allows_md_impl(node->md,
+  } else if (node->md && reachable_addr_allows_md_impl(node->md,
                                                          fw_connection,
                                                          pref_only,
                                                          pref_ipv6)) {
@@ -721,9 +721,9 @@ fascist_firewall_allows_node(const node_t *node,
   }
 }
 
-/** Like fascist_firewall_allows_rs(), but takes ds. */
+/** Like reachable_addr_allows_rs(), but takes ds. */
 int
-fascist_firewall_allows_dir_server(const dir_server_t *ds,
+reachable_addr_allows_dir_server(const dir_server_t *ds,
                                    firewall_connection_t fw_connection,
                                    int pref_only)
 {
@@ -734,8 +734,8 @@ fascist_firewall_allows_dir_server(const dir_server_t *ds,
   /* A dir_server_t always has a fake_status. As long as it has the same
    * addresses/ports in both fake_status and dir_server_t, this works fine.
    * (See #17867.)
-   * fascist_firewall_allows_rs only checks the addresses in fake_status. */
-  return fascist_firewall_allows_rs(&ds->fake_status, fw_connection,
+   * reachable_addr_allows_rs only checks the addresses in fake_status. */
+  return reachable_addr_allows_rs(&ds->fake_status, fw_connection,
                                     pref_only);
 }
 
@@ -743,10 +743,10 @@ fascist_firewall_allows_dir_server(const dir_server_t *ds,
  * choose one based on want_a and return it.
  * Otherwise, return whichever is allowed.
  * Otherwise, return NULL.
- * pref_only and pref_ipv6 work as in fascist_firewall_allows_address_addr().
+ * pref_only and pref_ipv6 work as in reachable_addr_allows_addr().
  */
 static const tor_addr_port_t *
-fascist_firewall_choose_address_impl(const tor_addr_port_t *a,
+reachable_addr_choose_impl(const tor_addr_port_t *a,
                                      const tor_addr_port_t *b,
                                      int want_a,
                                      firewall_connection_t fw_connection,
@@ -755,12 +755,12 @@ fascist_firewall_choose_address_impl(const tor_addr_port_t *a,
   const tor_addr_port_t *use_a = NULL;
   const tor_addr_port_t *use_b = NULL;
 
-  if (fascist_firewall_allows_address_ap(a, fw_connection, pref_only,
+  if (reachable_addr_allows_ap(a, fw_connection, pref_only,
                                          pref_ipv6)) {
     use_a = a;
   }
 
-  if (fascist_firewall_allows_address_ap(b, fw_connection, pref_only,
+  if (reachable_addr_allows_ap(b, fw_connection, pref_only,
                                          pref_ipv6)) {
     use_b = b;
   }
@@ -784,13 +784,13 @@ fascist_firewall_choose_address_impl(const tor_addr_port_t *a,
  *  - Otherwise, return whichever is preferred.
  * Otherwise, return NULL. */
 STATIC const tor_addr_port_t *
-fascist_firewall_choose_address(const tor_addr_port_t *a,
+reachable_addr_choose(const tor_addr_port_t *a,
                                 const tor_addr_port_t *b,
                                 int want_a,
                                 firewall_connection_t fw_connection,
                                 int pref_only, int pref_ipv6)
 {
-  const tor_addr_port_t *pref = fascist_firewall_choose_address_impl(
+  const tor_addr_port_t *pref = reachable_addr_choose_impl(
                                                                 a, b, want_a,
                                                                 fw_connection,
                                                                 1, pref_ipv6);
@@ -802,7 +802,7 @@ fascist_firewall_choose_address(const tor_addr_port_t *a,
   } else {
     /* If there's no preferred address, and we can return addresses that are
      * not preferred, use an address that's allowed */
-    return fascist_firewall_choose_address_impl(a, b, want_a, fw_connection,
+    return reachable_addr_choose_impl(a, b, want_a, fw_connection,
                                                 0, pref_ipv6);
   }
 }
@@ -817,7 +817,7 @@ fascist_firewall_choose_address(const tor_addr_port_t *a,
  * If both addresses could be chosen (they are both preferred or both allowed)
  * choose IPv6 if pref_ipv6 is true, otherwise choose IPv4. */
 static void
-fascist_firewall_choose_address_base(const tor_addr_t *ipv4_addr,
+reachable_addr_choose_base(const tor_addr_t *ipv4_addr,
                                      uint16_t ipv4_orport,
                                      uint16_t ipv4_dirport,
                                      const tor_addr_t *ipv6_addr,
@@ -849,7 +849,7 @@ fascist_firewall_choose_address_base(const tor_addr_t *ipv4_addr,
                   ? ipv6_orport
                   : ipv6_dirport);
 
-  result = fascist_firewall_choose_address(&ipv4_ap, &ipv6_ap,
+  result = reachable_addr_choose(&ipv4_ap, &ipv6_ap,
                                            want_ipv4,
                                            fw_connection, pref_only,
                                            pref_ipv6);
@@ -860,13 +860,13 @@ fascist_firewall_choose_address_base(const tor_addr_t *ipv4_addr,
   }
 }
 
-/** Like fascist_firewall_choose_address_base(), but takes <b>rs</b>.
+/** Like reachable_addr_choose_base(), but takes <b>rs</b>.
  * Consults the corresponding node, then falls back to rs if node is NULL.
  * This should only happen when there's no valid consensus, and rs doesn't
  * correspond to a bridge client's bridge.
  */
 void
-fascist_firewall_choose_address_rs(const routerstatus_t *rs,
+reachable_addr_choose_from_rs(const routerstatus_t *rs,
                                    firewall_connection_t fw_connection,
                                    int pref_only, tor_addr_port_t* ap)
 {
@@ -883,15 +883,15 @@ fascist_firewall_choose_address_rs(const routerstatus_t *rs,
   const node_t *node = node_get_by_id(rs->identity_digest);
 
   if (node) {
-    fascist_firewall_choose_address_node(node, fw_connection, pref_only, ap);
+    reachable_addr_choose_from_node(node, fw_connection, pref_only, ap);
   } else {
     /* There's no node-specific IPv6 preference, so use the generic IPv6
      * preference instead. */
     int pref_ipv6 = (fw_connection == FIREWALL_OR_CONNECTION
-                     ? fascist_firewall_prefer_ipv6_orport(options)
-                     : fascist_firewall_prefer_ipv6_dirport(options));
+                     ? reachable_addr_prefer_ipv6_orport(options)
+                     : reachable_addr_prefer_ipv6_dirport(options));
 
-    fascist_firewall_choose_address_base(&rs->ipv4_addr, rs->ipv4_orport,
+    reachable_addr_choose_base(&rs->ipv4_addr, rs->ipv4_orport,
                                           rs->ipv4_dirport, &rs->ipv6_addr,
                                           rs->ipv6_orport, rs->ipv4_dirport,
                                           fw_connection, pref_only, pref_ipv6,
@@ -899,13 +899,13 @@ fascist_firewall_choose_address_rs(const routerstatus_t *rs,
   }
 }
 
-/** Like fascist_firewall_choose_address_base(), but takes in a smartlist
+/** Like reachable_addr_choose_base(), but takes in a smartlist
  * <b>lspecs</b> consisting of one or more link specifiers. We assume
  * fw_connection is FIREWALL_OR_CONNECTION as link specifiers cannot
  * contain DirPorts.
  */
 void
-fascist_firewall_choose_address_ls(const smartlist_t *lspecs,
+reachable_addr_choose_from_ls(const smartlist_t *lspecs,
                                    int pref_only, tor_addr_port_t* ap)
 {
   int have_v4 = 0, have_v6 = 0;
@@ -967,20 +967,20 @@ fascist_firewall_choose_address_ls(const smartlist_t *lspecs,
   /* Here, don't check for DirPorts as link specifiers are only used for
    * ORPorts. */
   const or_options_t *options = get_options();
-  int pref_ipv6 = fascist_firewall_prefer_ipv6_orport(options);
+  int pref_ipv6 = reachable_addr_prefer_ipv6_orport(options);
   /* Assume that the DirPorts are zero as link specifiers only use ORPorts. */
-  fascist_firewall_choose_address_base(&addr_v4, port_v4, 0,
+  reachable_addr_choose_base(&addr_v4, port_v4, 0,
                                        &addr_v6, port_v6, 0,
                                        FIREWALL_OR_CONNECTION,
                                        pref_only, pref_ipv6,
                                        ap);
 }
 
-/** Like fascist_firewall_choose_address_base(), but takes <b>node</b>, and
+/** Like reachable_addr_choose_base(), but takes <b>node</b>, and
  * looks up the node's IPv6 preference rather than taking an argument
  * for pref_ipv6. */
 void
-fascist_firewall_choose_address_node(const node_t *node,
+reachable_addr_choose_from_node(const node_t *node,
                                      firewall_connection_t fw_connection,
                                      int pref_only, tor_addr_port_t *ap)
 {
@@ -1010,16 +1010,16 @@ fascist_firewall_choose_address_node(const node_t *node,
   node_get_pref_ipv6_dirport(node, &ipv6_dir_ap);
 
   /* Assume the IPv6 OR and Dir addresses are the same. */
-  fascist_firewall_choose_address_base(&ipv4_or_ap.addr, ipv4_or_ap.port,
+  reachable_addr_choose_base(&ipv4_or_ap.addr, ipv4_or_ap.port,
                                        ipv4_dir_ap.port, &ipv6_or_ap.addr,
                                        ipv6_or_ap.port, ipv6_dir_ap.port,
                                        fw_connection, pref_only,
                                        pref_ipv6_node, ap);
 }
 
-/** Like fascist_firewall_choose_address_rs(), but takes <b>ds</b>. */
+/** Like reachable_addr_choose_from_rs(), but takes <b>ds</b>. */
 void
-fascist_firewall_choose_address_dir_server(const dir_server_t *ds,
+reachable_addr_choose_from_dir_server(const dir_server_t *ds,
                                            firewall_connection_t fw_connection,
                                            int pref_only,
                                            tor_addr_port_t *ap)
@@ -1036,9 +1036,9 @@ fascist_firewall_choose_address_dir_server(const dir_server_t *ds,
   /* A dir_server_t always has a fake_status. As long as it has the same
    * addresses/ports in both fake_status and dir_server_t, this works fine.
    * (See #17867.)
-   * This function relies on fascist_firewall_choose_address_rs looking up the
+   * This function relies on reachable_addr_choose_from_rs looking up the
    * node if it can, because that will get the latest info for the relay. */
-  fascist_firewall_choose_address_rs(&ds->fake_status, fw_connection,
+  reachable_addr_choose_from_rs(&ds->fake_status, fw_connection,
                                      pref_only, ap);
 }