foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-21 12:22:50 -05:00
Code Issues Activity

test: move the implementation of StaticContentsSock to .cpp

Browse source 
Move the implementation (method definitions) from `test/util/net.h` to
`test/util/net.cpp` to make the header easier to follow.
This commit is contained in:
Vasil Dimov 2022-12-06 13:38:21 +01:00
parent ccc2d3abcd
commit 4b58d55878
No known key found for this signature in database
GPG key ID: 54DF06F64B55CBBF
2 changed files with 107 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
src/test/util/net.cpp
View file

@ -137,3 +137,93 @@ std::vector<NodeEvictionCandidate> GetRandomNodeEvictionCandidates(int n_candida
}
return candidates;
}
StaticContentsSock::StaticContentsSock(const std::string& contents)
: Sock{INVALID_SOCKET}, m_contents{contents}
{
}
StaticContentsSock::~StaticContentsSock() { m_socket = INVALID_SOCKET; }
StaticContentsSock& StaticContentsSock::operator=(Sock&& other)
{
assert(false && "Move of Sock into MockSock not allowed.");
return *this;
}
ssize_t StaticContentsSock::Send(const void*, size_t len, int) const { return len; }
ssize_t StaticContentsSock::Recv(void* buf, size_t len, int flags) const
{
const size_t consume_bytes{std::min(len, m_contents.size() - m_consumed)};
std::memcpy(buf, m_contents.data() + m_consumed, consume_bytes);
if ((flags & MSG_PEEK) == 0) {
m_consumed += consume_bytes;
}
return consume_bytes;
}
int StaticContentsSock::Connect(const sockaddr*, socklen_t) const { return 0; }
int StaticContentsSock::Bind(const sockaddr*, socklen_t) const { return 0; }
int StaticContentsSock::Listen(int) const { return 0; }
std::unique_ptr<Sock> StaticContentsSock::Accept(sockaddr* addr, socklen_t* addr_len) const
{
if (addr != nullptr) {
// Pretend all connections come from 5.5.5.5:6789
memset(addr, 0x00, *addr_len);
const socklen_t write_len = static_cast<socklen_t>(sizeof(sockaddr_in));
if (*addr_len >= write_len) {
*addr_len = write_len;
sockaddr_in* addr_in = reinterpret_cast<sockaddr_in*>(addr);
addr_in->sin_family = AF_INET;
memset(&addr_in->sin_addr, 0x05, sizeof(addr_in->sin_addr));
addr_in->sin_port = htons(6789);
}
}
return std::make_unique<StaticContentsSock>("");
};
int StaticContentsSock::GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const
{
std::memset(opt_val, 0x0, *opt_len);
return 0;
}
int StaticContentsSock::SetSockOpt(int, int, const void*, socklen_t) const { return 0; }
int StaticContentsSock::GetSockName(sockaddr* name, socklen_t* name_len) const
{
std::memset(name, 0x0, *name_len);
return 0;
}
bool StaticContentsSock::SetNonBlocking() const { return true; }
bool StaticContentsSock::IsSelectable() const { return true; }
bool StaticContentsSock::Wait(std::chrono::milliseconds timeout,
Event requested,
Event* occurred) const
{
if (occurred != nullptr) {
*occurred = requested;
}
return true;
}
bool StaticContentsSock::WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const
{
for (auto& [sock, events] : events_per_sock) {
(void)sock;
events.occurred = events.requested;
}
return true;
}
bool StaticContentsSock::IsConnected(std::string&) const
{
return true;
}

89
src/test/util/net.h
View file

@ -141,96 +141,41 @@ constexpr auto ALL_NETWORKS = std::array{
class StaticContentsSock : public Sock
{
public:
explicit StaticContentsSock(const std::string& contents)
: Sock{INVALID_SOCKET},
m_contents{contents}
{
}
explicit StaticContentsSock(const std::string& contents);
~StaticContentsSock() override { m_socket = INVALID_SOCKET; }
~StaticContentsSock() override;
StaticContentsSock& operator=(Sock&& other) override
{
assert(false && "Move of Sock into MockSock not allowed.");
return *this;
}
StaticContentsSock& operator=(Sock&& other) override;
ssize_t Send(const void*, size_t len, int) const override { return len; }
ssize_t Send(const void*, size_t len, int) const override;
ssize_t Recv(void* buf, size_t len, int flags) const override
{
const size_t consume_bytes{std::min(len, m_contents.size() - m_consumed)};
std::memcpy(buf, m_contents.data() + m_consumed, consume_bytes);
if ((flags & MSG_PEEK) == 0) {
m_consumed += consume_bytes;
}
return consume_bytes;
}
ssize_t Recv(void* buf, size_t len, int flags) const override;
int Connect(const sockaddr*, socklen_t) const override { return 0; }
int Connect(const sockaddr*, socklen_t) const override;
int Bind(const sockaddr*, socklen_t) const override { return 0; }
int Bind(const sockaddr*, socklen_t) const override;
int Listen(int) const override { return 0; }
int Listen(int) const override;
std::unique_ptr<Sock> Accept(sockaddr* addr, socklen_t* addr_len) const override
{
if (addr != nullptr) {
// Pretend all connections come from 5.5.5.5:6789
memset(addr, 0x00, *addr_len);
const socklen_t write_len = static_cast<socklen_t>(sizeof(sockaddr_in));
if (*addr_len >= write_len) {
*addr_len = write_len;
sockaddr_in* addr_in = reinterpret_cast<sockaddr_in*>(addr);
addr_in->sin_family = AF_INET;
memset(&addr_in->sin_addr, 0x05, sizeof(addr_in->sin_addr));
addr_in->sin_port = htons(6789);
}
}
return std::make_unique<StaticContentsSock>("");
};
std::unique_ptr<Sock> Accept(sockaddr* addr, socklen_t* addr_len) const override;
int GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const override
{
std::memset(opt_val, 0x0, *opt_len);
return 0;
}
int GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const override;
int SetSockOpt(int, int, const void*, socklen_t) const override { return 0; }
int SetSockOpt(int, int, const void*, socklen_t) const override;
int GetSockName(sockaddr* name, socklen_t* name_len) const override
{
std::memset(name, 0x0, *name_len);
return 0;
}
int GetSockName(sockaddr* name, socklen_t* name_len) const override;
bool SetNonBlocking() const override { return true; }
bool SetNonBlocking() const override;
bool IsSelectable() const override { return true; }
bool IsSelectable() const override;
bool Wait(std::chrono::milliseconds timeout,
Event requested,
Event* occurred = nullptr) const override
{
if (occurred != nullptr) {
*occurred = requested;
}
return true;
}
Event* occurred = nullptr) const override;
bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const override
{
for (auto& [sock, events] : events_per_sock) {
(void)sock;
events.occurred = events.requested;
}
return true;
}
bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const override;
bool IsConnected(std::string&) const override
{
return true;
}
bool IsConnected(std::string&) const override;
private:
const std::string m_contents;