Skip to content

Commit 4ac1ce1

Browse files
jasnellMylesBorins
jasnell
authored and
MylesBorins
committedMar 9, 2020
src: introduce node_sockaddr
Introduce the SocketAddress utility class. The QUIC implementation makes extensive use of this for handling of socket addresses. It was separated out to make it generically reusable throughout core Signed-off-by: James M Snell <jasnell@gmail.com> PR-URL: #32070 Reviewed-By: David Carlier <devnexen@gmail.com> Reviewed-By: Richard Lau <riclau@uk.ibm.com> Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Denys Otrishko <shishugi@gmail.com>
·
v13.14.0v13.11.0
1 parent a727b13 commit 4ac1ce1

File tree

7 files changed

+460
-11
lines changed

7 files changed

+460
-11
lines changed
 

‎node.gyp

+4
Original file line numberDiff line numberDiff line change
@@ -597,6 +597,7 @@
597597
'src/node_process_methods.cc',
598598
'src/node_process_object.cc',
599599
'src/node_serdes.cc',
600+
'src/node_sockaddr.cc',
600601
'src/node_stat_watcher.cc',
601602
'src/node_symbols.cc',
602603
'src/node_task_queue.cc',
@@ -684,6 +685,8 @@
684685
'src/node_process.h',
685686
'src/node_revert.h',
686687
'src/node_root_certs.h',
688+
'src/node_sockaddr.h',
689+
'src/node_sockaddr-inl.h',
687690
'src/node_stat_watcher.h',
688691
'src/node_union_bytes.h',
689692
'src/node_url.h',
@@ -1150,6 +1153,7 @@
11501153
'test/cctest/test_linked_binding.cc',
11511154
'test/cctest/test_per_process.cc',
11521155
'test/cctest/test_platform.cc',
1156+
'test/cctest/test_sockaddr.cc',
11531157
'test/cctest/test_traced_value.cc',
11541158
'test/cctest/test_util.cc',
11551159
'test/cctest/test_url.cc',

‎src/node_sockaddr-inl.h

