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

Refactor Addr -> IpAddress/SockAddr

Browse Source
pull/1257/head
Stephen Shelton 4 years ago
parent 1cab83ad01
commit aee96e53a3
No known key found for this signature in database
GPG Key ID: EE4BADACCE8B631C
39 changed files with 325 additions and 251 deletions
Show Stats Download Patch File Download Diff File

3
libabyss/include/abyss/client.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define ABYSS_CLIENT_HPP #define ABYSS_CLIENT_HPP
#include <ev/ev.h> #include <ev/ev.h>
#include <net/ip_address.hpp>
#include <util/json.hpp> #include <util/json.hpp>
#include <abyss/http.hpp> #include <abyss/http.hpp>
@ -67,7 +68,7 @@ namespace abyss
/// start runing on event loop async /// start runing on event loop async
/// return true on success otherwise return false /// return true on success otherwise return false
bool 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 /// must be called after RunAsync returns true
/// queue a call for rpc /// queue a call for rpc

5
libabyss/include/abyss/server.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define ABYSS_SERVER_HPP #define ABYSS_SERVER_HPP
#include <ev/ev.h> #include <ev/ev.h>
#include <net/sock_addr.hpp>
#include <util/json.hpp> #include <util/json.hpp>
#include <util/thread/logic.hpp> #include <util/thread/logic.hpp>
#include <util/time.hpp> #include <util/time.hpp>
@ -50,7 +51,9 @@ namespace abyss
bool bool
ServeAsync( 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 void
RemoveConn(IRPCHandler* handler); RemoveConn(IRPCHandler* handler);

4
libabyss/src/client.cpp
Unescape Escape View File

@ -404,9 +404,9 @@ namespace abyss
} }
bool 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 // TODO: ipv6
m_connect.connected = &JSONRPC::OnConnected; m_connect.connected = &JSONRPC::OnConnected;
m_connect.error = &JSONRPC::OnConnectFail; m_connect.error = &JSONRPC::OnConnectFail;

4
libabyss/src/server.cpp
Unescape Escape View File

