Merge branch 'maint-0.2.9'

3 files changed, 30 insertions, 12 deletions

diff --git a/src/or/directory.c b/src/or/directory.c
index ba6d38c426..8c7953020d 100644
--- a/src/or/directory.c
+++ b/src/or/directory.c
@@ -3971,7 +3971,10 @@ find_dl_min_and_max_delay(download_status_t *dls, const or_options_t *options,
   const smartlist_t *schedule = find_dl_schedule(dls, options);
   tor_assert(schedule != NULL && smartlist_len(schedule) >= 2);
   *min = *((int *)(smartlist_get(schedule, 0)));
-  *max = *((int *)((smartlist_get(schedule, smartlist_len(schedule) - 1))));
+  if (dls->backoff == DL_SCHED_DETERMINISTIC)
+    *max = *((int *)((smartlist_get(schedule, smartlist_len(schedule) - 1))));
+  else
+    *max = INT_MAX;
 }
 
 /** Advance one delay step.  The algorithm is to use the previous delay to
@@ -4077,9 +4080,9 @@ download_status_schedule_get_delay(download_status_t *dls,
    * non-negative allows us to safely do the wrapping check below. */
   tor_assert(delay >= 0);
 
-  /* Avoid now+delay overflowing INT_MAX, by comparing with a subtraction
+  /* Avoid now+delay overflowing TIME_MAX, by comparing with a subtraction
    * that won't overflow (since delay is non-negative). */
-  if (delay < INT_MAX && now <= INT_MAX - delay) {
+  if (delay < INT_MAX && now <= TIME_MAX - delay) {
     dls->next_attempt_at = now+delay;
   } else {
     dls->next_attempt_at = TIME_MAX;
@@ -4192,7 +4195,7 @@ download_status_increment_attempt(download_status_t *dls, const char *item,
   if (dls->increment_on == DL_SCHED_INCREMENT_FAILURE) {
     /* this schedule should retry on failure, and not launch any concurrent
      attempts */
-    log_info(LD_BUG, "Tried to launch an attempt-based connection on a "
+    log_warn(LD_BUG, "Tried to launch an attempt-based connection on a "
              "failure-based schedule.");
     return TIME_MAX;
   }
diff --git a/src/or/directory.h b/src/or/directory.h
index acb7394136..589df7b70d 100644
--- a/src/or/directory.h
+++ b/src/or/directory.h
@@ -114,9 +114,15 @@ static inline int
 download_status_is_ready(download_status_t *dls, time_t now,
                          int max_failures)
 {
-  int under_failure_limit = (dls->n_download_failures <= max_failures
-                             && dls->n_download_attempts <= max_failures);
-  return (under_failure_limit && dls->next_attempt_at <= now);
+  if (dls->backoff == DL_SCHED_DETERMINISTIC) {
+    /* Deterministic schedules can hit an endpoint; exponential backoff
+     * schedules just wait longer and longer. */
+    int under_failure_limit = (dls->n_download_failures <= max_failures
+                               && dls->n_download_attempts <= max_failures);
+    if (!under_failure_limit)
+      return 0;
+  }
+  return dls->next_attempt_at <= now;
 }
 
 static void download_status_mark_impossible(download_status_t *dl);
diff --git a/src/or/networkstatus.c b/src/or/networkstatus.c
index ed888fb53e..316ce48387 100644
--- a/src/or/networkstatus.c
+++ b/src/or/networkstatus.c
@@ -841,9 +841,15 @@ we_want_to_fetch_flavor(const or_options_t *options, int flavor)
  * fetching certs before we check whether there is a better one? */
 #define DELAY_WHILE_FETCHING_CERTS (20*60)
 
+/** What is the minimum time we need to have waited fetching certs, before we
+ * increment the consensus download schedule on failure? */
+#define MIN_DELAY_FOR_FETCH_CERT_STATUS_FAILURE (1*60)
+
 /* Check if a downloaded consensus flavor should still wait for certificates
- * to download now.
- * If so, return 1. If not, fail dls and return 0. */
+ * to download now. If we decide not to wait, check if enough time has passed
+ * to consider the certificate download failure a separate failure. If so,
+ * fail dls.
+ * If waiting for certificates to download, return 1. If not, return 0. */
 static int
 check_consensus_waiting_for_certs(int flavor, time_t now,
                                   download_status_t *dls)
@@ -857,11 +863,14 @@ check_consensus_waiting_for_certs(int flavor, time_t now,
   waiting = &consensus_waiting_for_certs[flavor];
   if (waiting->consensus) {
     /* XXXX make sure this doesn't delay sane downloads. */
-    if (waiting->set_at + DELAY_WHILE_FETCHING_CERTS > now) {
+    if (waiting->set_at + DELAY_WHILE_FETCHING_CERTS > now &&
+        waiting->consensus->valid_until > now) {
       return 1;
     } else {
       if (!waiting->dl_failed) {
-        download_status_failed(dls, 0);
+        if (waiting->set_at + MIN_DELAY_FOR_FETCH_CERT_STATUS_FAILURE > now) {
+          download_status_failed(dls, 0);
+        }
         waiting->dl_failed=1;
       }
     }
@@ -906,7 +915,7 @@ update_consensus_networkstatus_downloads(time_t now)
     resource = networkstatus_get_flavor_name(i);
 
     /* Check if we already have enough connections in progress */
-    if (we_are_bootstrapping) {
+    if (we_are_bootstrapping && use_multi_conn) {
       max_in_progress_conns =
         options->ClientBootstrapConsensusMaxInProgressTries;
     }