oxen-io
/
lokinet
mirror of https://github.com/oxen-io/lokinet
1
1
Fork 0
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

This commit is contained in:
Jeff Becker 2018-12-20 12:23:01 -05:00
parent 259283f3c4 ad58645116
commit 3e37165749
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
19 changed files with 436 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@ -600,25 +600,25 @@ set(DNS_SRC
)
set(TEST_SRC
test/main.cpp
test/alignedbuffer_unittest.cpp
test/base32_unittest.cpp
test/dht_unittest.cpp
test/encrypted_frame_unittest.cpp
test/exit_unittest.cpp
test/hiddenservice_unittest.cpp
test/traffic_transfer_unittest.cpp
test/main.cpp
test/net_unittest.cpp
test/obtain_exit_unittest.cpp
test/pq_unittest.cpp
test/net_unittest.cpp
test/test_dns_unit.cpp
test/test_dnsc_unit.cpp
test/test_dnsd_unit.cpp
test/test_dnslib.cpp
test/test_llarp_queue.cpp
test/test_llarp_aligned.cpp
test/test_llarp_queue_manager.cpp
test/test_llarp_queue.cpp
test/test_llarp_thread_pool.cpp
test/test_service_address.cpp
test/traffic_transfer_unittest.cpp
)
set(TEST_EXE testAll)

2
llarp/address_info.hpp
View File

@ -73,7 +73,7 @@ namespace llarp
size_t
operator()(const AddressInfo& addr) const
{
return *addr.pubkey.data_l();
return AlignedBuffer< PUBKEYSIZE >::Hash()(addr.pubkey);
}
};
};

156
llarp/aligned.hpp
View File

