addr: Use tor_addr_t instead of uint32_t for IPv4

This changes a LOT of code but in the end, behavior is the same.
Unfortunately, many functions had to be changed to accomodate but in majority
of cases, to become simpler.

Functions are also removed specifically those that were there to convert an
IPv4 as a host format to a tor_addr_t. Those are not needed anymore.

The IPv4 address field has been standardized to "ipv4_addr", the ORPort to
"ipv4_orport" (currently IPv6 uses ipv6_orport) and DirPort to "ipv4_dirport".

This is related to Sponsor 55 work that adds IPv6 support for relays and this
work is needed in order to have a common interface between IPv4 and IPv6.

Closes #40043.

Signed-off-by: David Goulet <dgoulet@torproject.org>

29 files changed, 326 insertions, 408 deletions

diff --git a/src/feature/client/bridges.c b/src/feature/client/bridges.c
index caa4776493..6892c4a25f 100644
--- a/src/feature/client/bridges.c
+++ b/src/feature/client/bridges.c
@@ -303,51 +303,21 @@ routerinfo_is_a_configured_bridge(const routerinfo_t *ri)
 }
 
 /**
- * Return 1 iff <b>bridge_list</b> contains entry matching
- * given; IPv4 address in host byte order (<b>ipv4_addr</b>
- * and <b>port</b> (and no identity digest) OR it contains an
- * entry whose identity matches <b>digest</b>. Otherwise,
- * return 0.
- */
-static int
-bridge_exists_with_ipv4h_addr_and_port(const uint32_t ipv4_addr,
-                                       const uint16_t port,
-                                       const char *digest)
-{
-  tor_addr_t node_ipv4;
-
-  if (tor_addr_port_is_valid_ipv4h(ipv4_addr, port, 0)) {
-    tor_addr_from_ipv4h(&node_ipv4, ipv4_addr);
-
-   bridge_info_t *bridge =
-    get_configured_bridge_by_addr_port_digest(&node_ipv4,
-                                              port,
-                                              digest);
-
-   return (bridge != NULL);
-  }
-
-  return 0;
-}
-
-/**
  * Return 1 iff <b>bridge_list</b> contains entry matching given
- * <b>ipv6_addr</b> and <b>port</b> (and no identity digest) OR
+ * <b>addr</b> and <b>port</b> (and no identity digest) OR
  * it contains an  entry whose identity matches <b>digest</b>.
  * Otherwise, return 0.
  */
 static int
-bridge_exists_with_ipv6_addr_and_port(const tor_addr_t *ipv6_addr,
-                                      const uint16_t port,
-                                      const char *digest)
+bridge_exists_with_addr_and_port(const tor_addr_t *addr,
+                                 const uint16_t port,
+                                 const char *digest)
 {
-  if (!tor_addr_port_is_valid(ipv6_addr, port, 0))
+  if (!tor_addr_port_is_valid(addr, port, 0))
     return 0;
 
   bridge_info_t *bridge =
-   get_configured_bridge_by_addr_port_digest(ipv6_addr,
-                                             port,
-                                             digest);
+   get_configured_bridge_by_addr_port_digest(addr, port, digest);
 
   return (bridge != NULL);
 }
@@ -374,29 +344,29 @@ node_is_a_configured_bridge(const node_t *node)
    * check for absence of identity digest in a bridge.
    */
   if (node->ri) {
-    if (bridge_exists_with_ipv4h_addr_and_port(node->ri->addr,
-                                               node->ri->or_port,
-                                               node->identity))
+    if (bridge_exists_with_addr_and_port(&node->ri->ipv4_addr,
+                                         node->ri->ipv4_orport,
+                                         node->identity))
       return 1;
 
-    if (bridge_exists_with_ipv6_addr_and_port(&node->ri->ipv6_addr,
-                                              node->ri->ipv6_orport,
-                                              node->identity))
+    if (bridge_exists_with_addr_and_port(&node->ri->ipv6_addr,
+                                         node->ri->ipv6_orport,
+                                         node->identity))
       return 1;
   } else if (node->rs) {
-    if (bridge_exists_with_ipv4h_addr_and_port(node->rs->addr,
-                                               node->rs->or_port,
-                                               node->identity))
+    if (bridge_exists_with_addr_and_port(&node->rs->ipv4_addr,
+                                         node->rs->ipv4_orport,
+                                         node->identity))
       return 1;
 
-    if (bridge_exists_with_ipv6_addr_and_port(&node->rs->ipv6_addr,
-                                              node->rs->ipv6_orport,
-                                              node->identity))
+    if (bridge_exists_with_addr_and_port(&node->rs->ipv6_addr,
+                                         node->rs->ipv6_orport,
+                                         node->identity))
       return 1;
   }  else if (node->md) {
-    if (bridge_exists_with_ipv6_addr_and_port(&node->md->ipv6_addr,
-                                              node->md->ipv6_orport,
-                                              node->identity))
+    if (bridge_exists_with_addr_and_port(&node->md->ipv6_addr,
+                                         node->md->ipv6_orport,
+                                         node->identity))
       return 1;
   }
 
@@ -825,25 +795,23 @@ rewrite_node_address_for_bridge(const bridge_info_t *bridge, node_t *node)
    *   do that safely if we know that no function that connects to an OR
    *   does so through an address from any source other than node_get_addr().
    */
