Merge pull request #1072 from majestrate/2020-01-25-router-version

add router version

llarp/router_version.cpp

@@ -40,12 +40,10 @@ namespace llarp
   RouterVersion::Clear()
   {
     m_Version.fill(0);
-    m_ProtoVersion = LLARP_PROTO_VERSION;
+    m_ProtoVersion = INVALID_VERSION;
     assert(IsEmpty());
   }
 
-  static const RouterVersion emptyRouterVersion({0, 0, 0}, LLARP_PROTO_VERSION);
-
   bool
   RouterVersion::IsEmpty() const
   {
@@ -65,11 +63,16 @@ namespace llarp
                uint64_t i;
                if(idx == 0)
                {
-                 if(not bencode_read_integer(buffer, &self->m_ProtoVersion))
+                 uint64_t val = -1;
+                 if(not bencode_read_integer(buffer, &val))
                    return false;
+                 self->m_ProtoVersion = val;
                }
                else if(bencode_read_integer(buffer, &i))
                {
+                 // prevent overflow (note that idx includes version too)
+                 if(idx > self->m_Version.max_size())
+                   return false;
                  self->m_Version[idx - 1] = i;
                }
                else

llarp/router_version.hpp

@@ -60,8 +60,8 @@ namespace llarp
     }
 
    private:
-    Version_t m_Version     = {{0, 0, 0}};
-    uint64_t m_ProtoVersion = LLARP_PROTO_VERSION;
+    Version_t m_Version    = {{0, 0, 0}};
+    int64_t m_ProtoVersion = LLARP_PROTO_VERSION;
   };
 
   inline std::ostream&
@@ -69,6 +69,10 @@ namespace llarp
   {
     return out << rv.ToString();
   }
+
+  static constexpr int64_t INVALID_VERSION = -1;
+  static const RouterVersion emptyRouterVersion({0, 0, 0}, INVALID_VERSION);
+
 }  // namespace llarp
 
 #endif

test/CMakeLists.txt

@@ -19,6 +19,7 @@ list(APPEND TEST_SRC
     link/test_llarp_link.cpp
     llarp_test.cpp
     net/test_llarp_net.cpp
+    router/test_llarp_router_version.cpp
     routing/llarp_routing_transfer_traffic.cpp
     routing/test_llarp_routing_obtainexitmessage.cpp
     service/test_llarp_service_address.cpp

test/router/test_llarp_router_version.cpp

@@ -0,0 +1,91 @@
+#include <gtest/gtest.h>
+#include <router_version.hpp>
+#include "router/router.hpp"
+
+class TestRouterVersion : public ::testing::Test
+{
+};
+
+TEST_F(TestRouterVersion, TestCompatibilityWhenProtocolEqual)
+{
+  llarp::RouterVersion v1( {0, 1, 2}, 1);
+  llarp::RouterVersion v2( {0, 1, 2}, 1);
+
+  EXPECT_TRUE(v1.IsCompatableWith(v2));
+}
+
+TEST_F(TestRouterVersion, TestCompatibilityWhenProtocolUnequal)
+{
+  llarp::RouterVersion older( {0, 1, 2}, 1);
+  llarp::RouterVersion newer( {0, 1, 2}, 2);
+
+  EXPECT_FALSE(older.IsCompatableWith(newer));
+  EXPECT_FALSE(newer.IsCompatableWith(older));
+}
+
+TEST_F(TestRouterVersion, TestEmptyCompatibility)
+{
+  llarp::RouterVersion v1( {0, 0, 1}, LLARP_PROTO_VERSION);
+
+  EXPECT_FALSE(v1.IsCompatableWith(llarp::emptyRouterVersion));
+}
+
+TEST_F(TestRouterVersion, TestIsEmpty)
+{
+  llarp::RouterVersion notEmpty( {0, 0, 1}, LLARP_PROTO_VERSION);
+  EXPECT_FALSE(notEmpty.IsEmpty());
+
+  EXPECT_TRUE(llarp::emptyRouterVersion.IsEmpty());
+}
+
+TEST_F(TestRouterVersion, TestClear)
+{
+  llarp::RouterVersion version( {0, 0, 1}, LLARP_PROTO_VERSION);
+  EXPECT_FALSE(version.IsEmpty());
+
+  version.Clear();
+
+  EXPECT_TRUE(version.IsEmpty());
+}
+
+TEST_F(TestRouterVersion, TestBEncode)
+{
+  llarp::RouterVersion v1235( {1, 2, 3}, 5);
+
+  std::array< byte_t, 128 > tmp;
+  llarp_buffer_t buf(tmp);
+
+  EXPECT_TRUE(v1235.BEncode(&buf));
+
+  std::string s((const char*)buf.begin(), (buf.end() - buf.begin()));
+  LogInfo("bencoded: ", buf.begin());
+
+  EXPECT_STREQ((const char*)buf.begin(), "li5ei1ei2ei3ee");
+
+}
+
+TEST_F(TestRouterVersion, TestBDecode)
+{
+  llarp::RouterVersion version;
+  version.Clear();
+
+  const std::string bString("li9ei3ei2ei1ee");
+  llarp_buffer_t buf(bString.data(), bString.size());
+  EXPECT_TRUE(version.BDecode(&buf));
+
+  llarp::RouterVersion expected( {3, 2, 1}, 9);
+
+  EXPECT_EQ(expected, version);
+
+}
+
+TEST_F(TestRouterVersion, TestDecodeLongVersionArray)
+{
+  llarp::RouterVersion version;
+  version.Clear();
+
+  const std::string bString("li9ei3ei2ei1ei2ei3ei4ei5ei6ei7ei8ei9ee");
+  llarp_buffer_t buf(bString.data(), bString.size());
+  EXPECT_FALSE(version.BDecode(&buf));
+
+}