@ -5,50 +5,66 @@
#include <encode.hpp>
#include <logger.hpp>
#include <array>
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <memory>
#include <numeric>
#include <type_traits>
extern "C"
{
extern void
randombytes(unsigned char* const ptr, unsigned long long sz);
extern void
sodium_memzero(void* const ptr, const size_t sz);
extern int
sodium_is_zero(const unsigned char* ptr, size_t sz);
}
namespace llarp
{
/// aligned buffer that is sz bytes long and aligns to the nears Long_t
template < size_t sz, bool randomize = false, typename Long_t = uint64_t >
/// aligned buffer that is sz bytes long and aligns to the nearest Alignment
template < size_t sz >
struct AlignedBuffer
{
static constexpr size_t SIZE = sz;
using Data = std::array< byte_t, SIZE >;
AlignedBuffer()
{
if(randomize)
Randomize();
else
Zero();
new(&val) Data;
Zero();
}
AlignedBuffer(const byte_t* data)
{
new(&val) Data;
auto& b = as_array();
for(size_t idx = 0; idx < sz; ++idx)
{
b[idx] = data[idx];
}
}
AlignedBuffer(const Data& buf)
{
new(&val) Data;
std::copy(buf.begin(), buf.end(), as_array().begin());
}
AlignedBuffer&
operator=(const byte_t* data)
{
auto& b = as_array();
for(size_t idx = 0; idx < sz; ++idx)
{
b[idx] = data[idx];
}
return *this;
}
friend std::ostream&
operator<<(std::ostream& out, const AlignedBuffer& self)
{
char tmp[(1 + sz) * 2] = {0};
char tmp[(sz * 2) + 1] = {0};
return out << HexEncode(self, tmp);
}
@ -57,75 +73,72 @@ namespace llarp
operator~() const
{
AlignedBuffer< sz > ret;
size_t idx = 0;
while(idx < sz / sizeof(Long_t))
{
ret.data_l()[idx] = ~data_l()[idx];
++idx;
}
std::transform(as_array().begin(), as_array().end(),
ret.as_array().begin(), [](byte_t a) { return ~a; });
return ret;
}
bool
operator==(const AlignedBuffer& other) const
{
return memcmp(b, other.b, sz) == 0;
return as_array() == other.as_array();
}
bool
operator!=(const AlignedBuffer& other) const
{
return !(*this == other);
return as_array() != other.as_array();
}
bool
operator<(const AlignedBuffer& other) const
{
return memcmp(l, other.l, sz) < 0;
return as_array() < other.as_array();
}
bool
operator>(const AlignedBuffer& other) const
{
return memcmp(l, other.l, sz) > 0;
return as_array() > other.as_array();
}
bool
operator<=(const AlignedBuffer& other) const
{
return memcmp(l, other.l, sz) <= 0;
return as_array() <= other.as_array();
}
bool
operator>=(const AlignedBuffer& other) const
{
return memcmp(l, other.l, sz) >= 0;
return as_array() >= other.as_array();
}
AlignedBuffer
operator^(const AlignedBuffer& other) const
{
AlignedBuffer< sz > ret;
for(size_t idx = 0; idx < sz / sizeof(Long_t); ++idx)
ret.l[idx] = l[idx] ^ other.l[idx];
std::transform(as_array().begin(), as_array().end(),
other.as_array().begin(), ret.as_array().begin(),
std::bit_xor< byte_t >());
return ret;
}
AlignedBuffer&
operator^=(const AlignedBuffer& other)
{
for(size_t idx = 0; idx < sz / sizeof(Long_t); ++idx)
l[idx] ^= other.l[idx];
// Mutate in place instead.
// Well defined for std::transform,
for(size_t i = 0; i < as_array().size(); ++i)
{
as_array()[i] ^= other.as_array()[i];
}
return *this;
}
size_t
size() const
{
return sz;
}
size_t
static constexpr size_t
size()
{
return sz;
@ -134,66 +147,78 @@ namespace llarp
void
Fill(byte_t f)
{
for(size_t idx = 0; idx < sz; ++idx)
b[idx] = f;
as_array().fill(f);
}
Data&
as_array()
{
return reinterpret_cast< Data& >(val);
}
const Data&
as_array() const
{
return reinterpret_cast< const Data& >(val);
}
bool
IsZero() const
{
return sodium_is_zero(b, sz) != 0;
auto notZero = [](byte_t b) { return b != 0; };
return std::find_if(as_array().begin(), as_array().end(), notZero)
== as_array().end();
}
void
Zero()
{
sodium_memzero(l, sz);
as_array().fill(0);
}
void
Randomize()
{
randombytes(b, sz);
randombytes(as_array().data(), SIZE);
}
byte_t*
data()
{
return b;
return as_array().data();
}
const byte_t*
data() const
{
return b;
}
Long_t*
data_l()
{
return l;
}
const Long_t*
data_l() const
{
return l;
return as_array().data();
}
operator const byte_t*() const
{
return b;
return as_array().data();
}
operator byte_t*()
{
return b;
return as_array().data();
}
operator const Data&() const
{
return as_array();
}
operator Data&()
{
return as_array();
}
bool
BEncode(llarp_buffer_t* buf) const
{
return bencode_write_bytestring(buf, b, sz);
return bencode_write_bytestring(buf, as_array().data(), sz);
}
bool
@ -201,13 +226,15 @@ namespace llarp
{
llarp_buffer_t strbuf;
if(!bencode_read_string(buf, &strbuf))
{
return false;
}
if(strbuf.sz != sz)
{
llarp::LogError("bdecode buffer size missmatch ", strbuf.sz, "!=", sz);
return false;
}
memcpy(b, strbuf.base, sz);
memcpy(as_array().data(), strbuf.base, sz);
return true;
}
@ -221,17 +248,18 @@ namespace llarp
struct Hash
{
size_t
operator()(const AlignedBuffer< sz, randomize, Long_t >& buf) const
operator()(const AlignedBuffer& buf) const
{
return buf.l[0];
return std::accumulate(buf.as_array().begin(), buf.as_array().end(), 0,
std::bit_xor< size_t >());
}
};
protected:
union {
byte_t b[sz];
Long_t l[(sz / sizeof(Long_t)) + (sz % sizeof(Long_t))];
};
private:
using AlignedStorage =
typename std::aligned_storage< sizeof(Data),
alignof(std::max_align_t) >::type;
AlignedStorage val;
};
} // namespace llarp

7
llarp/dht/context.cpp
View File

@ -669,7 +669,12 @@ namespace llarp
"cannot handle exploritory router lookup, no dht peers");
return false;
}
size_t want = std::min(size_t(4), nodeCount);
llarp::LogDebug("We have ", nodes->Size(), " connected nodes into the DHT");
// ourKey should never be in the connected list
// requester is likely in the connected list
// 4 or connection nodes (minus a potential requestor), whatever is less
size_t want = std::min(size_t(4), nodeCount - 1);
llarp::LogDebug("We want ", want, " connected nodes in the DHT");
if(!nodes->GetManyNearExcluding(t, found, want,
std::set< Key_t >{ourKey, requester}))
{

24
llarp/dht/key.hpp
View File

@ -3,17 +3,24 @@
#include <aligned.hpp>
#include <array>
namespace llarp
{
namespace dht
{
struct Key_t : public llarp::AlignedBuffer< 32 >
{
Key_t(const byte_t* val) : llarp::AlignedBuffer< 32 >(val)
Key_t(const byte_t* buf) : llarp::AlignedBuffer< SIZE >(buf)
{
}
Key_t() : llarp::AlignedBuffer< 32 >()
Key_t(const std::array< byte_t, SIZE >& val)
: llarp::AlignedBuffer< SIZE >(val.data())
{
}
Key_t() : llarp::AlignedBuffer< SIZE >()
{
}
@ -21,33 +28,34 @@ namespace llarp
operator^(const Key_t& other) const
{
Key_t dist;
for(size_t idx = 0; idx < (size() / sizeof(l[0])); ++idx)
dist.l[idx] = l[idx] ^ other.l[idx];
std::transform(as_array().begin(), as_array().end(),
other.as_array().begin(), dist.as_array().begin(),
std::bit_xor< byte_t >());
return dist;
}
bool
operator==(const Key_t& other) const
{
return memcmp(data(), other.data(), 32) == 0;
return memcmp(data(), other.data(), SIZE) == 0;
}
bool
operator!=(const Key_t& other) const
{
return memcmp(data(), other.data(), 32) != 0;
return memcmp(data(), other.data(), SIZE) != 0;
}
bool
operator<(const Key_t& other) const
{
return memcmp(data(), other.data(), 32) < 0;
return memcmp(data(), other.data(), SIZE) < 0;
}
bool
operator>(const Key_t& other) const
{
return memcmp(data(), other.data(), 32) > 0;
return memcmp(data(), other.data(), SIZE) > 0;
}
};
} // namespace dht

4
llarp/dns_dotlokilookup.cpp
View File

@ -41,7 +41,7 @@ decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr,
auto pos = name.find(".snode");
if(pos != std::string::npos)
{
if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data(),
if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data().data(),
serviceAddr.size()))
{
return false;
@ -55,7 +55,7 @@ decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr,
{
return false;
}
addr = serviceAddr.data();
addr = serviceAddr.data().data();
isSNode = false;
}
return true;

16
llarp/handlers/tun.cpp
View File

@ -211,9 +211,9 @@ namespace llarp
}
else if(addr.FromString(qname, ".loki"))
{
if(HasAddress(addr.data()))
if(HasAddress(addr.data().data()))
{
huint32_t ip = ObtainIPForAddr(addr.data(), false);
huint32_t ip = ObtainIPForAddr(addr.data().data(), false);
msg.AddINReply(ip);
}
else
@ -227,8 +227,8 @@ namespace llarp
else if(addr.FromString(qname, ".snode"))
{
// TODO: add hook to EnsurePathToSNode
EnsurePathToSNode(addr.data());
huint32_t ip = ObtainIPForAddr(addr.data(), true);
EnsurePathToSNode(addr.data().data());
huint32_t ip = ObtainIPForAddr(addr.data().data(), true);
msg.AddINReply(ip);
}
else
@ -310,7 +310,7 @@ namespace llarp
{
if(ctx)
{
huint32_t ip = ObtainIPForAddr(addr.data(), false);
huint32_t ip = ObtainIPForAddr(addr.data().data(), false);
request.AddINReply(ip);
}
else
@ -333,9 +333,9 @@ namespace llarp
}
llarp::LogInfo(Name() + " map ", addr.ToString(), " to ", ip);
m_IPToAddr[ip] = addr.data();
m_AddrToIP[addr.data()] = ip;
m_SNodes[addr.data()] = SNode;
m_IPToAddr[ip] = addr.data().data();
m_AddrToIP[addr.data().data()] = ip;
m_SNodes[addr.data().data()] = SNode;
MarkIPActiveForever(ip);
return true;
}