@ -340,7 +340,9 @@ namespace abyss
bool bool
BaseReqHandler::ServeAsync( 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_loop = loop;
m_Logic = logic; m_Logic = logic;

31
llarp/config/config.cpp
Unescape Escape View File

@ -88,21 +88,15 @@ namespace llarp
if (arg.size() > 16) if (arg.size() > 16)
throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg)); throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg));
// assume IPv4 m_publicAddress.setAddress(arg);
llarp::Addr a(arg);
llarp::LogInfo("setting public ipv4 ", a);
m_addrInfo.ip = *a.addr6();
m_publicOverride = true;
} }
}); });
conf.defineOption<int>("router", "public-port", false, DefaultPublicPort, [this](int arg) { conf.defineOption<int>("router", "public-port", false, DefaultPublicPort, [this](int arg) {
if (arg <= 0) if (arg <= 0 || arg > std::numeric_limits<uint16_t>::max())
throw std::invalid_argument("public-port must be > 0"); throw std::invalid_argument("public-port must be >= 0 and <= 65536");
m_ip4addr.sin_port = arg; m_publicAddress.setPort(arg);
m_addrInfo.port = arg;
m_publicOverride = true;
}); });
conf.defineOption<int>( conf.defineOption<int>(
@ -232,26 +226,13 @@ namespace llarp
{ {
(void)params; (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>( conf.defineOption<std::string>(
"dns", "upstream", false, true, std::nullopt, [=](std::string arg) { "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>( 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 LinksConfig::LinkInfo

9
llarp/config/config.hpp
Unescape Escape View File

@ -9,6 +9,7 @@
#include <config/ini.hpp> #include <config/ini.hpp>
#include <config/definition.hpp> #include <config/definition.hpp>
#include <constants/files.hpp> #include <constants/files.hpp>
#include <net/ip_address.hpp>
#include <cstdlib> #include <cstdlib>
#include <functional> #include <functional>
@ -45,9 +46,7 @@ namespace llarp
bool m_blockBogons; bool m_blockBogons;
bool m_publicOverride = false; IpAddress m_publicAddress;
struct sockaddr_in m_ip4addr;
AddressInfo m_addrInfo;
int m_workerThreads; int m_workerThreads;
int m_numNetThreads; int m_numNetThreads;
@ -93,8 +92,8 @@ namespace llarp
struct DnsConfig struct DnsConfig
{ {
Addr m_bind; IpAddress m_bind;
std::vector<Addr> m_upstreamDNS; std::vector<IpAddress> m_upstreamDNS;
void void
defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params);

42
llarp/dns/server.cpp
Unescape Escape View File

@ -35,17 +35,17 @@ namespace llarp
} }
bool 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.clear();
m_Resolvers = resolvers; 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(); auto self = shared_from_this();
LogicCall(m_ClientLogic, [=]() { 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, [=]() { 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; return true;
} }
@ -59,28 +59,26 @@ namespace llarp
} }
void 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); Buffer_t msgbuf = CopyBuffer(buf.underlying);
auto self = static_cast<Proxy*>(u->user)->shared_from_this(); 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 // yes we use the server loop here because if the server loop is not the
// client loop we'll crash again // client loop we'll crash again
LogicCall( LogicCall(
self->m_ServerLogic, [self, addr, msgbuf]() { self->HandlePktServer(addr, msgbuf); }); self->m_ServerLogic, [self, from, msgbuf]() { self->HandlePktServer(from, msgbuf); });
} }
void 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); Buffer_t msgbuf = CopyBuffer(buf.underlying);
auto self = static_cast<Proxy*>(u->user)->shared_from_this(); auto self = static_cast<Proxy*>(u->user)->shared_from_this();
LogicCall( 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 Proxy::PickRandomResolver() const
{ {
const size_t sz = m_Resolvers.size(); const size_t sz = m_Resolvers.size();
@ -97,7 +95,7 @@ namespace llarp
} }
void void
Proxy::SendServerMessageTo(llarp::Addr to, Message msg) Proxy::SendServerMessageTo(const SockAddr& to, Message msg)
{ {
auto self = shared_from_this(); auto self = shared_from_this();
LogicCall(m_ServerLogic, [to, msg, self]() { LogicCall(m_ServerLogic, [to, msg, self]() {
@ -115,7 +113,7 @@ namespace llarp
} }
void void
Proxy::SendClientMessageTo(llarp::Addr to, Message msg) Proxy::SendClientMessageTo(const SockAddr& to, Message msg)
{ {
auto self = shared_from_this(); auto self = shared_from_this();
LogicCall(m_ClientLogic, [to, msg, self]() { LogicCall(m_ClientLogic, [to, msg, self]() {
@ -133,7 +131,7 @@ namespace llarp
} }
void void
Proxy::HandlePktClient(llarp::Addr from, Buffer_t buf) Proxy::HandlePktClient(const SockAddr& from, Buffer_t buf)
{ {
llarp_buffer_t pkt(buf); llarp_buffer_t pkt(buf);
MessageHeader hdr; MessageHeader hdr;
@ -146,7 +144,7 @@ namespace llarp
auto itr = m_Forwarded.find(tx); auto itr = m_Forwarded.find(tx);
if (itr == m_Forwarded.end()) if (itr == m_Forwarded.end())
return; return;
const Addr requester = itr->second; const auto& requester = itr->second;
auto self = shared_from_this(); auto self = shared_from_this();
Message msg(hdr); Message msg(hdr);
if (msg.Decode(&pkt)) if (msg.Decode(&pkt))
@ -156,7 +154,11 @@ namespace llarp
msg.hdr_id = itr->first.txid; msg.hdr_id = itr->first.txid;
if (!m_QueryHandler->HandleHookedDNSMessage( if (!m_QueryHandler->HandleHookedDNSMessage(
std::move(msg), 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"); llarp::LogWarn("failed to handle hooked dns");
} }
@ -166,14 +168,14 @@ namespace llarp
LogicCall(m_ServerLogic, [=]() { LogicCall(m_ServerLogic, [=]() {
// forward reply to requester via server // forward reply to requester via server
const llarp_buffer_t tmpbuf(buf); 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 // remove pending
m_Forwarded.erase(itr); m_Forwarded.erase(itr);
} }
void void
Proxy::HandlePktServer(llarp::Addr from, Buffer_t buf) Proxy::HandlePktServer(const SockAddr& from, Buffer_t buf)
{ {
MessageHeader hdr; MessageHeader hdr;
llarp_buffer_t pkt(buf); llarp_buffer_t pkt(buf);
@ -236,7 +238,7 @@ namespace llarp
LogicCall(m_ClientLogic, [=] { LogicCall(m_ClientLogic, [=] {
// do query // do query
const llarp_buffer_t tmpbuf(buf); 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 else
@ -246,7 +248,7 @@ namespace llarp
LogicCall(m_ClientLogic, [=] { LogicCall(m_ClientLogic, [=] {
// send it // send it
const llarp_buffer_t tmpbuf(buf); 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);
}); });
} }
} }

24
llarp/dns/server.hpp
Unescape Escape View File

@ -37,7 +37,7 @@ namespace llarp
IQueryHandler* handler); IQueryHandler* handler);
bool bool
Start(const llarp::Addr addr, const std::vector<llarp::Addr>& resolvers); Start(const IpAddress& addr, const std::vector<IpAddress>& resolvers);
void void
Stop(); Stop();
@ -47,9 +47,9 @@ namespace llarp
private: private:
/// low level packet handler /// low level packet handler
static void static void
HandleUDPRecv_client(llarp_udp_io*, const struct sockaddr*, ManagedBuffer); HandleUDPRecv_client(llarp_udp_io*, const SockAddr&, ManagedBuffer);
static void static void
HandleUDPRecv_server(llarp_udp_io*, const struct sockaddr*, ManagedBuffer); HandleUDPRecv_server(llarp_udp_io*, const SockAddr&, ManagedBuffer);
/// low level ticker /// low level ticker
static void static void
@ -59,18 +59,18 @@ namespace llarp
Tick(llarp_time_t now); Tick(llarp_time_t now);
void void
HandlePktClient(llarp::Addr from, Buffer_t buf); HandlePktClient(const SockAddr& from, Buffer_t buf);
void void
HandlePktServer(llarp::Addr from, Buffer_t buf); HandlePktServer(const SockAddr& from, Buffer_t buf);
void void
SendClientMessageTo(llarp::Addr to, Message msg); SendClientMessageTo(const SockAddr& to, Message msg);
void void
SendServerMessageTo(llarp::Addr to, Message msg); SendServerMessageTo(const SockAddr& to, Message msg);
llarp::Addr IpAddress
PickRandomResolver() const; PickRandomResolver() const;
private: private:
@ -81,12 +81,12 @@ namespace llarp
Logic_ptr m_ServerLogic; Logic_ptr m_ServerLogic;
Logic_ptr m_ClientLogic; Logic_ptr m_ClientLogic;
IQueryHandler* m_QueryHandler; IQueryHandler* m_QueryHandler;
std::vector<llarp::Addr> m_Resolvers; std::vector<IpAddress> m_Resolvers;
struct TX struct TX
{ {
MsgID_t txid; MsgID_t txid;
llarp::Addr from; IpAddress from;
bool bool
operator==(const TX& other) const operator==(const TX& other) const
@ -99,13 +99,13 @@ namespace llarp
size_t size_t
operator()(const TX& t) const noexcept 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 // 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 dns
} // namespace llarp } // namespace llarp

34
llarp/ev/ev.cpp
Unescape Escape View File

@ -1,7 +1,7 @@
#include <ev/ev.h> #include <ev/ev.h>
#include <util/mem.hpp> #include <util/mem.hpp>
#include <util/str.hpp>
#include <util/thread/logic.hpp> #include <util/thread/logic.hpp>
#include <net/net_addr.hpp>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
@ -37,7 +37,7 @@ llarp_ev_loop_run_single_process(llarp_ev_loop_ptr ev, std::shared_ptr<llarp::Lo
} }
int 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; udp->parent = ev;
if (ev->udp_listen(udp, src)) if (ev->udp_listen(udp, src))
@ -68,7 +68,7 @@ llarp_ev_loop_stop(const llarp_ev_loop_ptr& loop)
} }
int 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); 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) llarp_tcp_async_try_connect(struct llarp_ev_loop* loop, struct llarp_tcp_connecter* tcp)
{ {
tcp->loop = loop; 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::IpAddress address(tcp->remote);
{
llarp::LogError("bad address: ", tcp->remote); if (not address.getPort())
if (tcp->error) throw std::runtime_error(llarp::stringify("Address with no port: ", address));
tcp->error(tcp);
return; llarp::SockAddr addr = address.createSockAddr();
}
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);
if (!loop->tcp_connect(tcp, addr)) if (!loop->tcp_connect(tcp, addr))
{ {

16
llarp/ev/ev.h
Unescape Escape View File

@ -1,6 +1,7 @@
#ifndef LLARP_EV_H #ifndef LLARP_EV_H
#define LLARP_EV_H #define LLARP_EV_H
#include <net/ip_address.hpp>
#include <util/buffer.hpp> #include <util/buffer.hpp>
#include <util/time.hpp> #include <util/time.hpp>
#include <tuntap.h> #include <tuntap.h>
@ -76,10 +77,10 @@ struct llarp_udp_io
/// called every event loop tick after reads /// called every event loop tick after reads
void (*tick)(struct llarp_udp_io*); 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 /// 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 /// 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 /// add UDP handler
int 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 /// send a UDP packet
int 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 /// close UDP handler
int int
@ -140,7 +141,7 @@ struct llarp_tcp_connecter
/// remote address family /// remote address family
int af; int af;
/// remote address string /// remote address string
char remote[512]; llarp::IpAddress remote;
/// userdata pointer /// userdata pointer
void* user; void* user;
/// private implementation (dont set me) /// private implementation (dont set me)
@ -180,7 +181,8 @@ struct llarp_tcp_acceptor
/// return false if failed to bind /// return false if failed to bind
/// return true on success /// return true on success
bool 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 /// close and stop accepting connections
void void

26
llarp/ev/ev.hpp
Unescape Escape View File

@ -1,7 +1,7 @@
#ifndef LLARP_EV_HPP #ifndef LLARP_EV_HPP
#define LLARP_EV_HPP #define LLARP_EV_HPP
#include <net/net_addr.hpp> #include <net/ip_address.hpp>
#include <ev/ev.h> #include <ev/ev.h>
#include <util/buffer.hpp> #include <util/buffer.hpp>
#include <util/codel.hpp> #include <util/codel.hpp>
@ -159,7 +159,7 @@ namespace llarp
read(byte_t* buf, size_t sz) = 0; read(byte_t* buf, size_t sz) = 0;
virtual int 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(dst);
UNREFERENCED_PARAMETER(data); UNREFERENCED_PARAMETER(data);
@ -379,7 +379,7 @@ namespace llarp
virtual int virtual int
sendto( sendto(
__attribute__((unused)) const sockaddr* dst, __attribute__((unused)) const SockAddr& dst,
__attribute__((unused)) const void* data, __attribute__((unused)) const void* data,
__attribute__((unused)) size_t sz) __attribute__((unused)) size_t sz)
{ {
@ -525,7 +525,6 @@ namespace llarp
// on sockets // on sockets
struct tcp_conn : public ev_io struct tcp_conn : public ev_io
{ {
sockaddr_storage _addr;
bool _shouldClose = false; bool _shouldClose = false;
bool _calledConnected = false; bool _calledConnected = false;
llarp_tcp_conn tcp; llarp_tcp_conn tcp;
@ -551,15 +550,10 @@ namespace llarp
} }
/// outbound /// 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) : ev_io(_fd, new LosslessWriteQueue_t{}), _conn(conn)
{ {
socklen_t slen = sizeof(sockaddr_in); (void)addr;
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);
tcp.impl = this; tcp.impl = this;
tcp.loop = loop; tcp.loop = loop;
tcp.closed = nullptr; tcp.closed = nullptr;
@ -730,7 +724,7 @@ struct llarp_ev_loop
/// return false on socket error (non blocking) /// return false on socket error (non blocking)
virtual bool 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 virtual int
tick(int ms) = 0; tick(int ms) = 0;
@ -748,7 +742,7 @@ struct llarp_ev_loop
stop() = 0; stop() = 0;
virtual bool 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 virtual bool
udp_close(llarp_udp_io* l) = 0; udp_close(llarp_udp_io* l) = 0;
@ -772,7 +766,7 @@ struct llarp_ev_loop
create_tun(llarp_tun_io* tun) = 0; create_tun(llarp_tun_io* tun) = 0;
virtual llarp::ev_io* 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 virtual bool
add_pipe(llarp_ev_pkt_pipe*) add_pipe(llarp_ev_pkt_pipe*)
@ -788,7 +782,7 @@ struct llarp_ev_loop
add_ev(llarp::ev_io* ev, bool write) = 0; add_ev(llarp::ev_io* ev, bool write) = 0;
virtual bool 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); auto conn = bind_tcp(tcp, addr);
return conn && add_ev(conn, true); return conn && add_ev(conn, true);
@ -878,7 +872,7 @@ struct PacketBuffer
struct PacketEvent struct PacketEvent
{ {
llarp::Addr remote; llarp::SockAddr remote;
PacketBuffer pkt; PacketBuffer pkt;
}; };

34
llarp/ev/ev_libuv.cpp
Unescape Escape View File

@ -1,5 +1,4 @@
#include <ev/ev_libuv.hpp> #include <ev/ev_libuv.hpp>
#include <net/net_addr.hpp>
#include <util/thread/logic.hpp> #include <util/thread/logic.hpp>
#include <util/thread/queue.hpp> #include <util/thread/queue.hpp>
@ -54,10 +53,10 @@ namespace libuv
llarp_tcp_connecter* const m_TCP; llarp_tcp_connecter* const m_TCP;
llarp_tcp_acceptor* const m_Accept; llarp_tcp_acceptor* const m_Accept;
llarp_tcp_conn m_Conn; 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) conn_glue(uv_loop_t* loop, llarp_tcp_connecter* tcp, const llarp::SockAddr& addr)
: m_TCP(tcp), m_Accept(nullptr), m_Addr(*addr) : m_TCP(tcp), m_Accept(nullptr), m_Addr(addr)
{ {
m_Connect.data = this; m_Connect.data = this;
m_Handle.data = this; m_Handle.data = this;
@ -69,8 +68,8 @@ namespace libuv
m_Conn.write = &ExplicitWrite; m_Conn.write = &ExplicitWrite;
} }
conn_glue(uv_loop_t* loop, llarp_tcp_acceptor* tcp, const sockaddr* 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_TCP(nullptr), m_Accept(tcp), m_Addr(addr)
{ {
m_Connect.data = nullptr; m_Connect.data = nullptr;
m_Handle.data = this; m_Handle.data = this;
@ -397,11 +396,12 @@ namespace libuv
uv_udp_t m_Handle; uv_udp_t m_Handle;
uv_check_t m_Ticker; uv_check_t m_Ticker;
llarp_udp_io* const m_UDP; llarp_udp_io* const m_UDP;
llarp::Addr m_Addr; llarp::SockAddr m_Addr;
llarp_pkt_list m_LastPackets; llarp_pkt_list m_LastPackets;
std::array<char, 1500> m_Buffer; 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_Handle.data = this;
m_Ticker.data = this; m_Ticker.data = this;
@ -417,13 +417,13 @@ namespace libuv
buf->len = sz; buf->len = sz;
} }
/// callback for libuv
static void static void
OnRecv( OnRecv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const sockaddr* addr, unsigned)
uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned)
{ {
udp_glue* glue = static_cast<udp_glue*>(handle->data); udp_glue* glue = static_cast<udp_glue*>(handle->data);
if (addr) 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) if (nread <= 0 || glue->m_UDP == nullptr || glue->m_UDP->recvfrom != nullptr)
delete[] buf->base; delete[] buf->base;
} }
@ -437,7 +437,7 @@ namespace libuv
} }
void 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) if (sz > 0 && m_UDP)
{ {
@ -450,7 +450,7 @@ namespace libuv
else else
{ {
PacketBuffer pbuf(buf->base, pktsz); 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 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); auto* self = static_cast<udp_glue*>(udp->impl);
if (self == nullptr) if (self == nullptr)
@ -817,7 +817,7 @@ namespace libuv
} }
bool 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); auto* impl = new conn_glue(&m_Impl, tcp, addr);
tcp->impl = impl; tcp->impl = impl;
@ -981,7 +981,7 @@ namespace libuv
} }
bool 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); auto* impl = new udp_glue(&m_Impl, udp, src);
udp->impl = impl; udp->impl = impl;
@ -1036,7 +1036,7 @@ namespace libuv
} }
bool 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); auto* glue = new conn_glue(&m_Impl, tcp, addr);
tcp->impl = glue; tcp->impl = glue;

8
llarp/ev/ev_libuv.hpp
Unescape Escape View File

@ -43,7 +43,7 @@ namespace libuv
/// return false on socket error (non blocking) /// return false on socket error (non blocking)
bool bool
tcp_connect(llarp_tcp_connecter* tcp, const sockaddr* addr) override; tcp_connect(llarp_tcp_connecter* tcp, const llarp::SockAddr& addr) override;
int int
tick(int ms) override; tick(int ms) override;
@ -73,7 +73,7 @@ namespace libuv
CloseAll(); CloseAll();
bool bool
udp_listen(llarp_udp_io* l, const sockaddr* src) override; udp_listen(llarp_udp_io* l, const llarp::SockAddr& src) override;
bool bool
udp_close(llarp_udp_io* l) override; udp_close(llarp_udp_io* l) override;
@ -95,13 +95,13 @@ namespace libuv
} }
bool bool
tcp_listen(llarp_tcp_acceptor* tcp, const sockaddr* addr) override; tcp_listen(llarp_tcp_acceptor* tcp, const llarp::SockAddr& addr) override;
bool bool
add_pipe(llarp_ev_pkt_pipe* p) override; add_pipe(llarp_ev_pkt_pipe* p) override;
llarp::ev_io* llarp::ev_io*
bind_tcp(llarp_tcp_acceptor*, const sockaddr*) override bind_tcp(llarp_tcp_acceptor*, const llarp::SockAddr&) override
{ {
return nullptr; return nullptr;
} }

2
llarp/handlers/exit.cpp
Unescape Escape View File

@ -343,7 +343,7 @@ namespace llarp
llarp::LogWarn("Could not create tunnel for exit endpoint"); llarp::LogWarn("Could not create tunnel for exit endpoint");
return false; 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 m_Resolver->Start(m_LocalResolverAddr, m_UpstreamResolvers);
} }
return true; return true;

4
llarp/handlers/exit.hpp
Unescape Escape View File

@ -166,8 +166,8 @@ namespace llarp
llarp_tun_io m_Tun; llarp_tun_io m_Tun;
Addr m_LocalResolverAddr; IpAddress m_LocalResolverAddr;
std::vector<Addr> m_UpstreamResolvers; std::vector<IpAddress> m_UpstreamResolvers;
using Pkt_t = net::IPPacket; using Pkt_t = net::IPPacket;
using PacketQueue_t = util::CoDelQueue< using PacketQueue_t = util::CoDelQueue<

6
llarp/handlers/tun.cpp
Unescape Escape View File

@ -80,9 +80,9 @@ namespace llarp
std::vector<std::string> resolvers; std::vector<std::string> resolvers;
for (const auto& addr : m_UpstreamResolvers) for (const auto& addr : m_UpstreamResolvers)
resolvers.emplace_back(addr.ToString()); resolvers.emplace_back(addr.toString());
obj["ustreamResolvers"] = resolvers; obj["ustreamResolvers"] = resolvers;
obj["localResolver"] = m_LocalResolverAddr.ToString(); obj["localResolver"] = m_LocalResolverAddr.toString();
util::StatusObject ips{}; util::StatusObject ips{};
for (const auto& item : m_IPActivity) for (const auto& item : m_IPActivity)
{ {
@ -818,7 +818,7 @@ namespace llarp
env.emplace("IF_NAME", tunif->ifname); env.emplace("IF_NAME", tunif->ifname);
std::string strictConnect; std::string strictConnect;
for (const auto& addr : m_StrictConnectAddrs) for (const auto& addr : m_StrictConnectAddrs)
strictConnect += addr.ToString() + " "; strictConnect += addr.toString() + " ";
env.emplace("STRICT_CONNECT_ADDRS", strictConnect); env.emplace("STRICT_CONNECT_ADDRS", strictConnect);
return env; return env;
} }

6
llarp/handlers/tun.hpp
Unescape Escape View File

@ -298,11 +298,11 @@ namespace llarp
/// our ip range we are using /// our ip range we are using
llarp::IPRange m_OurRange; llarp::IPRange m_OurRange;
/// upstream dns resolver list /// upstream dns resolver list
std::vector<llarp::Addr> m_UpstreamResolvers; std::vector<IpAddress> m_UpstreamResolvers;
/// local dns /// local dns
llarp::Addr m_LocalResolverAddr; IpAddress m_LocalResolverAddr;
/// list of strict connect addresses for hooks /// list of strict connect addresses for hooks
std::vector<llarp::Addr> m_StrictConnectAddrs; std::vector<IpAddress> m_StrictConnectAddrs;
/// use v6? /// use v6?
bool m_UseV6; bool m_UseV6;
struct lazy_vpn struct lazy_vpn

6
llarp/iwp/linklayer.cpp
Unescape Escape View File

@ -45,7 +45,7 @@ namespace llarp
} }
void void
LinkLayer::RecvFrom(const Addr& from, ILinkSession::Packet_t pkt) LinkLayer::RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt)
{ {
std::shared_ptr<ILinkSession> session; std::shared_ptr<ILinkSession> session;
auto itr = m_AuthedAddrs.find(from); auto itr = m_AuthedAddrs.find(from);
@ -89,9 +89,9 @@ namespace llarp
} }
void void
LinkLayer::UnmapAddr(const Addr& a) LinkLayer::UnmapAddr(const IpAddress& addr)
{ {
m_AuthedAddrs.erase(a); m_AuthedAddrs.erase(addr);
} }
std::shared_ptr<ILinkSession> std::shared_ptr<ILinkSession>

