Merge remote-tracking branch 'valentecaio/t-24714'

changes/ticket24714

@@ -0,0 +1,6 @@
+  o Code simplification and refactoring:
+    - Rename two fields of connection_t struct.
+      timestamp_lastwritten is renamed to timestamp_last_write_allowed and
+      timestamp_lastread is renamed to timestamp_last_read_allowed.
+      Closes ticket 24714, patch by "valentecaio".
+

src/or/circuituse.c

@@ -2584,7 +2584,7 @@ link_apconn_to_circ(entry_connection_t *apconn, origin_circuit_t *circ,
   log_debug(LD_APP|LD_CIRC, "attaching new conn to circ. n_circ_id %u.",
             (unsigned)circ->base_.n_circ_id);
   /* reset it, so we can measure circ timeouts */
-  ENTRY_TO_CONN(apconn)->timestamp_lastread = time(NULL);
+  ENTRY_TO_CONN(apconn)->timestamp_last_read_allowed = time(NULL);
   ENTRY_TO_EDGE_CONN(apconn)->next_stream = circ->p_streams;
   ENTRY_TO_EDGE_CONN(apconn)->on_circuit = TO_CIRCUIT(circ);
   /* assert_connection_ok(conn, time(NULL)); */

src/or/connection.c

@@ -462,8 +462,8 @@ connection_init(time_t now, connection_t *conn, int type, int socket_family)
   }
 
   conn->timestamp_created = now;
-  conn->timestamp_lastread = now;
+  conn->timestamp_last_read_allowed = now;
-  conn->timestamp_lastwritten = now;
+  conn->timestamp_last_write_allowed = now;
 }
 
 /** Create a link between <b>conn_a</b> and <b>conn_b</b>. */
