Use path type hint for Vegas queue parameters.

These parameters will vary depending on path length, especially for onions.

10 files changed, 174 insertions, 26 deletions

diff --git a/src/app/config/config.c b/src/app/config/config.c
index 05bd96fc6a..15addd5be4 100644
--- a/src/app/config/config.c
+++ b/src/app/config/config.c
@@ -676,6 +676,7 @@ static const config_var_t option_vars_[] = {
   V(UseMicrodescriptors,         AUTOBOOL, "auto"),
   OBSOLETE("UseNTorHandshake"),
   VAR("__AlwaysCongestionControl",  BOOL, AlwaysCongestionControl, "0"),
+  VAR("__SbwsExit",  BOOL, SbwsExit, "0"),
   V_IMMUTABLE(User,              STRING,   NULL),
   OBSOLETE("UserspaceIOCPBuffers"),
   OBSOLETE("V1AuthoritativeDirectory"),
diff --git a/src/app/config/or_options_st.h b/src/app/config/or_options_st.h
index a1ef7a8cf8..290a2bb9b4 100644
--- a/src/app/config/or_options_st.h
+++ b/src/app/config/or_options_st.h
@@ -604,6 +604,9 @@ struct or_options_t {
   /** Boolean: Switch to override consensus to enable congestion control */
   int AlwaysCongestionControl;
 
+  /** Boolean: Switch to specify this is an sbws measurement exit */
+  int SbwsExit;
+
   int RephistTrackTime; /**< How many seconds do we keep rephist info? */
   /** Should we always fetch our dir info on the mirror schedule (which
    * means directly from the authorities) no matter our other config? */
diff --git a/src/core/mainloop/cpuworker.c b/src/core/mainloop/cpuworker.c
index 2cb667615d..ab970259b5 100644
--- a/src/core/mainloop/cpuworker.c
+++ b/src/core/mainloop/cpuworker.c
@@ -391,7 +391,13 @@ cpuworker_onion_handshake_replyfn(void *work_)
   /* If the client asked for congestion control, if our consensus parameter
    * allowed it to negotiate as enabled, allocate a congestion control obj. */
   if (rpl.circ_params.cc_enabled) {
-    TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params);
+    if (get_options()->SbwsExit) {
+      TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params,
+                                                          CC_PATH_SBWS);
+    } else {
+      TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params,
+                                                          CC_PATH_EXIT);
+    }
   }
 
   if (onionskin_answer(circ,
diff --git a/src/core/or/circuitbuild.c b/src/core/or/circuitbuild.c
index 2326dc2a6d..f62a1d93f5 100644
--- a/src/core/or/circuitbuild.c
+++ b/src/core/or/circuitbuild.c
@@ -1275,7 +1275,21 @@ circuit_finish_handshake(origin_circuit_t *circ,
   }
 
   if (params.cc_enabled) {
-    hop->ccontrol = congestion_control_new(&params);
+    int circ_len = circuit_get_cpath_len(circ);
+
+    if (circ_len == DEFAULT_ROUTE_LEN &&
+        circuit_get_cpath_hop(circ, DEFAULT_ROUTE_LEN) == hop) {
+      hop->ccontrol = congestion_control_new(&params, CC_PATH_EXIT);
+    } else if (circ_len == SBWS_ROUTE_LEN &&
+               circuit_get_cpath_hop(circ, SBWS_ROUTE_LEN) == hop) {
+      hop->ccontrol = congestion_control_new(&params, CC_PATH_SBWS);
+    } else {
+      static ratelim_t cc_path_limit = RATELIM_INIT(600);
+      log_fn_ratelim(&cc_path_limit, LOG_WARN, LD_CIRC,
+                     "Unexpected path length %d for circuit",
+                     circ_len);
+      hop->ccontrol = congestion_control_new(&params, CC_PATH_EXIT);
+    }
   }
 
   hop->state = CPATH_STATE_OPEN;
diff --git a/src/core/or/congestion_control_common.c b/src/core/or/congestion_control_common.c
index 09c6c04bf3..e316b631d1 100644
--- a/src/core/or/congestion_control_common.c
+++ b/src/core/or/congestion_control_common.c
@@ -168,7 +168,8 @@ congestion_control_new_consensus_params(const networkstatus_t *ns)
  */
 static void
 congestion_control_init_params(congestion_control_t *cc,
-                               const circuit_params_t *params)
+                               const circuit_params_t *params,
+                               cc_path_t path)
 {
   const or_options_t *opts = get_options();
   cc->sendme_inc = params->sendme_inc_cells;
@@ -266,7 +267,7 @@ congestion_control_init_params(congestion_control_t *cc,
   if (cc->cc_alg == CC_ALG_WESTWOOD) {
     congestion_control_westwood_set_params(cc);
   } else if (cc->cc_alg == CC_ALG_VEGAS) {
-    congestion_control_vegas_set_params(cc);
+    congestion_control_vegas_set_params(cc, path);
   } else if (cc->cc_alg == CC_ALG_NOLA) {
     congestion_control_nola_set_params(cc);
   }
@@ -326,24 +327,25 @@ congestion_control_set_cc_enabled(void)
  */
 static void
 congestion_control_init(congestion_control_t *cc,
-                        const circuit_params_t *params)
+                        const circuit_params_t *params,
+                        cc_path_t path)
 {
   cc->sendme_pending_timestamps = smartlist_new();
   cc->sendme_arrival_timestamps = smartlist_new();
 
   cc->in_slow_start = 1;
-  congestion_control_init_params(cc, params);
+  congestion_control_init_params(cc, params, path);
 
   cc->next_cc_event = CWND_UPDATE_RATE(cc);
 }
 
 /** Allocate and initialize a new congestion control object */
 congestion_control_t *
-congestion_control_new(const circuit_params_t *params)
+congestion_control_new(const circuit_params_t *params, cc_path_t path)
 {
   congestion_control_t *cc = tor_malloc_zero(sizeof(congestion_control_t));
 
-  congestion_control_init(cc, params);
+  congestion_control_init(cc, params, path);
 
   return cc;
 }
diff --git a/src/core/or/congestion_control_common.h b/src/core/or/congestion_control_common.h
index 1e5a00c942..1a57d71331 100644
--- a/src/core/or/congestion_control_common.h
+++ b/src/core/or/congestion_control_common.h
@@ -19,6 +19,21 @@
 
 typedef struct congestion_control_t congestion_control_t;
 
+/**
+ * Specifies the path type to help choose congestion control
+ * parameters. Since these paths are different lengths, they
+ * will need different queue parameters. */
+typedef enum {
+  CC_PATH_EXIT = 0,
+  CC_PATH_ONION = 1,
+  CC_PATH_ONION_SOS = 2,
+  CC_PATH_ONION_VG = 3,
+  CC_PATH_SBWS = 4,
+} cc_path_t;
+
+/** The length of a path for sbws measurement */
+#define SBWS_ROUTE_LEN 2
+
 /** Wrapper for the free function, set the CC pointer to NULL after free */
 #define congestion_control_free(cc) \
     FREE_AND_NULL(congestion_control_t, congestion_control_free_, cc)
@@ -27,7 +42,8 @@ void congestion_control_free_(congestion_control_t *cc);
 
 struct circuit_params_t;
 congestion_control_t *congestion_control_new(
-                                    const struct circuit_params_t *params);
+                                    const struct circuit_params_t *params,
+                                    cc_path_t path);
 
 int congestion_control_dispatch_cc_alg(congestion_control_t *cc,
                                        const circuit_t *circ,
diff --git a/src/core/or/congestion_control_vegas.c b/src/core/or/congestion_control_vegas.c
index 8e13499aff..e7ed838478 100644
--- a/src/core/or/congestion_control_vegas.c
+++ b/src/core/or/congestion_control_vegas.c
@@ -25,9 +25,31 @@
 
 #define OUTBUF_CELLS (2*TLS_RECORD_MAX_CELLS)
 
-#define VEGAS_ALPHA(cc)   (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
-#define VEGAS_BETA(cc)    (3*OUTBUF_CELLS)
-#define VEGAS_GAMMA(cc)   (3*OUTBUF_CELLS)
+/* sbws circs are two hops, so params are based on 2 outbufs of cells */
+#define VEGAS_ALPHA_SBWS_DFLT (2*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
+#define VEGAS_BETA_SBWS_DFLT (2*OUTBUF_CELLS)
+#define VEGAS_GAMMA_SBWS_DFLT (2*OUTBUF_CELLS)
+
+/* Exits are three hops, so params are based on 3 outbufs of cells */
+#define VEGAS_ALPHA_EXIT_DFLT (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
+#define VEGAS_BETA_EXIT_DFLT (3*OUTBUF_CELLS)
+#define VEGAS_GAMMA_EXIT_DFLT (3*OUTBUF_CELLS)
+
+/* Onion rends are six hops, so params are based on 6 outbufs of cells */
+#define VEGAS_ALPHA_ONION_DFLT (6*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
+#define VEGAS_BETA_ONION_DFLT (6*OUTBUF_CELLS)
+#define VEGAS_GAMMA_ONION_DFLT (6*OUTBUF_CELLS)
+
+/* Single Onions are three hops, so params are based on 3 outbufs of cells */
+#define VEGAS_ALPHA_SOS_DFLT (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
+#define VEGAS_BETA_SOS_DFLT (3*OUTBUF_CELLS)
+#define VEGAS_GAMMA_SOS_DFLT (3*OUTBUF_CELLS)
+
+/* Vanguard Onions are 7 hops (or 8 if both sides use vanguards, but that
+ * should be rare), so params are based on 7 outbufs of cells */
+#define VEGAS_ALPHA_VG_DFLT (7*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS)
+#define VEGAS_BETA_VG_DFLT (7*OUTBUF_CELLS)
+#define VEGAS_GAMMA_VG_DFLT (7*OUTBUF_CELLS)
 
 #define VEGAS_BDP_MIX_PCT       100
 
@@ -54,25 +76,74 @@ vegas_bdp_mix(const congestion_control_t *cc)
  * Cache Vegas consensus parameters.
  */
 void
-congestion_control_vegas_set_params(congestion_control_t *cc)
+congestion_control_vegas_set_params(congestion_control_t *cc,
+                                    cc_path_t path)
 {
   tor_assert(cc->cc_alg == CC_ALG_VEGAS);
+  const char *alpha_str = NULL, *beta_str = NULL, *gamma_str = NULL;
+  int alpha, beta, gamma;
 
-  cc->vegas_params.gamma =
-   networkstatus_get_param(NULL, "cc_vegas_gamma",
-      VEGAS_GAMMA(cc),
-      0,
-      1000);
+  switch (path) {
+    case CC_PATH_SBWS:
+      alpha_str = "cc_vegas_alpha_sbws";
+      beta_str = "cc_vegas_beta_sbws";
+      gamma_str = "cc_vegas_gamma_sbws";
+      alpha = VEGAS_ALPHA_SBWS_DFLT;
+      beta = VEGAS_BETA_SBWS_DFLT;
+      gamma = VEGAS_GAMMA_SBWS_DFLT;
+      break;
+    case CC_PATH_EXIT:
+      alpha_str = "cc_vegas_alpha_exit";
+      beta_str = "cc_vegas_beta_exit";
+      gamma_str = "cc_vegas_gamma_exit";
+      alpha = VEGAS_ALPHA_EXIT_DFLT;
+      beta = VEGAS_BETA_EXIT_DFLT;
+      gamma = VEGAS_GAMMA_EXIT_DFLT;
+      break;
+    case CC_PATH_ONION:
+      alpha_str = "cc_vegas_alpha_onion";
+      beta_str = "cc_vegas_beta_onion";
+      gamma_str = "cc_vegas_gamma_onion";
+      alpha = VEGAS_ALPHA_ONION_DFLT;
+      beta = VEGAS_BETA_ONION_DFLT;
+      gamma = VEGAS_GAMMA_ONION_DFLT;
+      break;
+    case CC_PATH_ONION_SOS:
+      alpha_str = "cc_vegas_alpha_sos";
+      beta_str = "cc_vegas_beta_sos";
+      gamma_str = "cc_vegas_gamma_sos";
+      alpha = VEGAS_ALPHA_SOS_DFLT;
+      beta = VEGAS_BETA_SOS_DFLT;
+      gamma = VEGAS_GAMMA_SOS_DFLT;
+      break;
+    case CC_PATH_ONION_VG:
+      alpha_str = "cc_vegas_alpha_vg";
+      beta_str = "cc_vegas_beta_vg";
+      gamma_str = "cc_vegas_gamma_vg";
+      alpha = VEGAS_ALPHA_VG_DFLT;
+      beta = VEGAS_BETA_VG_DFLT;
+      gamma = VEGAS_GAMMA_VG_DFLT;
+      break;
+    default:
+      tor_assert(0);
+      break;
+  }
 
   cc->vegas_params.alpha =
-   networkstatus_get_param(NULL, "cc_vegas_alpha",
-      VEGAS_ALPHA(cc),
+   networkstatus_get_param(NULL, alpha_str,
+      alpha,
       0,
       1000);
 
   cc->vegas_params.beta =
-   networkstatus_get_param(NULL, "cc_vegas_beta",
-      VEGAS_BETA(cc),
+   networkstatus_get_param(NULL, beta_str,
+      beta,
+      0,
+      1000);
+
+  cc->vegas_params.gamma =
+   networkstatus_get_param(NULL, gamma_str,
+      gamma,
       0,
       1000);
 
diff --git a/src/core/or/congestion_control_vegas.h b/src/core/or/congestion_control_vegas.h
index 111345081c..95fcea5722 100644
--- a/src/core/or/congestion_control_vegas.h
+++ b/src/core/or/congestion_control_vegas.h
@@ -16,7 +16,8 @@
 int congestion_control_vegas_process_sendme(struct congestion_control_t *cc,
                                             const circuit_t *circ,
                                             const crypt_path_t *layer_hint);
-void congestion_control_vegas_set_params(struct congestion_control_t *cc);
+void congestion_control_vegas_set_params(struct congestion_control_t *cc,
+                                         cc_path_t path);
 
 /* Private section starts. */
 #ifdef TOR_CONGESTION_CONTROL_VEGAS_PRIVATE
diff --git a/src/feature/hs/hs_circuit.c b/src/feature/hs/hs_circuit.c
index f2953cfb02..271bf652e7 100644
--- a/src/feature/hs/hs_circuit.c
+++ b/src/feature/hs/hs_circuit.c
@@ -415,7 +415,20 @@ launch_rendezvous_point_circuit,(const hs_service_t *service,
       .cc_enabled = data->cc_enabled,
       .sendme_inc_cells = congestion_control_sendme_inc(),
     };
-    TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params);
+
+    /* Initialize ccontrol for appropriate path type */
+    if (service->config.is_single_onion) {
+      TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                          CC_PATH_ONION_SOS);
+    } else {
+      if (get_options()->HSLayer3Nodes) {
+        TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                            CC_PATH_ONION_VG);
+      } else {
+        TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                            CC_PATH_ONION);
+      }
+    }
   }
 
  end:
@@ -519,7 +532,16 @@ retry_service_rendezvous_point(const origin_circuit_t *circ)
       .cc_enabled = 1,
       .sendme_inc_cells = TO_CIRCUIT(circ)->ccontrol->sendme_inc,
     };
-    TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params);
+
+    /* As per above, in this case, we are a full 3 hop rend, even if we're a
+     * single-onion service */
+    if (get_options()->HSLayer3Nodes) {
+      TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params,
+                                        CC_PATH_ONION_VG);
+    } else {
+      TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params,
+                                        CC_PATH_ONION_SOS);
+    }
   }
 
  done:
diff --git a/src/feature/hs/hs_client.c b/src/feature/hs/hs_client.c
index 69b071e197..81c0459a86 100644
--- a/src/feature/hs/hs_client.c
+++ b/src/feature/hs/hs_client.c
@@ -788,7 +788,19 @@ setup_rendezvous_circ_congestion_control(origin_circuit_t *circ)
   circ_params.cc_enabled = congestion_control_enabled();
   if (circ_params.cc_enabled) {
     circ_params.sendme_inc_cells = desc->encrypted_data.sendme_inc;
-    TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params);
+
+    if (desc->encrypted_data.single_onion_service) {
+      TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                          CC_PATH_ONION_SOS);
+    } else {
+      if (get_options()->HSLayer3Nodes) {
+        TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                            CC_PATH_ONION_VG);
+      } else {
+        TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params,
+                                                            CC_PATH_ONION);
+      }
+    }
   }
 }