2
llarp/pathset.hpp
View File

@ -191,7 +191,7 @@ namespace llarp
size_t
operator()(const PathInfo_t& i) const
{
return *i.first.data_l() ^ *i.second.data_l();
return RouterID::Hash()(i.first) ^ PathID_t::Hash()(i.second);
}
};
using Mtx_t = llarp::util::NullMutex;

35
llarp/router.cpp
View File

@ -660,25 +660,26 @@ namespace llarp
}
}
size_t N = nodedb->num_loaded();
if(N < minRequiredRouters)
{
llarp::LogInfo("We need at least ", minRequiredRouters,
" service nodes to build paths but we have ", N, " in nodedb");
// TODO: only connect to random subset
if(bootstrapRCList.size())
{
for(const auto &rc : bootstrapRCList)
{
llarp_router_try_connect(this, rc, 4);
dht->impl.ExploreNetworkVia(rc.pubkey.data());
}
}
else
llarp::LogError("we have no bootstrap nodes specified");
}
if(inboundLinks.size() == 0)
{
size_t N = nodedb->num_loaded();
if(N < minRequiredRouters)
{
llarp::LogInfo("We need at least ", minRequiredRouters,
" service nodes to build paths but we have ", N);
// TODO: only connect to random subset
if(bootstrapRCList.size())
{
for(const auto &rc : bootstrapRCList)
{
llarp_router_try_connect(this, rc, 4);
dht->impl.ExploreNetworkVia(rc.pubkey.data());
}
}
else
llarp::LogError("we have no bootstrap nodes specified");
}
paths.BuildPaths(now);
hiddenServiceContext.Tick(now);
}

