Use multipath backup, not standby

Author: huitema

UnitTest1/unittest1.cpp

@@ -2841,8 +2841,8 @@ namespace UnitTest1
             Assert::AreEqual(ret, 0);
         }
 
-        TEST_METHOD(multipath_standby) {
-            int ret = multipath_standby_test();
+        TEST_METHOD(multipath_backup) {
+            int ret = multipath_backup_test();
 
             Assert::AreEqual(ret, 0);
         }

picoquic/frames.c

@@ -5508,9 +5508,9 @@ int picoquic_queue_path_abandon_frame(picoquic_cnx_t* cnx,
     return ret;
 }
 
-/* Multipath PATH STANDBY and AVAILABLE frames
+/* Multipath PATH BACKUP and AVAILABLE frames
 */
-uint8_t* picoquic_format_path_available_or_standby_frame(
+uint8_t* picoquic_format_path_available_or_backup_frame(
     uint8_t* bytes, const uint8_t* bytes_max, uint64_t frame_type,
     uint64_t path_id, uint64_t sequence, int* more_data)
 {
@@ -5525,7 +5525,7 @@ uint8_t* picoquic_format_path_available_or_standby_frame(
     return bytes;
 }
 
-int picoquic_queue_path_available_or_standby_frame(
+int picoquic_queue_path_available_or_backup_frame(
     picoquic_cnx_t * cnx, picoquic_path_t * path_x, picoquic_path_status_enum status)
 {
     int ret = 0;
@@ -5544,7 +5544,7 @@ int picoquic_queue_path_available_or_standby_frame(
             path_x->p_remote_cnxid->sequence;
         int is_pure_ack = 0;
         int more_data = 0;
-        uint8_t* bytes_next = picoquic_format_path_available_or_standby_frame(
+        uint8_t* bytes_next = picoquic_format_path_available_or_backup_frame(
             frame_buffer, frame_buffer + sizeof(frame_buffer), frame_type, path_id, sequence, &more_data);
         size_t consumed = bytes_next - frame_buffer;
         ret = picoquic_queue_misc_frame(cnx, frame_buffer, consumed, is_pure_ack,
@@ -5557,7 +5557,7 @@ int picoquic_queue_path_available_or_standby_frame(
     return ret;
 }
 
-const uint8_t* picoquic_skip_path_available_or_standby_frame(const uint8_t* bytes, const uint8_t* bytes_max)
+const uint8_t* picoquic_skip_path_available_or_backup_frame(const uint8_t* bytes, const uint8_t* bytes_max)
 {
     /* This code assumes that the frame type is already skipped */
     if ((bytes = picoquic_frames_varint_skip(bytes, bytes_max)) != NULL){
@@ -5566,7 +5566,7 @@ const uint8_t* picoquic_skip_path_available_or_standby_frame(const uint8_t* byte
     return bytes;
 }
 
-const uint8_t* picoquic_parse_path_available_or_standby_frame(const uint8_t* bytes, const uint8_t* bytes_max,
+const uint8_t* picoquic_parse_path_available_or_backup_frame(const uint8_t* bytes, const uint8_t* bytes_max,
     uint64_t* path_id, uint64_t* sequence)
 {
     if ((bytes = picoquic_frames_varint_decode(bytes, bytes_max, path_id)) != NULL){
@@ -5575,7 +5575,7 @@ const uint8_t* picoquic_parse_path_available_or_standby_frame(const uint8_t* byt
     return bytes;
 }
 
-const uint8_t* picoquic_decode_path_available_or_standby_frame(const uint8_t* bytes, const uint8_t* bytes_max,
+const uint8_t* picoquic_decode_path_available_or_backup_frame(const uint8_t* bytes, const uint8_t* bytes_max,
     uint64_t frame_id64, picoquic_cnx_t* cnx, uint64_t current_time)
 {
     uint64_t path_id;
@@ -5588,7 +5588,7 @@ const uint8_t* picoquic_decode_path_available_or_standby_frame(const uint8_t* by
         picoquic_connection_error_ex(cnx, PICOQUIC_TRANSPORT_FRAME_FORMAT_ERROR,
             frame_id64, "multipath not negotiated");
     }
-    else if ((bytes = picoquic_parse_path_available_or_standby_frame(bytes, bytes_max, &path_id, &sequence)) == NULL) {
+    else if ((bytes = picoquic_parse_path_available_or_backup_frame(bytes, bytes_max, &path_id, &sequence)) == NULL) {
         /* Bad frame encoding */
         picoquic_connection_error_ex(cnx, PICOQUIC_TRANSPORT_FRAME_FORMAT_ERROR,
             frame_id64, "bad status frame");
@@ -5599,18 +5599,18 @@ const uint8_t* picoquic_decode_path_available_or_standby_frame(const uint8_t* by
         if (path_number < 0) {
             /* Invalid path ID. Just ignore this frame. Add line in log for debug */
             picoquic_log_app_message(cnx, "Ignore path %s frame with invalid ID: %" PRIu64,
-                (frame_id64 == picoquic_frame_type_path_available)?"available":"standby", path_id);
+                (frame_id64 == picoquic_frame_type_path_available)?"available":"backup", path_id);
         }
         else {
             if (cnx->path[path_number]->status_sequence_to_receive_next > sequence) {
                 /* Old frame, ignore. */
             }
             else {
-                /* Status will be set to 1 for standby, 2 for available.
-                 * Default status is 0?
+                /* Status will be set to 1 for backup, 0 for available.
+                 * Default status is 0.
                  */
                 cnx->path[path_number]->status_sequence_to_receive_next = sequence + 1;
-                cnx->path[path_number]->path_is_standby = (frame_id64 == picoquic_frame_type_path_available) ? 0:1;
+                cnx->path[path_number]->path_is_backup = (frame_id64 == picoquic_frame_type_path_available) ? 0:1;
             }
         }
     }
@@ -5626,7 +5626,7 @@ int picoquic_path_available_or_backup_frame_need_repeat(picoquic_cnx_t* cnx, con
 
     *no_need_to_repeat = 0;
 
-    if ((bytes = picoquic_parse_path_available_or_standby_frame(bytes, bytes_max, &path_id, &sequence)) == NULL){
+    if ((bytes = picoquic_parse_path_available_or_backup_frame(bytes, bytes_max, &path_id, &sequence)) == NULL){
         /* Malformed frame, do not retransmit */
         *no_need_to_repeat = 1;
     }
@@ -6541,7 +6541,7 @@ int picoquic_decode_frames(picoquic_cnx_t* cnx, picoquic_path_t * path_x, const
                             break;
                         case picoquic_frame_type_path_backup:
                         case picoquic_frame_type_path_available:
-                            bytes = picoquic_decode_path_available_or_standby_frame(bytes, bytes_max, frame_id64, cnx, current_time);
+                            bytes = picoquic_decode_path_available_or_backup_frame(bytes, bytes_max, frame_id64, cnx, current_time);
                             ack_needed = 1;
                             break;
                         case picoquic_frame_type_max_path_id:
@@ -6889,7 +6889,7 @@ int picoquic_skip_frame(const uint8_t* bytes, size_t bytes_maxsize, size_t* cons
                     break;
                 case picoquic_frame_type_path_backup:
                 case picoquic_frame_type_path_available:
-                    bytes = picoquic_skip_path_available_or_standby_frame(bytes, bytes_max);
+                    bytes = picoquic_skip_path_available_or_backup_frame(bytes, bytes_max);
                     *pure_ack = 0;
                     break;
                 case picoquic_frame_type_max_path_id:

picoquic/logger.c

@@ -1398,7 +1398,7 @@ size_t textlog_path_abandon_frame(FILE* F, const uint8_t* bytes, size_t bytes_ma
     return byte_index;
 }
 
-size_t textlog_path_available_or_standby_frame(FILE* F, const uint8_t* bytes, size_t bytes_max)
+size_t textlog_path_available_or_backup_frame(FILE* F, const uint8_t* bytes, size_t bytes_max)
 {
     const uint8_t* bytes_end = bytes + bytes_max;
     const uint8_t* bytes0 = bytes;
@@ -1755,7 +1755,7 @@ void picoquic_textlog_frames(FILE* F, uint64_t cnx_id64, const uint8_t* bytes, s
             break;
         case picoquic_frame_type_path_backup:
         case picoquic_frame_type_path_available:
-            byte_index += textlog_path_available_or_standby_frame(F, bytes + byte_index, length - byte_index);
+            byte_index += textlog_path_available_or_backup_frame(F, bytes + byte_index, length - byte_index);
             break;
         case picoquic_frame_type_max_path_id:
             byte_index += textlog_max_path_id_frame(F, bytes + byte_index, length - byte_index);

picoquic/logwriter.c

@@ -443,7 +443,7 @@ static const uint8_t* picoquic_log_path_available_or_backup_frame(FILE* f, const
 {
     const uint8_t* bytes_begin = bytes;
     bytes = picoquic_log_varint_skip(bytes, bytes_max); /* frame type as varint */
-    bytes = picoquic_skip_path_available_or_standby_frame(bytes, bytes_max); /* skip available or standby frame */
+    bytes = picoquic_skip_path_available_or_backup_frame(bytes, bytes_max); /* skip available or backup frame */
     picoquic_binlog_frame(f, bytes_begin, bytes);
 
     return bytes;

picoquic/picoquic.h

@@ -229,7 +229,7 @@ typedef enum {
 
 typedef enum {
     picoquic_path_status_available = 0, /* Path available for sending */
-    picoquic_path_status_standby = 1 /* Do not use if other path available */
+    picoquic_path_status_backup = 1 /* Do not use if other path available */
 } picoquic_path_status_enum;
 
 /*

picoquic/picoquic_internal.h

@@ -1094,7 +1094,7 @@ typedef struct st_picoquic_path_t {
     unsigned int challenge_failed : 1;
     unsigned int response_required : 1;
     unsigned int nat_challenge_required : 1;
-    unsigned int path_is_standby : 1;
+    unsigned int path_is_backup : 1;
     unsigned int path_is_demoted : 1;
     unsigned int path_abandon_received : 1;
     unsigned int path_abandon_sent : 1;
@@ -2042,8 +2042,8 @@ void picoquic_update_peer_addr(picoquic_path_t* path_x, const struct sockaddr* p
 
 int picoquic_skip_frame(const uint8_t* bytes, size_t bytes_max, size_t* consumed, int* pure_ack);
 const uint8_t* picoquic_skip_path_abandon_frame(const uint8_t* bytes, const uint8_t* bytes_max);
-const uint8_t* picoquic_skip_path_available_or_standby_frame(const uint8_t* bytes, const uint8_t* bytes_max);
-int picoquic_queue_path_available_or_standby_frame(
+const uint8_t* picoquic_skip_path_available_or_backup_frame(const uint8_t* bytes, const uint8_t* bytes_max);
+int picoquic_queue_path_available_or_backup_frame(
     picoquic_cnx_t* cnx, picoquic_path_t* path_x, picoquic_path_status_enum status);
 /* Internal only API, notify that next path is now allowed. */
 void picoquic_test_and_signal_new_path_allowed(picoquic_cnx_t* cnx);

picoquic/quicctx.c

@@ -1816,7 +1816,7 @@ void picoquic_delete_abandoned_paths(picoquic_cnx_t* cnx, uint64_t current_time,
             if (cnx->path[i]->path_is_demoted) {
                 continue;
             }
-            if (cnx->path[i]->path_is_standby && path_backup < 0) {
+            if (cnx->path[i]->path_is_backup && path_backup < 0) {
                 path_backup = i;
             }
             else {
@@ -1825,8 +1825,8 @@ void picoquic_delete_abandoned_paths(picoquic_cnx_t* cnx, uint64_t current_time,
             }
         }
         if (path_left < 0 && path_backup >= 0) {
-            cnx->path[path_backup]->path_is_standby = 0;
-            (void)picoquic_queue_path_available_or_standby_frame(cnx, cnx->path[path_backup], picoquic_path_status_available);
+            cnx->path[path_backup]->path_is_backup = 0;
+            (void)picoquic_queue_path_available_or_backup_frame(cnx, cnx->path[path_backup], picoquic_path_status_available);
         }
     }
 }
@@ -2546,8 +2546,8 @@ int picoquic_set_path_status(picoquic_cnx_t* cnx, uint64_t unique_path_id, picoq
     int ret = 0;
     int path_id = picoquic_get_path_id_from_unique(cnx, unique_path_id);
     if (path_id >= 0) {
-        cnx->path[path_id]->path_is_standby = (status != picoquic_path_status_available);
-        ret = picoquic_queue_path_available_or_standby_frame(cnx, cnx->path[path_id], status);
+        cnx->path[path_id]->path_is_backup = (status != picoquic_path_status_available);
+        ret = picoquic_queue_path_available_or_backup_frame(cnx, cnx->path[path_id], status);
     }
     return ret;
 }

picoquic/sender.c

@@ -3954,7 +3954,7 @@ int picoquic_prepare_segment(picoquic_cnx_t* cnx, picoquic_path_t* path_x, picoq
  * criteria evolves over time:
  * - as long as continuity is not verified, a path is not available.
  * - if continuity is verified but the path is not "validated", the path
- *   is marked as standby.
+ *   is marked as backup.
  * - if the path is validated and no other path has a higher priority,
  *   the path is available.
  * If several paths are available at the same priority level, the code
@@ -3964,14 +3964,14 @@ int picoquic_prepare_segment(picoquic_cnx_t* cnx, picoquic_path_t* path_x, picoq
  *
  * There are potential corner cases. If a challenge or a response is required
  * on a path, that takes priority over sending data. A challenge may be required
- * on a "standby" path to test continuity if no data has been received for
+ * on a "backup" path to test continuity if no data has been received for
  * a long time, or maybe following a packet loss episode.
  *
  * If all available paths are blocked by congestion control and acknowledgements
  * need to be sent, the lowest RTT path not blocked by pacing is selected.
  *
  * Need to consider special code for dealing with packet losses. If a path
- * exhibits persistent packet loss, it loses its priority and moves to "standby"
+ * exhibits persistent packet loss, it loses its priority and moves to "backup"
  * state. At that point, the "challenge needed" flag is set, triggering a
  * continuity test.
  *
@@ -4006,8 +4006,8 @@ int picoquic_prepare_segment(picoquic_cnx_t* cnx, picoquic_path_t* path_x, picoq
  * Instead, these various interactions may need to be selective, mark some
  * paths as ready based on conditions.
  * 
- * The handling of "standby" should be integrated in the sending process,
- * so congestion controlled data is not sent on standby path, and delay
+ * The handling of "backup" should be integrated in the sending process,
+ * so congestion controlled data is not sent on backup path, and delay
  * sensitive data is not sent on suspect paths.
  */
 
@@ -4069,7 +4069,7 @@ static int picoquic_select_next_path_mp(picoquic_cnx_t* cnx, uint64_t current_ti
     }
 
     for (i = 0; i < cnx->nb_paths; i++) {
-        int path_priority = (cnx->path[i]->path_is_standby) ? 0 : 1;
+        int path_priority = (cnx->path[i]->path_is_backup) ? 0 : 1;
         cnx->path[i]->is_probing_nat = 0;
         if (cnx->path[i]->nb_retransmit > 0) {
             path_priority = 0;
@@ -4226,8 +4226,8 @@ static int picoquic_select_next_path_mp(picoquic_cnx_t* cnx, uint64_t current_ti
         }
         path_id = 0;
     }
-    if (cnx->path[path_id]->path_is_standby && challenge_path != path_id) {
-        /* Set the selected path to available if it was standby. Selecting a standby
+    if (cnx->path[path_id]->path_is_backup && challenge_path != path_id) {
+        /* Set the selected path to available if it was backup. Selecting a backup
          * path means that the available path was of lower quality, the only exception
          * being if the selection was due to a pending challenge. */
         (void)picoquic_set_path_status(cnx, cnx->path[path_id]->unique_path_id, picoquic_path_status_available);

picoquic_t/picoquic_t.c

@@ -491,7 +491,7 @@ static const picoquic_test_def_t test_table[] = {
     { "multipath_stream_af", multipath_stream_af_test },
     { "multipath_datagram", multipath_datagram_test },
     { "multipath_dg_af", multipath_dg_af_test },
-    { "multipath_standby", multipath_standby_test },
+    { "multipath_backup", multipath_backup_test },
     { "multipath_standup", multipath_standup_test },
     { "multipath_discovery", multipath_discovery_test },
     { "multipath_qlog", multipath_qlog_test },

picoquictest/multipath_test.c

@@ -446,7 +446,7 @@ typedef enum {
     multipath_test_abandon,
     multipath_test_datagram,
     multipath_test_dg_af,
-    multipath_test_standby,
+    multipath_test_backup,
     multipath_test_standup,
     multipath_test_tunnel,
     multipath_test_fail,
@@ -901,9 +901,9 @@ int multipath_test_one(uint64_t max_completion_microsec, multipath_test_enum_t t
                 DBG_PRINTF("Cannot set stream affinity, ret = %d", ret);
             }
         }
-        else if (test_id == multipath_test_standby ||
+        else if (test_id == multipath_test_backup ||
             test_id == multipath_test_standup) {
-            ret = picoquic_set_path_status(test_ctx->cnx_client, 1, picoquic_path_status_standby);
+            ret = picoquic_set_path_status(test_ctx->cnx_client, 1, picoquic_path_status_backup);
         }
     }
 
@@ -1134,13 +1134,13 @@ int multipath_test_one(uint64_t max_completion_microsec, multipath_test_enum_t t
         ret = multipath_verify_datagram_sent(&dg_ctx, test_id);
     }
 
-    /* In the standby scenario, verify that the flag is set
+    /* In the backup scenario, verify that the flag is set
     * correctly at the server, and that not too much data is
-    * sent on standby path.
+    * sent on backup path.
     */
-    if (ret == 0 && (test_id == multipath_test_standby)) {
-        if (!test_ctx->cnx_server->path[1]->path_is_standby) {
-            DBG_PRINTF("Standby not set on server path 1 (%d).\n", test_ctx->cnx_server->path[1]->path_is_standby);
+    if (ret == 0 && (test_id == multipath_test_backup)) {
+        if (!test_ctx->cnx_server->path[1]->path_is_backup) {
+            DBG_PRINTF("Backup not set on server path 1 (%d).\n", test_ctx->cnx_server->path[1]->path_is_backup);
             ret = -1;
         }
         else if (test_ctx->cnx_server->path[1]->delivered > 50000) {
@@ -1378,11 +1378,11 @@ int multipath_dg_af_test()
     return multipath_test_one(max_completion_microsec, multipath_test_dg_af);
 }
 
-int multipath_standby_test()
+int multipath_backup_test()
 {
     uint64_t max_completion_microsec = 2000000;
 
-    return multipath_test_one(max_completion_microsec, multipath_test_standby);
+    return multipath_test_one(max_completion_microsec, multipath_test_backup);
 }
 
 int multipath_standup_test()