mirror of https://github.com/oxen-io/lokinet
Refactor Addr -> IpAddress/SockAddr
This commit is contained in:
parent
1cab83ad01
commit
aee96e53a3
|
@ -2,6 +2,7 @@
|
|||
#define ABYSS_CLIENT_HPP
|
||||
|
||||
#include <ev/ev.h>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <util/json.hpp>
|
||||
#include <abyss/http.hpp>
|
||||
|
||||
|
@ -67,7 +68,7 @@ namespace abyss
|
|||
/// start runing on event loop async
|
||||
/// return true on success otherwise return false
|
||||
bool
|
||||
RunAsync(llarp_ev_loop_ptr loop, const std::string& endpoint);
|
||||
RunAsync(llarp_ev_loop_ptr loop, const llarp::IpAddress& endpoint);
|
||||
|
||||
/// must be called after RunAsync returns true
|
||||
/// queue a call for rpc
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define ABYSS_SERVER_HPP
|
||||
|
||||
#include <ev/ev.h>
|
||||
#include <net/sock_addr.hpp>
|
||||
#include <util/json.hpp>
|
||||
#include <util/thread/logic.hpp>
|
||||
#include <util/time.hpp>
|
||||
|
@ -50,7 +51,9 @@ namespace abyss
|
|||
|
||||
bool
|
||||
ServeAsync(
|
||||
llarp_ev_loop_ptr loop, std::shared_ptr<llarp::Logic> logic, const sockaddr* bindaddr);
|
||||
llarp_ev_loop_ptr loop,
|
||||
std::shared_ptr<llarp::Logic> logic,
|
||||
const llarp::SockAddr& bindaddr);
|
||||
|
||||
void
|
||||
RemoveConn(IRPCHandler* handler);
|
||||
|
|
|
@ -404,9 +404,9 @@ namespace abyss
|
|||
}
|
||||
|
||||
bool
|
||||
JSONRPC::RunAsync(llarp_ev_loop_ptr loop, const std::string& remote)
|
||||
JSONRPC::RunAsync(llarp_ev_loop_ptr loop, const llarp::IpAddress& remote)
|
||||
{
|
||||
strncpy(m_connect.remote, remote.c_str(), sizeof(m_connect.remote) - 1);
|
||||
m_connect.remote = remote;
|
||||
// TODO: ipv6
|
||||
m_connect.connected = &JSONRPC::OnConnected;
|
||||
m_connect.error = &JSONRPC::OnConnectFail;
|
||||
|
|
|
@ -340,7 +340,9 @@ namespace abyss
|
|||
|
||||
bool
|
||||
BaseReqHandler::ServeAsync(
|
||||
llarp_ev_loop_ptr loop, std::shared_ptr<llarp::Logic> logic, const sockaddr* bindaddr)
|
||||
llarp_ev_loop_ptr loop,
|
||||
std::shared_ptr<llarp::Logic> logic,
|
||||
const llarp::SockAddr& bindaddr)
|
||||
{
|
||||
m_loop = loop;
|
||||
m_Logic = logic;
|
||||
|
|
|
@ -88,21 +88,15 @@ namespace llarp
|
|||
if (arg.size() > 16)
|
||||
throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg));
|
||||
|
||||
// assume IPv4
|
||||
llarp::Addr a(arg);
|
||||
llarp::LogInfo("setting public ipv4 ", a);
|
||||
m_addrInfo.ip = *a.addr6();
|
||||
m_publicOverride = true;
|
||||
m_publicAddress.setAddress(arg);
|
||||
}
|
||||
});
|
||||
|
||||
conf.defineOption<int>("router", "public-port", false, DefaultPublicPort, [this](int arg) {
|
||||
if (arg <= 0)
|
||||
throw std::invalid_argument("public-port must be > 0");
|
||||
if (arg <= 0 || arg > std::numeric_limits<uint16_t>::max())
|
||||
throw std::invalid_argument("public-port must be >= 0 and <= 65536");
|
||||
|
||||
m_ip4addr.sin_port = arg;
|
||||
m_addrInfo.port = arg;
|
||||
m_publicOverride = true;
|
||||
m_publicAddress.setPort(arg);
|
||||
});
|
||||
|
||||
conf.defineOption<int>(
|
||||
|
@ -232,26 +226,13 @@ namespace llarp
|
|||
{
|
||||
(void)params;
|
||||
|
||||
auto parseAddr = [](std::string input) {
|
||||
Addr addr;
|
||||
bool success = addr.FromString(input);
|
||||
if (not success)
|
||||
throw std::invalid_argument(stringify(input, " is not a valid address"));
|
||||
|
||||
// default port if it wasn't specified
|
||||
if (input.find(":") == std::string::npos)
|
||||
addr.port(53);
|
||||
|
||||
return addr;
|
||||
};
|
||||
|
||||
conf.defineOption<std::string>(
|
||||
"dns", "upstream", false, true, std::nullopt, [=](std::string arg) {
|
||||
m_upstreamDNS.push_back(parseAddr(arg));
|
||||
m_upstreamDNS.push_back(IpAddress(arg));
|
||||
});
|
||||
|
||||
conf.defineOption<std::string>(
|
||||
"dns", "bind", false, std::nullopt, [=](std::string arg) { m_bind = parseAddr(arg); });
|
||||
"dns", "bind", false, std::nullopt, [=](std::string arg) { m_bind = IpAddress(arg); });
|
||||
}
|
||||
|
||||
LinksConfig::LinkInfo
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
#include <config/ini.hpp>
|
||||
#include <config/definition.hpp>
|
||||
#include <constants/files.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
|
||||
#include <cstdlib>
|
||||
#include <functional>
|
||||
|
@ -45,9 +46,7 @@ namespace llarp
|
|||
|
||||
bool m_blockBogons;
|
||||
|
||||
bool m_publicOverride = false;
|
||||
struct sockaddr_in m_ip4addr;
|
||||
AddressInfo m_addrInfo;
|
||||
IpAddress m_publicAddress;
|
||||
|
||||
int m_workerThreads;
|
||||
int m_numNetThreads;
|
||||
|
@ -93,8 +92,8 @@ namespace llarp
|
|||
|
||||
struct DnsConfig
|
||||
{
|
||||
Addr m_bind;
|
||||
std::vector<Addr> m_upstreamDNS;
|
||||
IpAddress m_bind;
|
||||
std::vector<IpAddress> m_upstreamDNS;
|
||||
|
||||
void
|
||||
defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params);
|
||||
|
|
|
@ -35,17 +35,17 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Proxy::Start(const llarp::Addr addr, const std::vector<llarp::Addr>& resolvers)
|
||||
Proxy::Start(const IpAddress& addr, const std::vector<IpAddress>& resolvers)
|
||||
{
|
||||
m_Resolvers.clear();
|
||||
m_Resolvers = resolvers;
|
||||
const llarp::Addr any("0.0.0.0", 0);
|
||||
const IpAddress any("0.0.0.0", 0);
|
||||
auto self = shared_from_this();
|
||||
LogicCall(m_ClientLogic, [=]() {
|
||||
llarp_ev_add_udp(self->m_ClientLoop.get(), &self->m_Client, any);
|
||||
llarp_ev_add_udp(self->m_ClientLoop.get(), &self->m_Client, any.createSockAddr());
|
||||
});
|
||||
LogicCall(m_ServerLogic, [=]() {
|
||||
llarp_ev_add_udp(self->m_ServerLoop.get(), &self->m_Server, addr);
|
||||
llarp_ev_add_udp(self->m_ServerLoop.get(), &self->m_Server, addr.createSockAddr());
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
@ -59,28 +59,26 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
Proxy::HandleUDPRecv_server(llarp_udp_io* u, const sockaddr* from, ManagedBuffer buf)
|
||||
Proxy::HandleUDPRecv_server(llarp_udp_io* u, const SockAddr& from, ManagedBuffer buf)
|
||||
{
|
||||
const llarp::Addr addr(*from);
|
||||
Buffer_t msgbuf = CopyBuffer(buf.underlying);
|
||||
auto self = static_cast<Proxy*>(u->user)->shared_from_this();
|
||||
// yes we use the server loop here because if the server loop is not the
|
||||
// client loop we'll crash again
|
||||
LogicCall(
|
||||
self->m_ServerLogic, [self, addr, msgbuf]() { self->HandlePktServer(addr, msgbuf); });
|
||||
self->m_ServerLogic, [self, from, msgbuf]() { self->HandlePktServer(from, msgbuf); });
|
||||
}
|
||||
|
||||
void
|
||||
Proxy::HandleUDPRecv_client(llarp_udp_io* u, const sockaddr* from, ManagedBuffer buf)
|
||||
Proxy::HandleUDPRecv_client(llarp_udp_io* u, const SockAddr& from, ManagedBuffer buf)
|
||||
{
|
||||
const llarp::Addr addr(*from);
|
||||
Buffer_t msgbuf = CopyBuffer(buf.underlying);
|
||||
auto self = static_cast<Proxy*>(u->user)->shared_from_this();
|
||||
LogicCall(
|
||||
self->m_ServerLogic, [self, addr, msgbuf]() { self->HandlePktClient(addr, msgbuf); });
|
||||
self->m_ServerLogic, [self, from, msgbuf]() { self->HandlePktClient(from, msgbuf); });
|
||||
}
|
||||
|
||||
llarp::Addr
|
||||
IpAddress
|
||||
Proxy::PickRandomResolver() const
|
||||
{
|
||||
const size_t sz = m_Resolvers.size();
|
||||
|
@ -97,7 +95,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
Proxy::SendServerMessageTo(llarp::Addr to, Message msg)
|
||||
Proxy::SendServerMessageTo(const SockAddr& to, Message msg)
|
||||
{
|
||||
auto self = shared_from_this();
|
||||
LogicCall(m_ServerLogic, [to, msg, self]() {
|
||||
|
@ -115,7 +113,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
Proxy::SendClientMessageTo(llarp::Addr to, Message msg)
|
||||
Proxy::SendClientMessageTo(const SockAddr& to, Message msg)
|
||||
{
|
||||
auto self = shared_from_this();
|
||||
LogicCall(m_ClientLogic, [to, msg, self]() {
|
||||
|
@ -133,7 +131,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
Proxy::HandlePktClient(llarp::Addr from, Buffer_t buf)
|
||||
Proxy::HandlePktClient(const SockAddr& from, Buffer_t buf)
|
||||
{
|
||||
llarp_buffer_t pkt(buf);
|
||||
MessageHeader hdr;
|
||||
|
@ -146,7 +144,7 @@ namespace llarp
|
|||
auto itr = m_Forwarded.find(tx);
|
||||
if (itr == m_Forwarded.end())
|
||||
return;
|
||||
const Addr requester = itr->second;
|
||||
const auto& requester = itr->second;
|
||||
auto self = shared_from_this();
|
||||
Message msg(hdr);
|
||||
if (msg.Decode(&pkt))
|
||||
|
@ -156,7 +154,11 @@ namespace llarp
|
|||
msg.hdr_id = itr->first.txid;
|
||||
if (!m_QueryHandler->HandleHookedDNSMessage(
|
||||
std::move(msg),
|
||||
std::bind(&Proxy::SendServerMessageTo, self, requester, std::placeholders::_1)))
|
||||
std::bind(
|
||||
&Proxy::SendServerMessageTo,
|
||||
self,
|
||||
requester.createSockAddr(),
|
||||
std::placeholders::_1)))
|
||||
{
|
||||
llarp::LogWarn("failed to handle hooked dns");
|
||||
}
|
||||
|
@ -166,14 +168,14 @@ namespace llarp
|
|||
LogicCall(m_ServerLogic, [=]() {
|
||||
// forward reply to requester via server
|
||||
const llarp_buffer_t tmpbuf(buf);
|
||||
llarp_ev_udp_sendto(&self->m_Server, requester, tmpbuf);
|
||||
llarp_ev_udp_sendto(&self->m_Server, requester.createSockAddr(), tmpbuf);
|
||||
});
|
||||
// remove pending
|
||||
m_Forwarded.erase(itr);
|
||||
}
|
||||
|
||||
void
|
||||
Proxy::HandlePktServer(llarp::Addr from, Buffer_t buf)
|
||||
Proxy::HandlePktServer(const SockAddr& from, Buffer_t buf)
|
||||
{
|
||||
MessageHeader hdr;
|
||||
llarp_buffer_t pkt(buf);
|
||||
|
@ -236,7 +238,7 @@ namespace llarp
|
|||
LogicCall(m_ClientLogic, [=] {
|
||||
// do query
|
||||
const llarp_buffer_t tmpbuf(buf);
|
||||
llarp_ev_udp_sendto(&self->m_Client, tx.from, tmpbuf);
|
||||
llarp_ev_udp_sendto(&self->m_Client, tx.from.createSockAddr(), tmpbuf);
|
||||
});
|
||||
}
|
||||
else
|
||||
|
@ -246,7 +248,7 @@ namespace llarp
|
|||
LogicCall(m_ClientLogic, [=] {
|
||||
// send it
|
||||
const llarp_buffer_t tmpbuf(buf);
|
||||
llarp_ev_udp_sendto(&self->m_Client, resolver, tmpbuf);
|
||||
llarp_ev_udp_sendto(&self->m_Client, resolver.createSockAddr(), tmpbuf);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
@ -37,7 +37,7 @@ namespace llarp
|
|||
IQueryHandler* handler);
|
||||
|
||||
bool
|
||||
Start(const llarp::Addr addr, const std::vector<llarp::Addr>& resolvers);
|
||||
Start(const IpAddress& addr, const std::vector<IpAddress>& resolvers);
|
||||
|
||||
void
|
||||
Stop();
|
||||
|
@ -47,9 +47,9 @@ namespace llarp
|
|||
private:
|
||||
/// low level packet handler
|
||||
static void
|
||||
HandleUDPRecv_client(llarp_udp_io*, const struct sockaddr*, ManagedBuffer);
|
||||
HandleUDPRecv_client(llarp_udp_io*, const SockAddr&, ManagedBuffer);
|
||||
static void
|
||||
HandleUDPRecv_server(llarp_udp_io*, const struct sockaddr*, ManagedBuffer);
|
||||
HandleUDPRecv_server(llarp_udp_io*, const SockAddr&, ManagedBuffer);
|
||||
|
||||
/// low level ticker
|
||||
static void
|
||||
|
@ -59,18 +59,18 @@ namespace llarp
|
|||
Tick(llarp_time_t now);
|
||||
|
||||
void
|
||||
HandlePktClient(llarp::Addr from, Buffer_t buf);
|
||||
HandlePktClient(const SockAddr& from, Buffer_t buf);
|
||||
|
||||
void
|
||||
HandlePktServer(llarp::Addr from, Buffer_t buf);
|
||||
HandlePktServer(const SockAddr& from, Buffer_t buf);
|
||||
|
||||
void
|
||||
SendClientMessageTo(llarp::Addr to, Message msg);
|
||||
SendClientMessageTo(const SockAddr& to, Message msg);
|
||||
|
||||
void
|
||||
SendServerMessageTo(llarp::Addr to, Message msg);
|
||||
SendServerMessageTo(const SockAddr& to, Message msg);
|
||||
|
||||
llarp::Addr
|
||||
IpAddress
|
||||
PickRandomResolver() const;
|
||||
|
||||
private:
|
||||
|
@ -81,12 +81,12 @@ namespace llarp
|
|||
Logic_ptr m_ServerLogic;
|
||||
Logic_ptr m_ClientLogic;
|
||||
IQueryHandler* m_QueryHandler;
|
||||
std::vector<llarp::Addr> m_Resolvers;
|
||||
std::vector<IpAddress> m_Resolvers;
|
||||
|
||||
struct TX
|
||||
{
|
||||
MsgID_t txid;
|
||||
llarp::Addr from;
|
||||
IpAddress from;
|
||||
|
||||
bool
|
||||
operator==(const TX& other) const
|
||||
|
@ -99,13 +99,13 @@ namespace llarp
|
|||
size_t
|
||||
operator()(const TX& t) const noexcept
|
||||
{
|
||||
return t.txid ^ llarp::Addr::Hash()(t.from);
|
||||
return t.txid ^ IpAddress::Hash()(t.from);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
// maps tx to who to send reply to
|
||||
std::unordered_map<TX, llarp::Addr, TX::Hash> m_Forwarded;
|
||||
std::unordered_map<TX, IpAddress, TX::Hash> m_Forwarded;
|
||||
};
|
||||
} // namespace dns
|
||||
} // namespace llarp
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#include <ev/ev.h>
|
||||
#include <util/mem.hpp>
|
||||
#include <util/str.hpp>
|
||||
#include <util/thread/logic.hpp>
|
||||
#include <net/net_addr.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
|
@ -37,7 +37,7 @@ llarp_ev_loop_run_single_process(llarp_ev_loop_ptr ev, std::shared_ptr<llarp::Lo
|
|||
}
|
||||
|
||||
int
|
||||
llarp_ev_add_udp(struct llarp_ev_loop* ev, struct llarp_udp_io* udp, const struct sockaddr* src)
|
||||
llarp_ev_add_udp(struct llarp_ev_loop* ev, struct llarp_udp_io* udp, const llarp::SockAddr& src)
|
||||
{
|
||||
udp->parent = ev;
|
||||
if (ev->udp_listen(udp, src))
|
||||
|
@ -68,7 +68,7 @@ llarp_ev_loop_stop(const llarp_ev_loop_ptr& loop)
|
|||
}
|
||||
|
||||
int
|
||||
llarp_ev_udp_sendto(struct llarp_udp_io* udp, const sockaddr* to, const llarp_buffer_t& buf)
|
||||
llarp_ev_udp_sendto(struct llarp_udp_io* udp, const llarp::SockAddr& to, const llarp_buffer_t& buf)
|
||||
{
|
||||
return udp->sendto(udp, to, buf.base, buf.sz);
|
||||
}
|
||||
|
@ -144,29 +144,13 @@ void
|
|||
llarp_tcp_async_try_connect(struct llarp_ev_loop* loop, struct llarp_tcp_connecter* tcp)
|
||||
{
|
||||
tcp->loop = loop;
|
||||
std::string_view addr_str, port_str;
|
||||
// try parsing address
|
||||
const char* begin = tcp->remote;
|
||||
const char* ptr = strstr(tcp->remote, ":");
|
||||
// get end of address
|
||||
|
||||
if (ptr == nullptr)
|
||||
{
|
||||
llarp::LogError("bad address: ", tcp->remote);
|
||||
if (tcp->error)
|
||||
tcp->error(tcp);
|
||||
return;
|
||||
}
|
||||
const char* end = ptr;
|
||||
while (*end && ((end - begin) < static_cast<ptrdiff_t>(sizeof tcp->remote)))
|
||||
{
|
||||
++end;
|
||||
}
|
||||
addr_str = std::string_view(begin, ptr - begin);
|
||||
++ptr;
|
||||
port_str = std::string_view(ptr, end - ptr);
|
||||
// actually parse address
|
||||
llarp::Addr addr(addr_str, port_str);
|
||||
llarp::IpAddress address(tcp->remote);
|
||||
|
||||
if (not address.getPort())
|
||||
throw std::runtime_error(llarp::stringify("Address with no port: ", address));
|
||||
|
||||
llarp::SockAddr addr = address.createSockAddr();
|
||||
|
||||
if (!loop->tcp_connect(tcp, addr))
|
||||
{
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef LLARP_EV_H
|
||||
#define LLARP_EV_H
|
||||
|
||||
#include <net/ip_address.hpp>
|
||||
#include <util/buffer.hpp>
|
||||
#include <util/time.hpp>
|
||||
#include <tuntap.h>
|
||||
|
@ -76,10 +77,10 @@ struct llarp_udp_io
|
|||
|
||||
/// called every event loop tick after reads
|
||||
void (*tick)(struct llarp_udp_io*);
|
||||
/// sockaddr * is the source address
|
||||
void (*recvfrom)(struct llarp_udp_io*, const struct sockaddr*, ManagedBuffer);
|
||||
|
||||
void (*recvfrom)(struct llarp_udp_io*, const llarp::SockAddr& source, ManagedBuffer);
|
||||
/// set by parent
|
||||
int (*sendto)(struct llarp_udp_io*, const struct sockaddr*, const byte_t*, size_t);
|
||||
int (*sendto)(struct llarp_udp_io*, const llarp::SockAddr&, const byte_t*, size_t);
|
||||
};
|
||||
|
||||
/// get all packets recvieved last tick
|
||||
|
@ -89,11 +90,11 @@ llarp_ev_udp_recvmany(struct llarp_udp_io* udp, struct llarp_pkt_list* pkts);
|
|||
|
||||
/// add UDP handler
|
||||
int
|
||||
llarp_ev_add_udp(struct llarp_ev_loop* ev, struct llarp_udp_io* udp, const struct sockaddr* src);
|
||||
llarp_ev_add_udp(struct llarp_ev_loop* ev, struct llarp_udp_io* udp, const llarp::SockAddr& src);
|
||||
|
||||
/// send a UDP packet
|
||||
int
|
||||
llarp_ev_udp_sendto(struct llarp_udp_io* udp, const struct sockaddr* to, const llarp_buffer_t& pkt);
|
||||
llarp_ev_udp_sendto(struct llarp_udp_io* udp, const llarp::SockAddr& to, const llarp_buffer_t& pkt);
|
||||
|
||||
/// close UDP handler
|
||||
int
|
||||
|
@ -140,7 +141,7 @@ struct llarp_tcp_connecter
|
|||
/// remote address family
|
||||
int af;
|
||||
/// remote address string
|
||||
char remote[512];
|
||||
llarp::IpAddress remote;
|
||||
/// userdata pointer
|
||||
void* user;
|
||||
/// private implementation (dont set me)
|
||||
|
@ -180,7 +181,8 @@ struct llarp_tcp_acceptor
|
|||
/// return false if failed to bind
|
||||
/// return true on success
|
||||
bool
|
||||
llarp_tcp_serve(struct llarp_ev_loop* loop, struct llarp_tcp_acceptor* t, const sockaddr* bindaddr);
|
||||
llarp_tcp_serve(
|
||||
struct llarp_ev_loop* loop, struct llarp_tcp_acceptor* t, const llarp::SockAddr& bindaddr);
|
||||
|
||||
/// close and stop accepting connections
|
||||
void
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#ifndef LLARP_EV_HPP
|
||||
#define LLARP_EV_HPP
|
||||
|
||||
#include <net/net_addr.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <ev/ev.h>
|
||||
#include <util/buffer.hpp>
|
||||
#include <util/codel.hpp>
|
||||
|
@ -159,7 +159,7 @@ namespace llarp
|
|||
read(byte_t* buf, size_t sz) = 0;
|
||||
|
||||
virtual int
|
||||
sendto(const sockaddr* dst, const void* data, size_t sz)
|
||||
sendto(const SockAddr& dst, const void* data, size_t sz)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(dst);
|
||||
UNREFERENCED_PARAMETER(data);
|
||||
|
@ -379,7 +379,7 @@ namespace llarp
|
|||
|
||||
virtual int
|
||||
sendto(
|
||||
__attribute__((unused)) const sockaddr* dst,
|
||||
__attribute__((unused)) const SockAddr& dst,
|
||||
__attribute__((unused)) const void* data,
|
||||
__attribute__((unused)) size_t sz)
|
||||
{
|
||||
|
@ -525,7 +525,6 @@ namespace llarp
|
|||
// on sockets
|
||||
struct tcp_conn : public ev_io
|
||||
{
|
||||
sockaddr_storage _addr;
|
||||
bool _shouldClose = false;
|
||||
bool _calledConnected = false;
|
||||
llarp_tcp_conn tcp;
|
||||
|
@ -551,15 +550,10 @@ namespace llarp
|
|||
}
|
||||
|
||||
/// outbound
|
||||
tcp_conn(llarp_ev_loop* loop, int _fd, const sockaddr* addr, llarp_tcp_connecter* conn)
|
||||
tcp_conn(llarp_ev_loop* loop, int _fd, const SockAddr& addr, llarp_tcp_connecter* conn)
|
||||
: ev_io(_fd, new LosslessWriteQueue_t{}), _conn(conn)
|
||||
{
|
||||
socklen_t slen = sizeof(sockaddr_in);
|
||||
if (addr->sa_family == AF_INET6)
|
||||
slen = sizeof(sockaddr_in6);
|
||||
else if (addr->sa_family == AF_UNIX)
|
||||
slen = sizeof(sockaddr_un);
|
||||
memcpy(&_addr, addr, slen);
|
||||
(void)addr;
|
||||
tcp.impl = this;
|
||||
tcp.loop = loop;
|
||||
tcp.closed = nullptr;
|
||||
|
@ -730,7 +724,7 @@ struct llarp_ev_loop
|
|||
|
||||
/// return false on socket error (non blocking)
|
||||
virtual bool
|
||||
tcp_connect(llarp_tcp_connecter* tcp, const sockaddr* addr) = 0;
|
||||
tcp_connect(llarp_tcp_connecter* tcp, const llarp::SockAddr& addr) = 0;
|
||||
|
||||
virtual int
|
||||
tick(int ms) = 0;
|
||||
|
@ -748,7 +742,7 @@ struct llarp_ev_loop
|
|||
stop() = 0;
|
||||
|
||||
virtual bool
|
||||
udp_listen(llarp_udp_io* l, const sockaddr* src) = 0;
|
||||
udp_listen(llarp_udp_io* l, const llarp::SockAddr& src) = 0;
|
||||
|
||||
virtual bool
|
||||
udp_close(llarp_udp_io* l) = 0;
|
||||
|
@ -772,7 +766,7 @@ struct llarp_ev_loop
|
|||
create_tun(llarp_tun_io* tun) = 0;
|
||||
|
||||
virtual llarp::ev_io*
|
||||
bind_tcp(llarp_tcp_acceptor* tcp, const sockaddr* addr) = 0;
|
||||
bind_tcp(llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr) = 0;
|
||||
|
||||
virtual bool
|
||||
add_pipe(llarp_ev_pkt_pipe*)
|
||||
|
@ -788,7 +782,7 @@ struct llarp_ev_loop
|
|||
add_ev(llarp::ev_io* ev, bool write) = 0;
|
||||
|
||||
virtual bool
|
||||
tcp_listen(llarp_tcp_acceptor* tcp, const sockaddr* addr)
|
||||
tcp_listen(llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr)
|
||||
{
|
||||
auto conn = bind_tcp(tcp, addr);
|
||||
return conn && add_ev(conn, true);
|
||||
|
@ -878,7 +872,7 @@ struct PacketBuffer
|
|||
|
||||
struct PacketEvent
|
||||
{
|
||||
llarp::Addr remote;
|
||||
llarp::SockAddr remote;
|
||||
PacketBuffer pkt;
|
||||
};
|
||||
|
||||
|
|
|
@ -1,5 +1,4 @@
|
|||
#include <ev/ev_libuv.hpp>
|
||||
#include <net/net_addr.hpp>
|
||||
#include <util/thread/logic.hpp>
|
||||
#include <util/thread/queue.hpp>
|
||||
|
||||
|
@ -54,10 +53,10 @@ namespace libuv
|
|||
llarp_tcp_connecter* const m_TCP;
|
||||
llarp_tcp_acceptor* const m_Accept;
|
||||
llarp_tcp_conn m_Conn;
|
||||
llarp::Addr m_Addr;
|
||||
llarp::SockAddr m_Addr;
|
||||
|
||||
conn_glue(uv_loop_t* loop, llarp_tcp_connecter* tcp, const sockaddr* addr)
|
||||
: m_TCP(tcp), m_Accept(nullptr), m_Addr(*addr)
|
||||
conn_glue(uv_loop_t* loop, llarp_tcp_connecter* tcp, const llarp::SockAddr& addr)
|
||||
: m_TCP(tcp), m_Accept(nullptr), m_Addr(addr)
|
||||
{
|
||||
m_Connect.data = this;
|
||||
m_Handle.data = this;
|
||||
|
@ -69,8 +68,8 @@ namespace libuv
|
|||
m_Conn.write = &ExplicitWrite;
|
||||
}
|
||||
|
||||
conn_glue(uv_loop_t* loop, llarp_tcp_acceptor* tcp, const sockaddr* addr)
|
||||
: m_TCP(nullptr), m_Accept(tcp), m_Addr(*addr)
|
||||
conn_glue(uv_loop_t* loop, llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr)
|
||||
: m_TCP(nullptr), m_Accept(tcp), m_Addr(addr)
|
||||
{
|
||||
m_Connect.data = nullptr;
|
||||
m_Handle.data = this;
|
||||
|
@ -397,11 +396,12 @@ namespace libuv
|
|||
uv_udp_t m_Handle;
|
||||
uv_check_t m_Ticker;
|
||||
llarp_udp_io* const m_UDP;
|
||||
llarp::Addr m_Addr;
|
||||
llarp::SockAddr m_Addr;
|
||||
llarp_pkt_list m_LastPackets;
|
||||
std::array<char, 1500> m_Buffer;
|
||||
|
||||
udp_glue(uv_loop_t* loop, llarp_udp_io* udp, const sockaddr* src) : m_UDP(udp), m_Addr(*src)
|
||||
udp_glue(uv_loop_t* loop, llarp_udp_io* udp, const llarp::SockAddr& src)
|
||||
: m_UDP(udp), m_Addr(src)
|
||||
{
|
||||
m_Handle.data = this;
|
||||
m_Ticker.data = this;
|
||||
|
@ -417,13 +417,13 @@ namespace libuv
|
|||
buf->len = sz;
|
||||
}
|
||||
|
||||
/// callback for libuv
|
||||
static void
|
||||
OnRecv(
|
||||
uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned)
|
||||
OnRecv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const sockaddr* addr, unsigned)
|
||||
{
|
||||
udp_glue* glue = static_cast<udp_glue*>(handle->data);
|
||||
if (addr)
|
||||
glue->RecvFrom(nread, buf, addr);
|
||||
glue->RecvFrom(nread, buf, llarp::SockAddr(addr));
|
||||
if (nread <= 0 || glue->m_UDP == nullptr || glue->m_UDP->recvfrom != nullptr)
|
||||
delete[] buf->base;
|
||||
}
|
||||
|
@ -437,7 +437,7 @@ namespace libuv
|
|||
}
|
||||
|
||||
void
|
||||
RecvFrom(ssize_t sz, const uv_buf_t* buf, const struct sockaddr* fromaddr)
|
||||
RecvFrom(ssize_t sz, const uv_buf_t* buf, const llarp::SockAddr& fromaddr)
|
||||
{
|
||||
if (sz > 0 && m_UDP)
|
||||
{
|
||||
|
@ -450,7 +450,7 @@ namespace libuv
|
|||
else
|
||||
{
|
||||
PacketBuffer pbuf(buf->base, pktsz);
|
||||
m_LastPackets.emplace_back(PacketEvent{*fromaddr, std::move(pbuf)});
|
||||
m_LastPackets.emplace_back(PacketEvent{fromaddr, std::move(pbuf)});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -470,7 +470,7 @@ namespace libuv
|
|||
}
|
||||
|
||||
static int
|
||||
SendTo(llarp_udp_io* udp, const sockaddr* to, const byte_t* ptr, size_t sz)
|
||||
SendTo(llarp_udp_io* udp, const llarp::SockAddr& to, const byte_t* ptr, size_t sz)
|
||||
{
|
||||
auto* self = static_cast<udp_glue*>(udp->impl);
|
||||
if (self == nullptr)
|
||||
|
@ -817,7 +817,7 @@ namespace libuv
|
|||
}
|
||||
|
||||
bool
|
||||
Loop::tcp_connect(llarp_tcp_connecter* tcp, const sockaddr* addr)
|
||||
Loop::tcp_connect(llarp_tcp_connecter* tcp, const llarp::SockAddr& addr)
|
||||
{
|
||||
auto* impl = new conn_glue(&m_Impl, tcp, addr);
|
||||
tcp->impl = impl;
|
||||
|
@ -981,7 +981,7 @@ namespace libuv
|
|||
}
|
||||
|
||||
bool
|
||||
Loop::udp_listen(llarp_udp_io* udp, const sockaddr* src)
|
||||
Loop::udp_listen(llarp_udp_io* udp, const llarp::SockAddr& src)
|
||||
{
|
||||
auto* impl = new udp_glue(&m_Impl, udp, src);
|
||||
udp->impl = impl;
|
||||
|
@ -1036,7 +1036,7 @@ namespace libuv
|
|||
}
|
||||
|
||||
bool
|
||||
Loop::tcp_listen(llarp_tcp_acceptor* tcp, const sockaddr* addr)
|
||||
Loop::tcp_listen(llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr)
|
||||
{
|
||||
auto* glue = new conn_glue(&m_Impl, tcp, addr);
|
||||
tcp->impl = glue;
|
||||
|
|
|
@ -43,7 +43,7 @@ namespace libuv
|
|||
|
||||
/// return false on socket error (non blocking)
|
||||
bool
|
||||
tcp_connect(llarp_tcp_connecter* tcp, const sockaddr* addr) override;
|
||||
tcp_connect(llarp_tcp_connecter* tcp, const llarp::SockAddr& addr) override;
|
||||
|
||||
int
|
||||
tick(int ms) override;
|
||||
|
@ -73,7 +73,7 @@ namespace libuv
|
|||
CloseAll();
|
||||
|
||||
bool
|
||||
udp_listen(llarp_udp_io* l, const sockaddr* src) override;
|
||||
udp_listen(llarp_udp_io* l, const llarp::SockAddr& src) override;
|
||||
|
||||
bool
|
||||
udp_close(llarp_udp_io* l) override;
|
||||
|
@ -95,13 +95,13 @@ namespace libuv
|
|||
}
|
||||
|
||||
bool
|
||||
tcp_listen(llarp_tcp_acceptor* tcp, const sockaddr* addr) override;
|
||||
tcp_listen(llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr) override;
|
||||
|
||||
bool
|
||||
add_pipe(llarp_ev_pkt_pipe* p) override;
|
||||
|
||||
llarp::ev_io*
|
||||
bind_tcp(llarp_tcp_acceptor*, const sockaddr*) override
|
||||
bind_tcp(llarp_tcp_acceptor*, const llarp::SockAddr&) override
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
|
|
@ -343,7 +343,7 @@ namespace llarp
|
|||
llarp::LogWarn("Could not create tunnel for exit endpoint");
|
||||
return false;
|
||||
}
|
||||
llarp::LogInfo("Trying to start resolver ", m_LocalResolverAddr.ToString());
|
||||
llarp::LogInfo("Trying to start resolver ", m_LocalResolverAddr.toString());
|
||||
return m_Resolver->Start(m_LocalResolverAddr, m_UpstreamResolvers);
|
||||
}
|
||||
return true;
|
||||
|
|
|
@ -166,8 +166,8 @@ namespace llarp
|
|||
|
||||
llarp_tun_io m_Tun;
|
||||
|
||||
Addr m_LocalResolverAddr;
|
||||
std::vector<Addr> m_UpstreamResolvers;
|
||||
IpAddress m_LocalResolverAddr;
|
||||
std::vector<IpAddress> m_UpstreamResolvers;
|
||||
|
||||
using Pkt_t = net::IPPacket;
|
||||
using PacketQueue_t = util::CoDelQueue<
|
||||
|
|
|
@ -80,9 +80,9 @@ namespace llarp
|
|||
|
||||
std::vector<std::string> resolvers;
|
||||
for (const auto& addr : m_UpstreamResolvers)
|
||||
resolvers.emplace_back(addr.ToString());
|
||||
resolvers.emplace_back(addr.toString());
|
||||
obj["ustreamResolvers"] = resolvers;
|
||||
obj["localResolver"] = m_LocalResolverAddr.ToString();
|
||||
obj["localResolver"] = m_LocalResolverAddr.toString();
|
||||
util::StatusObject ips{};
|
||||
for (const auto& item : m_IPActivity)
|
||||
{
|
||||
|
@ -818,7 +818,7 @@ namespace llarp
|
|||
env.emplace("IF_NAME", tunif->ifname);
|
||||
std::string strictConnect;
|
||||
for (const auto& addr : m_StrictConnectAddrs)
|
||||
strictConnect += addr.ToString() + " ";
|
||||
strictConnect += addr.toString() + " ";
|
||||
env.emplace("STRICT_CONNECT_ADDRS", strictConnect);
|
||||
return env;
|
||||
}
|
||||
|
|
|
@ -298,11 +298,11 @@ namespace llarp
|
|||
/// our ip range we are using
|
||||
llarp::IPRange m_OurRange;
|
||||
/// upstream dns resolver list
|
||||
std::vector<llarp::Addr> m_UpstreamResolvers;
|
||||
std::vector<IpAddress> m_UpstreamResolvers;
|
||||
/// local dns
|
||||
llarp::Addr m_LocalResolverAddr;
|
||||
IpAddress m_LocalResolverAddr;
|
||||
/// list of strict connect addresses for hooks
|
||||
std::vector<llarp::Addr> m_StrictConnectAddrs;
|
||||
std::vector<IpAddress> m_StrictConnectAddrs;
|
||||
/// use v6?
|
||||
bool m_UseV6;
|
||||
struct lazy_vpn
|
||||
|
|
|
@ -45,7 +45,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
LinkLayer::RecvFrom(const Addr& from, ILinkSession::Packet_t pkt)
|
||||
LinkLayer::RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt)
|
||||
{
|
||||
std::shared_ptr<ILinkSession> session;
|
||||
auto itr = m_AuthedAddrs.find(from);
|
||||
|
@ -89,9 +89,9 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
LinkLayer::UnmapAddr(const Addr& a)
|
||||
LinkLayer::UnmapAddr(const IpAddress& addr)
|
||||
{
|
||||
m_AuthedAddrs.erase(a);
|
||||
m_AuthedAddrs.erase(addr);
|
||||
}
|
||||
|
||||
std::shared_ptr<ILinkSession>
|
||||
|
|
|
@ -41,19 +41,19 @@ namespace llarp
|
|||
Rank() const override;
|
||||
|
||||
void
|
||||
RecvFrom(const Addr& from, ILinkSession::Packet_t pkt) override;
|
||||
RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) override;
|
||||
|
||||
bool
|
||||
MapAddr(const RouterID& pk, ILinkSession* s) override;
|
||||
|
||||
void
|
||||
UnmapAddr(const Addr& addr);
|
||||
UnmapAddr(const IpAddress& addr);
|
||||
|
||||
void
|
||||
QueueWork(std::function<void(void)> work);
|
||||
|
||||
private:
|
||||
std::unordered_map<Addr, RouterID, Addr::Hash> m_AuthedAddrs;
|
||||
std::unordered_map<IpAddress, RouterID, IpAddress::Hash> m_AuthedAddrs;
|
||||
const bool permitInbound;
|
||||
};
|
||||
|
||||
|
|
|
@ -31,7 +31,7 @@ namespace llarp
|
|||
, m_Inbound{false}
|
||||
, m_Parent(p)
|
||||
, m_CreatedAt{p->Now()}
|
||||
, m_RemoteAddr(ai)
|
||||
, m_RemoteAddr(ai.toIpAddress())
|
||||
, m_ChosenAI(ai)
|
||||
, m_RemoteRC(rc)
|
||||
{
|
||||
|
@ -40,7 +40,7 @@ namespace llarp
|
|||
CryptoManager::instance()->shorthash(m_SessionKey, llarp_buffer_t(rc.pubkey));
|
||||
}
|
||||
|
||||
Session::Session(LinkLayer* p, const Addr& from)
|
||||
Session::Session(LinkLayer* p, const IpAddress& from)
|
||||
: m_State{State::Initial}
|
||||
, m_Inbound{true}
|
||||
, m_Parent(p)
|
||||
|
@ -58,7 +58,7 @@ namespace llarp
|
|||
{
|
||||
LogDebug("send ", sz, " to ", m_RemoteAddr);
|
||||
const llarp_buffer_t pkt(buf, sz);
|
||||
m_Parent->SendTo_LL(m_RemoteAddr, pkt);
|
||||
m_Parent->SendTo_LL(m_RemoteAddr.createSockAddr(), pkt);
|
||||
m_LastTX = time_now_ms();
|
||||
m_TXRate += sz;
|
||||
}
|
||||
|
@ -309,7 +309,7 @@ namespace llarp
|
|||
{"replayFilter", m_ReplayFilter.size()},
|
||||
{"txMsgQueueSize", m_TXMsgs.size()},
|
||||
{"rxMsgQueueSize", m_RXMsgs.size()},
|
||||
{"remoteAddr", m_RemoteAddr.ToString()},
|
||||
{"remoteAddr", m_RemoteAddr.toString()},
|
||||
{"remoteRC", m_RemoteRC.ExtractStatus()},
|
||||
{"created", to_json(m_CreatedAt)},
|
||||
{"uptime", to_json(now - m_CreatedAt)}};
|
||||
|
|
|
@ -4,6 +4,8 @@
|
|||
#include <link/session.hpp>
|
||||
#include <iwp/linklayer.hpp>
|
||||
#include <iwp/message_buffer.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
|
||||
#include <unordered_set>
|
||||
#include <deque>
|
||||
|
||||
|
@ -41,7 +43,7 @@ namespace llarp
|
|||
/// outbound session
|
||||
Session(LinkLayer* parent, const RouterContact& rc, const AddressInfo& ai);
|
||||
/// inbound session
|
||||
Session(LinkLayer* parent, const Addr& from);
|
||||
Session(LinkLayer* parent, const IpAddress& from);
|
||||
|
||||
~Session() = default;
|
||||
|
||||
|
@ -88,7 +90,7 @@ namespace llarp
|
|||
return m_RemoteRC.pubkey;
|
||||
}
|
||||
|
||||
Addr
|
||||
IpAddress
|
||||
GetRemoteEndpoint() const override
|
||||
{
|
||||
return m_RemoteAddr;
|
||||
|
@ -164,7 +166,7 @@ namespace llarp
|
|||
/// parent link layer
|
||||
LinkLayer* const m_Parent;
|
||||
const llarp_time_t m_CreatedAt;
|
||||
const Addr m_RemoteAddr;
|
||||
const IpAddress m_RemoteAddr;
|
||||
|
||||
AddressInfo m_ChosenAI;
|
||||
/// remote rc
|
||||
|
|
|
@ -132,12 +132,19 @@ namespace llarp
|
|||
}
|
||||
else
|
||||
{
|
||||
if (not m_ourAddr.FromString(ifname))
|
||||
throw std::invalid_argument(stringify("cannot parse network address: ", ifname));
|
||||
try
|
||||
{
|
||||
m_ourAddr = IpAddress(ifname);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
LogError(stringify("Could not use ifname ", ifname, " to configure ILinkLayer"));
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
m_ourAddr.port(port);
|
||||
return llarp_ev_add_udp(m_Loop.get(), &m_udp, m_ourAddr) != -1;
|
||||
m_ourAddr.setPort(port);
|
||||
return llarp_ev_add_udp(m_Loop.get(), &m_udp, m_ourAddr.createSockAddr()) != -1;
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -208,7 +215,7 @@ namespace llarp
|
|||
{
|
||||
Lock_t l_authed(m_AuthedLinksMutex);
|
||||
Lock_t l_pending(m_PendingMutex);
|
||||
llarp::Addr addr = s->GetRemoteEndpoint();
|
||||
IpAddress addr = s->GetRemoteEndpoint();
|
||||
auto itr = m_Pending.find(addr);
|
||||
if (itr != m_Pending.end())
|
||||
{
|
||||
|
@ -264,7 +271,7 @@ namespace llarp
|
|||
|
||||
return {{"name", Name()},
|
||||
{"rank", uint64_t(Rank())},
|
||||
{"addr", m_ourAddr.ToString()},
|
||||
{"addr", m_ourAddr.toString()},
|
||||
{"sessions", util::StatusObject{{"pending", pending}, {"established", established}}}};
|
||||
}
|
||||
|
||||
|
@ -282,14 +289,14 @@ namespace llarp
|
|||
llarp::AddressInfo to;
|
||||
if (!PickAddress(rc, to))
|
||||
return false;
|
||||
const llarp::Addr addr(to);
|
||||
const IpAddress address = to.toIpAddress();
|
||||
{
|
||||
Lock_t l(m_PendingMutex);
|
||||
if (m_Pending.count(addr) >= MaxSessionsPerKey)
|
||||
if (m_Pending.count(address) >= MaxSessionsPerKey)
|
||||
{
|
||||
LogDebug(
|
||||
"Too many pending connections to ",
|
||||
addr,
|
||||
address,
|
||||
" while establishing to ",
|
||||
RouterID{rc.pubkey},
|
||||
", not establishing another");
|
||||
|
@ -440,11 +447,10 @@ namespace llarp
|
|||
bool
|
||||
ILinkLayer::GetOurAddressInfo(llarp::AddressInfo& addr) const
|
||||
{
|
||||
addr.fromIpAddress(m_ourAddr);
|
||||
addr.dialect = Name();
|
||||
addr.pubkey = TransportPubKey();
|
||||
addr.rank = Rank();
|
||||
addr.port = m_ourAddr.port();
|
||||
addr.ip = *m_ourAddr.addr6();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -465,10 +471,10 @@ namespace llarp
|
|||
{
|
||||
static constexpr size_t MaxSessionsPerEndpoint = 5;
|
||||
Lock_t lock(m_PendingMutex);
|
||||
llarp::Addr addr = s->GetRemoteEndpoint();
|
||||
if (m_Pending.count(addr) >= MaxSessionsPerEndpoint)
|
||||
IpAddress address = s->GetRemoteEndpoint();
|
||||
if (m_Pending.count(address) >= MaxSessionsPerEndpoint)
|
||||
return false;
|
||||
m_Pending.emplace(addr, s);
|
||||
m_Pending.emplace(address, s);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
#include <crypto/types.hpp>
|
||||
#include <ev/ev.h>
|
||||
#include <link/session.hpp>
|
||||
#include <net/net.hpp>
|
||||
#include <net/sock_addr.hpp>
|
||||
#include <router_contact.hpp>
|
||||
#include <util/status.hpp>
|
||||
#include <util/thread/logic.hpp>
|
||||
|
@ -82,7 +82,7 @@ namespace llarp
|
|||
udp_tick(llarp_udp_io* udp);
|
||||
|
||||
void
|
||||
SendTo_LL(const llarp::Addr& to, const llarp_buffer_t& pkt)
|
||||
SendTo_LL(const SockAddr& to, const llarp_buffer_t& pkt)
|
||||
{
|
||||
llarp_ev_udp_sendto(&m_udp, to, pkt);
|
||||
}
|
||||
|
@ -97,7 +97,7 @@ namespace llarp
|
|||
Pump();
|
||||
|
||||
virtual void
|
||||
RecvFrom(const Addr& from, ILinkSession::Packet_t pkt) = 0;
|
||||
RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) = 0;
|
||||
|
||||
bool
|
||||
PickAddress(const RouterContact& rc, AddressInfo& picked) const;
|
||||
|
@ -225,20 +225,20 @@ namespace llarp
|
|||
std::shared_ptr<llarp::Logic> m_Logic = nullptr;
|
||||
std::shared_ptr<llarp::thread::ThreadPool> m_Worker = nullptr;
|
||||
llarp_ev_loop_ptr m_Loop;
|
||||
Addr m_ourAddr;
|
||||
IpAddress m_ourAddr;
|
||||
llarp_udp_io m_udp;
|
||||
SecretKey m_SecretKey;
|
||||
|
||||
using AuthedLinks =
|
||||
std::unordered_multimap<RouterID, std::shared_ptr<ILinkSession>, RouterID::Hash>;
|
||||
using Pending =
|
||||
std::unordered_multimap<llarp::Addr, std::shared_ptr<ILinkSession>, llarp::Addr::Hash>;
|
||||
std::unordered_multimap<IpAddress, std::shared_ptr<ILinkSession>, IpAddress::Hash>;
|
||||
mutable DECLARE_LOCK(Mutex_t, m_AuthedLinksMutex, ACQUIRED_BEFORE(m_PendingMutex));
|
||||
AuthedLinks m_AuthedLinks GUARDED_BY(m_AuthedLinksMutex);
|
||||
mutable DECLARE_LOCK(Mutex_t, m_PendingMutex, ACQUIRED_AFTER(m_AuthedLinksMutex));
|
||||
Pending m_Pending GUARDED_BY(m_PendingMutex);
|
||||
|
||||
std::unordered_map<llarp::Addr, llarp_time_t, llarp::Addr::Hash> m_RecentlyClosed;
|
||||
std::unordered_map<IpAddress, llarp_time_t, IpAddress::Hash> m_RecentlyClosed;
|
||||
};
|
||||
|
||||
using LinkLayer_ptr = std::shared_ptr<ILinkLayer>;
|
||||
|
|
|
@ -87,7 +87,7 @@ namespace llarp
|
|||
IsInbound() const = 0;
|
||||
|
||||
/// get remote address
|
||||
virtual Addr
|
||||
virtual IpAddress
|
||||
GetRemoteEndpoint() const = 0;
|
||||
|
||||
// get remote rc
|
||||
|
|
|
@ -185,7 +185,7 @@ namespace llarp
|
|||
// the actual hop
|
||||
std::shared_ptr<Hop> hop;
|
||||
|
||||
const std::optional<llarp::Addr> fromAddr;
|
||||
const std::optional<IpAddress> fromAddr;
|
||||
|
||||
LRCMFrameDecrypt(Context* ctx, Decrypter_ptr dec, const LR_CommitMessage* commit)
|
||||
: decrypter(std::move(dec))
|
||||
|
@ -194,7 +194,7 @@ namespace llarp
|
|||
, hop(std::make_shared<Hop>())
|
||||
, fromAddr(
|
||||
commit->session->GetRemoteRC().IsPublicRouter()
|
||||
? std::optional<llarp::Addr>{}
|
||||
? std::optional<IpAddress>{}
|
||||
: commit->session->GetRemoteEndpoint())
|
||||
{
|
||||
hop->info.downstream = commit->session->GetPubKey();
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define LLARP_AI_HPP
|
||||
|
||||
#include <crypto/types.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <net/net.h>
|
||||
#include <util/bencode.hpp>
|
||||
#include <util/mem.h>
|
||||
|
@ -39,6 +40,14 @@ namespace llarp
|
|||
bool
|
||||
DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf);
|
||||
|
||||
/// Return an IpAddress representing the address portion of this AddressInfo
|
||||
IpAddress
|
||||
toIpAddress() const;
|
||||
|
||||
/// Updates our ip and port to reflact that of the given IpAddress
|
||||
void
|
||||
fromIpAddress(const IpAddress& address);
|
||||
|
||||
std::ostream&
|
||||
print(std::ostream& stream, int level, int spaces) const;
|
||||
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#endif
|
||||
|
||||
#include <net/exit_info.hpp>
|
||||
#include <net/net.hpp>
|
||||
#include <util/bencode.h>
|
||||
#include <util/bits.hpp>
|
||||
#include <util/mem.h>
|
||||
|
@ -15,6 +16,11 @@ namespace llarp
|
|||
bool
|
||||
ExitInfo::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
// TODO: derive these from ipAdress
|
||||
throw std::runtime_error("FIXME: need in6_addr and netmask from IpAddress");
|
||||
in6_addr address;
|
||||
in6_addr netmask;
|
||||
|
||||
char tmp[128] = {0};
|
||||
if (!bencode_start_dict(buf))
|
||||
return false;
|
||||
|
@ -57,6 +63,11 @@ namespace llarp
|
|||
bool
|
||||
ExitInfo::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
// TODO: derive these from ipAdress
|
||||
throw std::runtime_error("FIXME: need in6_addr and netmask from IpAddress");
|
||||
in6_addr address;
|
||||
in6_addr netmask;
|
||||
|
||||
bool read = false;
|
||||
if (!BEncodeMaybeReadDictEntry("k", pubkey, read, k, buf))
|
||||
return false;
|
||||
|
@ -72,6 +83,11 @@ namespace llarp
|
|||
std::ostream&
|
||||
ExitInfo::print(std::ostream& stream, int level, int spaces) const
|
||||
{
|
||||
// TODO: derive these from ipAdress
|
||||
throw std::runtime_error("FIXME: need in6_addr and netmask from IpAddress");
|
||||
in6_addr address;
|
||||
in6_addr netmask;
|
||||
|
||||
Printer printer(stream, level, spaces);
|
||||
|
||||
std::ostringstream ss;
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
#define LLARP_XI_HPP
|
||||
|
||||
#include <crypto/types.hpp>
|
||||
#include <net/net.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <util/bencode.hpp>
|
||||
|
||||
#include <iosfwd>
|
||||
|
@ -18,20 +18,14 @@ namespace llarp
|
|||
{
|
||||
struct ExitInfo
|
||||
{
|
||||
in6_addr address = {};
|
||||
in6_addr netmask = {};
|
||||
IpAddress ipAddress;
|
||||
PubKey pubkey;
|
||||
uint64_t version = LLARP_PROTO_VERSION;
|
||||
|
||||
ExitInfo() = default;
|
||||
|
||||
ExitInfo(const PubKey& pk, const nuint32_t& ipv4_exit) : pubkey(pk)
|
||||
ExitInfo(const PubKey& pk, const IpAddress& address) : ipAddress(address), pubkey(pk)
|
||||
{
|
||||
memset(address.s6_addr, 0, 16);
|
||||
address.s6_addr[11] = 0xff;
|
||||
address.s6_addr[10] = 0xff;
|
||||
memcpy(address.s6_addr + 12, &ipv4_exit.n, 4);
|
||||
memset(netmask.s6_addr, 0xff, 16);
|
||||
}
|
||||
|
||||
bool
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include <net/sock_addr.hpp>
|
||||
|
||||
#include <optional>
|
||||
#include <string_view>
|
||||
#include <string>
|
||||
|
||||
|
@ -18,6 +19,9 @@ namespace llarp
|
|||
/// TODO: IPv6 is not currently supported.
|
||||
struct IpAddress
|
||||
{
|
||||
/// Empty constructor.
|
||||
IpAddress() = default;
|
||||
|
||||
/// Constructor. Takes a string which can be an IPv4 or IPv6 address optionally followed by
|
||||
/// a colon and a port.
|
||||
///
|
||||
|
@ -39,6 +43,14 @@ namespace llarp
|
|||
/// @throws std::invalid_argument if str cannot be parsed
|
||||
IpAddress(std::string_view str, std::optional<uint16_t> port);
|
||||
|
||||
/// Construct from a SockAddr.
|
||||
///
|
||||
/// @param addr is an SockAddr to initialize from.
|
||||
IpAddress(const SockAddr& addr);
|
||||
|
||||
SockAddr&
|
||||
operator=(const sockaddr& other);
|
||||
|
||||
/// Return the port. Returns -1 if no port has been provided.
|
||||
///
|
||||
/// @return the port, if present
|
||||
|
@ -51,6 +63,13 @@ namespace llarp
|
|||
void
|
||||
setPort(std::optional<uint16_t> port);
|
||||
|
||||
/// Set the IP address. Follows the same logic as the constructor with the same signature, but
|
||||
/// doesn't overwrite the port if the port isn't present in the string.
|
||||
void
|
||||
setAddress(std::string_view str);
|
||||
void
|
||||
setAddress(std::string_view str, std::optional<uint16_t> port);
|
||||
|
||||
/// Returns true if this is an IPv4 address (or an IPv6 address representing an IPv4 address)
|
||||
///
|
||||
/// TODO: could return an int (e.g. 4 or 6) or an enum
|
||||
|
@ -59,22 +78,69 @@ namespace llarp
|
|||
bool
|
||||
isIPv4();
|
||||
|
||||
/// Returns true if this represents a valid IpAddress, false otherwise.
|
||||
///
|
||||
/// @return whether or not this IpAddress is empty
|
||||
bool
|
||||
isEmpty() const;
|
||||
|
||||
/// Creates an instance of SockAddr representing this IpAddress.
|
||||
///
|
||||
/// @return an instance of a SockAddr created from this IpAddress
|
||||
SockAddr
|
||||
createSockAddr() const;
|
||||
|
||||
/// Returns true if this IpAddress is a bogon, false otherwise
|
||||
///
|
||||
/// @return whether or not this IpAddress is a bogon
|
||||
bool
|
||||
isBogon() const;
|
||||
|
||||
/// Returns a string representing this IpAddress
|
||||
///
|
||||
/// @return string representation of this IpAddress
|
||||
std::string
|
||||
toString() const;
|
||||
|
||||
// TODO: other utility functions left over from Addr which may be useful
|
||||
// IsBogon() const;
|
||||
// isPrivate() const;
|
||||
// struct Hash
|
||||
// operator<(const Addr& other) const;
|
||||
// operator==(const Addr& other) const;
|
||||
// operator=(const sockaddr& other);
|
||||
// to string / stream / etc
|
||||
|
||||
bool
|
||||
operator<(const IpAddress& other) const;
|
||||
|
||||
bool
|
||||
operator==(const IpAddress& other) const;
|
||||
|
||||
struct Hash
|
||||
{
|
||||
std::size_t
|
||||
operator()(const IpAddress& address) const noexcept
|
||||
{
|
||||
(void)address;
|
||||
// throw std::runtime_error("FIXME: IpAddress::Hash"); // can't do this in operator(),
|
||||
// apparently, so hopefully it's me that stumbles upon this (if not, sorry!)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
if(a.af() == AF_INET)
|
||||
{
|
||||
return a.port() ^ a.addr4()->s_addr;
|
||||
}
|
||||
static const uint8_t empty[16] = {0};
|
||||
return (a.af() + memcmp(a.addr6(), empty, 16)) ^ a.port();
|
||||
*/
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
std::string m_ipAddress;
|
||||
std::optional<uint16_t> m_port;
|
||||
std::optional<uint16_t> m_port = std::nullopt;
|
||||
};
|
||||
|
||||
std::ostream&
|
||||
operator<<(std::ostream& out, const IpAddress& address);
|
||||
|
||||
} // namespace llarp
|
||||
|
|
|
@ -13,7 +13,6 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#include <net/net_addr.hpp>
|
||||
#include <net/ip.hpp>
|
||||
#include <util/logging/logger.hpp>
|
||||
#include <util/str.hpp>
|
||||
|
@ -428,9 +427,10 @@ namespace llarp
|
|||
{
|
||||
if (i->ifa_addr->sa_family == af)
|
||||
{
|
||||
llarp::Addr a(*i->ifa_addr);
|
||||
llarp::SockAddr a(*i->ifa_addr);
|
||||
llarp::IpAddress ip(a);
|
||||
|
||||
if (!a.IsBogon())
|
||||
if (!ip.isBogon())
|
||||
{
|
||||
ifname = i->ifa_name;
|
||||
found = true;
|
||||
|
@ -533,18 +533,18 @@ namespace llarp
|
|||
return std::nullopt;
|
||||
}
|
||||
|
||||
std::optional<llarp::Addr>
|
||||
std::optional<IpAddress>
|
||||
GetIFAddr(const std::string& ifname, int af)
|
||||
{
|
||||
sockaddr_storage s;
|
||||
sockaddr* sptr = (sockaddr*)&s;
|
||||
if (!llarp_getifaddr(ifname.c_str(), af, sptr))
|
||||
return std::nullopt;
|
||||
return llarp::Addr{*sptr};
|
||||
return IpAddress(SockAddr(sptr));
|
||||
}
|
||||
|
||||
bool
|
||||
AllInterfaces(int af, Addr& result)
|
||||
AllInterfaces(int af, IpAddress& result)
|
||||
{
|
||||
if (af == AF_INET)
|
||||
{
|
||||
|
@ -552,17 +552,20 @@ namespace llarp
|
|||
addr.sin_family = AF_INET;
|
||||
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
addr.sin_port = htons(0);
|
||||
result = addr;
|
||||
result = IpAddress(SockAddr(addr));
|
||||
return true;
|
||||
}
|
||||
if (af == AF_INET6)
|
||||
{
|
||||
throw std::runtime_error("Fix me: IPv6 not supported yet");
|
||||
/*
|
||||
sockaddr_in6 addr6;
|
||||
addr6.sin6_family = AF_INET6;
|
||||
addr6.sin6_port = htons(0);
|
||||
addr6.sin6_addr = IN6ADDR_ANY_INIT;
|
||||
result = addr6;
|
||||
result = IpAddress(SockAddr(addr6));
|
||||
return true;
|
||||
*/
|
||||
}
|
||||
|
||||
// TODO: implement sockaddr_ll
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
|
||||
#include <net/uint128.hpp>
|
||||
#include <net/address_info.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <net/net_int.hpp>
|
||||
#include <net/net.h>
|
||||
#include <util/mem.hpp>
|
||||
|
@ -158,10 +159,8 @@ namespace llarp
|
|||
bool
|
||||
IsBogonRange(const in6_addr& host, const in6_addr& mask);
|
||||
|
||||
struct Addr; // fwd declr
|
||||
|
||||
bool
|
||||
AllInterfaces(int af, Addr& addr);
|
||||
AllInterfaces(int af, IpAddress& addr);
|
||||
|
||||
/// get first network interface with public address
|
||||
bool
|
||||
|
@ -176,11 +175,9 @@ namespace llarp
|
|||
FindFreeTun();
|
||||
|
||||
/// get network interface address for network interface with ifname
|
||||
std::optional<llarp::Addr>
|
||||
std::optional<IpAddress>
|
||||
GetIFAddr(const std::string& ifname, int af = AF_INET);
|
||||
|
||||
} // namespace llarp
|
||||
|
||||
#include <net/net_addr.hpp>
|
||||
|
||||
#endif
|
||||
|
|
|
@ -10,16 +10,33 @@ namespace llarp
|
|||
/// A simple SockAddr wrapper which provides a sockaddr_in (IPv4). Memory management is handled
|
||||
/// in constructor and destructor (if needed) and copying is disabled.
|
||||
///
|
||||
/// This is immutable.
|
||||
/// This is immutable other than assignment operator.
|
||||
struct SockAddr
|
||||
{
|
||||
sockaddr_in _addr4;
|
||||
|
||||
SockAddr();
|
||||
SockAddr(uint8_t a, uint8_t b, uint8_t c, uint8_t d);
|
||||
SockAddr(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint16_t port);
|
||||
SockAddr(uint32_t addr);
|
||||
SockAddr(std::string_view addr);
|
||||
|
||||
SockAddr(const SockAddr&);
|
||||
SockAddr&
|
||||
operator=(const SockAddr&) const;
|
||||
|
||||
SockAddr(const sockaddr* addr);
|
||||
SockAddr(const sockaddr& addr);
|
||||
SockAddr(const sockaddr_in* addr);
|
||||
SockAddr(const sockaddr_in& addr);
|
||||
operator const sockaddr*() const;
|
||||
|
||||
bool
|
||||
isEmpty() const;
|
||||
|
||||
private:
|
||||
sockaddr_in addr;
|
||||
};
|
||||
|
||||
std::ostream&
|
||||
operator<<(std::ostream& out, const SockAddr& address);
|
||||
|
||||
} // namespace llarp
|
||||
|
|
|
@ -35,14 +35,14 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
PathContext::CheckPathLimitHitByIP(const llarp::Addr& ip)
|
||||
PathContext::CheckPathLimitHitByIP(const IpAddress& ip)
|
||||
{
|
||||
#ifdef TESTNET
|
||||
return false;
|
||||
#else
|
||||
llarp::Addr remote = ip;
|
||||
// set port to zero
|
||||
remote.port(0);
|
||||
IpAddress remote = ip;
|
||||
// null out the port -- we don't care about it for path limiting purposes
|
||||
remote.setPort(0);
|
||||
// try inserting remote address by ip into decaying hash set
|
||||
// if it cannot insert it has hit a limit
|
||||
return not m_PathLimits.Insert(remote);
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define LLARP_PATH_CONTEXT_HPP
|
||||
|
||||
#include <crypto/encrypted_frame.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
#include <path/ihophandler.hpp>
|
||||
#include <path/path_types.hpp>
|
||||
#include <path/pathset.hpp>
|
||||
|
@ -52,7 +53,7 @@ namespace llarp
|
|||
RejectTransit();
|
||||
|
||||
bool
|
||||
CheckPathLimitHitByIP(const llarp::Addr& ip);
|
||||
CheckPathLimitHitByIP(const IpAddress& ip);
|
||||
|
||||
bool
|
||||
AllowingTransit() const;
|
||||
|
@ -170,7 +171,7 @@ namespace llarp
|
|||
SyncTransitMap_t m_TransitPaths;
|
||||
SyncOwnedPathsMap_t m_OurPaths;
|
||||
bool m_AllowTransit;
|
||||
util::DecayingHashSet<llarp::Addr> m_PathLimits;
|
||||
util::DecayingHashSet<IpAddress> m_PathLimits;
|
||||
};
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
|
|
|
@ -65,10 +65,6 @@ namespace llarp
|
|||
{
|
||||
m_keyManager = std::make_shared<KeyManager>();
|
||||
|
||||
// set rational defaults
|
||||
this->ip4addr.sin_family = AF_INET;
|
||||
this->ip4addr.sin_port = htons(1090);
|
||||
|
||||
_stopping.store(false);
|
||||
_running.store(false);
|
||||
_lastTick = llarp::time_now_ms();
|
||||
|
@ -401,9 +397,7 @@ namespace llarp
|
|||
encryption_keyfile = conf->router.m_dataDir / our_enc_key_filename;
|
||||
our_rc_file = conf->router.m_dataDir / our_rc_filename;
|
||||
transport_keyfile = conf->router.m_dataDir / our_transport_key_filename;
|
||||
addrInfo = conf->router.m_addrInfo;
|
||||
publicOverride = conf->router.m_publicOverride;
|
||||
ip4addr = conf->router.m_ip4addr;
|
||||
_ourAddress = conf->router.m_publicAddress;
|
||||
|
||||
RouterContact::BlockBogons = conf->router.m_blockBogons;
|
||||
|
||||
|
@ -411,7 +405,7 @@ namespace llarp
|
|||
usingSNSeed = conf->lokid.usingSNSeed;
|
||||
ident_keyfile = conf->lokid.ident_keyfile;
|
||||
whitelistRouters = conf->lokid.whitelistRouters;
|
||||
lokidRPCAddr = conf->lokid.lokidRPCAddr;
|
||||
lokidRPCAddr = IpAddress(conf->lokid.lokidRPCAddr); // TODO: make config's option an IpAddress
|
||||
lokidRPCUser = conf->lokid.lokidRPCUser;
|
||||
lokidRPCPassword = conf->lokid.lokidRPCPassword;
|
||||
|
||||
|
@ -572,7 +566,7 @@ namespace llarp
|
|||
|
||||
// API config
|
||||
enableRPCServer = conf->api.m_enableRPCServer;
|
||||
rpcBindAddr = conf->api.m_rpcBindAddr;
|
||||
rpcBindAddr = IpAddress(conf->api.m_rpcBindAddr); // TODO: make this an IpAddress in config
|
||||
if (not IsServiceNode())
|
||||
{
|
||||
hiddenServiceContext().AddEndpoint(*conf);
|
||||
|
@ -843,7 +837,7 @@ namespace llarp
|
|||
|
||||
if (enableRPCServer)
|
||||
{
|
||||
if (rpcBindAddr.empty())
|
||||
if (rpcBindAddr.isEmpty())
|
||||
{
|
||||
rpcBindAddr = DefaultRPCBindAddr;
|
||||
}
|
||||
|
@ -891,8 +885,6 @@ namespace llarp
|
|||
|
||||
routerProfiling().Load(routerProfilesFile.c_str());
|
||||
|
||||
Addr publicAddr(this->addrInfo);
|
||||
|
||||
// set public signing key
|
||||
_rc.pubkey = seckey_topublic(identity());
|
||||
// set router version if service node
|
||||
|
@ -906,10 +898,9 @@ namespace llarp
|
|||
if (link->GetOurAddressInfo(ai))
|
||||
{
|
||||
// override ip and port
|
||||
if (this->publicOverride)
|
||||
if (not _ourAddress.isEmpty())
|
||||
{
|
||||
ai.ip = *publicAddr.addr6();
|
||||
ai.port = publicAddr.port();
|
||||
ai.fromIpAddress(_ourAddress);
|
||||
}
|
||||
if (RouterContact::BlockBogons && IsBogon(ai.ip))
|
||||
return;
|
||||
|
@ -917,10 +908,9 @@ namespace llarp
|
|||
_rc.addrs.push_back(ai);
|
||||
if (ExitEnabled())
|
||||
{
|
||||
const llarp::Addr addr(ai);
|
||||
const nuint32_t a{addr.addr4()->s_addr};
|
||||
_rc.exits.emplace_back(_rc.pubkey, a);
|
||||
LogInfo("Exit relay started, advertised as exiting at: ", a);
|
||||
const IpAddress address = ai.toIpAddress();
|
||||
_rc.exits.emplace_back(_rc.pubkey, address);
|
||||
LogInfo("Exit relay started, advertised as exiting at: ", address);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
|
|
@ -163,10 +163,7 @@ namespace llarp
|
|||
return disk;
|
||||
}
|
||||
|
||||
// our ipv4 public setting
|
||||
bool publicOverride = false;
|
||||
struct sockaddr_in ip4addr;
|
||||
AddressInfo addrInfo;
|
||||
IpAddress _ourAddress;
|
||||
|
||||
llarp_ev_loop_ptr _netloop;
|
||||
std::shared_ptr<llarp::thread::ThreadPool> cryptoworker;
|
||||
|
@ -245,15 +242,15 @@ namespace llarp
|
|||
NetworkConfig networkConfig;
|
||||
DnsConfig dnsConfig;
|
||||
|
||||
const std::string DefaultRPCBindAddr = "127.0.0.1:1190";
|
||||
const IpAddress DefaultRPCBindAddr = IpAddress("127.0.0.1:1190");
|
||||
bool enableRPCServer = false;
|
||||
std::unique_ptr<rpc::Server> rpcServer;
|
||||
std::string rpcBindAddr = DefaultRPCBindAddr;
|
||||
IpAddress rpcBindAddr = DefaultRPCBindAddr;
|
||||
const llarp_time_t _randomStartDelay;
|
||||
|
||||
/// lokid caller
|
||||
std::unique_ptr<rpc::Caller> rpcCaller;
|
||||
std::string lokidRPCAddr = "127.0.0.1:22023";
|
||||
IpAddress lokidRPCAddr = IpAddress("127.0.0.1:22023");
|
||||
std::string lokidRPCUser;
|
||||
std::string lokidRPCPassword;
|
||||
|
||||
|
|
|
@ -343,7 +343,9 @@ namespace llarp
|
|||
}
|
||||
for (const auto& exit : exits)
|
||||
{
|
||||
if (IsBogonRange(exit.address, exit.netmask))
|
||||
// TODO: see if exit's range overlaps with bogon...?
|
||||
// e.g. "IsBogonRange(address, netmask)"
|
||||
if (exit.ipAddress.isBogon())
|
||||
{
|
||||
llarp::LogError("bogon exit: ", exit);
|
||||
return false;
|
||||
|
|
|
@ -188,7 +188,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Start(const std::string& remote)
|
||||
Start(const IpAddress& remote)
|
||||
{
|
||||
return RunAsync(router->netloop(), remote);
|
||||
}
|
||||
|
@ -459,8 +459,12 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Start(const std::string& addr)
|
||||
Start(const IpAddress& addr)
|
||||
{
|
||||
// NOTE/TODO: RPC on HTTP here can assume 127.0.0.1 or localhost, this isn't safe to expose
|
||||
// externally anyway
|
||||
throw std::runtime_error("FIXME: replace with lokimq, or fix this stuff");
|
||||
/*
|
||||
sockaddr_in saddr;
|
||||
saddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
saddr.sin_family = AF_INET;
|
||||
|
@ -478,7 +482,8 @@ namespace llarp
|
|||
{
|
||||
_handler.expectedHostname = addr;
|
||||
}
|
||||
return _handler.ServeAsync(router->netloop(), router->logic(), (const sockaddr*)&saddr);
|
||||
*/
|
||||
return _handler.ServeAsync(router->netloop(), router->logic(), addr.createSockAddr());
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -495,7 +500,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Caller::Start(const std::string& addr)
|
||||
Caller::Start(const IpAddress& addr)
|
||||
{
|
||||
return m_Impl->Start(addr);
|
||||
}
|
||||
|
@ -525,7 +530,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Server::Start(const std::string& addr)
|
||||
Server::Start(const IpAddress& addr)
|
||||
{
|
||||
return m_Impl->Start(addr);
|
||||
}
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define LLARP_RPC_HPP
|
||||
|
||||
#include <util/time.hpp>
|
||||
#include <net/ip_address.hpp>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
@ -23,7 +24,7 @@ namespace llarp
|
|||
~Server();
|
||||
|
||||
bool
|
||||
Start(const std::string& bindaddr);
|
||||
Start(const IpAddress& bindaddr);
|
||||
|
||||
/// stop and close
|
||||
void
|
||||
|
@ -47,7 +48,7 @@ namespace llarp
|
|||
|
||||
/// start with jsonrpc endpoint address
|
||||
bool
|
||||
Start(const std::string& remote);
|
||||
Start(const IpAddress& remote);
|
||||
|
||||
/// stop and close
|
||||
void
|
||||
|
|
Loading…
Reference in New Issue