6
llarp/iwp/linklayer.hpp
Unescape Escape View File

@ -41,19 +41,19 @@ namespace llarp
Rank() const override; Rank() const override;
void void
RecvFrom(const Addr& from, ILinkSession::Packet_t pkt) override; RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) override;
bool bool
MapAddr(const RouterID& pk, ILinkSession* s) override; MapAddr(const RouterID& pk, ILinkSession* s) override;
void void
UnmapAddr(const Addr& addr); UnmapAddr(const IpAddress& addr);
void void
QueueWork(std::function<void(void)> work); QueueWork(std::function<void(void)> work);
private: private:
std::unordered_map<Addr, RouterID, Addr::Hash> m_AuthedAddrs; std::unordered_map<IpAddress, RouterID, IpAddress::Hash> m_AuthedAddrs;
const bool permitInbound; const bool permitInbound;
}; };

8
llarp/iwp/session.cpp
Unescape Escape View File

@ -31,7 +31,7 @@ namespace llarp
, m_Inbound{false} , m_Inbound{false}
, m_Parent(p) , m_Parent(p)
, m_CreatedAt{p->Now()} , m_CreatedAt{p->Now()}
, m_RemoteAddr(ai) , m_RemoteAddr(ai.toIpAddress())
, m_ChosenAI(ai) , m_ChosenAI(ai)
, m_RemoteRC(rc) , m_RemoteRC(rc)
{ {
@ -40,7 +40,7 @@ namespace llarp
CryptoManager::instance()->shorthash(m_SessionKey, llarp_buffer_t(rc.pubkey)); 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_State{State::Initial}
, m_Inbound{true} , m_Inbound{true}
, m_Parent(p) , m_Parent(p)
@ -58,7 +58,7 @@ namespace llarp
{ {
LogDebug("send ", sz, " to ", m_RemoteAddr); LogDebug("send ", sz, " to ", m_RemoteAddr);
const llarp_buffer_t pkt(buf, sz); 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_LastTX = time_now_ms();
m_TXRate += sz; m_TXRate += sz;
} }
@ -309,7 +309,7 @@ namespace llarp
{"replayFilter", m_ReplayFilter.size()}, {"replayFilter", m_ReplayFilter.size()},
{"txMsgQueueSize", m_TXMsgs.size()}, {"txMsgQueueSize", m_TXMsgs.size()},
{"rxMsgQueueSize", m_RXMsgs.size()}, {"rxMsgQueueSize", m_RXMsgs.size()},
{"remoteAddr", m_RemoteAddr.ToString()}, {"remoteAddr", m_RemoteAddr.toString()},
{"remoteRC", m_RemoteRC.ExtractStatus()}, {"remoteRC", m_RemoteRC.ExtractStatus()},
{"created", to_json(m_CreatedAt)}, {"created", to_json(m_CreatedAt)},
{"uptime", to_json(now - m_CreatedAt)}}; {"uptime", to_json(now - m_CreatedAt)}};

