GTEST/UCP: Add coverage of the lane address token sections

The token sections are parsed ahead of the packed addresses, so a malformed
section must be rejected rather than shift the addresses. Feed crafted
sections to the parser, including truncated ones, which the empty sections
of the wire itself do not exercise.

Author: evgeny-leksikov

test/gtest/ucp/test_ucp_wireup.cc

@@ -2459,3 +2459,78 @@ UCS_TEST_P(test_ucp_reconfig_connect_remote, put_canceled)
 }
 
 UCP_INSTANTIATE_TEST_CASE_TLS(test_ucp_reconfig_connect_remote, tcp, "tcp")
+
+
+/* The token sections of a LANES_ADDR message are parsed before the addresses,
+ * so a malformed section must be rejected rather than shift the addresses. */
+class test_ucp_wireup_token_section : public ucs::test {
+protected:
+    /* One length byte per lane, followed by the tokens themselves */
+    static std::vector<uint8_t> make_section(const std::vector<uint8_t> &lengths)
+    {
+        std::vector<uint8_t> section(lengths);
+        uint8_t value = 0;
+
+        for (std::vector<uint8_t>::const_iterator it = lengths.begin();
+             it != lengths.end(); ++it) {
+            section.insert(section.end(), *it, ++value);
+        }
+
+        return section;
+    }
+
+    static const ucp_lane_map_t THREE_LANES;
+};
+
+const ucp_lane_map_t test_ucp_wireup_token_section::THREE_LANES =
+        UCS_BIT(0) | UCS_BIT(3) | UCS_BIT(5);
+
+UCS_TEST_F(test_ucp_wireup_token_section, unpack) {
+    std::vector<uint8_t> lengths = {4, 0, 7};
+    std::vector<uint8_t> section = make_section(lengths);
+    const uint8_t *unpacked_lengths;
+    const void *tokens;
+    size_t consumed;
+
+    /* The address follows the section, so extra bytes must be left alone */
+    section.push_back(0xff);
+
+    ASSERT_UCS_OK(ucp_wireup_unpack_token_section(THREE_LANES, &section[0],
+                                                  section.size(), &consumed,
+                                                  &unpacked_lengths, &tokens));
+    EXPECT_EQ(section.size() - 1, consumed);
+    EXPECT_EQ(lengths[0], unpacked_lengths[0]);
+    EXPECT_EQ(lengths[1], unpacked_lengths[1]);
+    EXPECT_EQ(lengths[2], unpacked_lengths[2]);
+    EXPECT_EQ(static_cast<const void*>(&section[lengths.size()]), tokens);
+}
+
+UCS_TEST_F(test_ucp_wireup_token_section, unpack_no_lanes) {
+    std::vector<uint8_t> section(4, 0);
+    const uint8_t *lengths;
+    const void *tokens;
+    size_t consumed;
+
+    ASSERT_UCS_OK(ucp_wireup_unpack_token_section(0, &section[0],
+                                                  section.size(), &consumed,
+                                                  &lengths, &tokens));
+    EXPECT_EQ(0ul, consumed);
+    EXPECT_EQ(NULL, lengths);
+    EXPECT_EQ(NULL, tokens);
+}
+
+UCS_TEST_F(test_ucp_wireup_token_section, unpack_truncated) {
+    std::vector<uint8_t> section = make_section({4, 0, 7});
+    const uint8_t *lengths;
+    const void *tokens;
+    size_t consumed;
+
+    /* Cut in the length array, and then in the tokens themselves */
+    EXPECT_EQ(UCS_ERR_MESSAGE_TRUNCATED,
+              ucp_wireup_unpack_token_section(THREE_LANES, &section[0], 2,
+                                              &consumed, &lengths, &tokens));
+    EXPECT_EQ(UCS_ERR_MESSAGE_TRUNCATED,
+              ucp_wireup_unpack_token_section(THREE_LANES, &section[0],
+                                              section.size() - 1, &consumed,
+                                              &lengths, &tokens));
+}