Separated block sorting from encoding, use block number as key

Author: BrianSipos

src/mock_bpa/agent.c

@@ -725,7 +725,7 @@ static void *MockBPA_Agent_work_over_rx(void *arg)
             break;
         }
         BSL_LOG_INFO("over_rx item");
-        mock_bpa_decode(&item);
+        mock_bpa_ctr_decode(&item);
 
         MockBPA_Bundle_t *bundle = item.bundle_ref.data;
         if (MockBPA_Agent_process(agent, &agent->appin, BSL_POLICYLOCATION_APPIN, bundle))
@@ -764,7 +764,7 @@ static void *MockBPA_Agent_work_under_rx(void *arg)
         }
 
         BSL_LOG_INFO("under_rx item");
-        if (mock_bpa_decode(&item))
+        if (mock_bpa_ctr_decode(&item))
         {
             BSL_LOG_ERR("failed to decode bundle");
             mock_bpa_ctr_deinit(&item);
@@ -822,7 +822,7 @@ static void *MockBPA_Agent_work_deliver(void *arg)
             continue;
         }
 
-        mock_bpa_encode(&item);
+        mock_bpa_ctr_encode(&item);
         MockBPA_data_queue_push(agent->over_tx, item);
         {
             uint8_t buf    = 0;
@@ -867,7 +867,7 @@ static void *MockBPA_Agent_work_forward(void *arg)
             continue;
         }
 
