Use connection_describe() for log messages.

3 files changed, 74 insertions, 87 deletions

diff --git a/src/core/or/channeltls.c b/src/core/or/channeltls.c
index 6503c2ebb0..e4dbdda7db 100644
--- a/src/core/or/channeltls.c
+++ b/src/core/or/channeltls.c
@@ -1519,7 +1519,7 @@ channel_tls_process_versions_cell(var_cell_t *cell, channel_tls_t *chan)
     log_fn(LOG_WARN, LD_OR,
            "Negotiated link with non-2 protocol after doing a v2 TLS "
            "handshake with %s. Closing connection.",
-           fmt_addr(&chan->conn->base_.addr));
+           connection_describe_peer(TO_CONN(chan->conn)));
     connection_or_close_for_error(chan->conn, 0);
     return;
   }
@@ -1531,10 +1531,9 @@ channel_tls_process_versions_cell(var_cell_t *cell, channel_tls_t *chan)
 
   if (chan->conn->link_proto == 2) {
     log_info(LD_OR,
-             "Negotiated version %d with %s:%d; sending NETINFO.",
+             "Negotiated version %d on %s; sending NETINFO.",
              highest_supported_version,
-             safe_str_client(chan->conn->base_.address),
-             chan->conn->base_.port);
+             connection_describe(TO_CONN(chan->conn)));
 
     if (connection_or_send_netinfo(chan->conn) < 0) {
       connection_or_close_for_error(chan->conn, 0);
@@ -1554,10 +1553,9 @@ channel_tls_process_versions_cell(var_cell_t *cell, channel_tls_t *chan)
     tor_assert(chan->conn->link_proto >= 3);
 
     log_info(LD_OR,
-             "Negotiated version %d with %s:%d; %s%s%s%s%s",
+             "Negotiated version %d with on %s; %s%s%s%s%s",
              highest_supported_version,
-             safe_str_client(chan->conn->base_.address),
-             chan->conn->base_.port,
+             connection_describe(TO_CONN(chan->conn)),
              send_any ? "Sending cells:" : "Waiting for CERTS cell",
              send_versions ? " VERSIONS" : "",
              send_certs ? " CERTS" : "",
@@ -1950,18 +1948,16 @@ channel_tls_process_netinfo_cell(cell_t *cell, channel_tls_t *chan)
 
   if (connection_or_set_state_open(chan->conn) < 0) {
     log_fn(LOG_PROTOCOL_WARN, LD_OR,
-           "Got good NETINFO cell from %s:%d; but "
+           "Got good NETINFO cell on %s; but "
            "was unable to make the OR connection become open.",
-           safe_str_client(chan->conn->base_.address),
-           chan->conn->base_.port);
+           connection_describe(TO_CONN(chan->conn)));
     connection_or_close_for_error(chan->conn, 0);
   } else {
     log_info(LD_OR,
-             "Got good NETINFO cell from %s:%d; OR connection is now "
+             "Got good NETINFO cell on %s; OR connection is now "
              "open, using protocol version %d. Its ID digest is %s. "
              "Our address is apparently %s.",
-             safe_str_client(chan->conn->base_.address),
-             chan->conn->base_.port,
+             connection_describe(TO_CONN(chan->conn)),
              (int)(chan->conn->link_proto),
              hex_str(identity_digest, DIGEST_LEN),
              tor_addr_is_null(&my_apparent_addr) ?
@@ -2046,9 +2042,9 @@ channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
 #define ERR(s)                                                  \
   do {                                                          \
     log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
-           "Received a bad CERTS cell from %s:%d: %s",          \
-           safe_str(chan->conn->base_.address),                 \
-           chan->conn->base_.port, (s));                        \
+           "Received a bad CERTS cell on %s: %s",               \
+           connection_describe(TO_CONN(chan->conn)),            \
+           (s));                                                \
     connection_or_close_for_error(chan->conn, 0);               \
     goto err;                                                   \
   } while (0)
@@ -2096,9 +2092,8 @@ channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
         tor_x509_cert_t *x509_cert = tor_x509_cert_decode(cert_body, cert_len);
         if (!x509_cert) {
           log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
-                 "Received undecodable certificate in CERTS cell from %s:%d",
-                 safe_str(chan->conn->base_.address),
-               chan->conn->base_.port);
+                 "Received undecodable certificate in CERTS cell on %s",
+                 connection_describe(TO_CONN(chan->conn)));
         } else {
           if (x509_certs[cert_type]) {
             tor_x509_cert_free(x509_cert);
@@ -2114,9 +2109,8 @@ channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
         if (!ed_cert) {
           log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
                  "Received undecodable Ed certificate "
-                 "in CERTS cell from %s:%d",
-                 safe_str(chan->conn->base_.address),
-               chan->conn->base_.port);
+                 "in CERTS cell on %s",
+                 connection_describe(TO_CONN(chan->conn)));
         } else {
           if (ed_certs[cert_type]) {
             tor_cert_free(ed_cert);
@@ -2226,9 +2220,9 @@ channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
       ERR("Problem setting or checking peer id");
 
     log_info(LD_HANDSHAKE,
-             "Got some good certificates from %s:%d: Authenticated it with "
+             "Got some good certificates on %s: Authenticated it with "
              "RSA%s",
-             safe_str(chan->conn->base_.address), chan->conn->base_.port,
+             connection_describe(TO_CONN(chan->conn)),
              checked_ed_id ? " and Ed25519" : "");
 
     if (!public_server_mode(get_options())) {
@@ -2240,11 +2234,10 @@ channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
   } else {
     /* We can't call it authenticated till we see an AUTHENTICATE cell. */
     log_info(LD_OR,
-             "Got some good RSA%s certificates from %s:%d. "
+             "Got some good RSA%s certificates on %s. "
              "Waiting for AUTHENTICATE.",
              checked_ed_id ? " and Ed25519" : "",
-             safe_str(chan->conn->base_.address),
-             chan->conn->base_.port);
+             connection_describe(TO_CONN(chan->conn)));
     /* XXXX check more stuff? */
   }
 
@@ -2293,9 +2286,9 @@ channel_tls_process_auth_challenge_cell(var_cell_t *cell, channel_tls_t *chan)
 #define ERR(s)                                                  \
   do {                                                          \
     log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
-           "Received a bad AUTH_CHALLENGE cell from %s:%d: %s", \
-           safe_str(chan->conn->base_.address),                 \
-           chan->conn->base_.port, (s));                        \
+           "Received a bad AUTH_CHALLENGE cell on %s: %s",      \
+           connection_describe(TO_CONN(chan->conn)),            \
+           (s));                                                \
     connection_or_close_for_error(chan->conn, 0);               \
     goto done;                                                  \
   } while (0)