8
llarp/iwp/session.hpp
Unescape Escape View File

@ -4,6 +4,8 @@
#include <link/session.hpp> #include <link/session.hpp>
#include <iwp/linklayer.hpp> #include <iwp/linklayer.hpp>
#include <iwp/message_buffer.hpp> #include <iwp/message_buffer.hpp>
#include <net/ip_address.hpp>
#include <unordered_set> #include <unordered_set>
#include <deque> #include <deque>
@ -41,7 +43,7 @@ namespace llarp
/// outbound session /// outbound session
Session(LinkLayer* parent, const RouterContact& rc, const AddressInfo& ai); Session(LinkLayer* parent, const RouterContact& rc, const AddressInfo& ai);
/// inbound session /// inbound session
Session(LinkLayer* parent, const Addr& from); Session(LinkLayer* parent, const IpAddress& from);
~Session() = default; ~Session() = default;
@ -88,7 +90,7 @@ namespace llarp
return m_RemoteRC.pubkey; return m_RemoteRC.pubkey;
} }
Addr IpAddress
GetRemoteEndpoint() const override GetRemoteEndpoint() const override
{ {
return m_RemoteAddr; return m_RemoteAddr;
@ -164,7 +166,7 @@ namespace llarp
/// parent link layer /// parent link layer
LinkLayer* const m_Parent; LinkLayer* const m_Parent;
const llarp_time_t m_CreatedAt; const llarp_time_t m_CreatedAt;
const Addr m_RemoteAddr; const IpAddress m_RemoteAddr;
AddressInfo m_ChosenAI; AddressInfo m_ChosenAI;
/// remote rc /// remote rc

34
llarp/link/server.cpp
Unescape Escape View File

@ -132,12 +132,19 @@ namespace llarp
} }
else else
{ {
if (not m_ourAddr.FromString(ifname)) try
throw std::invalid_argument(stringify("cannot parse network address: ", ifname)); {
m_ourAddr = IpAddress(ifname);
}
catch (const std::exception& e)
{
LogError(stringify("Could not use ifname ", ifname, " to configure ILinkLayer"));
}
throw;
} }
} }
m_ourAddr.port(port); m_ourAddr.setPort(port);
return llarp_ev_add_udp(m_Loop.get(), &m_udp, m_ourAddr) != -1; return llarp_ev_add_udp(m_Loop.get(), &m_udp, m_ourAddr.createSockAddr()) != -1;
} }
void void
@ -208,7 +215,7 @@ namespace llarp
{ {
Lock_t l_authed(m_AuthedLinksMutex); Lock_t l_authed(m_AuthedLinksMutex);
Lock_t l_pending(m_PendingMutex); Lock_t l_pending(m_PendingMutex);
llarp::Addr addr = s->GetRemoteEndpoint(); IpAddress addr = s->GetRemoteEndpoint();
auto itr = m_Pending.find(addr); auto itr = m_Pending.find(addr);
if (itr != m_Pending.end()) if (itr != m_Pending.end())
{ {
@ -264,7 +271,7 @@ namespace llarp
return {{"name", Name()}, return {{"name", Name()},
{"rank", uint64_t(Rank())}, {"rank", uint64_t(Rank())},
{"addr", m_ourAddr.ToString()}, {"addr", m_ourAddr.toString()},
{"sessions", util::StatusObject{{"pending", pending}, {"established", established}}}}; {"sessions", util::StatusObject{{"pending", pending}, {"established", established}}}};
} }
@ -282,14 +289,14 @@ namespace llarp
llarp::AddressInfo to; llarp::AddressInfo to;
if (!PickAddress(rc, to)) if (!PickAddress(rc, to))
return false; return false;
const llarp::Addr addr(to); const IpAddress address = to.toIpAddress();
{ {
Lock_t l(m_PendingMutex); Lock_t l(m_PendingMutex);
if (m_Pending.count(addr) >= MaxSessionsPerKey) if (m_Pending.count(address) >= MaxSessionsPerKey)
{ {
LogDebug( LogDebug(
"Too many pending connections to ", "Too many pending connections to ",
addr, address,
" while establishing to ", " while establishing to ",
RouterID{rc.pubkey}, RouterID{rc.pubkey},
", not establishing another"); ", not establishing another");
@ -440,11 +447,10 @@ namespace llarp
bool bool
ILinkLayer::GetOurAddressInfo(llarp::AddressInfo& addr) const ILinkLayer::GetOurAddressInfo(llarp::AddressInfo& addr) const
{ {
addr.fromIpAddress(m_ourAddr);
addr.dialect = Name(); addr.dialect = Name();
addr.pubkey = TransportPubKey(); addr.pubkey = TransportPubKey();
addr.rank = Rank(); addr.rank = Rank();
addr.port = m_ourAddr.port();
addr.ip = *m_ourAddr.addr6();
return true; return true;
} }
@ -465,10 +471,10 @@ namespace llarp
{ {
static constexpr size_t MaxSessionsPerEndpoint = 5; static constexpr size_t MaxSessionsPerEndpoint = 5;
Lock_t lock(m_PendingMutex); Lock_t lock(m_PendingMutex);
llarp::Addr addr = s->GetRemoteEndpoint(); IpAddress address = s->GetRemoteEndpoint();
if (m_Pending.count(addr) >= MaxSessionsPerEndpoint) if (m_Pending.count(address) >= MaxSessionsPerEndpoint)
return false; return false;
m_Pending.emplace(addr, s); m_Pending.emplace(address, s);
return true; return true;
} }

12
llarp/link/server.hpp
Unescape Escape View File

@ -4,7 +4,7 @@
#include <crypto/types.hpp> #include <crypto/types.hpp>
#include <ev/ev.h> #include <ev/ev.h>
#include <link/session.hpp> #include <link/session.hpp>
#include <net/net.hpp> #include <net/sock_addr.hpp>
#include <router_contact.hpp> #include <router_contact.hpp>
#include <util/status.hpp> #include <util/status.hpp>
#include <util/thread/logic.hpp> #include <util/thread/logic.hpp>
@ -82,7 +82,7 @@ namespace llarp
udp_tick(llarp_udp_io* udp); udp_tick(llarp_udp_io* udp);
void 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); llarp_ev_udp_sendto(&m_udp, to, pkt);
} }
@ -97,7 +97,7 @@ namespace llarp
Pump(); Pump();
virtual void virtual void
RecvFrom(const Addr& from, ILinkSession::Packet_t pkt) = 0; RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) = 0;
bool bool
PickAddress(const RouterContact& rc, AddressInfo& picked) const; 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::Logic> m_Logic = nullptr;
std::shared_ptr<llarp::thread::ThreadPool> m_Worker = nullptr; std::shared_ptr<llarp::thread::ThreadPool> m_Worker = nullptr;
llarp_ev_loop_ptr m_Loop; llarp_ev_loop_ptr m_Loop;
Addr m_ourAddr; IpAddress m_ourAddr;
llarp_udp_io m_udp; llarp_udp_io m_udp;
SecretKey m_SecretKey; SecretKey m_SecretKey;
using AuthedLinks = using AuthedLinks =
std::unordered_multimap<RouterID, std::shared_ptr<ILinkSession>, RouterID::Hash>; std::unordered_multimap<RouterID, std::shared_ptr<ILinkSession>, RouterID::Hash>;
using Pending = 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)); mutable DECLARE_LOCK(Mutex_t, m_AuthedLinksMutex, ACQUIRED_BEFORE(m_PendingMutex));
AuthedLinks m_AuthedLinks GUARDED_BY(m_AuthedLinksMutex); AuthedLinks m_AuthedLinks GUARDED_BY(m_AuthedLinksMutex);
mutable DECLARE_LOCK(Mutex_t, m_PendingMutex, ACQUIRED_AFTER(m_AuthedLinksMutex)); mutable DECLARE_LOCK(Mutex_t, m_PendingMutex, ACQUIRED_AFTER(m_AuthedLinksMutex));
Pending m_Pending GUARDED_BY(m_PendingMutex); 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>; using LinkLayer_ptr = std::shared_ptr<ILinkLayer>;