16
llarp/router_id.hpp
View File

@ -7,11 +7,19 @@ namespace llarp
{
struct RouterID : public AlignedBuffer< 32 >
{
RouterID() : AlignedBuffer< 32 >()
static constexpr size_t SIZE = 32;
using Data = std::array< byte_t, SIZE >;
RouterID() : AlignedBuffer< SIZE >()
{
}
RouterID(const byte_t* buf) : AlignedBuffer< 32 >(buf)
RouterID(const byte_t* buf) : AlignedBuffer< SIZE >(buf)
{
}
RouterID(const Data& data) : AlignedBuffer< SIZE >(data)
{
}
@ -24,7 +32,7 @@ namespace llarp
RouterID&
operator=(const byte_t* ptr)
{
memcpy(data(), ptr, 32);
memcpy(data(), ptr, SIZE);
return *this;
}
@ -34,7 +42,7 @@ namespace llarp
return out << id.ToString();
}
using Hash = AlignedBuffer< 32 >::Hash;
using Hash = AlignedBuffer< SIZE >::Hash;
};
} // namespace llarp

3
llarp/service/Info.hpp
View File

@ -121,8 +121,7 @@ namespace llarp
}
/// calculate our address
bool
CalculateAddress(byte_t* buf) const;
bool CalculateAddress(std::array< byte_t, 32 >& data) const;
bool
BDecode(llarp_buffer_t* buf) override

2
llarp/service/Intro.hpp
View File

@ -86,7 +86,7 @@ namespace llarp
size_t
operator()(const Introduction& i) const
{
return *i.router.data_l() ^ *i.pathID.data_l();
return PubKey::Hash()(i.router) ^ PathID_t::Hash()(i.pathID);
}
};
};

66
llarp/service/address.hpp
View File