@@ -2340,10 +2333,9 @@ channel_tls_process_auth_challenge_cell(var_cell_t *cell, channel_tls_t *chan)
 
   if (use_type >= 0) {
     log_info(LD_OR,
-             "Got an AUTH_CHALLENGE cell from %s:%d: Sending "
+             "Got an AUTH_CHALLENGE cell on %s: Sending "
              "authentication type %d",
-             safe_str(chan->conn->base_.address),
-             chan->conn->base_.port,
+             connection_describe(TO_CONN(chan->conn)),
              use_type);
 
     if (connection_or_send_authenticate_cell(chan->conn, use_type) < 0) {
@@ -2354,10 +2346,9 @@ channel_tls_process_auth_challenge_cell(var_cell_t *cell, channel_tls_t *chan)
     }
   } else {
     log_info(LD_OR,
-             "Got an AUTH_CHALLENGE cell from %s:%d, but we don't "
+             "Got an AUTH_CHALLENGE cell on %s, but we don't "
              "know any of its authentication types. Not authenticating.",
-             safe_str(chan->conn->base_.address),
-             chan->conn->base_.port);
+             connection_describe(TO_CONN(chan->conn)));
   }
 
   if (connection_or_send_netinfo(chan->conn) < 0) {
@@ -2397,9 +2388,9 @@ channel_tls_process_authenticate_cell(var_cell_t *cell, channel_tls_t *chan)
 #define ERR(s)                                                  \
   do {                                                          \
     log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
-           "Received a bad AUTHENTICATE cell from %s:%d: %s",   \
-           safe_str(chan->conn->base_.address),                 \
-           chan->conn->base_.port, (s));                        \
+           "Received a bad AUTHENTICATE cell on %s: %s",        \
+           connection_describe(TO_CONN(chan->conn)),            \
+           (s));                                                \
     connection_or_close_for_error(chan->conn, 0);               \
     var_cell_free(expected_cell);                               \
     return;                                                     \
@@ -2560,9 +2551,9 @@ channel_tls_process_authenticate_cell(var_cell_t *cell, channel_tls_t *chan)
     crypto_pk_free(identity_rcvd);
 
     log_debug(LD_HANDSHAKE,
-              "Calling connection_or_init_conn_from_address for %s "
+              "Calling connection_or_init_conn_from_address on %s "
               " from %s, with%s ed25519 id.",
-              safe_str(chan->conn->base_.address),
+              connection_describe(TO_CONN(chan->conn)),
               __func__,
               ed_identity_received ? "" : "out");
 