+170
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,170 @@
1+
#ifndef SRC_NODE_SOCKADDR_INL_H_
2+
#define SRC_NODE_SOCKADDR_INL_H_
3+
4+
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5+
6+
#include "node.h"
7+
#include "node_internals.h"
8+
#include "node_sockaddr.h"
9+
#include "util-inl.h"
10+
11+
#include <string>
12+
13+
namespace node {
14+
15+
static constexpr uint32_t kLabelMask = 0xFFFFF;
16+
17+
inline void hash_combine(size_t* seed) { }
18+
19+
template <typename T, typename... Args>
20+
inline void hash_combine(size_t* seed, const T& value, Args... rest) {
21+
*seed ^= std::hash<T>{}(value) + 0x9e3779b9 + (*seed << 6) + (*seed >> 2);
22+
hash_combine(seed, rest...);
23+
}
24+
25+
bool SocketAddress::is_numeric_host(const char* hostname) {
26+
return is_numeric_host(hostname, AF_INET) ||
27+
is_numeric_host(hostname, AF_INET6);
28+
}
29+
30+
bool SocketAddress::is_numeric_host(const char* hostname, int family) {
31+
in6_addr dst;
32+
return inet_pton(family, hostname, &dst) == 1;
33+
}
34+
35+
int SocketAddress::GetPort(const sockaddr* addr) {
36+
CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
37+
return ntohs(addr->sa_family == AF_INET ?
38+
reinterpret_cast<const sockaddr_in*>(addr)->sin_port :
39+
reinterpret_cast<const sockaddr_in6*>(addr)->sin6_port);
40+
}
41+
42+
int SocketAddress::GetPort(const sockaddr_storage* addr) {
43+
return GetPort(reinterpret_cast<const sockaddr*>(addr));
44+
}
45+
46+
std::string SocketAddress::GetAddress(const sockaddr* addr) {
47+
CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
48+
char host[INET6_ADDRSTRLEN];
49+
const void* src = addr->sa_family == AF_INET ?
50+
static_cast<const void*>(
51+
&(reinterpret_cast<const sockaddr_in*>(addr)->sin_addr)) :
52+
static_cast<const void*>(
53+
&(reinterpret_cast<const sockaddr_in6*>(addr)->sin6_addr));
54+
uv_inet_ntop(addr->sa_family, src, host, INET6_ADDRSTRLEN);
55+
return std::string(host);
56+
}
57+
58+
std::string SocketAddress::GetAddress(const sockaddr_storage* addr) {
59+
return GetAddress(reinterpret_cast<const sockaddr*>(addr));
60+
}
61+
62+
size_t SocketAddress::GetLength(const sockaddr* addr) {
63+
return addr->sa_family == AF_INET ?
64+
sizeof(sockaddr_in) : sizeof(sockaddr_in6);
65+
}
66+
67+
size_t SocketAddress::GetLength(const sockaddr_storage* addr) {
68+
return GetLength(reinterpret_cast<const sockaddr*>(addr));
69+
}
70+
71+
SocketAddress::SocketAddress(const sockaddr* addr) {
72+
memcpy(&address_, addr, GetLength(addr));
73+
}
74+
75+
SocketAddress::SocketAddress(const SocketAddress& addr) {
76+
memcpy(&address_, &addr.address_, addr.length());
77+
}
78+
79+
SocketAddress& SocketAddress::operator=(const sockaddr* addr) {
80+
memcpy(&address_, addr, GetLength(addr));
81+
return *this;
82+
}
83+
84+
SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
85+
memcpy(&address_, &addr.address_, addr.length());
86+
return *this;
87+
}
88+
89+
const sockaddr& SocketAddress::operator*() const {
90+
return *this->data();
91+
}
92+
93+
const sockaddr* SocketAddress::operator->() const {
94+
return this->data();
95+
}
96+
97+
size_t SocketAddress::length() const {
98+
return GetLength(&address_);
99+
}
100+
101+
const sockaddr* SocketAddress::data() const {
102+
return reinterpret_cast<const sockaddr*>(&address_);
103+
}
104+
105+
const uint8_t* SocketAddress::raw() const {
106+
return reinterpret_cast<const uint8_t*>(&address_);
107+
}
108+
109+
sockaddr* SocketAddress::storage() {
110+
return reinterpret_cast<sockaddr*>(&address_);
111+
}
112+
113+
int SocketAddress::family() const {
114+
return address_.ss_family;
115+
}
116+
117+
std::string SocketAddress::address() const {
118+
return GetAddress(&address_);
119+
}
120+
121+
int SocketAddress::port() const {
122+
return GetPort(&address_);
123+
}
124+
125+
uint32_t SocketAddress::flow_label() const {
126+
if (family() != AF_INET6)
127+
return 0;
128+
const sockaddr_in6* in = reinterpret_cast<const sockaddr_in6*>(data());
129+
return in->sin6_flowinfo;
130+
}
131+
132+
void SocketAddress::set_flow_label(uint32_t label) {
133+
if (family() != AF_INET6)
134+
return;
135+
CHECK_LE(label, kLabelMask);
136+
sockaddr_in6* in = reinterpret_cast<sockaddr_in6*>(&address_);
137+
in->sin6_flowinfo = label;
138+
}
139+
140+
std::string SocketAddress::ToString() const {
141+
if (family() != AF_INET && family() != AF_INET6) return "";
142+
return (family() == AF_INET6 ?
143+
std::string("[") + address() + "]:" :
144+
address() + ":") +
145+
std::to_string(port());
146+
}
147+
148+
void SocketAddress::Update(uint8_t* data, size_t len) {
149+
CHECK_LE(len, sizeof(address_));
150+
memcpy(&address_, data, len);
151+
}
152+
153+
v8::Local<v8::Object> SocketAddress::ToJS(
154+
Environment* env,
155+
v8::Local<v8::Object> info) const {
156+
return AddressToJS(env, data(), info);
157+
}
158+
159+
bool SocketAddress::operator==(const SocketAddress& other) const {
160+
if (family() != other.family()) return false;
161+
return memcmp(raw(), other.raw(), length()) == 0;
162+
}
163+
164+
bool SocketAddress::operator!=(const SocketAddress& other) const {
165+
return !(*this == other);
166+
}
167+
} // namespace node
168+
169+
#endif // NODE_WANT_INTERNALS
170+
#endif // SRC_NODE_SOCKADDR_INL_H_

‎src/node_sockaddr.cc