@ -5,6 +5,8 @@
#include <dht/key.hpp>
#include <router_id.hpp>
#include <functional>
#include <numeric>
#include <string>
namespace llarp
@ -14,6 +16,10 @@ namespace llarp
/// Snapp/Snode Address
struct Address
{
static constexpr size_t SIZE = 32;
using Data = std::array< byte_t, SIZE >;
std::string
ToString(const char* tld = ".loki") const;
@ -27,12 +33,12 @@ namespace llarp
Address(const byte_t* buf)
{
memcpy(b, buf, 32);
std::copy(buf, buf + SIZE, b.begin());
}
Address(const Address& other)
{
memcpy(b, other.b, 32);
b = other.b;
}
byte_t& operator[](size_t idx)
@ -48,7 +54,7 @@ namespace llarp
bool
BEncode(llarp_buffer_t* buf) const
{
return bencode_write_bytestring(buf, b, 32);
return bencode_write_bytestring(buf, b.data(), SIZE);
}
bool
@ -57,49 +63,39 @@ namespace llarp
llarp_buffer_t strbuf;
if(!bencode_read_string(buf, &strbuf))
return false;
if(strbuf.sz != 32)
if(strbuf.sz != SIZE)
{
llarp::LogErrorTag("Address::BDecode",
"bdecode buffer size missmatch ", strbuf.sz,
"!=32");
return false;
}
memcpy(b, strbuf.base, 32);
std::copy(strbuf.base, strbuf.base + SIZE, b.begin());
return true;
}
size_t
size() const
static constexpr size_t
size()
{
return 32;
return SIZE;
}
bool
IsZero() const
{
size_t sz = 4;
while(sz)
{
if(l[--sz])
return false;
}
return true;
return b == Data{};
}
void
Zero()
{
size_t sz = 4;
while(sz)
{
l[--sz] = 0;
}
b.fill(0);
}
bool
operator<(const Address& other) const
{
return memcmp(data(), other.data(), 32) < 0;
return data() < other.data();
}
friend std::ostream&
@ -111,7 +107,7 @@ namespace llarp
bool
operator==(const Address& other) const
{
return memcmp(data(), other.data(), 32) == 0;
return data() == other.data();
}
bool
@ -121,11 +117,7 @@ namespace llarp
}
Address&
operator=(const Address& other)
{
memcpy(data(), other.data(), 32);
return *this;
}
operator=(const Address& other) = default;
const dht::Key_t
ToKey() const
@ -136,41 +128,33 @@ namespace llarp
const RouterID
ToRouter() const
{
return RouterID(data());
return RouterID(data().data());
}
const byte_t*
const Data&
data() const
{
return b;
}
byte_t*
Data&
data()
{
return b;
}
const uint64_t*
data_l() const
{
return l;
}
struct Hash
{
size_t
operator()(const Address& buf) const
{
return *buf.data_l();
return std::accumulate(buf.data().begin(), buf.data().end(), 0,
std::bit_xor< size_t >());
}
};
private:
union {
byte_t b[32];
uint64_t l[4];
};
Data b;
};
} // namespace service

9
llarp/service/endpoint.cpp
View File

@ -538,7 +538,7 @@ namespace llarp
Endpoint::PublishIntroSet(llarp::Router* r)
{
// publish via near router
RouterID location = m_Identity.pub.Addr().data();
RouterID location = m_Identity.pub.Addr().data().data();
auto path = GetEstablishedPathClosestTo(location);
return path && PublishIntroSetVia(r, path);
}
@ -827,9 +827,10 @@ namespace llarp
if(msg->proto == eProtocolTraffic)
{
auto buf = llarp::Buffer(msg->payload);
return HandleWriteIPPacket(buf,
std::bind(&Endpoint::ObtainIPForAddr, this,
msg->sender.Addr().data(), false));
return HandleWriteIPPacket(
buf,
std::bind(&Endpoint::ObtainIPForAddr, this,
msg->sender.Addr().data().data(), false));
}
else if(msg->proto == eProtocolText)
{

7
llarp/service/info.cpp
View File

@ -56,15 +56,14 @@ namespace llarp
return m_CachedAddr.ToString();
}
bool
ServiceInfo::CalculateAddress(byte_t* addr) const
bool ServiceInfo::CalculateAddress(std::array< byte_t, 32 >& data) const
{
byte_t tmp[256] = {0};
auto buf = llarp::StackBuffer< decltype(tmp) >(tmp);
if(!BEncode(&buf))
return false;
return crypto_generichash_blake2b(addr, 32, buf.base, buf.cur - buf.base,
nullptr, 0)
return crypto_generichash_blake2b(data.data(), data.size(), buf.base,
buf.cur - buf.base, nullptr, 0)
!= -1;
}