2
llarp/link/session.hpp
Unescape Escape View File

@ -87,7 +87,7 @@ namespace llarp
IsInbound() const = 0; IsInbound() const = 0;
/// get remote address /// get remote address
virtual Addr virtual IpAddress
GetRemoteEndpoint() const = 0; GetRemoteEndpoint() const = 0;
// get remote rc // get remote rc

4
llarp/messages/relay_commit.cpp
Unescape Escape View File

@ -185,7 +185,7 @@ namespace llarp
// the actual hop // the actual hop
std::shared_ptr<Hop> 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) LRCMFrameDecrypt(Context* ctx, Decrypter_ptr dec, const LR_CommitMessage* commit)
: decrypter(std::move(dec)) : decrypter(std::move(dec))
@ -194,7 +194,7 @@ namespace llarp
, hop(std::make_shared<Hop>()) , hop(std::make_shared<Hop>())
, fromAddr( , fromAddr(
commit->session->GetRemoteRC().IsPublicRouter() commit->session->GetRemoteRC().IsPublicRouter()
? std::optional<llarp::Addr>{} ? std::optional<IpAddress>{}
: commit->session->GetRemoteEndpoint()) : commit->session->GetRemoteEndpoint())
{ {
hop->info.downstream = commit->session->GetPubKey(); hop->info.downstream = commit->session->GetPubKey();

9
llarp/net/address_info.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define LLARP_AI_HPP #define LLARP_AI_HPP
#include <crypto/types.hpp> #include <crypto/types.hpp>
#include <net/ip_address.hpp>
#include <net/net.h> #include <net/net.h>
#include <util/bencode.hpp> #include <util/bencode.hpp>
#include <util/mem.h> #include <util/mem.h>
@ -39,6 +40,14 @@ namespace llarp
bool bool
DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf); 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& std::ostream&
print(std::ostream& stream, int level, int spaces) const; print(std::ostream& stream, int level, int spaces) const;

16
llarp/net/exit_info.cpp
Unescape Escape View File

@ -3,6 +3,7 @@
#endif #endif
#include <net/exit_info.hpp> #include <net/exit_info.hpp>
#include <net/net.hpp>
#include <util/bencode.h> #include <util/bencode.h>
#include <util/bits.hpp> #include <util/bits.hpp>
#include <util/mem.h> #include <util/mem.h>
@ -15,6 +16,11 @@ namespace llarp
bool bool
ExitInfo::BEncode(llarp_buffer_t* buf) const 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}; char tmp[128] = {0};
if (!bencode_start_dict(buf)) if (!bencode_start_dict(buf))
return false; return false;
@ -57,6 +63,11 @@ namespace llarp
bool bool
ExitInfo::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf) 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; bool read = false;
if (!BEncodeMaybeReadDictEntry("k", pubkey, read, k, buf)) if (!BEncodeMaybeReadDictEntry("k", pubkey, read, k, buf))
return false; return false;
@ -72,6 +83,11 @@ namespace llarp
std::ostream& std::ostream&
ExitInfo::print(std::ostream& stream, int level, int spaces) const 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); Printer printer(stream, level, spaces);
std::ostringstream ss; std::ostringstream ss;