-  tor_addr_t addr;
   const or_options_t *options = get_options();
 
   if (node->ri) {
     routerinfo_t *ri = node->ri;
-    tor_addr_from_ipv4h(&addr, ri->addr);
-    if ((!tor_addr_compare(&bridge->addr, &addr, CMP_EXACT) &&
-         bridge->port == ri->or_port) ||
+    if ((!tor_addr_compare(&bridge->addr, &ri->ipv4_addr, CMP_EXACT) &&
+         bridge->port == ri->ipv4_orport) ||
         (!tor_addr_compare(&bridge->addr, &ri->ipv6_addr, CMP_EXACT) &&
          bridge->port == ri->ipv6_orport)) {
       /* they match, so no need to do anything */
     } else {
       if (tor_addr_family(&bridge->addr) == AF_INET) {
-        ri->addr = tor_addr_to_ipv4h(&bridge->addr);
-        ri->or_port = bridge->port;
+        tor_addr_copy(&ri->ipv4_addr, &bridge->addr);
+        ri->ipv4_orport = bridge->port;
         log_info(LD_DIR,
                  "Adjusted bridge routerinfo for '%s' to match configured "
                  "address %s:%d.",
-                 ri->nickname, fmt_addr32(ri->addr), ri->or_port);
+                 ri->nickname, fmt_addr(&ri->ipv4_addr), ri->ipv4_orport);
       } else if (tor_addr_family(&bridge->addr) == AF_INET6) {
         tor_addr_copy(&ri->ipv6_addr, &bridge->addr);
         ri->ipv6_orport = bridge->port;
@@ -886,21 +854,20 @@ rewrite_node_address_for_bridge(const bridge_info_t *bridge, node_t *node)
   }
   if (node->rs) {
     routerstatus_t *rs = node->rs;
-    tor_addr_from_ipv4h(&addr, rs->addr);
 
-    if ((!tor_addr_compare(&bridge->addr, &addr, CMP_EXACT) &&
-        bridge->port == rs->or_port) ||
+    if ((!tor_addr_compare(&bridge->addr, &rs->ipv4_addr, CMP_EXACT) &&
+        bridge->port == rs->ipv4_orport) ||
        (!tor_addr_compare(&bridge->addr, &rs->ipv6_addr, CMP_EXACT) &&
         bridge->port == rs->ipv6_orport)) {
       /* they match, so no need to do anything */
     } else {
       if (tor_addr_family(&bridge->addr) == AF_INET) {
-        rs->addr = tor_addr_to_ipv4h(&bridge->addr);
-        rs->or_port = bridge->port;
+        tor_addr_copy(&rs->ipv4_addr, &bridge->addr);
+        rs->ipv4_orport = bridge->port;
         log_info(LD_DIR,
                  "Adjusted bridge routerstatus for '%s' to match "
                  "configured address %s.",
-                 rs->nickname, fmt_addrport(&bridge->addr, rs->or_port));
+                 rs->nickname, fmt_addrport(&bridge->addr, rs->ipv4_orport));
       /* set IPv6 preferences even if there is no ri */
       } else if (tor_addr_family(&bridge->addr) == AF_INET6) {
         tor_addr_copy(&rs->ipv6_addr, &bridge->addr);
diff --git a/src/feature/dirauth/dirvote.c b/src/feature/dirauth/dirvote.c
index 5fda842246..c067c9b85e 100644
--- a/src/feature/dirauth/dirvote.c
+++ b/src/feature/dirauth/dirvote.c
@@ -225,7 +225,6 @@ format_networkstatus_vote(crypto_pk_t *private_signing_key,
   smartlist_t *chunks = smartlist_new();
   char fingerprint[FINGERPRINT_LEN+1];
   char digest[DIGEST_LEN];
-  uint32_t addr;
   char *protocols_lines = NULL;
   char *client_versions_line = NULL, *server_versions_line = NULL;
   char *shared_random_vote_str = NULL;
@@ -237,8 +236,6 @@ format_networkstatus_vote(crypto_pk_t *private_signing_key,
 
   voter = smartlist_get(v3_ns->voters, 0);
 
-  addr = voter->addr;
-
   base16_encode(fingerprint, sizeof(fingerprint),
                 v3_ns->cert->cache_info.identity_digest, DIGEST_LEN);
 
@@ -322,7 +319,7 @@ format_networkstatus_vote(crypto_pk_t *private_signing_key,
       tor_free(digest_algo_b64_digest_bw_file);
     }
 
-    const char *ip_str = fmt_addr32(addr);
+    const char *ip_str = fmt_addr(&voter->ipv4_addr);
 
     if (ip_str[0]) {
       smartlist_add_asprintf(chunks,
@@ -358,7 +355,7 @@ format_networkstatus_vote(crypto_pk_t *private_signing_key,
                    bw_headers_line ? bw_headers_line : "",
                    bw_file_digest ? bw_file_digest: "",
                    voter->nickname, fingerprint, voter->address,
-                   ip_str, voter->dir_port, voter->or_port,
+                   ip_str, voter->ipv4_dirport, voter->ipv4_orport,
                    voter->contact,
                    shared_random_vote_str ?
                              shared_random_vote_str : "");
@@ -636,9 +633,12 @@ compare_vote_rs(const vote_routerstatus_t *a, const vote_routerstatus_t *b)
   if ((r = strcmp(b->status.nickname, a->status.nickname)))
     return r;
 
-  CMP_FIELD(unsigned, int, addr);
-  CMP_FIELD(unsigned, int, or_port);
-  CMP_FIELD(unsigned, int, dir_port);
+  if ((r = tor_addr_compare(&a->status.ipv4_addr, &b->status.ipv4_addr,
+                            CMP_EXACT))) {
+    return r;
+  }
+  CMP_FIELD(unsigned, int, ipv4_orport);
+  CMP_FIELD(unsigned, int, ipv4_dirport);
 
   return 0;
 }
@@ -1740,9 +1740,9 @@ networkstatus_compute_consensus(smartlist_t *votes,
       smartlist_add_asprintf(chunks,
                    "dir-source %s%s %s %s %s %d %d\n",
                    voter->nickname, e->is_legacy ? "-legacy" : "",
-                   fingerprint, voter->address, fmt_addr32(voter->addr),
-                   voter->dir_port,
-                   voter->or_port);
+                   fingerprint, voter->address, fmt_addr(&voter->ipv4_addr),
+                   voter->ipv4_dirport,
+                   voter->ipv4_orport);
       if (! e->is_legacy) {
         smartlist_add_asprintf(chunks,
                      "contact %s\n"
@@ -2039,10 +2039,10 @@ networkstatus_compute_consensus(smartlist_t *votes,
       memcpy(rs_out.identity_digest, current_rsa_id, DIGEST_LEN);
       memcpy(rs_out.descriptor_digest, rs->status.descriptor_digest,
              DIGEST_LEN);
-      rs_out.addr = rs->status.addr;
+      tor_addr_copy(&rs_out.ipv4_addr, &rs->status.ipv4_addr);
       rs_out.published_on = rs->status.published_on;
-      rs_out.dir_port = rs->status.dir_port;
-      rs_out.or_port = rs->status.or_port;
+      rs_out.ipv4_dirport = rs->status.ipv4_dirport;
+      rs_out.ipv4_orport = rs->status.ipv4_orport;
       tor_addr_copy(&rs_out.ipv6_addr, &alt_orport.addr);
       rs_out.ipv6_orport = alt_orport.port;
       rs_out.has_bandwidth = 0;
@@ -4219,12 +4219,14 @@ compare_routerinfo_by_ip_and_bw_(const void **a, const void **b)
   uint32_t bw_kb_first, bw_kb_second;
   const node_t *node_first, *node_second;
   int first_is_running, second_is_running;
+  uint32_t first_ipv4h = tor_addr_to_ipv4h(&first->ipv4_addr);
+  uint32_t second_ipv4h = tor_addr_to_ipv4h(&second->ipv4_addr);
 
   /* we return -1 if first should appear before second... that is,
    * if first is a better router. */
-  if (first->addr < second->addr)
+  if (first_ipv4h < second_ipv4h)
     return -1;
-  else if (first->addr > second->addr)
+  else if (first_ipv4h > second_ipv4h)
     return 1;
 
   /* Potentially, this next bit could cause k n lg n memeq calls.  But in
@@ -4275,7 +4277,7 @@ get_possible_sybil_list(const smartlist_t *routers)
   const dirauth_options_t *options = dirauth_get_options();
   digestmap_t *omit_as_sybil;
   smartlist_t *routers_by_ip = smartlist_new();
-  uint32_t last_addr;
+  tor_addr_t last_addr = TOR_ADDR_NULL;
   int addr_count;
   /* Allow at most this number of Tor servers on a single IP address, ... */
   int max_with_same_addr = options->AuthDirMaxServersPerAddr;
@@ -4286,11 +4288,10 @@ get_possible_sybil_list(const smartlist_t *routers)
   smartlist_sort(routers_by_ip, compare_routerinfo_by_ip_and_bw_);
   omit_as_sybil = digestmap_new();
 
-  last_addr = 0;
   addr_count = 0;
   SMARTLIST_FOREACH_BEGIN(routers_by_ip, routerinfo_t *, ri) {
-    if (last_addr != ri->addr) {
-      last_addr = ri->addr;
+    if (!tor_addr_eq(&last_addr, &ri->ipv4_addr)) {
+      tor_addr_copy(&last_addr, &ri->ipv4_addr);
       addr_count = 1;
     } else if (++addr_count > max_with_same_addr) {
       digestmap_set(omit_as_sybil, ri->cache_info.identity_digest, ri);
@@ -4722,9 +4723,9 @@ dirserv_generate_networkstatus_vote_obj(crypto_pk_t *private_key,
   memcpy(voter->identity_digest, identity_digest, DIGEST_LEN);
   voter->sigs = smartlist_new();
   voter->address = hostname;
-  voter->addr = tor_addr_to_ipv4h(&addr);
-  voter->dir_port = router_get_advertised_dir_port(options, 0);
-  voter->or_port = router_get_advertised_or_port(options);
+  tor_addr_copy(&voter->ipv4_addr, &addr);
+  voter->ipv4_dirport = router_get_advertised_dir_port(options, 0);
+  voter->ipv4_orport = router_get_advertised_or_port(options);
   voter->contact = tor_strdup(contact);
   if (options->V3AuthUseLegacyKey) {
     authority_cert_t *c = get_my_v3_legacy_cert();
diff --git a/src/feature/dirauth/process_descs.c b/src/feature/dirauth/process_descs.c
index bc659d032d..b08ffeba07 100644
--- a/src/feature/dirauth/process_descs.c
+++ b/src/feature/dirauth/process_descs.c
@@ -56,8 +56,9 @@ static was_router_added_t dirserv_add_extrainfo(extrainfo_t *ei,
 static uint32_t
 dirserv_get_status_impl(const char *id_digest,
                         const ed25519_public_key_t *ed25519_public_key,
-                        const char *nickname, uint32_t addr, uint16_t or_port,
-                        const char *platform, const char **msg, int severity);
+                        const char *nickname, const tor_addr_t *ipv4_addr,
+                        uint16_t ipv4_orport, const char *platform,
+                        const char **msg, int severity);
 
 /** Should be static; exposed for testing. */
 static authdir_config_t *fingerprint_list = NULL;
@@ -307,9 +308,9 @@ dirserv_router_get_status(const routerinfo_t *router, const char **msg,
     /* This has an ed25519 identity key. */
     signing_key = &router->cache_info.signing_key_cert->signing_key;
   }
-  r = dirserv_get_status_impl(d, signing_key, router->nickname, router->addr,
-                              router->or_port, router->platform, msg,
-                              severity);
+  r = dirserv_get_status_impl(d, signing_key, router->nickname,
+                              &router->ipv4_addr, router->ipv4_orport,
+                              router->platform, msg, severity);
 
   if (r)
     return r;
@@ -378,7 +379,8 @@ dirserv_would_reject_router(const routerstatus_t *rs,
   memcpy(&pk.pubkey, vrs->ed25519_id, ED25519_PUBKEY_LEN);
 
   res = dirserv_get_status_impl(rs->identity_digest, &pk, rs->nickname,
-                                rs->addr, rs->or_port, NULL, NULL, LOG_DEBUG);
+                                &rs->ipv4_addr, rs->ipv4_orport, NULL, NULL,
+                                LOG_DEBUG);
 
   return (res & RTR_REJECT) != 0;
 }
@@ -433,8 +435,9 @@ dirserv_rejects_tor_version(const char *platform,
 static uint32_t
 dirserv_get_status_impl(const char *id_digest,
                         const ed25519_public_key_t *ed25519_public_key,
-                        const char *nickname, uint32_t addr, uint16_t or_port,
-                        const char *platform, const char **msg, int severity)
+                        const char *nickname, const tor_addr_t *ipv4_addr,
+                        uint16_t ipv4_orport, const char *platform,
+                        const char **msg, int severity)
 {
   uint32_t result = 0;
   rtr_flags_t *status_by_digest;
@@ -485,16 +488,16 @@ dirserv_get_status_impl(const char *id_digest,
       *msg = "Fingerprint and/or ed25519 identity is marked invalid";
   }
 
-  if (authdir_policy_badexit_address(addr, or_port)) {
+  if (authdir_policy_badexit_address(ipv4_addr, ipv4_orport)) {
     log_fn(severity, LD_DIRSERV,
            "Marking '%s' as bad exit because of address '%s'",
-               nickname, fmt_addr32(addr));
+               nickname, fmt_addr(ipv4_addr));
     result |= RTR_BADEXIT;
   }
 
-  if (!authdir_policy_permits_address(addr, or_port)) {
+  if (!authdir_policy_permits_address(ipv4_addr, ipv4_orport)) {
     log_fn(severity, LD_DIRSERV, "Rejecting '%s' because of address '%s'",
-               nickname, fmt_addr32(addr));
+               nickname, fmt_addr(ipv4_addr));
     if (msg)
       *msg = "Suspicious relay address range -- if you think this is a "
              "mistake please set a valid email address in ContactInfo and "
@@ -502,10 +505,10 @@ dirserv_get_status_impl(const char *id_digest,
              "your address(es) and fingerprint(s)?";
     return RTR_REJECT;
   }
-  if (!authdir_policy_valid_address(addr, or_port)) {
+  if (!authdir_policy_valid_address(ipv4_addr, ipv4_orport)) {
     log_fn(severity, LD_DIRSERV,
            "Not marking '%s' valid because of address '%s'",
-               nickname, fmt_addr32(addr));
+               nickname, fmt_addr(ipv4_addr));
     result |= RTR_INVALID;
   }
 
@@ -534,13 +537,11 @@ dirserv_free_fingerprint_list(void)
 STATIC int
 dirserv_router_has_valid_address(routerinfo_t *ri)
 {
-  tor_addr_t addr;
-
   if (get_options()->DirAllowPrivateAddresses)
     return 0; /* whatever it is, we're fine with it */
 
-  tor_addr_from_ipv4h(&addr, ri->addr);
-  if (tor_addr_is_null(&addr) || tor_addr_is_internal(&addr, 0)) {
+  if (tor_addr_is_null(&ri->ipv4_addr) ||
+      tor_addr_is_internal(&ri->ipv4_addr, 0)) {
     log_info(LD_DIRSERV,
              "Router %s published internal IPv4 address. Refusing.",
              router_describe(ri));
diff --git a/src/feature/dirauth/reachability.c b/src/feature/dirauth/reachability.c
index 30938f528d..eb88b4aa07 100644
--- a/src/feature/dirauth/reachability.c
+++ b/src/feature/dirauth/reachability.c
@@ -84,7 +84,7 @@ dirserv_orconn_tls_done(const tor_addr_t *addr,
       log_info(LD_DIRSERV, "Found router %s to be reachable at %s:%d. Yay.",
                router_describe(ri),
                tor_addr_to_str(addrstr, addr, sizeof(addrstr), 1),
-               ri->or_port);
+               ri->ipv4_orport);
       if (tor_addr_family(addr) == AF_INET) {
         rep_hist_note_router_reachable(digest_rcvd, addr, or_port, now);
         node->last_reachable = now;
@@ -132,7 +132,6 @@ dirserv_single_reachability_test(time_t now, routerinfo_t *router)
   const dirauth_options_t *dirauth_options = dirauth_get_options();
   channel_t *chan = NULL;
   const node_t *node = NULL;
-  tor_addr_t router_addr;
   const ed25519_public_key_t *ed_id_key;
   (void) now;
 
@@ -150,9 +149,9 @@ dirserv_single_reachability_test(time_t now, routerinfo_t *router)
 
   /* IPv4. */
   log_debug(LD_OR,"Testing reachability of %s at %s:%u.",
-            router->nickname, fmt_addr32(router->addr), router->or_port);
-  tor_addr_from_ipv4h(&router_addr, router->addr);
-  chan = channel_tls_connect(&router_addr, router->or_port,
+            router->nickname, fmt_addr(&router->ipv4_addr),
+            router->ipv4_orport);
+  chan = channel_tls_connect(&router->ipv4_addr, router->ipv4_orport,
                              router->cache_info.identity_digest,
                              ed_id_key);
   if (chan) command_setup_channel(chan);
diff --git a/src/feature/dirclient/dir_server_st.h b/src/feature/dirclient/dir_server_st.h
index 37fa3148a7..57530a571b 100644
--- a/src/feature/dirclient/dir_server_st.h
+++ b/src/feature/dirclient/dir_server_st.h
@@ -24,10 +24,10 @@ struct dir_server_t {
   char *address; /**< Hostname. */
   /* XX/teor - why do we duplicate the address and port fields here and in
    *           fake_status? Surely we could just use fake_status (#17867). */
+  tor_addr_t ipv4_addr;
+  uint16_t ipv4_dirport; /**< Directory port. */
+  uint16_t ipv4_orport; /**< OR port: Used for tunneling connections. */
   tor_addr_t ipv6_addr; /**< IPv6 address if present; AF_UNSPEC if not */
-  uint32_t addr; /**< IPv4 address. */
-  uint16_t dir_port; /**< Directory port. */
-  uint16_t or_port; /**< OR port: Used for tunneling connections. */
   uint16_t ipv6_orport; /**< OR port corresponding to ipv6_addr. */
   double weight; /** Weight used when selecting this node at random */
   char digest[DIGEST_LEN]; /**< Digest of identity key. */
diff --git a/src/feature/dirclient/dirclient.c b/src/feature/dirclient/dirclient.c
index ae1e018df2..249618f081 100644
--- a/src/feature/dirclient/dirclient.c
+++ b/src/feature/dirclient/dirclient.c
@@ -654,11 +654,11 @@ directory_choose_address_routerstatus(const routerstatus_t *status,
 
   /* ORPort connections */
   if (indirection == DIRIND_ANONYMOUS) {
-    if (status->addr) {
+    if (!tor_addr_is_null(&status->ipv4_addr)) {
       /* Since we're going to build a 3-hop circuit and ask the 2nd relay
        * to extend to this address, always use the primary (IPv4) OR address */
-      tor_addr_from_ipv4h(&use_or_ap->addr, status->addr);
-      use_or_ap->port = status->or_port;
+      tor_addr_copy(&use_or_ap->addr, &status->ipv4_addr);
+      use_or_ap->port = status->ipv4_orport;
       have_or = 1;
     }
   } else if (indirection == DIRIND_ONEHOP) {
@@ -689,9 +689,9 @@ directory_choose_address_routerstatus(const routerstatus_t *status,
     log_info(LD_BUG, "Rejected all OR and Dir addresses from %s when "
              "launching an outgoing directory connection to: IPv4 %s OR %d "
              "Dir %d IPv6 %s OR %d Dir %d", routerstatus_describe(status),
-             fmt_addr32(status->addr), status->or_port,
-             status->dir_port, fmt_addr(&status->ipv6_addr),
-             status->ipv6_orport, status->dir_port);
+             fmt_addr(&status->ipv4_addr), status->ipv4_orport,
+             status->ipv4_dirport, fmt_addr(&status->ipv6_addr),
+             status->ipv6_orport, status->ipv4_dirport);
     if (!logged_backtrace) {
       log_backtrace(LOG_INFO, LD_BUG, "Addresses came from");
       logged_backtrace = 1;
@@ -713,8 +713,8 @@ directory_conn_is_self_reachability_test(dir_connection_t *conn)
     const routerinfo_t *me = router_get_my_routerinfo();
     if (me &&
         router_digest_is_me(conn->identity_digest) &&
-        tor_addr_eq_ipv4h(&conn->base_.addr, me->addr) && /*XXXX prop 118*/
-        me->dir_port == conn->base_.port)
+        tor_addr_eq(&TO_CONN(conn)->addr, &me->ipv4_addr) &&
+        me->ipv4_dirport == conn->base_.port)
       return 1;
   }
   return 0;
diff --git a/src/feature/dirparse/authcert_parse.c b/src/feature/dirparse/authcert_parse.c
index deb45c12de..b2460f6ace 100644
--- a/src/feature/dirparse/authcert_parse.c
+++ b/src/feature/dirparse/authcert_parse.c
@@ -130,13 +130,13 @@ authority_cert_parse_from_string(const char *s, size_t maxlen,
     tor_assert(tok->n_args);
     /* XXX++ use some tor_addr parse function below instead. -RD */
     if (tor_addr_port_split(LOG_WARN, tok->args[0], &address,
-                            &cert->dir_port) < 0 ||
+                            &cert->ipv4_dirport) < 0 ||
         tor_inet_aton(address, &in) == 0) {
       log_warn(LD_DIR, "Couldn't parse dir-address in certificate");
       tor_free(address);
       goto err;
     }
-    cert->addr = ntohl(in.s_addr);
+    tor_addr_from_in(&cert->ipv4_addr, &in);
     tor_free(address);
   }
 
diff --git a/src/feature/dirparse/ns_parse.c b/src/feature/dirparse/ns_parse.c
index ac9325a608..761d6b8c97 100644
--- a/src/feature/dirparse/ns_parse.c
+++ b/src/feature/dirparse/ns_parse.c
@@ -384,12 +384,12 @@ routerstatus_parse_entry_from_string(memarea_t *area,
              escaped(tok->args[5+offset]));
     goto err;
   }
-  rs->addr = ntohl(in.s_addr);
+  tor_addr_from_in(&rs->ipv4_addr, &in);
 
-  rs->or_port = (uint16_t) tor_parse_long(tok->args[6+offset],
-                                         10,0,65535,NULL,NULL);
-  rs->dir_port = (uint16_t) tor_parse_long(tok->args[7+offset],
-                                           10,0,65535,NULL,NULL);
+  rs->ipv4_orport = (uint16_t) tor_parse_long(tok->args[6+offset],
+                                              10,0,65535,NULL,NULL);
+  rs->ipv4_dirport = (uint16_t) tor_parse_long(tok->args[7+offset],
+                                               10,0,65535,NULL,NULL);
 
   {
     smartlist_t *a_lines = find_all_by_keyword(tokens, K_A);
@@ -563,7 +563,7 @@ routerstatus_parse_entry_from_string(memarea_t *area,
       log_info(LD_BUG, "Found an entry in networkstatus with no "
                "microdescriptor digest. (Router %s ($%s) at %s:%d.)",
                rs->nickname, hex_str(rs->identity_digest, DIGEST_LEN),
-               fmt_addr32(rs->addr), rs->or_port);
+               fmt_addr(&rs->ipv4_addr), rs->ipv4_orport);
     }
   }
 
@@ -1367,13 +1367,13 @@ networkstatus_parse_vote_from_string(const char *s,
                  escaped(tok->args[3]));
         goto err;
       }
-      voter->addr = ntohl(in.s_addr);
+      tor_addr_from_in(&voter->ipv4_addr, &in);
       int ok;
-      voter->dir_port = (uint16_t)
+      voter->ipv4_dirport = (uint16_t)
         tor_parse_long(tok->args[4], 10, 0, 65535, &ok, NULL);
       if (!ok)
         goto err;
-      voter->or_port = (uint16_t)
+      voter->ipv4_orport = (uint16_t)
         tor_parse_long(tok->args[5], 10, 0, 65535, &ok, NULL);
       if (!ok)
         goto err;
diff --git a/src/feature/dirparse/routerparse.c b/src/feature/dirparse/routerparse.c
index 8828a0f97a..42a53101b0 100644
--- a/src/feature/dirparse/routerparse.c
+++ b/src/feature/dirparse/routerparse.c
@@ -519,15 +519,15 @@ router_parse_entry_from_string(const char *s, const char *end,
     log_warn(LD_DIR,"Router address is not an IP address.");
     goto err;
   }
-  router->addr = ntohl(in.s_addr);
+  tor_addr_from_in(&router->ipv4_addr, &in);
 
-  router->or_port =
+  router->ipv4_orport =
     (uint16_t) tor_parse_long(tok->args[2],10,0,65535,&ok,NULL);
   if (!ok) {
     log_warn(LD_DIR,"Invalid OR port %s", escaped(tok->args[2]));
     goto err;
   }
-  router->dir_port =
+  router->ipv4_dirport =
     (uint16_t) tor_parse_long(tok->args[4],10,0,65535,&ok,NULL);
   if (!ok) {
     log_warn(LD_DIR,"Invalid dir port %s", escaped(tok->args[4]));
@@ -907,13 +907,14 @@ router_parse_entry_from_string(const char *s, const char *end,
 
   /* This router accepts tunnelled directory requests via begindir if it has
    * an open dirport or it included "tunnelled-dir-server". */
-  if (find_opt_by_keyword(tokens, K_DIR_TUNNELLED) || router->dir_port > 0) {
+  if (find_opt_by_keyword(tokens, K_DIR_TUNNELLED) ||
+      router->ipv4_dirport > 0) {
     router->supports_tunnelled_dir_requests = 1;
   }
 
   tok = find_by_keyword(tokens, K_ROUTER_SIGNATURE);
 
-  if (!router->or_port) {
+  if (!router->ipv4_orport) {
     log_warn(LD_DIR,"or_port unreadable or 0. Failing.");
     goto err;
   }
diff --git a/src/feature/nodelist/authcert.c b/src/feature/nodelist/authcert.c
index 97e44d53e3..5103bf327b 100644
--- a/src/feature/nodelist/authcert.c
+++ b/src/feature/nodelist/authcert.c
@@ -460,19 +460,15 @@ trusted_dirs_load_certs_from_string(const char *contents, int source,
     if (ds && cert->cache_info.published_on > ds->addr_current_at) {
       /* Check to see whether we should update our view of the authority's
        * address. */
-      if (cert->addr && cert->dir_port &&
-          (ds->addr != cert->addr ||
-           ds->dir_port != cert->dir_port)) {
-        char *a = tor_dup_ip(cert->addr);
-        if (a) {
-          log_notice(LD_DIR, "Updating address for directory authority %s "
-                     "from %s:%d to %s:%d based on certificate.",
-                     ds->nickname, ds->address, (int)ds->dir_port,
-                     a, cert->dir_port);
-          tor_free(a);
-        }
-        ds->addr = cert->addr;
-        ds->dir_port = cert->dir_port;
+      if (!tor_addr_is_null(&cert->ipv4_addr) && cert->ipv4_dirport &&
+          (!tor_addr_eq(&ds->ipv4_addr, &cert->ipv4_addr) ||
+           ds->ipv4_dirport != cert->ipv4_dirport)) {
+        log_notice(LD_DIR, "Updating address for directory authority %s "
+                   "from %s:%"PRIu16" to %s:%"PRIu16" based on certificate.",
+                   ds->nickname, ds->address, ds->ipv4_dirport,
+                   fmt_addr(&cert->ipv4_addr), cert->ipv4_dirport);
+        tor_addr_copy(&ds->ipv4_addr, &cert->ipv4_addr);
+        ds->ipv4_dirport = cert->ipv4_dirport;
       }
       ds->addr_current_at = cert->cache_info.published_on;
     }
diff --git a/src/feature/nodelist/authority_cert_st.h b/src/feature/nodelist/authority_cert_st.h
index 9145b12bbf..aa9831d12e 100644
--- a/src/feature/nodelist/authority_cert_st.h
+++ b/src/feature/nodelist/authority_cert_st.h
@@ -27,10 +27,10 @@ struct authority_cert_t {
   char signing_key_digest[DIGEST_LEN];
   /** The listed expiration time of this certificate. */
   time_t expires;
-  /** This authority's IPv4 address, in host order. */
-  uint32_t addr;
+  /** This authority's IPv4 address. */
+  tor_addr_t ipv4_addr;
   /** This authority's directory port. */
-  uint16_t dir_port;
+  uint16_t ipv4_dirport;
 };
 
 #endif /* !defined(AUTHORITY_CERT_ST_H) */
diff --git a/src/feature/nodelist/describe.c b/src/feature/nodelist/describe.c
index f118436499..81a6ef2323 100644
--- a/src/feature/nodelist/describe.c
+++ b/src/feature/nodelist/describe.c
@@ -26,9 +26,8 @@
  * <b>id_digest</b>, nickname <b>nickname</b>, and addresses <b>addr32h</b> and
  * <b>addr</b>.
  *
- * The <b>nickname</b> and <b>addr</b> fields are optional and may be set to
- * NULL or the null address.  The <b>addr32h</b> field is optional and may be
- * set to 0.
+ * The <b>nickname</b>, <b>ipv6_addr</b> and <b>ipv4_addr</b> fields are
+ * optional and may be set to NULL or the null address.
  *
  * Return a pointer to the front of <b>buf</b>.
  * If buf is NULL, return a string constant describing the error.
@@ -37,11 +36,12 @@ STATIC const char *
 format_node_description(char *buf,
                         const char *id_digest,
                         const char *nickname,
-                        const tor_addr_t *addr,
-                        uint32_t addr32h)
+                        const tor_addr_t *ipv6_addr,
+                        const tor_addr_t *ipv4_addr)
 {
   size_t rv = 0;
-  bool has_addr = addr && !tor_addr_is_null(addr);
+  bool has_ipv6 = ipv6_addr && !tor_addr_is_null(ipv6_addr);
+  bool valid_ipv4 = false;
 
   if (!buf)
     return "<NULL BUFFER>";
@@ -77,39 +77,37 @@ format_node_description(char *buf,
     rv = strlcat(buf, nickname, NODE_DESC_BUF_LEN);
     tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
   }
-  if (addr32h || has_addr) {
+  if (ipv4_addr || has_ipv6) {
     rv = strlcat(buf, " at ", NODE_DESC_BUF_LEN);
     tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
   }
-  if (addr32h) {
-    int ntoa_rv = 0;
-    char ipv4_addr_str[INET_NTOA_BUF_LEN];
-    memset(ipv4_addr_str, 0, sizeof(ipv4_addr_str));
-    struct in_addr in;
-    memset(&in, 0, sizeof(in));
-
-    in.s_addr = htonl(addr32h);
-    ntoa_rv = tor_inet_ntoa(&in, ipv4_addr_str, sizeof(ipv4_addr_str));
-    tor_assert_nonfatal(ntoa_rv >= 0);
-
-    rv = strlcat(buf, ipv4_addr_str, NODE_DESC_BUF_LEN);
-    tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
+  if (ipv4_addr) {
+    const char *str_rv = NULL;
+    char addr_str[TOR_ADDR_BUF_LEN];
+    memset(addr_str, 0, sizeof(addr_str));
+
+    str_rv = tor_addr_to_str(addr_str, ipv4_addr, sizeof(addr_str), 0);
+    if (str_rv) {
+      rv = strlcat(buf, addr_str, NODE_DESC_BUF_LEN);
+      tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
+      valid_ipv4 = true;
+    }
   }
   /* Both addresses are valid */
-  if (addr32h && has_addr) {
+  if (valid_ipv4 && has_ipv6) {
     rv = strlcat(buf, " and ", NODE_DESC_BUF_LEN);
     tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
   }
-  if (has_addr) {
+  if (has_ipv6) {
     const char *str_rv = NULL;
     char addr_str[TOR_ADDR_BUF_LEN];
     memset(addr_str, 0, sizeof(addr_str));
 
-    str_rv = tor_addr_to_str(addr_str, addr, sizeof(addr_str), 1);
-    tor_assert_nonfatal(str_rv == addr_str);
-
-    rv = strlcat(buf, addr_str, NODE_DESC_BUF_LEN);
-    tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
+    str_rv = tor_addr_to_str(addr_str, ipv6_addr, sizeof(addr_str), 1);
+    if (str_rv) {
+      rv = strlcat(buf, addr_str, NODE_DESC_BUF_LEN);
+      tor_assert_nonfatal(rv < NODE_DESC_BUF_LEN);
+    }
   }
 
   return buf;
@@ -132,7 +130,7 @@ router_describe(const routerinfo_t *ri)
                                  ri->cache_info.identity_digest,
                                  ri->nickname,
                                  &ri->ipv6_addr,
-                                 ri->addr);
+                                 &ri->ipv4_addr);
 }
 
 /** Return a human-readable description of the node_t <b>node</b>.
@@ -145,15 +143,14 @@ node_describe(const node_t *node)
 {
   static char buf[NODE_DESC_BUF_LEN];
   const char *nickname = NULL;
-  uint32_t addr32h = 0;
-  const tor_addr_t *ipv6_addr = NULL;
+  const tor_addr_t *ipv6_addr = NULL, *ipv4_addr = NULL;
 
   if (!node)
     return "<null>";
 
   if (node->rs) {
     nickname = node->rs->nickname;
-    addr32h = node->rs->addr;
+    ipv4_addr = &node->rs->ipv4_addr;
     ipv6_addr = &node->rs->ipv6_addr;
     /* Support consensus versions less than 28, when IPv6 addresses were in
      * microdescs. This code can be removed when 0.2.9 is no longer supported,
@@ -163,7 +160,7 @@ node_describe(const node_t *node)
     }
   } else if (node->ri) {
     nickname = node->ri->nickname;
-    addr32h = node->ri->addr;
+    ipv4_addr = &node->ri->ipv4_addr;
     ipv6_addr = &node->ri->ipv6_addr;
   } else {
     return "<null rs and ri>";
@@ -173,7 +170,7 @@ node_describe(const node_t *node)
                                  node->identity,
                                  nickname,
                                  ipv6_addr,
-                                 addr32h);
+                                 ipv4_addr);
 }
 
 /** Return a human-readable description of the routerstatus_t <b>rs</b>.
@@ -193,7 +190,7 @@ routerstatus_describe(const routerstatus_t *rs)
                                  rs->identity_digest,
                                  rs->nickname,
                                  &rs->ipv6_addr,
-                                 rs->addr);
+                                 &rs->ipv4_addr);
 }
 
 /** Return a human-readable description of the extend_info_t <b>ei</b>.
@@ -211,7 +208,7 @@ extend_info_describe(const extend_info_t *ei)
 
   const tor_addr_port_t *ap4 = extend_info_get_orport(ei, AF_INET);
   const tor_addr_port_t *ap6 = extend_info_get_orport(ei, AF_INET6);
-  uint32_t addr4 = ap4 ? tor_addr_to_ipv4h(&ap4->addr) : 0;
+  const tor_addr_t *addr4 = ap4 ? &ap4->addr : NULL;
   const tor_addr_t *addr6 = ap6 ? &ap6->addr : NULL;
 
   return format_node_description(buf,
diff --git a/src/feature/nodelist/describe.h b/src/feature/nodelist/describe.h
index d0fa1af263..1a2b757943 100644
--- a/src/feature/nodelist/describe.h
+++ b/src/feature/nodelist/describe.h
@@ -49,8 +49,8 @@ void router_get_verbose_nickname(char *buf, const routerinfo_t *router);
 STATIC const char *format_node_description(char *buf,
                                            const char *id_digest,
                                            const char *nickname,
-                                           const tor_addr_t *addr,
-                                           uint32_t addr32h);
+                                           const tor_addr_t *ipv6_addr,
+                                           const tor_addr_t *ipv4_addr);
 
 #endif /* defined(TOR_UNIT_TESTS) */
 
diff --git a/src/feature/nodelist/dirlist.c b/src/feature/nodelist/dirlist.c
index c1864faedf..cd2921e653 100644
--- a/src/feature/nodelist/dirlist.c
+++ b/src/feature/nodelist/dirlist.c
@@ -59,9 +59,9 @@ add_trusted_dir_to_nodelist_addr_set(const dir_server_t *dir)
   tor_assert(dir->is_authority);
 
   /* Add IPv4 and then IPv6 if applicable. */
-  nodelist_add_addr4_to_address_set(dir->addr);
+  nodelist_add_addr_to_address_set(&dir->ipv4_addr);
   if (!tor_addr_is_null(&dir->ipv6_addr)) {
-    nodelist_add_addr6_to_address_set(&dir->ipv6_addr);
+    nodelist_add_addr_to_address_set(&dir->ipv6_addr);
   }
 }
 
@@ -269,7 +269,7 @@ router_addr_is_trusted_dir_type(const tor_addr_t *addr, dirinfo_type_t type)
       continue;
     }
     /* Match IPv4 or IPv6 address. */
-    if ((family == AF_INET && tor_addr_eq_ipv4h(addr, ent->addr)) ||
+    if ((family == AF_INET && tor_addr_eq(addr, &ent->ipv4_addr)) ||
         (family == AF_INET6 && tor_addr_eq(addr, &ent->ipv6_addr))) {
       return true;
     }
@@ -285,16 +285,15 @@ router_addr_is_trusted_dir_type(const tor_addr_t *addr, dirinfo_type_t type)
 static dir_server_t *
 dir_server_new(int is_authority,
                const char *nickname,
-               const tor_addr_t *addr,
+               const tor_addr_t *ipv4_addr,
                const char *hostname,
-               uint16_t dir_port, uint16_t or_port,
+               uint16_t ipv4_dirport, uint16_t ipv4_orport,
                const tor_addr_port_t *addrport_ipv6,
                const char *digest, const char *v3_auth_digest,
                dirinfo_type_t type,
                double weight)
 {
   dir_server_t *ent;
-  uint32_t a;
   char *hostname_ = NULL;
 
   tor_assert(digest);
@@ -302,22 +301,21 @@ dir_server_new(int is_authority,
   if (weight < 0)
     return NULL;
 
-  if (tor_addr_family(addr) == AF_INET)
-    a = tor_addr_to_ipv4h(addr);
-  else
+  if (!ipv4_addr) {
     return NULL;
+  }
 
   if (!hostname)
-    hostname_ = tor_addr_to_str_dup(addr);
+    hostname_ = tor_addr_to_str_dup(ipv4_addr);
   else
     hostname_ = tor_strdup(hostname);
 
   ent = tor_malloc_zero(sizeof(dir_server_t));
   ent->nickname = nickname ? tor_strdup(nickname) : NULL;
   ent->address = hostname_;
-  ent->addr = a;
-  ent->dir_port = dir_port;
-  ent->or_port = or_port;
+  tor_addr_copy(&ent->ipv4_addr, ipv4_addr);
+  ent->ipv4_dirport = ipv4_dirport;
+  ent->ipv4_orport = ipv4_orport;
   ent->is_running = 1;
   ent->is_authority = is_authority;
   ent->type = type;
@@ -339,13 +337,13 @@ dir_server_new(int is_authority,
     memcpy(ent->v3_identity_digest, v3_auth_digest, DIGEST_LEN);
 
   if (nickname)
-    tor_asprintf(&ent->description, "directory server \"%s\" at %s:%d",
-                 nickname, hostname_, (int)dir_port);
+    tor_asprintf(&ent->description, "directory server \"%s\" at %s:%" PRIu16,
+                 nickname, hostname_, ipv4_dirport);
   else
-    tor_asprintf(&ent->description, "directory server at %s:%d",
-                 hostname_, (int)dir_port);
+    tor_asprintf(&ent->description, "directory server at %s:%" PRIu16,
+                 hostname_, ipv4_dirport);
 
-  ent->fake_status.addr = ent->addr;
+  tor_addr_copy(&ent->fake_status.ipv4_addr, &ent->ipv4_addr);
   tor_addr_copy(&ent->fake_status.ipv6_addr, &ent->ipv6_addr);
   memcpy(ent->fake_status.identity_digest, digest, DIGEST_LEN);
   if (nickname)
@@ -353,30 +351,30 @@ dir_server_new(int is_authority,
             sizeof(ent->fake_status.nickname));
   else
     ent->fake_status.nickname[0] = '\0';
-  ent->fake_status.dir_port = ent->dir_port;
-  ent->fake_status.or_port = ent->or_port;
+  ent->fake_status.ipv4_dirport = ent->ipv4_dirport;
+  ent->fake_status.ipv4_orport = ent->ipv4_orport;
   ent->fake_status.ipv6_orport = ent->ipv6_orport;
 
   return ent;
 }
 
-/** Create an authoritative directory server at
- * <b>address</b>:<b>port</b>, with identity key <b>digest</b>.  If
- * <b>address</b> is NULL, add ourself.  Return the new trusted directory
- * server entry on success or NULL if we couldn't add it. */
+/** Create an authoritative directory server at <b>address</b>:<b>port</b>,
+ * with identity key <b>digest</b>.  If <b>ipv4_addr_str</b> is NULL, add
+ * ourself.  Return the new trusted directory server entry on success or NULL
+ * if we couldn't add it. */
 dir_server_t *
 trusted_dir_server_new(const char *nickname, const char *address,
-                       uint16_t dir_port, uint16_t or_port,
+                       uint16_t ipv4_dirport, uint16_t ipv4_orport,
                        const tor_addr_port_t *ipv6_addrport,
                        const char *digest, const char *v3_auth_digest,
                        dirinfo_type_t type, double weight)
 {
-  tor_addr_t addr;
+  tor_addr_t ipv4_addr;
   char *hostname=NULL;
   dir_server_t *result;
 
   if (!address) { /* The address is us; we should guess. */
-    if (!find_my_address(get_options(), AF_INET, LOG_WARN, &addr,
+    if (!find_my_address(get_options(), AF_INET, LOG_WARN, &ipv4_addr,
                          NULL, &hostname)) {
       log_warn(LD_CONFIG,
                "Couldn't find a suitable address when adding ourself as a "
@@ -384,24 +382,22 @@ trusted_dir_server_new(const char *nickname, const char *address,
       return NULL;
     }
     if (!hostname)
-      hostname = tor_addr_to_str_dup(&addr);
+      hostname = tor_addr_to_str_dup(&ipv4_addr);
 
     if (!hostname)
       return NULL;
   } else {
-    uint32_t a;
-    if (tor_lookup_hostname(address, &a)) {
+    if (tor_addr_lookup(address, AF_INET, &ipv4_addr)) {
       log_warn(LD_CONFIG,
                "Unable to lookup address for directory server at '%s'",
                address);
       return NULL;
     }
     hostname = tor_strdup(address);
-    tor_addr_from_ipv4h(&addr, a);
   }
 
-  result = dir_server_new(1, nickname, &addr, hostname,
-                          dir_port, or_port,
+  result = dir_server_new(1, nickname, &ipv4_addr, hostname,
+                          ipv4_dirport, ipv4_orport,
                           ipv6_addrport,
                           digest,
                           v3_auth_digest, type, weight);
@@ -413,15 +409,13 @@ trusted_dir_server_new(const char *nickname, const char *address,
  * <b>addr</b>:<b>or_port</b>/<b>dir_port</b>, with identity key digest
  * <b>id_digest</b> */
 dir_server_t *
-fallback_dir_server_new(const tor_addr_t *addr,
-                        uint16_t dir_port, uint16_t or_port,
+fallback_dir_server_new(const tor_addr_t *ipv4_addr,
+                        uint16_t ipv4_dirport, uint16_t ipv4_orport,
                         const tor_addr_port_t *addrport_ipv6,
                         const char *id_digest, double weight)
 {
-  return dir_server_new(0, NULL, addr, NULL, dir_port, or_port,
-                        addrport_ipv6,
-                        id_digest,
-                        NULL, ALL_DIRINFO, weight);
+  return dir_server_new(0, NULL, ipv4_addr, NULL, ipv4_dirport, ipv4_orport,
+                        addrport_ipv6, id_digest, NULL, ALL_DIRINFO, weight);
 }
 
 /** Add a directory server to the global list(s). */
diff --git a/src/feature/nodelist/fmt_routerstatus.c b/src/feature/nodelist/fmt_routerstatus.c
index ca4a312639..252b2e61fe 100644
--- a/src/feature/nodelist/fmt_routerstatus.c
+++ b/src/feature/nodelist/fmt_routerstatus.c
@@ -53,7 +53,7 @@ routerstatus_format_entry(const routerstatus_t *rs, const char *version,
   char digest64[BASE64_DIGEST_LEN+1];
   smartlist_t *chunks = smartlist_new();
 
-  const char *ip_str = fmt_addr32(rs->addr);
+  const char *ip_str = fmt_addr(&rs->ipv4_addr);
   if (ip_str[0] == '\0')
     goto err;
 
@@ -62,15 +62,15 @@ routerstatus_format_entry(const routerstatus_t *rs, const char *version,
   digest_to_base64(digest64, rs->descriptor_digest);
 
   smartlist_add_asprintf(chunks,
-                   "r %s %s %s%s%s %s %d %d\n",
+                   "r %s %s %s%s%s %s %" PRIu16 " %" PRIu16 "\n",
                    rs->nickname,
                    identity64,
                    (format==NS_V3_CONSENSUS_MICRODESC)?"":digest64,
                    (format==NS_V3_CONSENSUS_MICRODESC)?"":" ",
                    published,
                    ip_str,
-                   (int)rs->or_port,
-                   (int)rs->dir_port);
+                   rs->ipv4_orport,
+                   rs->ipv4_dirport);
 
   /* TODO: Maybe we want to pass in what we need to build the rest of
    * this here, instead of in the caller. Then we could use the
diff --git a/src/feature/nodelist/networkstatus.c b/src/feature/nodelist/networkstatus.c
index f63d598ef7..2baa405f57 100644
--- a/src/feature/nodelist/networkstatus.c
+++ b/src/feature/nodelist/networkstatus.c
@@ -608,25 +608,25 @@ networkstatus_check_consensus_signature(networkstatus_t *consensus,
     SMARTLIST_FOREACH(unrecognized, networkstatus_voter_info_t *, voter,
       {
         tor_log(severity, LD_DIR, "Consensus includes unrecognized authority "
-                 "'%s' at %s:%d (contact %s; identity %s)",
-                 voter->nickname, voter->address, (int)voter->dir_port,
+                 "'%s' at %s:%" PRIu16 " (contact %s; identity %s)",
+                 voter->nickname, voter->address, voter->ipv4_dirport,
                  voter->contact?voter->contact:"n/a",
                  hex_str(voter->identity_digest, DIGEST_LEN));
       });
     SMARTLIST_FOREACH(need_certs_from, networkstatus_voter_info_t *, voter,
       {
         tor_log(severity, LD_DIR, "Looks like we need to download a new "
-                 "certificate from authority '%s' at %s:%d (contact %s; "
-                 "identity %s)",
-                 voter->nickname, voter->address, (int)voter->dir_port,
+                 "certificate from authority '%s' at %s:%" PRIu16
+                 " (contact %s; identity %s)",
+                 voter->nickname, voter->address, voter->ipv4_dirport,
                  voter->contact?voter->contact:"n/a",
                  hex_str(voter->identity_digest, DIGEST_LEN));
       });
     SMARTLIST_FOREACH(missing_authorities, dir_server_t *, ds,
       {
         tor_log(severity, LD_DIR, "Consensus does not include configured "
-                 "authority '%s' at %s:%d (identity %s)",
-                 ds->nickname, ds->address, (int)ds->dir_port,
+                 "authority '%s' at %s:%" PRIu16 " (identity %s)",
+                 ds->nickname, ds->address, ds->ipv4_dirport,
                  hex_str(ds->v3_identity_digest, DIGEST_LEN));
       });
     {
@@ -1594,9 +1594,9 @@ routerstatus_has_visibly_changed(const routerstatus_t *a,
 
   return strcmp(a->nickname, b->nickname) ||
          fast_memneq(a->descriptor_digest, b->descriptor_digest, DIGEST_LEN) ||
-         a->addr != b->addr ||
-         a->or_port != b->or_port ||
-         a->dir_port != b->dir_port ||
+         !tor_addr_eq(&a->ipv4_addr, &b->ipv4_addr) ||
+         a->ipv4_orport != b->ipv4_orport ||
+         a->ipv4_dirport != b->ipv4_dirport ||
          a->is_authority != b->is_authority ||
          a->is_exit != b->is_exit ||
          a->is_stable != b->is_stable ||
@@ -2392,10 +2392,10 @@ set_routerstatus_from_routerinfo(routerstatus_t *rs,
   memcpy(rs->identity_digest, node->identity, DIGEST_LEN);
   memcpy(rs->descriptor_digest, ri->cache_info.signed_descriptor_digest,
          DIGEST_LEN);
-  rs->addr = ri->addr;
+  tor_addr_copy(&rs->ipv4_addr, &ri->ipv4_addr);
   strlcpy(rs->nickname, ri->nickname, sizeof(rs->nickname));
-  rs->or_port = ri->or_port;
-  rs->dir_port = ri->dir_port;
+  rs->ipv4_orport = ri->ipv4_orport;
+  rs->ipv4_dirport = ri->ipv4_dirport;
   rs->is_v2_dir = ri->supports_tunnelled_dir_requests;
 
   tor_addr_copy(&rs->ipv6_addr, &ri->ipv6_addr);
diff --git a/src/feature/nodelist/networkstatus_voter_info_st.h b/src/feature/nodelist/networkstatus_voter_info_st.h
index b4d0b1dd17..a0fba2e1b5 100644
--- a/src/feature/nodelist/networkstatus_voter_info_st.h
+++ b/src/feature/nodelist/networkstatus_voter_info_st.h
@@ -21,9 +21,9 @@ struct networkstatus_voter_info_t {
    * consensuses, we treat legacy keys as additional signers. */
   char legacy_id_digest[DIGEST_LEN];
   char *address; /**< Address of this voter, in string format. */
-  uint32_t addr; /**< Address of this voter, in IPv4, in host order. */
-  uint16_t dir_port; /**< Directory port of this voter */
-  uint16_t or_port; /**< OR port of this voter */
+  tor_addr_t ipv4_addr;
+  uint16_t ipv4_dirport; /**< Directory port of this voter */
+  uint16_t ipv4_orport; /**< OR port of this voter */
   char *contact; /**< Contact information for this voter. */
   char vote_digest[DIGEST_LEN]; /**< Digest of this voter's vote, as signed. */
 
diff --git a/src/feature/nodelist/node_select.c b/src/feature/nodelist/node_select.c
index 25904d4c63..a7c02f64d8 100644
--- a/src/feature/nodelist/node_select.c
+++ b/src/feature/nodelist/node_select.c
@@ -217,13 +217,15 @@ router_picked_poor_directory_log(const routerstatus_t *rs)
              ) {
     /* This is rare, and might be interesting to users trying to diagnose
      * connection issues on dual-stack machines. */
+    char *ipv4_str = tor_addr_to_str_dup(&rs->ipv4_addr);
     log_info(LD_DIR, "Selected a directory %s with non-preferred OR and Dir "
              "addresses for launching an outgoing connection: "
              "IPv4 %s OR %d Dir %d IPv6 %s OR %d Dir %d",
              routerstatus_describe(rs),
-             fmt_addr32(rs->addr), rs->or_port,
-             rs->dir_port, fmt_addr(&rs->ipv6_addr),
-             rs->ipv6_orport, rs->dir_port);
+             ipv4_str, rs->ipv4_orport,
+             rs->ipv4_dirport, fmt_addr(&rs->ipv6_addr),
+             rs->ipv6_orport, rs->ipv4_dirport);
+    tor_free(ipv4_str);
   }
 }
 
@@ -266,7 +268,7 @@ router_is_already_dir_fetching(const tor_addr_port_t *ap, int serverdesc,
  * If so, return 1, if not, return 0.
  */
 static int
-router_is_already_dir_fetching_(uint32_t ipv4_addr,
+router_is_already_dir_fetching_(const tor_addr_t *ipv4_addr,
                                 const tor_addr_t *ipv6_addr,
                                 uint16_t dir_port,
                                 int serverdesc,
@@ -275,7 +277,7 @@ router_is_already_dir_fetching_(uint32_t ipv4_addr,
   tor_addr_port_t ipv4_dir_ap, ipv6_dir_ap;
 
   /* Assume IPv6 DirPort is the same as IPv4 DirPort */
-  tor_addr_from_ipv4h(&ipv4_dir_ap.addr, ipv4_addr);
+  tor_addr_copy(&ipv4_dir_ap.addr, ipv4_addr);
   ipv4_dir_ap.port = dir_port;
   tor_addr_copy(&ipv6_dir_ap.addr, ipv6_addr);
   ipv6_dir_ap.port = dir_port;
@@ -352,9 +354,9 @@ router_pick_directory_server_impl(dirinfo_type_t type, int flags,
       continue;
     }
 
-    if (router_is_already_dir_fetching_(status->addr,
+    if (router_is_already_dir_fetching_(&status->ipv4_addr,
                                         &status->ipv6_addr,
-                                        status->dir_port,
+                                        status->ipv4_dirport,
                                         no_serverdesc_fetching,
                                         no_microdesc_fetching)) {
       ++n_busy;
@@ -1143,9 +1145,9 @@ router_pick_trusteddirserver_impl(const smartlist_t *sourcelist,
         continue;
       }
 
-      if (router_is_already_dir_fetching_(d->addr,
+      if (router_is_already_dir_fetching_(&d->ipv4_addr,
                                           &d->ipv6_addr,
-                                          d->dir_port,
+                                          d->ipv4_dirport,
                                           no_serverdesc_fetching,
                                           no_microdesc_fetching)) {
         ++n_busy;
diff --git a/src/feature/nodelist/nodelist.c b/src/feature/nodelist/nodelist.c
index a3c94554ec..c2e2f53038 100644
--- a/src/feature/nodelist/nodelist.c
+++ b/src/feature/nodelist/nodelist.c
@@ -454,38 +454,29 @@ node_add_to_address_set(const node_t *node)
    * to add them all than to compare them all for equality. */
 
   if (node->rs) {
-    if (node->rs->addr)
-      nodelist_add_addr4_to_address_set(node->rs->addr);
+    if (!tor_addr_is_null(&node->rs->ipv4_addr))
+      nodelist_add_addr_to_address_set(&node->rs->ipv4_addr);
     if (!tor_addr_is_null(&node->rs->ipv6_addr))
-      nodelist_add_addr6_to_address_set(&node->rs->ipv6_addr);
+      nodelist_add_addr_to_address_set(&node->rs->ipv6_addr);
   }
   if (node->ri) {
-    if (node->ri->addr)
-      nodelist_add_addr4_to_address_set(node->ri->addr);
+    if (!tor_addr_is_null(&node->ri->ipv4_addr))
+      nodelist_add_addr_to_address_set(&node->ri->ipv4_addr);
     if (!tor_addr_is_null(&node->ri->ipv6_addr))
-      nodelist_add_addr6_to_address_set(&node->ri->ipv6_addr);
+      nodelist_add_addr_to_address_set(&node->ri->ipv6_addr);
   }
   if (node->md) {
     if (!tor_addr_is_null(&node->md->ipv6_addr))
-      nodelist_add_addr6_to_address_set(&node->md->ipv6_addr);
+      nodelist_add_addr_to_address_set(&node->md->ipv6_addr);
   }
 }
 
-/** Add the given v4 address into the nodelist address set. */
+/** Add the given address into the nodelist address set. */
 void
-nodelist_add_addr4_to_address_set(const uint32_t addr)
+nodelist_add_addr_to_address_set(const tor_addr_t *addr)
 {
-  if (!the_nodelist || !the_nodelist->node_addrs || addr == 0) {
-    return;
-  }
-  address_set_add_ipv4h(the_nodelist->node_addrs, addr);
-}
-
-/** Add the given v6 address into the nodelist address set. */
-void
-nodelist_add_addr6_to_address_set(const tor_addr_t *addr)
-{
-  if (BUG(!addr) || tor_addr_is_null(addr) || tor_addr_is_v4(addr) ||
+  if (BUG(!addr) || tor_addr_is_null(addr) ||
+      (!tor_addr_is_v4(addr) && !tor_addr_is_v6(addr)) ||
       !the_nodelist || !the_nodelist->node_addrs) {
     return;
   }
@@ -1541,32 +1532,14 @@ node_exit_policy_is_exact(const node_t *node, sa_family_t family)
  * "addr" is an IPv4 host-order address and port_field is a uint16_t.
  * r is typically a routerinfo_t or routerstatus_t.
  */
-#define SL_ADD_NEW_IPV4_AP(r, port_field, sl, valid) \
-  STMT_BEGIN \
-    if (tor_addr_port_is_valid_ipv4h((r)->addr, (r)->port_field, 0)) { \
-      valid = 1; \
-      tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t)); \
-      tor_addr_from_ipv4h(&ap->addr, (r)->addr); \
-      ap->port = (r)->port_field; \
-      smartlist_add((sl), ap); \
-    } \
-  STMT_END
-
-/* Check if the "addr" and port_field fields from r are a valid non-listening
- * address/port. If so, set valid to true and add a newly allocated
- * tor_addr_port_t containing "addr" and port_field to sl.
- * "addr" is a tor_addr_t and port_field is a uint16_t.
- * r is typically a routerinfo_t or routerstatus_t.
- */
-#define SL_ADD_NEW_IPV6_AP(r, port_field, sl, valid) \
-  STMT_BEGIN \
-    if (tor_addr_port_is_valid(&(r)->ipv6_addr, (r)->port_field, 0)) { \
-      valid = 1; \
-      tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t)); \
-      tor_addr_copy(&ap->addr, &(r)->ipv6_addr); \
-      ap->port = (r)->port_field; \
-      smartlist_add((sl), ap); \
-    } \
+#define SL_ADD_NEW_AP(r, addr_field, port_field, sl, valid)             \
+  STMT_BEGIN                                                            \
+    if (tor_addr_port_is_valid(&(r)->addr_field, (r)->port_field, 0)) { \
+      valid = 1;                                                        \
+      tor_addr_port_t *ap = tor_addr_port_new(&(r)->addr_field,         \
+                                              (r)->port_field);         \
+      smartlist_add((sl), ap);                                          \
+    }                                                                   \
   STMT_END
 
 /** Return list of tor_addr_port_t with all OR ports (in the sense IP
@@ -1585,33 +1558,32 @@ node_get_all_orports(const node_t *node)
 
   /* Find a valid IPv4 address and port */
   if (node->ri != NULL) {
-    SL_ADD_NEW_IPV4_AP(node->ri, or_port, sl, valid);
+    SL_ADD_NEW_AP(node->ri, ipv4_addr, ipv4_orport, sl, valid);
   }
 
   /* If we didn't find a valid address/port in the ri, try the rs */
   if (!valid && node->rs != NULL) {
-    SL_ADD_NEW_IPV4_AP(node->rs, or_port, sl, valid);
+    SL_ADD_NEW_AP(node->rs, ipv4_addr, ipv4_orport, sl, valid);
   }
 
   /* Find a valid IPv6 address and port */
   valid = 0;
   if (node->ri != NULL) {
-    SL_ADD_NEW_IPV6_AP(node->ri, ipv6_orport, sl, valid);
+    SL_ADD_NEW_AP(node->ri, ipv6_addr, ipv6_orport, sl, valid);
   }
 
   if (!valid && node->rs != NULL) {
-    SL_ADD_NEW_IPV6_AP(node->rs, ipv6_orport, sl, valid);
+    SL_ADD_NEW_AP(node->rs, ipv6_addr, ipv6_orport, sl, valid);
   }
 
   if (!valid && node->md != NULL) {
-    SL_ADD_NEW_IPV6_AP(node->md, ipv6_orport, sl, valid);
+    SL_ADD_NEW_AP(node->md, ipv6_addr, ipv6_orport, sl, valid);
   }
 
   return sl;
 }
 
-#undef SL_ADD_NEW_IPV4_AP
-#undef SL_ADD_NEW_IPV6_AP
+#undef SL_ADD_NEW_AP
 
 /** Wrapper around node_get_prim_orport for backward
     compatibility.  */
@@ -1623,21 +1595,20 @@ node_get_addr(const node_t *node, tor_addr_t *addr_out)
   tor_addr_copy(addr_out, &ap.addr);
 }
 
-/** Return the host-order IPv4 address for <b>node</b>, or 0 if it doesn't
- * seem to have one.  */
-uint32_t
-node_get_prim_addr_ipv4h(const node_t *node)
+/** Return the IPv4 address for <b>node</b>, or NULL if none found. */
+static const tor_addr_t *
+node_get_prim_addr_ipv4(const node_t *node)
 {
   /* Don't check the ORPort or DirPort, as this function isn't port-specific,
    * and the node might have a valid IPv4 address, yet have a zero
    * ORPort or DirPort.
    */
-  if (node->ri && tor_addr_is_valid_ipv4h(node->ri->addr, 0)) {
-    return node->ri->addr;
-  } else if (node->rs && tor_addr_is_valid_ipv4h(node->rs->addr, 0)) {
-    return node->rs->addr;
+  if (node->ri && tor_addr_is_valid(&node->ri->ipv4_addr, 0)) {
+    return &node->ri->ipv4_addr;
+  } else if (node->rs && tor_addr_is_valid(&node->rs->ipv4_addr, 0)) {
+    return &node->rs->ipv4_addr;
   }
-  return 0;
+  return NULL;
 }
 
 /** Copy a string representation of an IP address for <b>node</b> into
@@ -1645,12 +1616,10 @@ node_get_prim_addr_ipv4h(const node_t *node)
 void
 node_get_address_string(const node_t *node, char *buf, size_t len)
 {
-  uint32_t ipv4_addr = node_get_prim_addr_ipv4h(node);
+  const tor_addr_t *ipv4_addr = node_get_prim_addr_ipv4(node);
 
-  if (tor_addr_is_valid_ipv4h(ipv4_addr, 0)) {
-    tor_addr_t addr;
-    tor_addr_from_ipv4h(&addr, ipv4_addr);
-    tor_addr_to_str(buf, &addr, len, 0);
+  if (ipv4_addr) {
+    tor_addr_to_str(buf, ipv4_addr, len, 0);
   } else if (len > 0) {
     buf[0] = '\0';
   }
@@ -1757,12 +1726,12 @@ node_ipv6_or_preferred(const node_t *node)
   return 0;
 }
 
-#define RETURN_IPV4_AP(r, port_field, ap_out) \
-  STMT_BEGIN \
-    if (r && tor_addr_port_is_valid_ipv4h((r)->addr, (r)->port_field, 0)) { \
-      tor_addr_from_ipv4h(&(ap_out)->addr, (r)->addr); \
-      (ap_out)->port = (r)->port_field; \
-    } \
+#define RETURN_IPV4_AP(r, port_field, ap_out)                               \
+  STMT_BEGIN                                                                \
+    if (r && tor_addr_port_is_valid(&(r)->ipv4_addr, (r)->port_field, 0)) { \
+      tor_addr_copy(&(ap_out)->addr, &(r)->ipv4_addr);                      \
+      (ap_out)->port = (r)->port_field;                                     \
+    }                                                                       \
   STMT_END
 
 /** Copy the primary (IPv4) OR port (IP address and TCP port) for <b>node</b>
@@ -1781,8 +1750,8 @@ node_get_prim_orport(const node_t *node, tor_addr_port_t *ap_out)
   /* Check ri first, because rewrite_node_address_for_bridge() updates
    * node->ri with the configured bridge address. */
 
-  RETURN_IPV4_AP(node->ri, or_port, ap_out);
-  RETURN_IPV4_AP(node->rs, or_port, ap_out);
+  RETURN_IPV4_AP(node->ri, ipv4_orport, ap_out);
+  RETURN_IPV4_AP(node->rs, ipv4_orport, ap_out);
   /* Microdescriptors only have an IPv6 address */
 }
 
@@ -1882,8 +1851,8 @@ node_get_prim_dirport(const node_t *node, tor_addr_port_t *ap_out)
   /* Check ri first, because rewrite_node_address_for_bridge() updates
    * node->ri with the configured bridge address. */
 
-  RETURN_IPV4_AP(node->ri, dir_port, ap_out);
-  RETURN_IPV4_AP(node->rs, dir_port, ap_out);
+  RETURN_IPV4_AP(node->ri, ipv4_dirport, ap_out);
+  RETURN_IPV4_AP(node->rs, ipv4_dirport, ap_out);
   /* Microdescriptors only have an IPv6 address */
 }
 
@@ -1920,13 +1889,13 @@ node_get_pref_ipv6_dirport(const node_t *node, tor_addr_port_t *ap_out)
 
   /* Assume IPv4 and IPv6 dirports are the same */
   if (node->ri && tor_addr_port_is_valid(&node->ri->ipv6_addr,
-                                         node->ri->dir_port, 0)) {
+                                         node->ri->ipv4_dirport, 0)) {
     tor_addr_copy(&ap_out->addr, &node->ri->ipv6_addr);
-    ap_out->port = node->ri->dir_port;
+    ap_out->port = node->ri->ipv4_dirport;
   } else if (node->rs && tor_addr_port_is_valid(&node->rs->ipv6_addr,
-                                                node->rs->dir_port, 0)) {
+                                                node->rs->ipv4_dirport, 0)) {
     tor_addr_copy(&ap_out->addr, &node->rs->ipv6_addr);
-    ap_out->port = node->rs->dir_port;
+    ap_out->port = node->rs->ipv4_dirport;
   } else {
     tor_addr_make_null(&ap_out->addr, AF_INET6);
     ap_out->port = 0;
@@ -2011,15 +1980,15 @@ node_get_rsa_onion_key(const node_t *node)
 void
 node_set_country(node_t *node)
 {
-  tor_addr_t addr = TOR_ADDR_NULL;
+  const tor_addr_t *ipv4_addr = NULL;
 
   /* XXXXipv6 */
   if (node->rs)
-    tor_addr_from_ipv4h(&addr, node->rs->addr);
+    ipv4_addr = &node->rs->ipv4_addr;
   else if (node->ri)
-    tor_addr_from_ipv4h(&addr, node->ri->addr);
+    ipv4_addr = &node->ri->ipv4_addr;
 
-  node->country = geoip_get_country_by_addr(&addr);
+  node->country = geoip_get_country_by_addr(ipv4_addr);
 }
 
 /** Set the country code of all routers in the routerlist. */
@@ -2250,21 +2219,18 @@ nodelist_add_node_and_family(smartlist_t *sl, const node_t *node)
 const node_t *
 router_find_exact_exit_enclave(const char *address, uint16_t port)
 {/*XXXX MOVE*/
-  uint32_t addr;
   struct in_addr in;
-  tor_addr_t a;
+  tor_addr_t ipv4_addr;
   const or_options_t *options = get_options();
 
   if (!tor_inet_aton(address, &in))
     return NULL; /* it's not an IP already */
-  addr = ntohl(in.s_addr);
-
-  tor_addr_from_ipv4h(&a, addr);
+  tor_addr_from_in(&ipv4_addr, &in);
 
   SMARTLIST_FOREACH(nodelist_get_list(), const node_t *, node, {
-    if (node_get_addr_ipv4h(node) == addr &&
+    if (tor_addr_eq(node_get_prim_addr_ipv4(node), &ipv4_addr) &&
         node->is_running &&
-        compare_tor_addr_to_node_policy(&a, port, node) ==
+        compare_tor_addr_to_node_policy(&ipv4_addr, port, node) ==
           ADDR_POLICY_ACCEPTED &&
         !routerset_contains_node(options->ExcludeExitNodesUnion_, node))
       return node;
diff --git a/src/feature/nodelist/nodelist.h b/src/feature/nodelist/nodelist.h
index 06cd7916ff..b762fb339c 100644
--- a/src/feature/nodelist/nodelist.h
+++ b/src/feature/nodelist/nodelist.h
@@ -35,8 +35,7 @@ node_t *nodelist_add_microdesc(microdesc_t *md);
 void nodelist_set_consensus(const networkstatus_t *ns);
 void nodelist_ensure_freshness(const networkstatus_t *ns);
 int nodelist_probably_contains_address(const tor_addr_t *addr);
-void nodelist_add_addr4_to_address_set(const uint32_t addr);
-void nodelist_add_addr6_to_address_set(const tor_addr_t *addr);
+void nodelist_add_addr_to_address_set(const tor_addr_t *addr);
 
 void nodelist_remove_microdesc(const char *identity_digest, microdesc_t *md);
 void nodelist_remove_routerinfo(routerinfo_t *ri);
@@ -67,7 +66,6 @@ smartlist_t *node_get_all_orports(const node_t *node);
 int node_allows_single_hop_exits(const node_t *node);
 const char *node_get_nickname(const node_t *node);
 const char *node_get_platform(const node_t *node);
-uint32_t node_get_prim_addr_ipv4h(const node_t *node);
 void node_get_address_string(const node_t *node, char *cp, size_t len);
 long node_get_declared_uptime(const node_t *node);
 MOCK_DECL(const struct ed25519_public_key_t *,node_get_ed25519_id,
@@ -114,7 +112,6 @@ MOCK_DECL(const smartlist_t *, nodelist_get_list, (void));
 
 /* Temporary during transition to multiple addresses.  */
 void node_get_addr(const node_t *node, tor_addr_t *addr_out);
-#define node_get_addr_ipv4h(n) node_get_prim_addr_ipv4h((n))
 
 void nodelist_refresh_countries(void);
 void node_set_country(node_t *node);
diff --git a/src/feature/nodelist/routerinfo.c b/src/feature/nodelist/routerinfo.c
index 55f21dfe67..2a094d7fae 100644
--- a/src/feature/nodelist/routerinfo.c
+++ b/src/feature/nodelist/routerinfo.c
@@ -29,8 +29,8 @@ router_get_orport(const routerinfo_t *router,
 {
   tor_assert(ap_out != NULL);
   if (family == AF_INET) {
-    tor_addr_from_ipv4h(&ap_out->addr, router->addr);
-    ap_out->port = router->or_port;
+    tor_addr_copy(&ap_out->addr, &router->ipv4_addr);
+    ap_out->port = router->ipv4_orport;
     return 0;
   } else if (family == AF_INET6) {
     /* IPv6 addresses are optional, so check if it is valid. */
@@ -54,8 +54,8 @@ int
 router_has_orport(const routerinfo_t *router, const tor_addr_port_t *orport)
 {
   return
-    (tor_addr_eq_ipv4h(&orport->addr, router->addr) &&
-     orport->port == router->or_port) ||
+    (tor_addr_eq(&orport->addr, &router->ipv4_addr) &&
+     orport->port == router->ipv4_orport) ||
     (tor_addr_eq(&orport->addr, &router->ipv6_addr) &&
      orport->port == router->ipv6_orport);
 }
diff --git a/src/feature/nodelist/routerinfo_st.h b/src/feature/nodelist/routerinfo_st.h
index 36ead50e33..7197c88c18 100644
--- a/src/feature/nodelist/routerinfo_st.h
+++ b/src/feature/nodelist/routerinfo_st.h
@@ -21,9 +21,10 @@ struct routerinfo_t {
   signed_descriptor_t cache_info;
   char *nickname; /**< Human-readable OR name. */
 
-  uint32_t addr; /**< IPv4 address of OR, in host order. */
-  uint16_t or_port; /**< Port for TLS connections. */
-  uint16_t dir_port; /**< Port for HTTP directory connections. */
+  /** A router's IPv4 address. */
+  tor_addr_t ipv4_addr;
+  uint16_t ipv4_orport;
+  uint16_t ipv4_dirport;
 
   /** A router's IPv6 address, if it has one. */
   tor_addr_t ipv6_addr;
diff --git a/src/feature/nodelist/routerlist.c b/src/feature/nodelist/routerlist.c
index 1afbdf056f..72824f2dd2 100644
--- a/src/feature/nodelist/routerlist.c
+++ b/src/feature/nodelist/routerlist.c
@@ -506,7 +506,8 @@ router_dir_conn_should_skip_reachable_address_check(
 int
 routers_have_same_or_addrs(const routerinfo_t *r1, const routerinfo_t *r2)
 {
-  return r1->addr == r2->addr && r1->or_port == r2->or_port &&
+  return tor_addr_eq(&r1->ipv4_addr, &r2->ipv4_addr) &&
+    r1->ipv4_orport == r2->ipv4_orport &&
     tor_addr_eq(&r1->ipv6_addr, &r2->ipv6_addr) &&
     r1->ipv6_orport == r2->ipv6_orport;
 }
@@ -2964,12 +2965,12 @@ router_differences_are_cosmetic(const routerinfo_t *r1, const routerinfo_t *r2)
   }
 
   /* If any key fields differ, they're different. */
-  if (r1->addr != r2->addr ||
+  if (!tor_addr_eq(&r1->ipv4_addr, &r2->ipv4_addr) ||
       strcasecmp(r1->nickname, r2->nickname) ||
-      r1->or_port != r2->or_port ||
+      r1->ipv4_orport != r2->ipv4_orport ||
       !tor_addr_eq(&r1->ipv6_addr, &r2->ipv6_addr) ||
       r1->ipv6_orport != r2->ipv6_orport ||
-      r1->dir_port != r2->dir_port ||
+      r1->ipv4_dirport != r2->ipv4_dirport ||
       r1->purpose != r2->purpose ||
       r1->onion_pkey_len != r2->onion_pkey_len ||
       !tor_memeq(r1->onion_pkey, r2->onion_pkey, r1->onion_pkey_len) ||
diff --git a/src/feature/nodelist/routerset.c b/src/feature/nodelist/routerset.c
index cba7203d44..7234dc5441 100644
--- a/src/feature/nodelist/routerset.c
+++ b/src/feature/nodelist/routerset.c
@@ -327,10 +327,8 @@ int
 routerset_contains_router(const routerset_t *set, const routerinfo_t *ri,
                           country_t country)
 {
-  tor_addr_t addr_v4;
-  tor_addr_from_ipv4h(&addr_v4, ri->addr);
-  return routerset_contains2(set, &addr_v4, ri->or_port, &ri->ipv6_addr,
-                             ri->ipv6_orport, ri->nickname,
+  return routerset_contains2(set, &ri->ipv4_addr, ri->ipv4_orport,
+                             &ri->ipv6_addr, ri->ipv6_orport, ri->nickname,
                              ri->cache_info.identity_digest, country);
 }
 
@@ -341,11 +339,9 @@ routerset_contains_routerstatus(const routerset_t *set,
                                 const routerstatus_t *rs,
                                 country_t country)
 {
-  tor_addr_t addr;
-  tor_addr_from_ipv4h(&addr, rs->addr);
   return routerset_contains(set,
-                            &addr,
-                            rs->or_port,
+                            &rs->ipv4_addr,
+                            rs->ipv4_orport,
                             rs->nickname,
                             rs->identity_digest,
                             country);
diff --git a/src/feature/nodelist/routerstatus_st.h b/src/feature/nodelist/routerstatus_st.h
index 735c754b31..254ba73f7f 100644
--- a/src/feature/nodelist/routerstatus_st.h
+++ b/src/feature/nodelist/routerstatus_st.h
@@ -29,9 +29,9 @@ struct routerstatus_t {
   /** Digest of the router's most recent descriptor or microdescriptor.
    * If it's a descriptor, we only use the first DIGEST_LEN bytes. */
   char descriptor_digest[DIGEST256_LEN];
-  uint32_t addr; /**< IPv4 address for this router, in host order. */
-  uint16_t or_port; /**< IPv4 OR port for this router. */
-  uint16_t dir_port; /**< Directory port for this router. */
+  tor_addr_t ipv4_addr;
+  uint16_t ipv4_orport; /**< IPv4 OR port for this router. */
+  uint16_t ipv4_dirport; /**< Directory port for this router. */
   tor_addr_t ipv6_addr; /**< IPv6 address for this router. */
   uint16_t ipv6_orport; /**< IPv6 OR port for this router. */
   unsigned int is_authority:1; /**< True iff this router is an authority. */
diff --git a/src/feature/relay/relay_periodic.c b/src/feature/relay/relay_periodic.c
index 0c056bdeb1..cc346bc3fc 100644
--- a/src/feature/relay/relay_periodic.c
+++ b/src/feature/relay/relay_periodic.c
@@ -208,14 +208,14 @@ reachability_warnings_callback(time_t now, const or_options_t *options)
     if (me && !(v4_ok && v6_ok)) {
       /* We need to warn that one or more of our ORPorts isn't reachable.
        * Determine which, and give a reasonable warning. */
-      char *address4 = tor_dup_ip(me->addr);
+      char *address4 = tor_addr_to_str_dup(&me->ipv4_addr);
       char *address6 = tor_addr_to_str_dup(&me->ipv6_addr);
       if (address4 || address6) {
         char *where4=NULL, *where6=NULL;
         if (!v4_ok)
-          tor_asprintf(&where4, "%s:%d", address4, me->or_port);
+          tor_asprintf(&where4, "%s:%d", address4, me->ipv4_orport);
         if (!v6_ok)
-          tor_asprintf(&where6, "[%s]:%d", address6, me->or_port);
+          tor_asprintf(&where6, "[%s]:%d", address6, me->ipv6_orport);
         const char *opt_and = (!v4_ok && !v6_ok) ? "and" : "";
 
         log_warn(LD_CONFIG,
@@ -231,7 +231,7 @@ reachability_warnings_callback(time_t now, const or_options_t *options)
         if (!v4_ok) {
           control_event_server_status(LOG_WARN,
                                       "REACHABILITY_FAILED ORADDRESS=%s:%d",
-                                      address4, me->or_port);
+                                      address4, me->ipv4_orport);
         }
         if (!v6_ok) {
           control_event_server_status(LOG_WARN,
@@ -244,19 +244,17 @@ reachability_warnings_callback(time_t now, const or_options_t *options)
     }
 
     if (me && !router_dirport_seems_reachable(options)) {
-      char *address = tor_dup_ip(me->addr);
-      if (address) {
-        log_warn(LD_CONFIG,
-                 "Your server (%s:%d) has not managed to confirm that its "
-                 "DirPort is reachable. Relays do not publish descriptors "
-                 "until their ORPort and DirPort are reachable. Please check "
-                 "your firewalls, ports, address, /etc/hosts file, etc.",
-                 address, me->dir_port);
-        control_event_server_status(LOG_WARN,
-                                    "REACHABILITY_FAILED DIRADDRESS=%s:%d",
-                                    address, me->dir_port);
-        tor_free(address);
-      }
+      char *address4 = tor_addr_to_str_dup(&me->ipv4_addr);
+      log_warn(LD_CONFIG,
+               "Your server (%s:%d) has not managed to confirm that its "
+               "DirPort is reachable. Relays do not publish descriptors "
+               "until their ORPort and DirPort are reachable. Please check "
+               "your firewalls, ports, address, /etc/hosts file, etc.",
+               address4, me->ipv4_dirport);
+      control_event_server_status(LOG_WARN,
+                                  "REACHABILITY_FAILED DIRADDRESS=%s:%d",
+                                  address4, me->ipv4_dirport);
+      tor_free(address4);
     }
   }
 
diff --git a/src/feature/relay/router.c b/src/feature/relay/router.c
index b63950ea13..4f4ba8559b 100644
--- a/src/feature/relay/router.c
+++ b/src/feature/relay/router.c
@@ -2057,9 +2057,9 @@ router_build_fresh_unsigned_routerinfo,(routerinfo_t **ri_out))
   ri = tor_malloc_zero(sizeof(routerinfo_t));
   ri->cache_info.routerlist_index = -1;
   ri->nickname = tor_strdup(options->Nickname);
-  ri->addr = addr;
-  ri->or_port = router_get_advertised_or_port(options);
-  ri->dir_port = router_get_advertised_dir_port(options, 0);
+  tor_addr_from_ipv4h(&ri->ipv4_addr, addr);
+  ri->ipv4_orport = router_get_advertised_or_port(options);
+  ri->ipv4_dirport = router_get_advertised_dir_port(options, 0);
   ri->supports_tunnelled_dir_requests =
     directory_permits_begindir_requests(options);
   ri->cache_info.published_on = time(NULL);
@@ -2105,7 +2105,8 @@ router_build_fresh_unsigned_routerinfo,(routerinfo_t **ri_out))
     /* DNS is screwed up; don't claim to be an exit. */
     policies_exit_policy_append_reject_star(&ri->exit_policy);
   } else {
-    policies_parse_exit_policy_from_options(options,ri->addr,&ri->ipv6_addr,
+    policies_parse_exit_policy_from_options(options, &ri->ipv4_addr,
+                                            &ri->ipv6_addr,
                                             &ri->exit_policy);
   }
   ri->policy_is_reject_star =
@@ -2608,7 +2609,7 @@ check_descriptor_ipaddress_changed(time_t now)
     return;
 
   /* XXXX ipv6 */
-  prev = my_ri->addr;
+  prev = tor_addr_to_ipv4h(&my_ri->ipv4_addr);
   if (!find_my_address(options, AF_INET, LOG_INFO, &addr, &method,
                        &hostname)) {
     log_info(LD_CONFIG,"options->Address didn't resolve into an IP.");
@@ -2857,7 +2858,7 @@ router_dump_router_to_string(routerinfo_t *router,
     proto_line = tor_strdup("");
   }
 
-  address = tor_dup_ip(router->addr);
+  address = tor_addr_to_str_dup(&router->ipv4_addr);
   if (!address)
     goto err;
 
@@ -2881,8 +2882,8 @@ router_dump_router_to_string(routerinfo_t *router,
                     "%s%s%s",
     router->nickname,
     address,
-    router->or_port,
-    router_should_advertise_dirport(options, router->dir_port),
+    router->ipv4_orport,
+    router_should_advertise_dirport(options, router->ipv4_dirport),
     ed_cert_line ? ed_cert_line : "",
     extra_or_address ? extra_or_address : "",
     router->platform,
diff --git a/src/feature/relay/selftest.c b/src/feature/relay/selftest.c
index 77c04abdd7..d24748b297 100644
--- a/src/feature/relay/selftest.c
+++ b/src/feature/relay/selftest.c
@@ -284,8 +284,8 @@ static void
 router_do_dirport_reachability_checks(const routerinfo_t *me)
 {
   tor_addr_port_t my_dirport;
-  tor_addr_from_ipv4h(&my_dirport.addr, me->addr);
-  my_dirport.port = me->dir_port;
+  tor_addr_copy(&my_dirport.addr, &me->ipv4_addr);
+  my_dirport.port = me->ipv4_dirport;
 
   /* If there is already a pending connection, don't open another one. */
   if (!connection_get_by_type_addr_port_purpose(
@@ -443,7 +443,7 @@ router_dirport_found_reachable(void)
   const or_options_t *options = get_options();
 
   if (!can_reach_dir_port && me) {
-    char *address = tor_dup_ip(me->addr);
+    char *address = tor_addr_to_str_dup(&me->ipv4_addr);
 
     if (!address)
       return;
@@ -454,7 +454,7 @@ router_dirport_found_reachable(void)
                ready_to_publish(options) ?
                " Publishing server descriptor." : "");
 
-    if (router_should_advertise_dirport(options, me->dir_port)) {
+    if (router_should_advertise_dirport(options, me->ipv4_dirport)) {
       mark_my_descriptor_dirty("DirPort found reachable");
       /* This is a significant enough change to upload immediately,
        * at least in a test network */
@@ -464,7 +464,7 @@ router_dirport_found_reachable(void)
     }
     control_event_server_status(LOG_NOTICE,
                                 "REACHABILITY_SUCCEEDED DIRADDRESS=%s:%d",
-                                address, me->dir_port);
+                                address, me->ipv4_dirport);
     tor_free(address);
   }
 }
diff --git a/src/feature/rend/rendservice.c b/src/feature/rend/rendservice.c
index 585fdb532e..1ac88d0eb7 100644
--- a/src/feature/rend/rendservice.c
+++ b/src/feature/rend/rendservice.c
@@ -3740,7 +3740,7 @@ directory_post_to_hs_dir(rend_service_descriptor_t *renddesc,
       rend_data_free(rend_data);
       base32_encode(desc_id_base32, sizeof(desc_id_base32),
                     desc->desc_id, DIGEST_LEN);
-      hs_dir_ip = tor_dup_ip(hs_dir->addr);
+      hs_dir_ip = tor_addr_to_str_dup(&hs_dir->ipv4_addr);
       if (hs_dir_ip) {
         log_info(LD_REND, "Launching upload for v2 descriptor for "
                           "service '%s' with descriptor ID '%s' with validity "
@@ -3751,7 +3751,7 @@ directory_post_to_hs_dir(rend_service_descriptor_t *renddesc,
                  seconds_valid,
                  hs_dir->nickname,
                  hs_dir_ip,
-                 hs_dir->or_port);
+                 hs_dir->ipv4_orport);
         tor_free(hs_dir_ip);
       }