@@ -2575,10 +2566,9 @@ channel_tls_process_authenticate_cell(var_cell_t *cell, channel_tls_t *chan)
                   0);
 
     log_debug(LD_HANDSHAKE,
-             "Got an AUTHENTICATE cell from %s:%d, type %d: Looks good.",
-             safe_str(chan->conn->base_.address),
-             chan->conn->base_.port,
-             authtype);
+             "Got an AUTHENTICATE cell on %s, type %d: Looks good.",
+              connection_describe(TO_CONN(chan->conn)),
+              authtype);
   }
 
   var_cell_free(expected_cell);
diff --git a/src/core/or/connection_edge.c b/src/core/or/connection_edge.c
index 45d2a9664a..cd4ec8be7b 100644
--- a/src/core/or/connection_edge.c
+++ b/src/core/or/connection_edge.c
@@ -424,9 +424,7 @@ warn_if_hs_unreachable(const edge_connection_t *conn, uint8_t reason)
     char *m;
     if ((m = rate_limit_log(&warn_limit, approx_time()))) {
       log_warn(LD_EDGE, "Onion service connection to %s failed (%s)",
-               (conn->base_.socket_family == AF_UNIX) ?
-               safe_str(conn->base_.address) :
-               safe_str(fmt_addrport(&conn->base_.addr, conn->base_.port)),
+               connection_describe_peer(TO_CONN(conn)),
                stream_end_reason_to_string(reason));
       tor_free(m);
     }
@@ -922,9 +920,8 @@ connection_edge_finished_connecting(edge_connection_t *edge_conn)
   conn = TO_CONN(edge_conn);
   tor_assert(conn->state == EXIT_CONN_STATE_CONNECTING);
 
-  log_info(LD_EXIT,"Exit connection to %s:%u (%s) established.",
-           escaped_safe_str(conn->address), conn->port,
-           safe_str(fmt_and_decorate_addr(&conn->addr)));
+  log_info(LD_EXIT,"%s established.",
+           connection_describe(conn));
 
   rep_hist_note_exit_stream_opened(conn->port);
 
@@ -3840,8 +3837,8 @@ handle_hs_exit_conn(circuit_t *circ, edge_connection_t *conn)
     return -1;
   }
   if (ret < 0) {
-    log_info(LD_REND, "Didn't find rendezvous service (addr%s, port %d)",
-             fmt_addr(&TO_CONN(conn)->addr), TO_CONN(conn)->port);
+    log_info(LD_REND, "Didn't find rendezvous service at %s",
+             connection_describe_peer(TO_CONN(conn)));
     /* Send back reason DONE because we want to make hidden service port
      * scanning harder thus instead of returning that the exit policy
      * didn't match, which makes it obvious that the port is closed,
@@ -4192,8 +4189,8 @@ connection_exit_connect(edge_connection_t *edge_conn)
                              &why_failed_exit_policy)) {
     if (BUG(!why_failed_exit_policy))
       why_failed_exit_policy = "";
-    log_info(LD_EXIT,"%s:%d failed exit policy%s. Closing.",
-             escaped_safe_str_client(conn->address), conn->port,
+    log_info(LD_EXIT,"%s failed exit policy%s. Closing.",
+             connection_describe(conn),
              why_failed_exit_policy);
     connection_edge_end(edge_conn, END_STREAM_REASON_EXITPOLICY);
     circuit_detach_stream(circuit_get_by_edge_conn(edge_conn), edge_conn);
diff --git a/src/core/or/connection_or.c b/src/core/or/connection_or.c
index 079fa3dfcb..e62c28821a 100644
--- a/src/core/or/connection_or.c
+++ b/src/core/or/connection_or.c
@@ -151,9 +151,9 @@ connection_or_set_identity_digest(or_connection_t *conn,
   if (conn->chan)
     chan = TLS_CHAN_TO_BASE(conn->chan);
 
-  log_info(LD_HANDSHAKE, "Set identity digest for %p (%s): %s %s.",
+  log_info(LD_HANDSHAKE, "Set identity digest for %s at %p: %s %s.",
+           connection_describe(TO_CONN(conn)),
            conn,
-           escaped_safe_str(conn->base_.address),
            hex_str(rsa_digest, DIGEST_LEN),
            ed25519_fmt(ed_id));
   log_info(LD_HANDSHAKE, "   (Previously: %s %s)",
@@ -575,11 +575,9 @@ connection_or_process_inbuf(or_connection_t *conn)
    * 100% true. */
   if (buf_datalen(conn->base_.inbuf) > MAX_OR_INBUF_WHEN_NONOPEN) {
     log_fn(LOG_PROTOCOL_WARN, LD_NET, "Accumulated too much data (%d bytes) "
-           "on nonopen OR connection %s %s:%u in state %s; closing.",
+           "on non-open %s; closing.",
            (int)buf_datalen(conn->base_.inbuf),
-           connection_or_nonopen_was_started_here(conn) ? "to" : "from",
-           conn->base_.address, conn->base_.port,
-           conn_state_to_string(conn->base_.type, conn->base_.state));
+           connection_describe(TO_CONN(conn)));
     connection_or_close_for_error(conn, 0);
     ret = -1;
   }