12
llarp/net/exit_info.hpp
Unescape Escape View File

@ -2,7 +2,7 @@
#define LLARP_XI_HPP #define LLARP_XI_HPP
#include <crypto/types.hpp> #include <crypto/types.hpp>
#include <net/net.hpp> #include <net/ip_address.hpp>
#include <util/bencode.hpp> #include <util/bencode.hpp>
#include <iosfwd> #include <iosfwd>
@ -18,20 +18,14 @@ namespace llarp
{ {
struct ExitInfo struct ExitInfo
{ {
in6_addr address = {}; IpAddress ipAddress;
in6_addr netmask = {};
PubKey pubkey; PubKey pubkey;
uint64_t version = LLARP_PROTO_VERSION; uint64_t version = LLARP_PROTO_VERSION;
ExitInfo() = default; 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 bool

74
llarp/net/ip_address.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#include <net/sock_addr.hpp> #include <net/sock_addr.hpp>
#include <optional>
#include <string_view> #include <string_view>
#include <string> #include <string>
@ -18,6 +19,9 @@ namespace llarp
/// TODO: IPv6 is not currently supported. /// TODO: IPv6 is not currently supported.
struct IpAddress struct IpAddress
{ {
/// Empty constructor.
IpAddress() = default;
/// Constructor. Takes a string which can be an IPv4 or IPv6 address optionally followed by /// Constructor. Takes a string which can be an IPv4 or IPv6 address optionally followed by
/// a colon and a port. /// a colon and a port.
/// ///
@ -39,6 +43,14 @@ namespace llarp
/// @throws std::invalid_argument if str cannot be parsed /// @throws std::invalid_argument if str cannot be parsed
IpAddress(std::string_view str, std::optional<uint16_t> port); 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. Returns -1 if no port has been provided.
/// ///
/// @return the port, if present /// @return the port, if present
@ -51,6 +63,13 @@ namespace llarp
void void
setPort(std::optional<uint16_t> port); 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) /// 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 /// TODO: could return an int (e.g. 4 or 6) or an enum
@ -59,22 +78,69 @@ namespace llarp
bool bool
isIPv4(); 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. /// Creates an instance of SockAddr representing this IpAddress.
/// ///
/// @return an instance of a SockAddr created from this IpAddress /// @return an instance of a SockAddr created from this IpAddress
SockAddr SockAddr
createSockAddr() const; 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 // TODO: other utility functions left over from Addr which may be useful
// IsBogon() const; // IsBogon() const;
// isPrivate() const; // isPrivate() const;
// struct Hash // struct Hash
// operator<(const Addr& other) const; // to string / stream / etc
// operator==(const Addr& other) const;
// operator=(const sockaddr& other); 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: private:
std::string m_ipAddress; 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 } // namespace llarp

19
llarp/net/net.cpp
Unescape Escape View File

@ -13,7 +13,6 @@
#endif #endif
#endif #endif
#include <net/net_addr.hpp>
#include <net/ip.hpp> #include <net/ip.hpp>
#include <util/logging/logger.hpp> #include <util/logging/logger.hpp>
#include <util/str.hpp> #include <util/str.hpp>
@ -428,9 +427,10 @@ namespace llarp
{ {
if (i->ifa_addr->sa_family == af) 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; ifname = i->ifa_name;
found = true; found = true;
@ -533,18 +533,18 @@ namespace llarp
return std::nullopt; return std::nullopt;
} }
std::optional<llarp::Addr> std::optional<IpAddress>
GetIFAddr(const std::string& ifname, int af) GetIFAddr(const std::string& ifname, int af)
{ {
sockaddr_storage s; sockaddr_storage s;
sockaddr* sptr = (sockaddr*)&s; sockaddr* sptr = (sockaddr*)&s;
if (!llarp_getifaddr(ifname.c_str(), af, sptr)) if (!llarp_getifaddr(ifname.c_str(), af, sptr))
return std::nullopt; return std::nullopt;
return llarp::Addr{*sptr}; return IpAddress(SockAddr(sptr));
} }
bool bool
AllInterfaces(int af, Addr& result) AllInterfaces(int af, IpAddress& result)
{ {
if (af == AF_INET) if (af == AF_INET)
{ {
@ -552,17 +552,20 @@ namespace llarp
addr.sin_family = AF_INET; addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY); addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(0); addr.sin_port = htons(0);
result = addr; result = IpAddress(SockAddr(addr));
return true; return true;
} }
if (af == AF_INET6) if (af == AF_INET6)
{ {
throw std::runtime_error("Fix me: IPv6 not supported yet");
/*
sockaddr_in6 addr6; sockaddr_in6 addr6;
addr6.sin6_family = AF_INET6; addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(0); addr6.sin6_port = htons(0);
addr6.sin6_addr = IN6ADDR_ANY_INIT; addr6.sin6_addr = IN6ADDR_ANY_INIT;
result = addr6; result = IpAddress(SockAddr(addr6));
return true; return true;
*/
} }
// TODO: implement sockaddr_ll // TODO: implement sockaddr_ll

9
llarp/net/net.hpp
Unescape Escape View File

@ -3,6 +3,7 @@
#include <net/uint128.hpp> #include <net/uint128.hpp>
#include <net/address_info.hpp> #include <net/address_info.hpp>
#include <net/ip_address.hpp>
#include <net/net_int.hpp> #include <net/net_int.hpp>
#include <net/net.h> #include <net/net.h>
#include <util/mem.hpp> #include <util/mem.hpp>
@ -158,10 +159,8 @@ namespace llarp
bool bool
IsBogonRange(const in6_addr& host, const in6_addr& mask); IsBogonRange(const in6_addr& host, const in6_addr& mask);
struct Addr; // fwd declr
bool bool
AllInterfaces(int af, Addr& addr); AllInterfaces(int af, IpAddress& addr);
/// get first network interface with public address /// get first network interface with public address
bool bool
@ -176,11 +175,9 @@ namespace llarp
FindFreeTun(); FindFreeTun();
/// get network interface address for network interface with ifname /// 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); GetIFAddr(const std::string& ifname, int af = AF_INET);
} // namespace llarp } // namespace llarp
#include <net/net_addr.hpp>
#endif #endif

23
llarp/net/sock_addr.hpp
Unescape Escape View File

@ -10,16 +10,33 @@ namespace llarp
/// A simple SockAddr wrapper which provides a sockaddr_in (IPv4). Memory management is handled /// A simple SockAddr wrapper which provides a sockaddr_in (IPv4). Memory management is handled
/// in constructor and destructor (if needed) and copying is disabled. /// in constructor and destructor (if needed) and copying is disabled.
/// ///
/// This is immutable. /// This is immutable other than assignment operator.
struct SockAddr 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);
SockAddr(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint16_t port); SockAddr(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint16_t port);
SockAddr(uint32_t addr); SockAddr(uint32_t addr);
SockAddr(std::string_view 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; operator const sockaddr*() const;
bool
isEmpty() const;
private:
sockaddr_in addr;
}; };
std::ostream&
operator<<(std::ostream& out, const SockAddr& address);
} // namespace llarp } // namespace llarp

8
llarp/path/path_context.cpp
Unescape Escape View File

@ -35,14 +35,14 @@ namespace llarp
} }
bool bool
PathContext::CheckPathLimitHitByIP(const llarp::Addr& ip) PathContext::CheckPathLimitHitByIP(const IpAddress& ip)
{ {
#ifdef TESTNET #ifdef TESTNET
return false; return false;
#else #else
llarp::Addr remote = ip; IpAddress remote = ip;
// set port to zero // null out the port -- we don't care about it for path limiting purposes
remote.port(0); remote.setPort(0);
// try inserting remote address by ip into decaying hash set // try inserting remote address by ip into decaying hash set
// if it cannot insert it has hit a limit // if it cannot insert it has hit a limit
return not m_PathLimits.Insert(remote); return not m_PathLimits.Insert(remote);

5
llarp/path/path_context.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define LLARP_PATH_CONTEXT_HPP #define LLARP_PATH_CONTEXT_HPP
#include <crypto/encrypted_frame.hpp> #include <crypto/encrypted_frame.hpp>
#include <net/ip_address.hpp>
#include <path/ihophandler.hpp> #include <path/ihophandler.hpp>
#include <path/path_types.hpp> #include <path/path_types.hpp>
#include <path/pathset.hpp> #include <path/pathset.hpp>
@ -52,7 +53,7 @@ namespace llarp
RejectTransit(); RejectTransit();
bool bool
CheckPathLimitHitByIP(const llarp::Addr& ip); CheckPathLimitHitByIP(const IpAddress& ip);
bool bool
AllowingTransit() const; AllowingTransit() const;
@ -170,7 +171,7 @@ namespace llarp
SyncTransitMap_t m_TransitPaths; SyncTransitMap_t m_TransitPaths;
SyncOwnedPathsMap_t m_OurPaths; SyncOwnedPathsMap_t m_OurPaths;
bool m_AllowTransit; bool m_AllowTransit;
util::DecayingHashSet<llarp::Addr> m_PathLimits; util::DecayingHashSet<IpAddress> m_PathLimits;
}; };
} // namespace path } // namespace path
} // namespace llarp } // namespace llarp

