Skip to content

Commit 5c832c3

Browse files
brunoergbrunoerg
committed
p2p, refactor: return std::optional<CNetAddr> in LookupHost 
1 parent 34bcdfc commit 5c832c3

File tree

12 files changed

+61
-83
lines changed

12 files changed

+61
-83
lines changed

‎src/bench/addrman.cpp

Lines changed: 1 addition & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -72,13 +72,6 @@ static void FillAddrMan(AddrMan& addrman)
7272
AddAddressesToAddrMan(addrman);
7373
}
7474

75-
static CNetAddr ResolveIP(const std::string& ip)
76-
{
77-
CNetAddr addr;
78-
LookupHost(ip, addr, false);
79-
return addr;
80-
}
81-
8275
/* Benchmarks */
8376

8477
static void AddrManAdd(benchmark::Bench& bench)
@@ -128,7 +121,7 @@ static void AddrManSelectByNetwork(benchmark::Bench& bench)
128121
i2p_service.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p");
129122
CAddress i2p_address(i2p_service, NODE_NONE);
130123
i2p_address.nTime = Now<NodeSeconds>();
131-
CNetAddr source = ResolveIP("252.2.2.2");
124+
const CNetAddr source{LookupHost("252.2.2.2", false).value()};
132125
addrman.Add({i2p_address}, source);
133126

134127
FillAddrMan(addrman);