+95
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
#include "node_sockaddr-inl.h" // NOLINT(build/include)
2+
#include "uv.h"
3+
4+
namespace node {
5+
6+
namespace {
7+
template <typename T, typename F>
8+
SocketAddress FromUVHandle(F fn, const T& handle) {
9+
SocketAddress addr;
10+
int len = sizeof(sockaddr_storage);
11+
if (fn(&handle, addr.storage(), &len) == 0)
12+
CHECK_EQ(static_cast<size_t>(len), addr.length());
13+
else
14+
addr.storage()->sa_family = 0;
15+
return addr;
16+
}
17+
} // namespace
18+
19+
bool SocketAddress::ToSockAddr(
20+
int32_t family,
21+
const char* host,
22+
uint32_t port,
23+
sockaddr_storage* addr) {
24+
switch (family) {
25+
case AF_INET:
26+
return uv_ip4_addr(
27+
host,
28+
port,
29+
reinterpret_cast<sockaddr_in*>(addr)) == 0;
30+
case AF_INET6:
31+
return uv_ip6_addr(
32+
host,
33+
port,
34+
reinterpret_cast<sockaddr_in6*>(addr)) == 0;
35+
default:
36+
UNREACHABLE();
37+
}
38+
}
39+
40+
bool SocketAddress::New(
41+
const char* host,
42+
uint32_t port,
43+
SocketAddress* addr) {
44+
return New(AF_INET, host, port, addr) || New(AF_INET6, host, port, addr);
45+
}
46+
47+
bool SocketAddress::New(
48+
int32_t family,
49+
const char* host,
50+
uint32_t port,
51+
SocketAddress* addr) {
52+
return ToSockAddr(family, host, port,
53+
reinterpret_cast<sockaddr_storage*>(addr->storage()));
54+
}
55+
56+
size_t SocketAddress::Hash::operator()(const SocketAddress& addr) const {
57+
size_t hash = 0;
58+
switch (addr.family()) {
59+
case AF_INET: {
60+
const sockaddr_in* ipv4 =
61+
reinterpret_cast<const sockaddr_in*>(addr.raw());
62+
hash_combine(&hash, ipv4->sin_port, ipv4->sin_addr.s_addr);
63+
break;
64+
}
65+
case AF_INET6: {
66+
const sockaddr_in6* ipv6 =
67+
reinterpret_cast<const sockaddr_in6*>(addr.raw());
68+
const uint64_t* a =
69+
reinterpret_cast<const uint64_t*>(&ipv6->sin6_addr);
70+
hash_combine(&hash, ipv6->sin6_port, a[0], a[1]);
71+
break;
72+
}
73+
default:
74+
UNREACHABLE();
75+
}
76+
return hash;
77+
}
78+
79+
SocketAddress SocketAddress::FromSockName(const uv_tcp_t& handle) {
80+
return FromUVHandle(uv_tcp_getsockname, handle);
81+
}
82+
83+
SocketAddress SocketAddress::FromSockName(const uv_udp_t& handle) {
84+
return FromUVHandle(uv_udp_getsockname, handle);
85+
}
86+
87+
SocketAddress SocketAddress::FromPeerName(const uv_tcp_t& handle) {
88+
return FromUVHandle(uv_tcp_getpeername, handle);
89+
}
90+
91+
SocketAddress SocketAddress::FromPeerName(const uv_udp_t& handle) {
92+
return FromUVHandle(uv_udp_getpeername, handle);
93+
}
94+
95+
} // namespace node

‎src/node_sockaddr.h