28
llarp/router/router.cpp
Unescape Escape View File

@ -65,10 +65,6 @@ namespace llarp
{ {
m_keyManager = std::make_shared<KeyManager>(); m_keyManager = std::make_shared<KeyManager>();
// set rational defaults
this->ip4addr.sin_family = AF_INET;
this->ip4addr.sin_port = htons(1090);
_stopping.store(false); _stopping.store(false);
_running.store(false); _running.store(false);
_lastTick = llarp::time_now_ms(); _lastTick = llarp::time_now_ms();
@ -401,9 +397,7 @@ namespace llarp
encryption_keyfile = conf->router.m_dataDir / our_enc_key_filename; encryption_keyfile = conf->router.m_dataDir / our_enc_key_filename;
our_rc_file = conf->router.m_dataDir / our_rc_filename; our_rc_file = conf->router.m_dataDir / our_rc_filename;
transport_keyfile = conf->router.m_dataDir / our_transport_key_filename; transport_keyfile = conf->router.m_dataDir / our_transport_key_filename;
addrInfo = conf->router.m_addrInfo; _ourAddress = conf->router.m_publicAddress;
publicOverride = conf->router.m_publicOverride;
ip4addr = conf->router.m_ip4addr;
RouterContact::BlockBogons = conf->router.m_blockBogons; RouterContact::BlockBogons = conf->router.m_blockBogons;
@ -411,7 +405,7 @@ namespace llarp
usingSNSeed = conf->lokid.usingSNSeed; usingSNSeed = conf->lokid.usingSNSeed;
ident_keyfile = conf->lokid.ident_keyfile; ident_keyfile = conf->lokid.ident_keyfile;
whitelistRouters = conf->lokid.whitelistRouters; whitelistRouters = conf->lokid.whitelistRouters;
lokidRPCAddr = conf->lokid.lokidRPCAddr; lokidRPCAddr = IpAddress(conf->lokid.lokidRPCAddr); // TODO: make config's option an IpAddress
lokidRPCUser = conf->lokid.lokidRPCUser; lokidRPCUser = conf->lokid.lokidRPCUser;
lokidRPCPassword = conf->lokid.lokidRPCPassword; lokidRPCPassword = conf->lokid.lokidRPCPassword;
@ -572,7 +566,7 @@ namespace llarp
// API config // API config
enableRPCServer = conf->api.m_enableRPCServer; 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()) if (not IsServiceNode())
{ {
hiddenServiceContext().AddEndpoint(*conf); hiddenServiceContext().AddEndpoint(*conf);
@ -843,7 +837,7 @@ namespace llarp
if (enableRPCServer) if (enableRPCServer)
{ {
if (rpcBindAddr.empty()) if (rpcBindAddr.isEmpty())
{ {
rpcBindAddr = DefaultRPCBindAddr; rpcBindAddr = DefaultRPCBindAddr;
} }
@ -891,8 +885,6 @@ namespace llarp
routerProfiling().Load(routerProfilesFile.c_str()); routerProfiling().Load(routerProfilesFile.c_str());
Addr publicAddr(this->addrInfo);
// set public signing key // set public signing key
_rc.pubkey = seckey_topublic(identity()); _rc.pubkey = seckey_topublic(identity());
// set router version if service node // set router version if service node
@ -906,10 +898,9 @@ namespace llarp
if (link->GetOurAddressInfo(ai)) if (link->GetOurAddressInfo(ai))
{ {
// override ip and port // override ip and port
if (this->publicOverride) if (not _ourAddress.isEmpty())
{ {
ai.ip = *publicAddr.addr6(); ai.fromIpAddress(_ourAddress);
ai.port = publicAddr.port();
} }
if (RouterContact::BlockBogons && IsBogon(ai.ip)) if (RouterContact::BlockBogons && IsBogon(ai.ip))
return; return;
@ -917,10 +908,9 @@ namespace llarp
_rc.addrs.push_back(ai); _rc.addrs.push_back(ai);
if (ExitEnabled()) if (ExitEnabled())
{ {
const llarp::Addr addr(ai); const IpAddress address = ai.toIpAddress();
const nuint32_t a{addr.addr4()->s_addr}; _rc.exits.emplace_back(_rc.pubkey, address);
_rc.exits.emplace_back(_rc.pubkey, a); LogInfo("Exit relay started, advertised as exiting at: ", address);
LogInfo("Exit relay started, advertised as exiting at: ", a);
} }
} }
}); });

11
llarp/router/router.hpp
Unescape Escape View File

@ -163,10 +163,7 @@ namespace llarp
return disk; return disk;
} }
// our ipv4 public setting IpAddress _ourAddress;
bool publicOverride = false;
struct sockaddr_in ip4addr;
AddressInfo addrInfo;
llarp_ev_loop_ptr _netloop; llarp_ev_loop_ptr _netloop;
std::shared_ptr<llarp::thread::ThreadPool> cryptoworker; std::shared_ptr<llarp::thread::ThreadPool> cryptoworker;
@ -245,15 +242,15 @@ namespace llarp
NetworkConfig networkConfig; NetworkConfig networkConfig;
DnsConfig dnsConfig; DnsConfig dnsConfig;
const std::string DefaultRPCBindAddr = "127.0.0.1:1190"; const IpAddress DefaultRPCBindAddr = IpAddress("127.0.0.1:1190");
bool enableRPCServer = false; bool enableRPCServer = false;
std::unique_ptr<rpc::Server> rpcServer; std::unique_ptr<rpc::Server> rpcServer;
std::string rpcBindAddr = DefaultRPCBindAddr; IpAddress rpcBindAddr = DefaultRPCBindAddr;
const llarp_time_t _randomStartDelay; const llarp_time_t _randomStartDelay;
/// lokid caller /// lokid caller
std::unique_ptr<rpc::Caller> rpcCaller; 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 lokidRPCUser;
std::string lokidRPCPassword; std::string lokidRPCPassword;