@@ -691,8 +689,8 @@ connection_or_finished_connecting(or_connection_t *or_conn)
   conn = TO_CONN(or_conn);
   tor_assert(conn->state == OR_CONN_STATE_CONNECTING);
 
-  log_debug(LD_HANDSHAKE,"OR connect() to router at %s:%u finished.",
-            conn->address,conn->port);
+  log_debug(LD_HANDSHAKE,"connect finished for %s",
+            connection_describe(conn));
 
   if (proxy_type != PROXY_NONE) {
     /* start proxy handshake */
@@ -1010,9 +1008,10 @@ connection_or_single_set_badness_(time_t now,
       or_conn->base_.timestamp_created + TIME_BEFORE_OR_CONN_IS_TOO_OLD
         < now) {
     log_info(LD_OR,
-             "Marking OR conn to %s:%d as too old for new circuits "
+             "Marking %s as too old for new circuits "
              "(fd "TOR_SOCKET_T_FORMAT", %d secs old).",
-             or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
+             connection_describe(TO_CONN(or_conn)),
+             or_conn->base_.s,
              (int)(now - or_conn->base_.timestamp_created));
     connection_or_mark_bad_for_new_circs(or_conn);
   }
@@ -1077,10 +1076,11 @@ connection_or_group_set_badness_(smartlist_t *group, int force)
       /* We have at least one open canonical connection to this router,
        * and this one is open but not canonical.  Mark it bad. */
       log_info(LD_OR,
-               "Marking OR conn to %s:%d as unsuitable for new circuits: "
+               "Marking %s unsuitable for new circuits: "
                "(fd "TOR_SOCKET_T_FORMAT", %d secs old).  It is not "
                "canonical, and we have another connection to that OR that is.",
-               or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
+               connection_describe(TO_CONN(or_conn)),
+               or_conn->base_.s,
                (int)(now - or_conn->base_.timestamp_created));
       connection_or_mark_bad_for_new_circs(or_conn);
       continue;
@@ -1121,22 +1121,24 @@ connection_or_group_set_badness_(smartlist_t *group, int force)
       /* This isn't the best conn, _and_ the best conn is better than it */
       if (best->is_canonical) {
         log_info(LD_OR,
-                 "Marking OR conn to %s:%d as unsuitable for new circuits: "
+                 "Marking %s as unsuitable for new circuits: "
                  "(fd "TOR_SOCKET_T_FORMAT", %d secs old). "
                  "We have a better canonical one "
                  "(fd "TOR_SOCKET_T_FORMAT"; %d secs old).",
-                 or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
+                 connection_describe(TO_CONN(or_conn)),
+                 or_conn->base_.s,
                  (int)(now - or_conn->base_.timestamp_created),
                  best->base_.s, (int)(now - best->base_.timestamp_created));
         connection_or_mark_bad_for_new_circs(or_conn);
       } else if (!tor_addr_compare(&or_conn->real_addr,
                                    &best->real_addr, CMP_EXACT)) {
         log_info(LD_OR,
-                 "Marking OR conn to %s:%d as unsuitable for new circuits: "
+                 "Marking %s unsuitable for new circuits: "
                  "(fd "TOR_SOCKET_T_FORMAT", %d secs old).  We have a better "
                  "one with the "
                  "same address (fd "TOR_SOCKET_T_FORMAT"; %d secs old).",
-                 or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
+                 connection_describe(TO_CONN(or_conn)),
+                 or_conn->base_.s,
                  (int)(now - or_conn->base_.timestamp_created),
                  best->base_.s, (int)(now - best->base_.timestamp_created));
         connection_or_mark_bad_for_new_circs(or_conn);
@@ -1464,10 +1466,9 @@ connection_or_connect, (const tor_addr_t *_addr, uint16_t port,
    * that is we haven't had a failure earlier. This is to avoid to try to
    * constantly connect to relays that we think are not reachable. */
   if (!should_connect_to_relay(conn)) {
-    log_info(LD_GENERAL, "Can't connect to identity %s at %s:%u because we "
+    log_info(LD_GENERAL, "Can't connect to %s because we "
                          "failed earlier. Refusing.",
-             hex_str(id_digest, DIGEST_LEN), fmt_addr(&TO_CONN(conn)->addr),
-             TO_CONN(conn)->port);
+             connection_describe_peer(TO_CONN(conn)));
     connection_free_(TO_CONN(conn));
     return NULL;
   }
@@ -1507,7 +1508,7 @@ connection_or_connect, (const tor_addr_t *_addr, uint16_t port,
                "transport proxy supporting '%s'. This can happen if you "
                "haven't provided a ClientTransportPlugin line, or if "
                "your pluggable transport proxy stopped running.",
-               fmt_addrport(&TO_CONN(conn)->addr, TO_CONN(conn)->port),
+               connection_describe_peer(TO_CONN(conn)),
                transport_name, transport_name);
 
       control_event_bootstrap_prob_or(
@@ -1516,9 +1517,9 @@ connection_or_connect, (const tor_addr_t *_addr, uint16_t port,
                                 conn);
 
     } else {
-      log_warn(LD_GENERAL, "Tried to connect to '%s' through a proxy, but "
+      log_warn(LD_GENERAL, "Tried to connect to %s through a proxy, but "
                "the proxy address could not be found.",
-               fmt_addrport(&TO_CONN(conn)->addr, TO_CONN(conn)->port));
+               connection_describe_peer(TO_CONN(conn)));
     }
 
     connection_free_(TO_CONN(conn));
@@ -1891,9 +1892,9 @@ connection_or_client_learned_peer_id(or_connection_t *conn,
   const int expected_ed_key =
     ! ed25519_public_key_is_zero(&chan->ed25519_identity);
 
-  log_info(LD_HANDSHAKE, "learned peer id for %p (%s): %s, %s",
+  log_info(LD_HANDSHAKE, "learned peer id for %s at %p: %s, %s",
+           connection_describe(TO_CONN(conn)),
            conn,
-           safe_str_client(conn->base_.address),
            hex_str((const char*)rsa_peer_id, DIGEST_LEN),
            ed25519_fmt(ed_peer_id));
 
@@ -1907,9 +1908,9 @@ connection_or_client_learned_peer_id(or_connection_t *conn,
     conn->nickname[0] = '$';
     base16_encode(conn->nickname+1, HEX_DIGEST_LEN+1,
                   conn->identity_digest, DIGEST_LEN);
-    log_info(LD_HANDSHAKE, "Connected to router %s at %s:%d without knowing "
-                    "its key. Hoping for the best.",
-                    conn->nickname, conn->base_.address, conn->base_.port);
+    log_info(LD_HANDSHAKE, "Connected to router at %s without knowing "
+             "its key. Hoping for the best.",
+             connection_describe_peer(TO_CONN(conn)));
     /* if it's a bridge and we didn't know its identity fingerprint, now
      * we do -- remember it for future attempts. */
     learned_router_identity(&conn->base_.addr, conn->base_.port,
@@ -1983,9 +1984,9 @@ connection_or_client_learned_peer_id(or_connection_t *conn,
     }
 
     log_fn(severity, LD_HANDSHAKE,
-           "Tried connecting to router at %s:%d, but RSA + ed25519 identity "
+           "Tried connecting to router at %s, but RSA + ed25519 identity "
            "keys were not as expected: wanted %s + %s but got %s + %s.%s",
-           conn->base_.address, conn->base_.port,
+           connection_describe_peer(TO_CONN(conn)),
            expected_rsa, expected_ed, seen_rsa, seen_ed, extra_log);
 
     /* Tell the new guard API about the channel failure */
@@ -2057,11 +2058,10 @@ connection_tls_finish_handshake(or_connection_t *conn)
 
   tor_assert(!started_here);
 
-  log_debug(LD_HANDSHAKE,"%s tls handshake on %p with %s done, using "
+  log_debug(LD_HANDSHAKE,"%s tls handshake on %s done, using "
             "ciphersuite %s. verifying.",
             started_here?"outgoing":"incoming",
-            conn,
-            safe_str_client(conn->base_.address),
+            connection_describe_peer(TO_CONN(conn)),
             tor_tls_get_ciphersuite_name(conn->tls));
 
   if (connection_or_check_valid_tls_handshake(conn, started_here,