+122
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
#ifndef SRC_NODE_SOCKADDR_H_
2+
#define SRC_NODE_SOCKADDR_H_
3+
4+
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5+
6+
#include "env.h"
7+
#include "memory_tracker.h"
8+
#include "node.h"
9+
#include "uv.h"
10+
#include "v8.h"
11+
12+
#include <string>
13+
#include <unordered_map>
14+
15+
namespace node {
16+
17+
class SocketAddress : public MemoryRetainer {
18+
public:
19+
struct Hash {
20+
size_t operator()(const SocketAddress& addr) const;
21+
};
22+
23+
inline bool operator==(const SocketAddress& other) const;
24+
inline bool operator!=(const SocketAddress& other) const;
25+
26+
inline static bool is_numeric_host(const char* hostname);
27+
inline static bool is_numeric_host(const char* hostname, int family);
28+
29+
// Returns true if converting {family, host, port} to *addr succeeded.
30+
static bool ToSockAddr(
31+
int32_t family,
32+
const char* host,
33+
uint32_t port,
34+
sockaddr_storage* addr);
35+
36+
// Returns true if converting {family, host, port} to *addr succeeded.
37+
static bool New(
38+
int32_t family,
39+
const char* host,
40+
uint32_t port,
41+
SocketAddress* addr);
42+
43+
static bool New(
44+
const char* host,
45+
uint32_t port,
46+
SocketAddress* addr);
47+
48+
// Returns the port for an IPv4 or IPv6 address.
49+
inline static int GetPort(const sockaddr* addr);
50+
inline static int GetPort(const sockaddr_storage* addr);
51+
52+
// Returns the numeric host as a string for an IPv4 or IPv6 address.
53+
inline static std::string GetAddress(const sockaddr* addr);
54+
inline static std::string GetAddress(const sockaddr_storage* addr);
55+
56+
// Returns the struct length for an IPv4, IPv6 or UNIX domain.
57+
inline static size_t GetLength(const sockaddr* addr);
58+
inline static size_t GetLength(const sockaddr_storage* addr);
59+
60+
SocketAddress() = default;
61+
62+
inline explicit SocketAddress(const sockaddr* addr);
63+
inline SocketAddress(const SocketAddress& addr);
64+
inline SocketAddress& operator=(const sockaddr* other);
65+
inline SocketAddress& operator=(const SocketAddress& other);
66+
67+
inline const sockaddr& operator*() const;
68+
inline const sockaddr* operator->() const;
69+
70+
inline const sockaddr* data() const;
71+
inline const uint8_t* raw() const;
72+
inline sockaddr* storage();
73+
inline size_t length() const;
74+
75+
inline int family() const;
76+
inline std::string address() const;
77+
inline int port() const;
78+
79+
// If the SocketAddress is an IPv6 address, returns the
80+
// current value of the IPv6 flow label, if set. Otherwise
81+
// returns 0.
82+
inline uint32_t flow_label() const;
83+
84+
// If the SocketAddress is an IPv6 address, sets the
85+
// current value of the IPv6 flow label. If not an
86+
// IPv6 address, set_flow_label is a non-op. It
87+
// is important to note that the flow label,
88+
// while represented as an uint32_t, the flow
89+
// label is strictly limited to 20 bits, and
90+
// this will assert if any value larger than
91+
// 20-bits is specified.
92+
inline void set_flow_label(uint32_t label = 0);
93+
94+
inline void Update(uint8_t* data, size_t len);
95+
96+
static SocketAddress FromSockName(const uv_udp_t& handle);
97+
static SocketAddress FromSockName(const uv_tcp_t& handle);
98+
static SocketAddress FromPeerName(const uv_udp_t& handle);
99+
static SocketAddress FromPeerName(const uv_tcp_t& handle);
100+
101+
inline v8::Local<v8::Object> ToJS(
102+
Environment* env,
103+
v8::Local<v8::Object> obj = v8::Local<v8::Object>()) const;
104+
105+
inline std::string ToString() const;
106+
107+
SET_NO_MEMORY_INFO()
108+
SET_MEMORY_INFO_NAME(SocketAddress)
109+
SET_SELF_SIZE(SocketAddress)
110+
111+
template <typename T>
112+
using Map = std::unordered_map<SocketAddress, T, Hash>;
113+
114+
private:
115+
sockaddr_storage address_;
116+
};
117+
118+
} // namespace node
119+
120+
#endif // NOE_WANT_INTERNALS
121+
122+
#endif // SRC_NODE_SOCKADDR_H_

‎src/udp_wrap.cc

+5-4
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include "udp_wrap.h"
2323
#include "env-inl.h"
2424
#include "node_buffer.h"
25+
#include "node_sockaddr-inl.h"
2526
#include "handle_wrap.h"
2627
#include "req_wrap-inl.h"
2728
#include "util-inl.h"
@@ -628,12 +629,12 @@ AsyncWrap* UDPWrap::GetAsyncWrap() {
628629
return this;
629630
}
630631