4
llarp/router_contact.cpp
Unescape Escape View File

@ -343,7 +343,9 @@ namespace llarp
} }
for (const auto& exit : exits) 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); llarp::LogError("bogon exit: ", exit);
return false; return false;

15
llarp/rpc/rpc.cpp
Unescape Escape View File

@ -188,7 +188,7 @@ namespace llarp
} }
bool bool
Start(const std::string& remote) Start(const IpAddress& remote)
{ {
return RunAsync(router->netloop(), remote); return RunAsync(router->netloop(), remote);
} }
@ -459,8 +459,12 @@ namespace llarp
} }
bool 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; sockaddr_in saddr;
saddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); saddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
saddr.sin_family = AF_INET; saddr.sin_family = AF_INET;
@ -478,7 +482,8 @@ namespace llarp
{ {
_handler.expectedHostname = addr; _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 bool
Caller::Start(const std::string& addr) Caller::Start(const IpAddress& addr)
{ {
return m_Impl->Start(addr); return m_Impl->Start(addr);
} }
@ -525,7 +530,7 @@ namespace llarp
} }
bool bool
Server::Start(const std::string& addr) Server::Start(const IpAddress& addr)
{ {
return m_Impl->Start(addr); return m_Impl->Start(addr);
} }

5
llarp/rpc/rpc.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define LLARP_RPC_HPP #define LLARP_RPC_HPP
#include <util/time.hpp> #include <util/time.hpp>
#include <net/ip_address.hpp>
#include <functional> #include <functional>
#include <memory> #include <memory>
@ -23,7 +24,7 @@ namespace llarp
~Server(); ~Server();
bool bool
Start(const std::string& bindaddr); Start(const IpAddress& bindaddr);
/// stop and close /// stop and close
void void
@ -47,7 +48,7 @@ namespace llarp
/// start with jsonrpc endpoint address /// start with jsonrpc endpoint address
bool bool
Start(const std::string& remote); Start(const IpAddress& remote);
/// stop and close /// stop and close
void void

Write Preview
Loading…
Cancel
Save