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

use sane defaults and deprecated "auto" as it's horribly bad style

Browse Source
pull/686/head
Jeff Becker 5 years ago
parent 3638496e8d
commit c4aaa80e75
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
6 changed files with 69 additions and 181 deletions
Show Stats Download Patch File Download Diff File

6
llarp/config.cpp
Unescape Escape View File

@ -70,6 +70,12 @@ namespace llarp
{"services", services}};
auto visitor = [&](const char *name, const auto &item) {
if(item.second == "auto")
{
llarp::LogWarn(
"value 'auto' is deprecated, stop using this as it will break "
"things in the very near future");
}
functor(name, item.first.c_str(), item.second.c_str());
};

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

@ -97,7 +97,7 @@ llarp_ev_add_tun(struct llarp_ev_loop *loop, struct llarp_tun_io *tun)
// llarp::LogInfo("ev creating tunnel ", tun->ifaddr, " on ", tun->ifname);
if(strcmp(tun->ifaddr, "") == 0 || strcmp(tun->ifaddr, "auto") == 0)
{
std::string ifaddr = llarp::findFreePrivateRange();
std::string ifaddr = llarp::FindFreeRange();
auto pos = ifaddr.find("/");
if(pos == std::string::npos)
{
@ -124,7 +124,7 @@ llarp_ev_add_tun(struct llarp_ev_loop *loop, struct llarp_tun_io *tun)
}
if(strcmp(tun->ifname, "") == 0 || strcmp(tun->ifname, "auto") == 0)
{
std::string ifname = llarp::findFreeLokiTunIfName();
std::string ifname = llarp::FindFreeTun();
std::copy_n(ifname.begin(), std::min(sizeof(tun->ifname), ifname.size()),
tun->ifname);
llarp::LogInfo("IfName autodetect: ", tun->ifname);

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

@ -802,71 +802,37 @@ llarp_getifaddr(const char* ifname, int af, struct sockaddr* addr)
return found;
}
struct privatesInUse
llarp_getPrivateIfs()
{
struct privatesInUse result;
// mark all available for use
result.ten = false;
result.oneSeven = false;
result.oneNine = false;
ifaddrs* ifa = nullptr;
#ifndef _WIN32
if(getifaddrs(&ifa) == -1)
#else
if(!getifaddrs(&ifa))
#endif
return result;
ifaddrs* i = ifa;
while(i)
{
if(i->ifa_addr && i->ifa_addr->sa_family == AF_INET)
{
// llarp::LogInfo("scanning ", i->ifa_name, " af: ",
// std::to_string(i->ifa_addr->sa_family));
llarp::Addr test(*i->ifa_addr);
uint32_t byte = test.getHostLong();
if(test.isTenPrivate(byte))
{
llarp::LogDebug("private interface ", i->ifa_name, " ", test, " found");
result.ten = true;
}
else if(test.isOneSevenPrivate(byte))
{
llarp::LogDebug("private interface ", i->ifa_name, " ", test, " found");
result.oneSeven = true;
}
else if(test.isOneNinePrivate(byte))
{
llarp::LogDebug("private interface ", i->ifa_name, " ", test, " found");
result.oneNine = true;
}
}
i = i->ifa_next;
}
if(ifa)
freeifaddrs(ifa);
return result;
}
namespace llarp
{
bool
GetBestNetIF(std::string& ifname, int af)
static void
IterAllNetworkInterface(std::function< void(ifaddrs* const) > visit)
{
ifaddrs* ifa = nullptr;
bool found = false;
#ifndef _WIN32
if(getifaddrs(&ifa) == -1)
#else
if(!getifaddrs(&ifa))
#endif
return false;
return;
ifaddrs* i = ifa;
while(i)
{
visit(i);
i = ifa->ifa_next;
}
if(ifa)
freeifaddrs(ifa);
}
bool
GetBestNetIF(std::string& ifname, int af)
{
bool found = false;
IterAllNetworkInterface([&](ifaddrs* i) {
if(found)
return;
if(i->ifa_addr)
{
if(i->ifa_addr->sa_family == af)
@ -877,48 +843,54 @@ namespace llarp
{
ifname = i->ifa_name;
found = true;
break;
}
}
}
i = i->ifa_next;
}
if(ifa)
freeifaddrs(ifa);
});
return found;
}
// TODO: ipv6?
std::string
findFreePrivateRange()
FindFreeRange()
{
// pick ip
struct privatesInUse ifsInUse = llarp_getPrivateIfs();
std::string ip = "";
if(!ifsInUse.ten)
{
ip = "10.200.0.1/24";
}
else if(!ifsInUse.oneSeven)
{
ip = "172.16.10.1/24";
}
else if(!ifsInUse.oneNine)
{
ip = "192.168.10.1/24";
}
else
std::string ip;
std::vector< IPRange > currentRanges;
IterAllNetworkInterface([&](ifaddrs* i) {
if(i && i->ifa_addr)
{
const auto fam = i->ifa_addr->sa_family;
if(fam != AF_INET)
return;
sockaddr_in* addr = (sockaddr_in*)i->ifa_addr;
sockaddr_in* mask = (sockaddr_in*)i->ifa_netmask;
nuint32_t ifaddr{addr->sin_addr.s_addr};
nuint32_t ifmask{mask->sin_addr.s_addr};
currentRanges.emplace_back(
IPRange{net::IPPacket::ExpandV4(xntohl(ifaddr)),
net::IPPacket::ExpandV4(xntohl(ifmask))});
}
});
byte_t oct = 0;
while(oct < 255)
{
llarp::LogError(
"Couldn't easily detect a private range to map lokinet onto");
return "";
// TODO: check for range inbetween these
const huint32_t loaddr = ipaddr_ipv4_bits(10, oct, 0, 1);
const huint32_t hiaddr = ipaddr_ipv4_bits(10, oct, 255, 255);
bool hit = false;
for(const auto& range : currentRanges)
{
hit |= range.ContainsV4(loaddr) || range.ContainsV4(hiaddr);
}
if(!hit)
return loaddr.ToString() + "/16";
}
llarp::LogDebug("Detected " + ip
+ " is available for use, configuring as such");
return ip;
return "";
}
std::string
findFreeLokiTunIfName()
FindFreeTun()
{
uint8_t num = 0;
while(num < 255)
@ -938,7 +910,7 @@ namespace llarp
}
if(num == 255)
{
// llarp::LogError("Could not find any free lokitun interface names");
llarp::LogError("Could not find any free lokitun interface names");
return "";
}
// include lokitun prefix to communicate result is valid

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