9
llarp/service/tag.hpp
View File

@ -54,14 +54,7 @@ namespace llarp
return ToString().empty();
}
struct Hash
{
std::size_t
operator()(const Tag& t) const
{
return *t.data_l();
}
};
using Hash = AlignedBuffer< SIZE >::Hash;
};
} // namespace service
} // namespace llarp

8
lokinet-bootstrap
View File

@ -2,6 +2,10 @@
# this shell script will be replaced by a proper program in the future (probably)
#
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m' # No Color
if [ -z "$1" ]
then
url="https://i2p.rocks/i2procks.signed"
@ -16,4 +20,6 @@ then
mkdir $HOME/.lokinet
fi
wget -O $HOME/.lokinet/bootstrap.signed "$url" || echo "failed to download bootstrap from $url"
# MacOS does not have wget without homebrew but does have curl
# Rick also had indicated most BSDs have curl too
curl "$url" > $HOME/.lokinet/bootstrap.signed; echo -e "${GREEN}lokinet successfully bootstrapped${NC}" || echo -e "${RED}failed to download bootstrap from $url${NC}"

33
test/alignedbuffer_unittest.cpp
View File

@ -1,33 +0,0 @@
#include <gtest/gtest.h>
#include <crypto.hpp>
using Buffer_t = llarp::AlignedBuffer< 32 >;
using Map_t = std::unordered_map< Buffer_t, int, Buffer_t::Hash >;
struct AlignedBufferTest : public ::testing::Test
{
AlignedBufferTest() : crypto(llarp::Crypto::sodium{})
{
}
llarp::Crypto crypto;
};
TEST_F(AlignedBufferTest, TestHash)
{
Buffer_t k, other_k;
k.Randomize();
other_k.Randomize();
Map_t m;
ASSERT_TRUE(m.empty());
ASSERT_TRUE(m.emplace(k, 1).second);
ASSERT_TRUE(m.find(k) != m.end());
ASSERT_TRUE(m[k] == 1);
ASSERT_FALSE(m.find(other_k) != m.end());
ASSERT_TRUE(m.size() == 1);
Buffer_t k_copy = k;
ASSERT_FALSE(m.emplace(k_copy, 2).second);
ASSERT_FALSE(m[k_copy] == 2);
ASSERT_TRUE(m[k_copy] == 1);
};

232
test/test_llarp_aligned.cpp Normal file
View File