-        mock_bpa_encode(&item);
+        mock_bpa_ctr_encode(&item);
         MockBPA_data_queue_push(agent->under_tx, item);
         {
             uint8_t buf    = 0;

src/mock_bpa/bundle.c

@@ -21,13 +21,23 @@
  */
 #include "bundle.h"
 
+int MockBPA_CanonicalBlock_cmp(const MockBPA_CanonicalBlock_t *block_a, const MockBPA_CanonicalBlock_t *block_b)
+{
+    return M_CMP_DEFAULT(block_b->blk_num, block_a->blk_num);
+}
+
 int MockBPA_Bundle_Init(MockBPA_Bundle_t *bundle)
 {
     ASSERT_ARG_NONNULL(bundle);
     memset(bundle, 0, sizeof(*bundle));
 
     bundle->retain = true;
 
+    BSL_Data_Init(&bundle->primary_block.encoded);
+    BSL_HostEID_Init(&bundle->primary_block.src_node_id);
+    BSL_HostEID_Init(&bundle->primary_block.dest_eid);
+    BSL_HostEID_Init(&bundle->primary_block.report_to_eid);
+
     MockBPA_BlockList_init(bundle->blocks);
     MockBPA_BlockByNum_init(bundle->blocks_num);
 

src/mock_bpa/bundle.h

@@ -29,6 +29,7 @@
 
 #include "eid.h"
 
+#include <m-algo.h>
 #include <m-deque.h>
 #include <m-bptree.h>
 
@@ -68,17 +69,28 @@ typedef struct
  */
 typedef struct
 {
+    /// Block type code
     uint64_t blk_type;
+    /// Unique block number, with 0 reserved and 1 for payload
     uint64_t blk_num;
+    /// Block processing control flags
     uint64_t flags;
+    /// CRC type code
     uint64_t crc_type;
 
-    /// Pointer to memory managed by the BPA
+    /// Pointer to memory managed by the BPA outside this struct
     void *btsd;
     /// Known length of the #btsd
     size_t btsd_len;
 } MockBPA_CanonicalBlock_t;
 
+/** Block comparison which will order by block number in descending order.
+ */
+int MockBPA_CanonicalBlock_cmp(const MockBPA_CanonicalBlock_t *block_a, const MockBPA_CanonicalBlock_t *block_b);
+
+/// M*LIB OPLIST for ::MockBPA_CanonicalBlock_t
+#define M_OPL_MockBPA_CanonicalBlock_t() M_OPEXTEND(M_POD_OPLIST, CMP(API_6(MockBPA_CanonicalBlock_cmp)))
+
 /** @struct MockBPA_BlockList_t
  * An ordered list of ::MockBPA_CanonicalBlock_t storage
  * with fast size access.
@@ -89,15 +101,20 @@ typedef struct
  */
 /// @cond Doxygen_Suppress
 // GCOV_EXCL_START
-M_DEQUE_DEF(MockBPA_BlockList, MockBPA_CanonicalBlock_t, M_POD_OPLIST)
+M_DEQUE_DEF(MockBPA_BlockList, MockBPA_CanonicalBlock_t, M_OPL_MockBPA_CanonicalBlock_t())
+M_ALGO_DEF(MockBPA_BlockList, M_DEQUE_OPLIST(MockBPA_BlockList, M_OPL_MockBPA_CanonicalBlock_t()))
 M_BPTREE_DEF2(MockBPA_BlockByNum, 4, uint64_t, M_BASIC_OPLIST, MockBPA_CanonicalBlock_t *, M_PTR_OPLIST)
 // GCOV_EXCL_STOP
 /// @endcond
 
 typedef struct MockBPA_Bundle_s
 {
-    uint64_t               id;
-    bool                   retain;
+    /** Explicit retention constraint.
+     * When true, indicates to retain this bundle after forwarding or delivery.
+     * This defaults to true.
+     */
+    bool retain;
+    /// Primary block contents
     MockBPA_PrimaryBlock_t primary_block;
 
     /// Storage for blocks in this bundle

src/mock_bpa/ctr.c

@@ -24,7 +24,6 @@
  * Container structs for BPv7 data.
  */
 #include <BPSecLib_Private.h>
-#include <m-algo.h>
 
 #include "ctr.h"
 #include "decode.h"
@@ -68,7 +67,14 @@ void mock_bpa_ctr_deinit(mock_bpa_ctr_t *ctr)
     }
 }
 
-int mock_bpa_decode(mock_bpa_ctr_t *ctr)
+void mock_bpa_ctr_sort_blocks(mock_bpa_ctr_t *ctr)
+{
+    BSL_CHKVOID(ctr);
+    // normalize block list by block number in descending order
+    MockBPA_BlockList_sort(ctr->bundle->blocks);
+}
+
+int mock_bpa_ctr_decode(mock_bpa_ctr_t *ctr)
 {
     BSL_CHKERR1(ctr);
     MockBPA_Bundle_t *bundle = ctr->bundle_ref.data;
@@ -93,34 +99,12 @@ int mock_bpa_decode(mock_bpa_ctr_t *ctr)
     return 0;
 }
 
-// TODO this is not really defined by BPSec or BPv7
-static int block_cmp(const MockBPA_CanonicalBlock_t *block_a, const MockBPA_CanonicalBlock_t *block_b)
-{
-    if (block_b->blk_type > block_a->blk_type)
-    {
-        return 1;
-    }
-    else if (block_b->blk_type < block_a->blk_type)
-    {
-        return -1;
-    }
-    return 0;
-}
-
-// Add comparison by block type to sort just before encoding
-// GCOV_EXCL_START
-M_ALGO_DEF(MockBPA_BlockList, M_DEQUE_OPLIST(MockBPA_BlockList, M_OPEXTEND(M_POD_OPLIST, CMP(API_6(block_cmp)))))
-// GCOV_EXCL_STOP
-
-int mock_bpa_encode(mock_bpa_ctr_t *ctr)
+int mock_bpa_ctr_encode(mock_bpa_ctr_t *ctr)
 {
     BSL_CHKERR1(ctr);
-    MockBPA_Bundle_t *bundle = ctr->bundle_ref.data;
+    const MockBPA_Bundle_t *bundle = ctr->bundle_ref.data;
     BSL_CHKERR1(bundle);
 
-    // TODO this is not really defined by BPSec or BPv7
-    MockBPA_BlockList_sort(bundle->blocks);
-
     QCBOREncodeContext encoder;
     // first round of encoding is to get the full size
     QCBOREncode_Init(&encoder, SizeCalculateUsefulBuf);

src/mock_bpa/ctr.h

@@ -49,10 +49,25 @@ void mock_bpa_ctr_init_move(mock_bpa_ctr_t *ctr, mock_bpa_ctr_t *src);
 
 void mock_bpa_ctr_deinit(mock_bpa_ctr_t *ctr);
 
-int mock_bpa_decode(mock_bpa_ctr_t *ctr);
+/** Sort canonical blocks in a bundle by descending block number.
+ * This ensures the primary block is the last block.
+ * @param[in,out] ctr The container to read and decode PDU data from.
+ */
+void mock_bpa_ctr_sort_blocks(mock_bpa_ctr_t *ctr);
+
+/** Decode a bundle PDU into a container.
+ * @param[in,out] ctr The container to read and decode PDU data from.
+ * @return Zero if successful.
+ */
+int mock_bpa_ctr_decode(mock_bpa_ctr_t *ctr);
 
-int mock_bpa_encode(mock_bpa_ctr_t *ctr);
+/** Encode to a bundle PDU in a container.
+ * @param[in,out] ctr The container to encode and write PDU data into.
+ * @return Zero if successful.
+ */
+int mock_bpa_ctr_encode(mock_bpa_ctr_t *ctr);
 
+/// M*LIB OPLIST for ::mock_bpa_ctr_t
 #define M_OPL_mock_bpa_ctr_t() \
     (INIT(API_2(mock_bpa_ctr_init)), INIT_MOVE(API_6(mock_bpa_ctr_init_move)), CLEAR(API_2(mock_bpa_ctr_deinit)))
 

test/bsl_test_utils.c

@@ -343,7 +343,7 @@ int BSL_TestUtils_LoadBundleFromCBOR(BSL_TestContext_t *test_ctx, const char *cb
     MockBPA_Bundle_t *bundle = test_ctx->mock_bpa_ctr.bundle_ref.data;
     assert(bundle != NULL);
 
-    int decode_status = mock_bpa_decode(&(test_ctx->mock_bpa_ctr));
+    int decode_status = mock_bpa_ctr_decode(&(test_ctx->mock_bpa_ctr));
     assert(bundle->primary_block.version == 7);
     assert(bundle->primary_block.timestamp.seq_num > 0);
     assert(bundle->primary_block.lifetime > 0);

test/test_BackendSecurityContext.c

@@ -108,7 +108,8 @@ void test_SecurityContext_BIB_Source(void)
                                            (BSL_Data_t) { .len = target_block->btsd_len, .ptr = target_block->btsd });
     TEST_ASSERT_TRUE(x);
 
-    TEST_ASSERT_EQUAL(0, mock_bpa_encode(mock_bpa_ctr));
+    mock_bpa_ctr_sort_blocks(mock_bpa_ctr);
+    TEST_ASSERT_EQUAL(0, mock_bpa_ctr_encode(mock_bpa_ctr));
     bool is_expected =
         (BSL_TestUtils_IsB16StrEqualTo(RFC9173_TestVectors_AppendixA1.cbor_bundle_bib, mock_bpa_ctr->encoded));
 
@@ -149,7 +150,7 @@ void test_SecurityContext_BIB_Verifier(void)
 
     TEST_ASSERT_EQUAL(0, BSL_SecCtx_ExecutePolicyActionSet(&LocalTestCtx.bsl, malloced_responseset,
                                                            &mock_bpa_ctr->bundle_ref, malloced_actionset));
-    TEST_ASSERT_EQUAL(0, mock_bpa_encode(mock_bpa_ctr));
+    TEST_ASSERT_EQUAL(0, mock_bpa_ctr_encode(mock_bpa_ctr));
     bool is_match =
         (BSL_TestUtils_IsB16StrEqualTo(RFC9173_TestVectors_AppendixA1.cbor_bundle_bib, mock_bpa_ctr->encoded));
 
@@ -243,7 +244,7 @@ void test_SecurityContext_BIB_Acceptor(void)
     if (sec_context_result != 0)
         goto cleanup;
 
-    encode_result = mock_bpa_encode(mock_bpa_ctr);
+    encode_result = mock_bpa_ctr_encode(mock_bpa_ctr);
     if (encode_result != 0)
         goto cleanup;
 
@@ -528,7 +529,7 @@ void test_RFC9173_AppendixA_Example4_Acceptor(void)
     const char *expected_processed_bundle = ("9f88070000820282010282028202018202820201820018281a000f424085010100"
                                              "005823526561647920746f2067656e657261746520612033322d6279746520706179"
                                              "6c6f6164ff");
-    TEST_ASSERT_EQUAL(0, mock_bpa_encode(mock_bpa_ctr));
+    TEST_ASSERT_EQUAL(0, mock_bpa_ctr_encode(mock_bpa_ctr));
     TEST_ASSERT_TRUE(BSL_TestUtils_IsB16StrEqualTo(expected_processed_bundle, mock_bpa_ctr->encoded));
 
     BSL_SecurityAction_Deinit(malloced_action);

test/test_mock_bpa_ctr.c

@@ -77,10 +77,12 @@ void test_mock_bpa_ctr_loopback_decode_encode(const char *hexdata)
     mock_bpa_ctr_init(&ctr);
     TEST_ASSERT_EQUAL_INT(0, BSL_Data_CopyFrom(&ctr.encoded, in_data.len, in_data.ptr));
 
-    int res = mock_bpa_decode(&ctr);
+    int res = mock_bpa_ctr_decode(&ctr);
     TEST_ASSERT_EQUAL_INT_MESSAGE(0, res, "mock_bpa_decode() failed");
 
-    res = mock_bpa_encode(&ctr);
+    mock_bpa_ctr_sort_blocks(&ctr);
+
+    res = mock_bpa_ctr_encode(&ctr);
     TEST_ASSERT_EQUAL_INT_MESSAGE(0, res, "mock_bpa_encode() failed");
 
     TEST_ASSERT_EQUAL_INT(in_data.len, ctr.encoded.len);