‎src/httpserver.cpp

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -170,12 +170,8 @@ static bool ClientAllowed(const CNetAddr& netaddr)
170170
static bool InitHTTPAllowList()
171171
{
172172
rpc_allow_subnets.clear();
173-
CNetAddr localv4;
174-
CNetAddr localv6;
175-
LookupHost("127.0.0.1", localv4, false);
176-
LookupHost("::1", localv6, false);
177-
rpc_allow_subnets.push_back(CSubNet(localv4, 8)); // always allow IPv4 local subnet
178-
rpc_allow_subnets.push_back(CSubNet(localv6)); // always allow IPv6 localhost
173+
rpc_allow_subnets.push_back(CSubNet{LookupHost("127.0.0.1", false).value(), 8}); // always allow IPv4 local subnet
174+
rpc_allow_subnets.push_back(CSubNet{LookupHost("::1", false).value()}); // always allow IPv6 localhost
179175
for (const std::string& strAllow : gArgs.GetArgs("-rpcallowip")) {
180176
CSubNet subnet;
181177
LookupSubNet(strAllow, subnet);
@@ -338,8 +334,8 @@ static bool HTTPBindAddresses(struct evhttp* http)
338334
LogPrintf("Binding RPC on address %s port %i\n", i->first, i->second);
339335
evhttp_bound_socket *bind_handle = evhttp_bind_socket_with_handle(http, i->first.empty() ? nullptr : i->first.c_str(), i->second);
340336
if (bind_handle) {
341-
CNetAddr addr;
342-
if (i->first.empty() || (LookupHost(i->first, addr, false) && addr.IsBindAny())) {
337+
const std::optional<CNetAddr> addr{LookupHost(i->first, false)};
338+
if (i->first.empty() || (addr.has_value() && addr->IsBindAny())) {
343339
LogPrintf("WARNING: the RPC server is not safe to expose to untrusted networks such as the public internet\n");
344340
}
345341
boundSockets.push_back(bind_handle);

‎src/mapport.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -175,10 +175,10 @@ static bool ProcessUpnp()
175175
LogPrintf("UPnP: GetExternalIPAddress() returned %d\n", r);
176176
} else {
177177
if (externalIPAddress[0]) {
178-
CNetAddr resolved;
179-
if (LookupHost(externalIPAddress, resolved, false)) {
180-
LogPrintf("UPnP: ExternalIPAddress = %s\n", resolved.ToStringAddr());
181-
AddLocal(resolved, LOCAL_MAPPED);
178+
std::optional<CNetAddr> resolved{LookupHost(externalIPAddress, false)};
179+
if (resolved.has_value()) {
180+
LogPrintf("UPnP: ExternalIPAddress = %s\n", resolved->ToStringAddr());
181+
AddLocal(resolved.value(), LOCAL_MAPPED);
182182
}
183183
} else {
184184
LogPrintf("UPnP: GetExternalIPAddress failed.\n");

‎src/netbase.cpp

Lines changed: 9 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -173,16 +173,10 @@ std::vector<CNetAddr> LookupHost(const std::string& name, unsigned int nMaxSolut
173173
return LookupIntern(strHost, nMaxSolutions, fAllowLookup, dns_lookup_function);
174174
}
175175

176-
bool LookupHost(const std::string& name, CNetAddr& addr, bool fAllowLookup, DNSLookupFn dns_lookup_function)
176+
std::optional<CNetAddr> LookupHost(const std::string& name, bool fAllowLookup, DNSLookupFn dns_lookup_function)
177177
{
178-
if (!ContainsNoNUL(name)) {
179-
return false;
180-
}
181178
const std::vector<CNetAddr> addresses{LookupHost(name, 1, fAllowLookup, dns_lookup_function)};
182-
if(addresses.empty())
183-
return false;
184-
addr = addresses.front();
185-
return true;
179+
return addresses.empty() ? std::nullopt : std::make_optional(addresses.front());
186180
}
187181

188182
std::vector<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function)
@@ -669,27 +663,27 @@ bool LookupSubNet(const std::string& subnet_str, CSubNet& subnet_out)
669663

670664
const size_t slash_pos{subnet_str.find_last_of('/')};
671665
const std::string str_addr{subnet_str.substr(0, slash_pos)};
672-
CNetAddr addr;
666+
const std::optional<CNetAddr> addr{LookupHost(str_addr, /*fAllowLookup=*/false)};
673667

674-
if (LookupHost(str_addr, addr, /*fAllowLookup=*/false)) {
668+
if (addr.has_value()) {
675669
if (slash_pos != subnet_str.npos) {
676670
const std::string netmask_str{subnet_str.substr(slash_pos + 1)};
677671
uint8_t netmask;
678672
if (ParseUInt8(netmask_str, &netmask)) {
679673
// Valid number; assume CIDR variable-length subnet masking.
680-
subnet_out = CSubNet{addr, netmask};
674+
subnet_out = CSubNet{addr.value(), netmask};
681675
return subnet_out.IsValid();
682676
} else {
683677
// Invalid number; try full netmask syntax. Never allow lookup for netmask.
684-
CNetAddr full_netmask;
685-
if (LookupHost(netmask_str, full_netmask, /*fAllowLookup=*/false)) {
686-
subnet_out = CSubNet{addr, full_netmask};
678+
const std::optional<CNetAddr> full_netmask{LookupHost(netmask_str, /*fAllowLookup=*/false)};
679+
if (full_netmask.has_value()) {
680+
subnet_out = CSubNet{addr.value(), full_netmask.value()};
687681
return subnet_out.IsValid();
688682
}
689683
}
690684
} else {
691685
// Single IP subnet (<ipv4>/32 or <ipv6>/128).
692-
subnet_out = CSubNet{addr};
686+
subnet_out = CSubNet{addr.value()};
693687
return subnet_out.IsValid();
694688
}
695689
}

‎src/netbase.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -117,13 +117,13 @@ std::vector<CNetAddr> LookupHost(const std::string& name, unsigned int nMaxSolut
117117
/**
118118
* Resolve a host string to its first corresponding network address.
119119
*
120-
* @returns The resulting network addresses to which the specified host
121-
* string resolved.
120+
* @returns The resulting network address to which the specified host
121+
* string resolved or std::nullopt if host does not resolve to an address.
122122
*
123-
* @see LookupHost(const std::string&, uint16_t, bool, DNSLookupFn)
123+
* @see LookupHost(const std::string&, unsigned int, bool, DNSLookupFn)
124124
* for additional parameter descriptions.
125125
*/
126-
bool LookupHost(const std::string& name, CNetAddr& addr, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);
126+
std::optional<CNetAddr> LookupHost(const std::string& name, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);
127127

128128
/**
129129
* Resolve a service string to its corresponding service.

‎src/qt/optionsdialog.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -406,9 +406,8 @@ void OptionsDialog::updateProxyValidationState()
406406

407407
void OptionsDialog::updateDefaultProxyNets()
408408
{
409-
CNetAddr ui_proxy_netaddr;
410-
LookupHost(ui->proxyIp->text().toStdString(), ui_proxy_netaddr, /*fAllowLookup=*/false);
411-
const CService ui_proxy{ui_proxy_netaddr, ui->proxyPort->text().toUShort()};
409+
const std::optional<CNetAddr> ui_proxy_netaddr{LookupHost(ui->proxyIp->text().toStdString(), /*fAllowLookup=*/false)};
410+
const CService ui_proxy{ui_proxy_netaddr.value_or(CNetAddr{}), ui->proxyPort->text().toUShort()};
412411

413412
Proxy proxy;
414413
bool has_proxy;

‎src/rpc/net.cpp

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -713,9 +713,10 @@ static RPCHelpMan setban()
713713
isSubnet = true;
714714

715715
if (!isSubnet) {
716-
CNetAddr resolved;
717-
LookupHost(request.params[0].get_str(), resolved, false);
718-
netAddr = resolved;
716+
const std::optional<CNetAddr> addr{LookupHost(request.params[0].get_str(), false)};
717+
if (addr.has_value()) {
718+
netAddr = addr.value();
719+
}
719720
}
720721
else
721722
LookupSubNet(request.params[0].get_str(), subNet);
@@ -943,11 +944,11 @@ static RPCHelpMan addpeeraddress()
943944
const bool tried{request.params[2].isNull() ? false : request.params[2].get_bool()};
944945

945946
UniValue obj(UniValue::VOBJ);
946-
CNetAddr net_addr;
947+
std::optional<CNetAddr> net_addr{LookupHost(addr_string, false)};
947948
bool success{false};
948949

949-
if (LookupHost(addr_string, net_addr, false)) {
950-
CService service{net_addr, port};
950+
if (net_addr.has_value()) {
951+
CService service{net_addr.value(), port};
951952
CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS}};
952953
address.nTime = Now<NodeSeconds>();
953954
// The source address is set equal to the address. This is equivalent to the peer

‎src/test/addrman_tests.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -33,9 +33,9 @@ static int32_t GetCheckRatio(const NodeContext& node_ctx)
3333

3434
static CNetAddr ResolveIP(const std::string& ip)
3535
{
36-
CNetAddr addr;
37-
BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false), strprintf("failed to resolve: %s", ip));
38-
return addr;
36+
const std::optional<CNetAddr> addr{LookupHost(ip, false)};
37+
BOOST_CHECK_MESSAGE(addr.has_value(), strprintf("failed to resolve: %s", ip));
38+
return addr.value_or(CNetAddr{});
3939
}
4040

4141
static CService ResolveService(const std::string& ip, uint16_t port = 0)
@@ -1012,9 +1012,9 @@ static CDataStream MakeCorruptPeersDat()
10121012
const std::optional<CService> serv{Lookup("252.1.1.1", 7777, false)};
10131013
BOOST_REQUIRE(serv.has_value());
10141014
CAddress addr = CAddress(serv.value(), NODE_NONE);
1015-
CNetAddr resolved;
1016-
BOOST_REQUIRE(LookupHost("252.2.2.2", resolved, false));
1017-
AddrInfo info = AddrInfo(addr, resolved);
1015+
std::optional<CNetAddr> resolved{LookupHost("252.2.2.2", false)};
1016+
BOOST_REQUIRE(resolved.has_value());
1017+
AddrInfo info = AddrInfo(addr, resolved.value());
10181018
s << info;
10191019

10201020
return s;

‎src/test/fuzz/netbase_dns_lookup.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -36,9 +36,9 @@ FUZZ_TARGET(netbase_dns_lookup)
3636
assert(resolved_addresses.size() <= max_results || max_results == 0);
3737
}
3838
{
39-
CNetAddr resolved_address;
40-
if (LookupHost(name, resolved_address, allow_lookup, fuzzed_dns_lookup_function)) {
41-
assert(!resolved_address.IsInternal());
39+
const std::optional<CNetAddr> resolved_address{LookupHost(name, allow_lookup, fuzzed_dns_lookup_function)};
40+
if (resolved_address.has_value()) {
41+
assert(!resolved_address.value().IsInternal());
4242
}
4343
}
4444
{

‎src/test/net_tests.cpp

Lines changed: 14 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
135135
CNetAddr addr;
136136

137137
// IPv4, INADDR_ANY
138-
BOOST_REQUIRE(LookupHost("0.0.0.0", addr, false));
138+
addr = LookupHost("0.0.0.0", false).value();
139139
BOOST_REQUIRE(!addr.IsValid());
140140
BOOST_REQUIRE(addr.IsIPv4());
141141

@@ -144,7 +144,7 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
144144
BOOST_CHECK_EQUAL(addr.ToStringAddr(), "0.0.0.0");
145145

146146
// IPv4, INADDR_NONE
147-
BOOST_REQUIRE(LookupHost("255.255.255.255", addr, false));
147+
addr = LookupHost("255.255.255.255", false).value();
148148
BOOST_REQUIRE(!addr.IsValid());
149149
BOOST_REQUIRE(addr.IsIPv4());
150150

@@ -153,7 +153,7 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
153153
BOOST_CHECK_EQUAL(addr.ToStringAddr(), "255.255.255.255");
154154

155155
// IPv4, casual
156-
BOOST_REQUIRE(LookupHost("12.34.56.78", addr, false));
156+
addr = LookupHost("12.34.56.78", false).value();
157157
BOOST_REQUIRE(addr.IsValid());
158158
BOOST_REQUIRE(addr.IsIPv4());
159159

@@ -162,7 +162,7 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
162162
BOOST_CHECK_EQUAL(addr.ToStringAddr(), "12.34.56.78");
163163

164164
// IPv6, in6addr_any
165-
BOOST_REQUIRE(LookupHost("::", addr, false));
165+
addr = LookupHost("::", false).value();
166166
BOOST_REQUIRE(!addr.IsValid());
167167
BOOST_REQUIRE(addr.IsIPv6());
168168

@@ -171,7 +171,7 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
171171
BOOST_CHECK_EQUAL(addr.ToStringAddr(), "::");
172172

173173
// IPv6, casual
174-
BOOST_REQUIRE(LookupHost("1122:3344:5566:7788:9900:aabb:ccdd:eeff", addr, false));
174+
addr = LookupHost("1122:3344:5566:7788:9900:aabb:ccdd:eeff", false).value();
175175
BOOST_REQUIRE(addr.IsValid());
176176
BOOST_REQUIRE(addr.IsIPv6());
177177

@@ -186,14 +186,14 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
186186
// id of "32", return the address as "fe80::1%32".
187187
const std::string link_local{"fe80::1"};
188188
const std::string scoped_addr{link_local + "%32"};
189-
BOOST_REQUIRE(LookupHost(scoped_addr, addr, false));
189+
addr = LookupHost(scoped_addr, false).value();
190190
BOOST_REQUIRE(addr.IsValid());
191191
BOOST_REQUIRE(addr.IsIPv6());
192192
BOOST_CHECK(!addr.IsBindAny());
193193
BOOST_CHECK_EQUAL(addr.ToStringAddr(), scoped_addr);
194194

195195
// Test that the delimiter "%" and default zone id of 0 can be omitted for the default scope.
196-
BOOST_REQUIRE(LookupHost(link_local + "%0", addr, false));
196+
addr = LookupHost(link_local + "%0", false).value();
197197
BOOST_REQUIRE(addr.IsValid());
198198
BOOST_REQUIRE(addr.IsIPv6());
199199
BOOST_CHECK(!addr.IsBindAny());
@@ -318,10 +318,9 @@ BOOST_AUTO_TEST_CASE(cnetaddr_tostring_canonical_ipv6)
318318
{"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
319319
};
320320
for (const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) {
321-
CNetAddr net_addr;
322-
BOOST_REQUIRE(LookupHost(input_address, net_addr, false));
323-
BOOST_REQUIRE(net_addr.IsIPv6());
324-
BOOST_CHECK_EQUAL(net_addr.ToStringAddr(), expected_canonical_representation_output);
321+
const std::optional<CNetAddr> net_addr{LookupHost(input_address, false)};
322+
BOOST_REQUIRE(net_addr.value().IsIPv6());
323+
BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output);
325324
}
326325
}
327326

@@ -334,12 +333,12 @@ BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1)
334333
BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000");
335334
s.clear();
336335

337-
BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false));
336+
addr = LookupHost("1.2.3.4", false).value();
338337
s << addr;
339338
BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000ffff01020304");
340339
s.clear();
341340

342-
BOOST_REQUIRE(LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false));
341+
addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value();
343342
s << addr;
344343
BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
345344
s.clear();
@@ -370,12 +369,12 @@ BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2)
370369
BOOST_CHECK_EQUAL(HexStr(s), "021000000000000000000000000000000000");
371370
s.clear();
372371

373-
BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false));
372+
addr = LookupHost("1.2.3.4", false).value();
374373
s << addr;
375374
BOOST_CHECK_EQUAL(HexStr(s), "010401020304");
376375
s.clear();
377376

378-
BOOST_REQUIRE(LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false));
377+
addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value();
379378
s << addr;
380379
BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
381380
s.clear();

0 commit comments

Comments
 (0)