@ -0,0 +1,232 @@
#include <gtest/gtest.h>
#include <aligned.hpp>
#include <crypto.hpp>
#include <iostream>
#include <sstream>
#include <type_traits>
#include <unordered_map>
using TestSizes =
::testing::Types< std::integral_constant< std::size_t, 2 >,
std::integral_constant< std::size_t, 3 >,
std::integral_constant< std::size_t, 4 >,
std::integral_constant< std::size_t, 8 >,
std::integral_constant< std::size_t, 16 >,
std::integral_constant< std::size_t, 32 >,
std::integral_constant< std::size_t, 64 >,
std::integral_constant< std::size_t, 1024 > >;
template < typename T >
struct AlignedBufferTest : public ::testing::Test
{
AlignedBufferTest() : crypto(llarp::Crypto::sodium{})
{
}
llarp::Crypto crypto;
};
TYPED_TEST_CASE(AlignedBufferTest, TestSizes);
TYPED_TEST(AlignedBufferTest, Constructor)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
EXPECT_EQ(b.size(), TypeParam::value);
}
TYPED_TEST(AlignedBufferTest, CopyConstructor)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
Buffer c = b;
EXPECT_TRUE(c.IsZero());
c.Fill(1);
EXPECT_FALSE(c.IsZero());
Buffer d = c;
EXPECT_FALSE(d.IsZero());
}
TYPED_TEST(AlignedBufferTest, AltConstructors)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
b.Fill(2);
Buffer c(b.as_array());
EXPECT_FALSE(c.IsZero());
Buffer d(c.data());
EXPECT_FALSE(d.IsZero());
}
TYPED_TEST(AlignedBufferTest, Assignment)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
Buffer c;
c = b;
EXPECT_TRUE(c.IsZero());
c.Fill(1);
EXPECT_FALSE(c.IsZero());
Buffer d;
d = c;
EXPECT_FALSE(d.IsZero());
}
TYPED_TEST(AlignedBufferTest, StreamOut)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
std::stringstream stream;
stream << b;
EXPECT_EQ(stream.str(), std::string(TypeParam::value * 2, '0'));
stream.str("");
b.Fill(255);
stream << b;
EXPECT_EQ(stream.str(), std::string(TypeParam::value * 2, 'f'));
}
TYPED_TEST(AlignedBufferTest, BitwiseNot)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
Buffer c = ~b;
EXPECT_FALSE(c.IsZero());
for(auto val : c.as_array())
{
EXPECT_EQ(255, val);
}
Buffer d = ~c;
EXPECT_TRUE(d.IsZero());
}
TYPED_TEST(AlignedBufferTest, Operators)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
Buffer c = b;
EXPECT_EQ(b, c);
EXPECT_GE(b, c);
EXPECT_LE(b, c);
EXPECT_GE(c, b);
EXPECT_LE(c, b);
c.Fill(1);
EXPECT_NE(b, c);
EXPECT_LT(b, c);
EXPECT_GT(c, b);
}
TYPED_TEST(AlignedBufferTest, Xor)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
Buffer c;
b.Fill(255);
c.Fill(255);
EXPECT_FALSE(b.IsZero());
EXPECT_FALSE(c.IsZero());
Buffer d = b ^ c;
// 1 ^ 1 = 0
EXPECT_TRUE(d.IsZero());
// Verify unchanged
EXPECT_FALSE(b.IsZero());
EXPECT_FALSE(c.IsZero());
Buffer e, f;
e.Fill(255);
Buffer g = e ^ f;
// 1 ^ 0 = 1
EXPECT_FALSE(g.IsZero());
Buffer h, i;
i.Fill(255);
Buffer j = h ^ i;
// 0 ^ 1 = 1
EXPECT_FALSE(j.IsZero());
}
TYPED_TEST(AlignedBufferTest, XorAssign)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b, c;
b.Fill(255);
c.Fill(255);
EXPECT_FALSE(b.IsZero());
EXPECT_FALSE(c.IsZero());
b ^= c;
EXPECT_TRUE(b.IsZero());
}
TYPED_TEST(AlignedBufferTest, Zero)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
Buffer b;
EXPECT_TRUE(b.IsZero());
b.Fill(127);
EXPECT_FALSE(b.IsZero());
b.Zero();
EXPECT_TRUE(b.IsZero());
}
TYPED_TEST(AlignedBufferTest, TestHash)
{
using Buffer = llarp::AlignedBuffer< TypeParam::value >;
using Map_t = std::unordered_map< Buffer, int, typename Buffer::Hash >;
Buffer k, other_k;
k.Randomize();
other_k.Randomize();
Map_t m;
EXPECT_TRUE(m.empty());
EXPECT_TRUE(m.emplace(k, 1).second);
EXPECT_TRUE(m.find(k) != m.end());
EXPECT_TRUE(m[k] == 1);
EXPECT_FALSE(m.find(other_k) != m.end());
EXPECT_TRUE(m.size() == 1);
Buffer k_copy = k;
EXPECT_FALSE(m.emplace(k_copy, 2).second);
EXPECT_FALSE(m[k_copy] == 2);
EXPECT_TRUE(m[k_copy] == 1);
};
// TEST_P(Copy, )