@@ -861,7 +861,7 @@ connection_mark_for_close_internal_, (connection_t *conn,
   /* in case we're going to be held-open-til-flushed, reset
    * the number of seconds since last successful write, so
    * we get our whole 15 seconds */
-  conn->timestamp_lastwritten = time(NULL);
+  conn->timestamp_last_write_allowed = time(NULL);
 }
 
 /** Find each connection that has hold_open_until_flushed set to
@@ -883,7 +883,7 @@ connection_expire_held_open(void)
      */
     if (conn->hold_open_until_flushed) {
       tor_assert(conn->marked_for_close);
-      if (now - conn->timestamp_lastwritten >= 15) {
+      if (now - conn->timestamp_last_write_allowed >= 15) {
         int severity;
         if (conn->type == CONN_TYPE_EXIT ||
             (conn->type == CONN_TYPE_DIR &&
@@ -3417,7 +3417,7 @@ connection_handle_read_impl(connection_t *conn)
   if (conn->marked_for_close)
     return 0; /* do nothing */
 
-  conn->timestamp_lastread = approx_time();
+  conn->timestamp_last_read_allowed = approx_time();
 
   switch (conn->type) {
     case CONN_TYPE_OR_LISTENER:
@@ -3818,7 +3818,7 @@ update_send_buffer_size(tor_socket_t sock)
  * when libevent tells us that conn wants to write, or below
  * from connection_buf_add() when an entire TLS record is ready.
  *
- * Update <b>conn</b>-\>timestamp_lastwritten to now, and call flush_buf
+ * Update <b>conn</b>-\>timestamp_last_write_allowed to now, and call flush_buf
  * or flush_buf_tls appropriately. If it succeeds and there are no more
  * more bytes on <b>conn</b>-\>outbuf, then call connection_finished_flushing
  * on it too.
@@ -3851,7 +3851,7 @@ connection_handle_write_impl(connection_t *conn, int force)
     return 0;
   }
 
-  conn->timestamp_lastwritten = now;
+  conn->timestamp_last_write_allowed = now;
 
   /* Sometimes, "writable" means "connected". */
   if (connection_state_is_connecting(conn)) {

src/or/connection_edge.c

@@ -739,7 +739,7 @@ connection_ap_expire_beginning(void)
     /* if it's an internal linked connection, don't yell its status. */
     severity = (tor_addr_is_null(&base_conn->addr) && !base_conn->port)
       ? LOG_INFO : LOG_NOTICE;
-    seconds_idle = (int)( now - base_conn->timestamp_lastread );
+    seconds_idle = (int)( now - base_conn->timestamp_last_read_allowed );
     seconds_since_born = (int)( now - base_conn->timestamp_created );
 
     if (base_conn->state == AP_CONN_STATE_OPEN)
@@ -825,7 +825,7 @@ connection_ap_expire_beginning(void)
     mark_circuit_unusable_for_new_conns(TO_ORIGIN_CIRCUIT(circ));
 
     /* give our stream another 'cutoff' seconds to try */
-    conn->base_.timestamp_lastread += cutoff;
+    conn->base_.timestamp_last_read_allowed += cutoff;
     if (entry_conn->num_socks_retries < 250) /* avoid overflow */
       entry_conn->num_socks_retries++;
     /* move it back into 'pending' state, and try to attach. */
@@ -1135,7 +1135,7 @@ connection_ap_detach_retriable(entry_connection_t *conn,
                                int reason)
 {
   control_event_stream_status(conn, STREAM_EVENT_FAILED_RETRIABLE, reason);
-  ENTRY_TO_CONN(conn)->timestamp_lastread = time(NULL);
+  ENTRY_TO_CONN(conn)->timestamp_last_read_allowed = time(NULL);
 
   /* Roll back path bias use state so that we probe the circuit
    * if nothing else succeeds on it */

src/or/directory.c

@@ -2437,7 +2437,7 @@ connection_dir_client_reached_eof(dir_connection_t *conn)
      * and the date header.  (We used to check now-date_header, but that's
      * inaccurate if we spend a lot of time downloading.)
      */
-    apparent_skew = conn->base_.timestamp_lastwritten - date_header;
+    apparent_skew = conn->base_.timestamp_last_write_allowed - date_header;
     if (labs(apparent_skew)>ALLOW_DIRECTORY_TIME_SKEW) {
       int trusted = router_digest_is_trusted_dir(conn->identity_digest);
       clock_skew_warning(TO_CONN(conn), apparent_skew, trusted, LD_HTTP,

src/or/hs_client.c

@@ -1439,8 +1439,8 @@ hs_client_desc_has_arrived(const hs_ident_dir_conn_t *ident)
      * connection is considered "fresh" and can continue without being closed
      * too early. */
     base_conn->timestamp_created = now;
-    base_conn->timestamp_lastread = now;
+    base_conn->timestamp_last_read_allowed = now;
-    base_conn->timestamp_lastwritten = now;
+    base_conn->timestamp_last_write_allowed = now;
     /* Change connection's state into waiting for a circuit. */
     base_conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
 

src/or/main.c

@@ -1008,7 +1008,8 @@ conn_close_if_marked(int i)
         LOG_FN_CONN(conn, (LOG_INFO,LD_NET,
                            "Holding conn (fd %d) open for more flushing.",
                            (int)conn->s));
-        conn->timestamp_lastwritten = now; /* reset so we can flush more */
+        conn->timestamp_last_write_allowed = now; /* reset so we can flush
+                                                   * more */
       } else if (sz == 0) {
         /* Also, retval==0.  If we get here, we didn't want to write anything
          * (because of rate-limiting) and we didn't. */
@@ -1159,7 +1160,7 @@ run_connection_housekeeping(int i, time_t now)
   channel_t *chan = NULL;
   int have_any_circuits;
   int past_keepalive =
-    now >= conn->timestamp_lastwritten + options->KeepalivePeriod;
+    now >= conn->timestamp_last_write_allowed + options->KeepalivePeriod;
 
   if (conn->outbuf && !connection_get_outbuf_len(conn) &&
       conn->type == CONN_TYPE_OR)
@@ -1174,10 +1175,10 @@ run_connection_housekeeping(int i, time_t now)
    * if a server or received if a client) for 5 min */
   if (conn->type == CONN_TYPE_DIR &&
       ((DIR_CONN_IS_SERVER(conn) &&
-        conn->timestamp_lastwritten
+        conn->timestamp_last_write_allowed
             + options->TestingDirConnectionMaxStall < now) ||
        (!DIR_CONN_IS_SERVER(conn) &&
-        conn->timestamp_lastread
+        conn->timestamp_last_read_allowed
             + options->TestingDirConnectionMaxStall < now))) {
     log_info(LD_DIR,"Expiring wedged directory conn (fd %d, purpose %d)",
              (int)conn->s, conn->purpose);
@@ -1253,13 +1254,14 @@ run_connection_housekeeping(int i, time_t now)
     connection_or_close_normally(TO_OR_CONN(conn), 0);
   } else if (
       now >= or_conn->timestamp_lastempty + options->KeepalivePeriod*10 &&
-      now >= conn->timestamp_lastwritten + options->KeepalivePeriod*10) {
+      now >=
+          conn->timestamp_last_write_allowed + options->KeepalivePeriod*10) {
     log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,
            "Expiring stuck OR connection to fd %d (%s:%d). (%d bytes to "
            "flush; %d seconds since last write)",
            (int)conn->s, conn->address, conn->port,
            (int)connection_get_outbuf_len(conn),
-           (int)(now-conn->timestamp_lastwritten));
+           (int)(now-conn->timestamp_last_write_allowed));
     connection_or_close_normally(TO_OR_CONN(conn), 0);
   } else if (past_keepalive && !connection_get_outbuf_len(conn)) {
     /* send a padding cell */
@@ -3047,13 +3049,13 @@ dumpstats(int severity)
           i,
           (int)connection_get_inbuf_len(conn),
           (int)buf_allocation(conn->inbuf),
-          (int)(now - conn->timestamp_lastread));
+          (int)(now - conn->timestamp_last_read_allowed));
       tor_log(severity,LD_GENERAL,
           "Conn %d: %d bytes waiting on outbuf "
           "(len %d, last written %d secs ago)",i,
           (int)connection_get_outbuf_len(conn),
           (int)buf_allocation(conn->outbuf),
-          (int)(now - conn->timestamp_lastwritten));
+          (int)(now - conn->timestamp_last_write_allowed));
       if (conn->type == CONN_TYPE_OR) {
         or_connection_t *or_conn = TO_OR_CONN(conn);
         if (or_conn->tls) {

src/or/or.h

@@ -1361,10 +1361,10 @@ typedef struct connection_t {
                          * connection. */
   size_t outbuf_flushlen; /**< How much data should we try to flush from the
                            * outbuf? */
-  time_t timestamp_lastread; /**< When was the last time libevent said we could
+  time_t timestamp_last_read_allowed; /**< When was the last time libevent said
-                              * read? */
+                                       * we could read? */
-  time_t timestamp_lastwritten; /**< When was the last time libevent said we
+  time_t timestamp_last_write_allowed; /**< When was the last time libevent
-                                 * could write? */
+                                        * said we could write? */
 
   time_t timestamp_created; /**< When was this connection_t created? */
 

src/or/relay.c

@@ -1449,7 +1449,7 @@ connection_edge_process_relay_cell_not_open(
              "after %d seconds.",
              (unsigned)circ->n_circ_id,
              rh->stream_id,
-             (int)(time(NULL) - conn->base_.timestamp_lastread));
+             (int)(time(NULL) - conn->base_.timestamp_last_read_allowed));
     if (connected_cell_parse(rh, cell, &addr, &ttl) < 0) {
       log_fn(LOG_PROTOCOL_WARN, LD_APP,
              "Got a badly formatted connected cell. Closing.");

src/or/rendclient.c

@@ -915,8 +915,8 @@ rend_client_desc_trynow(const char *query)
       /* restart their timeout values, so they get a fair shake at
        * connecting to the hidden service. */
       base_conn->timestamp_created = now;
-      base_conn->timestamp_lastread = now;
+      base_conn->timestamp_last_read_allowed = now;
-      base_conn->timestamp_lastwritten = now;
+      base_conn->timestamp_last_write_allowed = now;
 
       connection_ap_mark_as_pending_circuit(conn);
     } else { /* 404, or fetch didn't get that far */