631-
int UDPWrap::GetPeerName(sockaddr* name, int* namelen) {
632-
return uv_udp_getpeername(&handle_, name, namelen);
632+
SocketAddress UDPWrap::GetPeerName() {
633+
return SocketAddress::FromPeerName(handle_);
633634
}
634635

635-
int UDPWrap::GetSockName(sockaddr* name, int* namelen) {
636-
return uv_udp_getsockname(&handle_, name, namelen);
636+
SocketAddress UDPWrap::GetSockName() {
637+
return SocketAddress::FromSockName(handle_);
637638
}
638639

639640
void UDPWrapBase::RecvStart(const FunctionCallbackInfo<Value>& args) {

‎src/udp_wrap.h

+7-7
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,7 @@
2626

2727
#include "handle_wrap.h"
2828
#include "req_wrap.h"
29+
#include "node_sockaddr.h"
2930
#include "uv.h"
3031
#include "v8.h"
3132

@@ -95,11 +96,8 @@ class UDPWrapBase {
9596
size_t nbufs,
9697
const sockaddr* addr) = 0;
9798

98-
// Stores the sockaddr for the peer in `name`.
99-
virtual int GetPeerName(sockaddr* name, int* namelen) = 0;
100-
101-
// Stores the sockaddr for the local socket in `name`.
102-
virtual int GetSockName(sockaddr* name, int* namelen) = 0;
99+
virtual SocketAddress GetPeerName() = 0;
100+
virtual SocketAddress GetSockName() = 0;
103101

104102
// Returns an AsyncWrap object with the same lifetime as this object.
105103
virtual AsyncWrap* GetAsyncWrap() = 0;
@@ -168,8 +166,10 @@ class UDPWrap final : public HandleWrap,
168166
ssize_t Send(uv_buf_t* bufs,
169167
size_t nbufs,
170168
const sockaddr* addr) override;
171-
int GetPeerName(sockaddr* name, int* namelen) override;
172-
int GetSockName(sockaddr* name, int* namelen) override;
169+
170+
SocketAddress GetPeerName() override;
171+
SocketAddress GetSockName() override;
172+
173173
AsyncWrap* GetAsyncWrap() override;
174174

175175
static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,

‎test/cctest/test_sockaddr.cc

+57
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
#include "node_sockaddr-inl.h"
2+
#include "gtest/gtest.h"
3+
4+
using node::SocketAddress;
5+
6+
TEST(SocketAddress, SocketAddress) {
7+
CHECK(SocketAddress::is_numeric_host("123.123.123.123"));
8+
CHECK(!SocketAddress::is_numeric_host("localhost"));
9+
10+
sockaddr_storage storage;
11+
sockaddr_storage storage2;
12+
SocketAddress::ToSockAddr(AF_INET, "123.123.123.123", 443, &storage);
13+
SocketAddress::ToSockAddr(AF_INET, "1.1.1.1", 80, &storage2);
14+
15+
SocketAddress addr(reinterpret_cast<const sockaddr*>(&storage));
16+
SocketAddress addr2(reinterpret_cast<const sockaddr*>(&storage2));
17+
18+
CHECK_EQ(addr.length(), sizeof(sockaddr_in));
19+
CHECK_EQ(addr.family(), AF_INET);
20+
CHECK_EQ(addr.address(), "123.123.123.123");
21+
CHECK_EQ(addr.port(), 443);
22+
23+
addr.set_flow_label(12345);
24+
CHECK_EQ(addr.flow_label(), 0);
25+
26+
CHECK_NE(addr, addr2);
27+
CHECK_EQ(addr, addr);
28+
29+
CHECK_EQ(SocketAddress::Hash()(addr), SocketAddress::Hash()(addr));
30+
CHECK_NE(SocketAddress::Hash()(addr), SocketAddress::Hash()(addr2));
31+
32+
addr.Update(reinterpret_cast<uint8_t*>(&storage2), sizeof(sockaddr_in));
33+
CHECK_EQ(addr.length(), sizeof(sockaddr_in));
34+
CHECK_EQ(addr.family(), AF_INET);
35+
CHECK_EQ(addr.address(), "1.1.1.1");
36+
CHECK_EQ(addr.port(), 80);
37+
38+
SocketAddress::Map<size_t> map;
39+
map[addr]++;
40+
map[addr]++;
41+
CHECK_EQ(map[addr], 2);
42+
}
43+
44+
TEST(SocketAddress, SocketAddressIPv6) {
45+
sockaddr_storage storage;
46+
SocketAddress::ToSockAddr(AF_INET6, "::1", 443, &storage);
47+
48+
SocketAddress addr(reinterpret_cast<const sockaddr*>(&storage));
49+
50+
CHECK_EQ(addr.length(), sizeof(sockaddr_in6));
51+
CHECK_EQ(addr.family(), AF_INET6);
52+
CHECK_EQ(addr.address(), "::1");
53+
CHECK_EQ(addr.port(), 443);
54+
55+
addr.set_flow_label(12345);
56+
CHECK_EQ(addr.flow_label(), 12345);
57+
}

0 commit comments

Comments
 (0)
Please sign in to comment.