@ -158,11 +158,11 @@ namespace llarp
/// look at adapter ranges and find a free one
std::string
findFreePrivateRange();
FindFreeRange();
/// look at adapter names and find a free one
std::string
findFreeLokiTunIfName();
FindFreeTun();
/// get network interface address for network interface with ifname
bool

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

@ -1772,16 +1772,10 @@ namespace llarp
return false;
}
// don't create default if we already have some defined
if(this->ShouldCreateDefaultHiddenService())
if(!CreateDefaultHiddenService())
{
// generate default hidden service
LogInfo("setting up default network endpoint");
if(!CreateDefaultHiddenService())
{
LogError("failed to set up default network endpoint");
return false;
}
LogError("failed to set up default network endpoint");
return false;
}
}
@ -1832,84 +1826,6 @@ namespace llarp
link->Stop();
}
bool
Router::ShouldCreateDefaultHiddenService()
{
std::string defaultIfAddr = "auto";
std::string defaultIfName = "auto";
std::string enabledOption = "auto";
auto itr = netConfig.find("defaultIfAddr");
if(itr != netConfig.end())
{
defaultIfAddr = itr->second;
}
itr = netConfig.find("defaultIfName");
if(itr != netConfig.end())
{
defaultIfName = itr->second;
}
itr = netConfig.find("enabled");
if(itr != netConfig.end())
{
enabledOption = itr->second;
}
LogDebug("IfName: ", defaultIfName, " IfAddr: ", defaultIfAddr,
" Enabled: ", enabledOption);
// LogInfo("IfAddr: ", itr->second);
// LogInfo("IfName: ", itr->second);
if(enabledOption == "false")
{
LogInfo("Disabling default hidden service");
return false;
}
else if(enabledOption == "auto")
{
// auto detect if we have any pre-defined endpoints
// no if we have a endpoints
if(hiddenServiceContext().hasEndpoints())
{
LogInfo("Auto mode detected and we have endpoints");
netConfig.emplace("enabled", "false");
return false;
}
netConfig.emplace("enabled", "true");
}
// ev.cpp llarp_ev_add_tun now handles this
/*
// so basically enabled at this point
if(defaultIfName == "auto")
{
// we don't have any endpoints, auto configure settings
// set a default IP range
defaultIfAddr = findFreePrivateRange();
if(defaultIfAddr == "")
{
LogError(
"Could not find any free lokitun interface names, can't
auto set up " "default HS context for client"); defaultIfAddr = "no";
netConfig.emplace("defaultIfAddr", defaultIfAddr);
return false;
}
netConfig.emplace("defaultIfAddr", defaultIfAddr);
}
if(defaultIfName == "auto")
{
// pick an ifName
defaultIfName = findFreeLokiTunIfName();
if(defaultIfName == "")
{
LogError(
"Could not find any free private ip ranges, can't auto
set up " "default HS context for client"); defaultIfName = "no";
netConfig.emplace("defaultIfName", defaultIfName);
return false;
}
netConfig.emplace("defaultIfName", defaultIfName);
}
*/
return true;
}
void
Router::Stop()
{
@ -2072,14 +1988,11 @@ namespace llarp
Router::CreateDefaultHiddenService()
{
// fallback defaults
// To NeuroScr: why run findFree* here instead of in tun.cpp?
// I think it should be in tun.cpp, better to closer to time of usage
// that way new tun may have grab a range we may have also grabbed here
static const std::unordered_map< std::string,
std::function< std::string(void) > >
netConfigDefaults = {
{"ifname", []() -> std::string { return "auto"; }},
{"ifaddr", []() -> std::string { return "auto"; }},
{"ifname", llarp::FindFreeTun},
{"ifaddr", llarp::FindFreeRange},
{"local-dns", []() -> std::string { return "127.0.0.1:53"; }}};
// populate with fallback defaults if values not present
auto itr = netConfigDefaults.begin();

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

@ -256,9 +256,6 @@ namespace llarp
bool
CreateDefaultHiddenService();
bool
ShouldCreateDefaultHiddenService();
const std::string DefaultRPCBindAddr = "127.0.0.1:1190";
bool enableRPCServer = true;
std::unique_ptr< rpc::Server > rpcServer;

Write Preview
Loading…
Cancel
Save