Page MenuHomePhabricator
Differential D560 Diff 1422 src/seeder/netbase.cpp

Changeset View

Standalone View

View Options

src/seeder/netbase.cpp

// Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers // Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying // Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "netbase.h" #include "netbase.h"
#include "strlcpy.h"
#include "util.h" #include "util.h"
#ifndef WIN32 #ifndef WIN32
#include <sys/fcntl.h> #include <sys/fcntl.h>
#endif #endif
#include "strlcpy.h"
#include <boost/algorithm/string/case_conv.hpp> // for to_lower() #include <boost/algorithm/string/case_conv.hpp> // for to_lower()
#define printf my_printf #define printf my_printf
using namespace std;
// Settings // Settings
typedef std::pair<CService, int> proxyType; typedef std::pair<CService, int> proxyType;
static proxyType proxyInfo[NET_MAX]; static proxyType proxyInfo[NET_MAX];
static proxyType nameproxyInfo; static proxyType nameproxyInfo;
int nConnectTimeout = 5000; int nConnectTimeout = 5000;
bool fNameLookup = false; bool fNameLookup = false;
static const unsigned char pchIPv4[12] = {0, 0, 0, 0, 0, 0, static const uint8_t pchIPv4[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};
0, 0, 0, 0, 0xff, 0xff};
enum Network ParseNetwork(std::string net) { enum Network ParseNetwork(std::string net) {
boost::to_lower(net); boost::to_lower(net);
if (net == "ipv4") return NET_IPV4; if (net == "ipv4") return NET_IPV4;
if (net == "ipv6") return NET_IPV6; if (net == "ipv6") return NET_IPV6;
if (net == "tor") return NET_TOR; if (net == "tor") return NET_TOR;
if (net == "i2p") return NET_I2P; if (net == "i2p") return NET_I2P;
return NET_UNROUTABLE; return NET_UNROUTABLE;
} }
void SplitHostPort(std::string in, int &portOut, std::string &hostOut) { void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
size_t colon = in.find_last_of(':'); size_t colon = in.find_last_of(':');
// if a : is found, and it either follows a [...], or no other : is in the // if a : is found, and it either follows a [...], or no other : is in the
// string, treat it as port separator // string, treat it as port separator
bool fHaveColon = colon != in.npos; bool fHaveColon = colon != in.npos;
bool fBracketed = // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is
fHaveColon && // safe
(in[0] == '[' && in[colon - 1] == ']'); // if there is a colon, and bool fBracketed = fHaveColon && (in[0] == '[' && in[colon - 1] == ']');
// in[0]=='[', colon is not 0,
// so in[colon-1] is safe
bool fMultiColon = bool fMultiColon =
fHaveColon && (in.find_last_of(':', colon - 1) != in.npos); fHaveColon && (in.find_last_of(':', colon - 1) != in.npos);
if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) { if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) {
char *endp = NULL; char *endp = nullptr;
int n = strtol(in.c_str() + colon + 1, &endp, 10); int n = strtol(in.c_str() + colon + 1, &endp, 10);
if (endp && *endp == 0 && n >= 0) { if (endp && *endp == 0 && n >= 0) {
in = in.substr(0, colon); in = in.substr(0, colon);
if (n > 0 && n < 0x10000) portOut = n; if (n > 0 && n < 0x10000) portOut = n;
} }
} }
if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']') if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']')
hostOut = in.substr(1, in.size() - 2); hostOut = in.substr(1, in.size() - 2);
else else
hostOut = in; hostOut = in;
} }
bool static LookupIntern(const char *pszName, std::vector<CNetAddr> &vIP, static bool LookupIntern(const char *pszName, std::vector<CNetAddr> &vIP,
unsigned int nMaxSolutions, bool fAllowLookup) { unsigned int nMaxSolutions, bool fAllowLookup) {
vIP.clear(); vIP.clear();
{ {
CNetAddr addr; CNetAddr addr;
if (addr.SetSpecial(std::string(pszName))) { if (addr.SetSpecial(std::string(pszName))) {
vIP.push_back(addr); vIP.push_back(addr);
return true; return true;
} }
} }
struct addrinfo aiHint; struct addrinfo aiHint;
memset(&aiHint, 0, sizeof(struct addrinfo)); memset(&aiHint, 0, sizeof(struct addrinfo));
aiHint.ai_socktype = SOCK_STREAM; aiHint.ai_socktype = SOCK_STREAM;
aiHint.ai_protocol = IPPROTO_TCP; aiHint.ai_protocol = IPPROTO_TCP;
#ifdef WIN32 #ifdef WIN32
aiHint.ai_family = AF_UNSPEC; aiHint.ai_family = AF_UNSPEC;
aiHint.ai_flags = fAllowLookup ? 0 : AI_NUMERICHOST; aiHint.ai_flags = fAllowLookup ? 0 : AI_NUMERICHOST;
#else #else
aiHint.ai_family = AF_UNSPEC; aiHint.ai_family = AF_UNSPEC;
aiHint.ai_flags = fAllowLookup ? AI_ADDRCONFIG : AI_NUMERICHOST; aiHint.ai_flags = fAllowLookup ? AI_ADDRCONFIG : AI_NUMERICHOST;
#endif #endif
struct addrinfo *aiRes = NULL; struct addrinfo *aiRes = nullptr;
int nErr = getaddrinfo(pszName, NULL, &aiHint, &aiRes); int nErr = getaddrinfo(pszName, nullptr, &aiHint, &aiRes);
if (nErr) return false; if (nErr) return false;
struct addrinfo *aiTrav = aiRes; struct addrinfo *aiTrav = aiRes;
while (aiTrav != NULL && while (aiTrav != nullptr &&
(nMaxSolutions == 0 || vIP.size() < nMaxSolutions)) { (nMaxSolutions == 0 || vIP.size() < nMaxSolutions)) {
if (aiTrav->ai_family == AF_INET) { if (aiTrav->ai_family == AF_INET) {
assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in)); assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in));
vIP.push_back( vIP.push_back(
CNetAddr(((struct sockaddr_in *)(aiTrav->ai_addr))->sin_addr)); CNetAddr(((struct sockaddr_in *)(aiTrav->ai_addr))->sin_addr));
} }
if (aiTrav->ai_family == AF_INET6) { if (aiTrav->ai_family == AF_INET6) {
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesbool Lookup(const char *pszName, CService &addr, int portDefault,
addr = vService[0]; addr = vService[0];
return true; return true;
} }
bool LookupNumeric(const char *pszName, CService &addr, int portDefault) { bool LookupNumeric(const char *pszName, CService &addr, int portDefault) {
return Lookup(pszName, addr, portDefault, false); return Lookup(pszName, addr, portDefault, false);
} }
bool static Socks4(const CService &addrDest, SOCKET &hSocket) { static bool Socks4(const CService &addrDest, SOCKET &hSocket) {
printf("SOCKS4 connecting %s\n", addrDest.ToString().c_str()); printf("SOCKS4 connecting %s\n", addrDest.ToString().c_str());
if (!addrDest.IsIPv4()) { if (!addrDest.IsIPv4()) {
closesocket(hSocket); closesocket(hSocket);
return error("Proxy destination is not IPv4"); return error("Proxy destination is not IPv4");
} }
char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user"; char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
struct sockaddr_in addr; struct sockaddr_in addr;
socklen_t len = sizeof(addr); socklen_t len = sizeof(addr);
Show All 22 Lines if (pchRet[1] != 0x5a) {
if (pchRet[1] != 0x5b) if (pchRet[1] != 0x5b)
printf("ERROR: Proxy returned error %d\n", pchRet[1]); printf("ERROR: Proxy returned error %d\n", pchRet[1]);
return false; return false;
} }
printf("SOCKS4 connected %s\n", addrDest.ToString().c_str()); printf("SOCKS4 connected %s\n", addrDest.ToString().c_str());
return true; return true;
} }
bool static Socks5(string strDest, int port, SOCKET &hSocket) { static bool Socks5(std::string strDest, int port, SOCKET &hSocket) {
printf("SOCKS5 connecting %s\n", strDest.c_str()); printf("SOCKS5 connecting %s\n", strDest.c_str());
if (strDest.size() > 255) { if (strDest.size() > 255) {
closesocket(hSocket); closesocket(hSocket);
return error("Hostname too long"); return error("Hostname too long");
} }
char pszSocks5Init[] = "\5\1\0"; char pszSocks5Init[] = "\5\1\0";
char *pszSocks5 = pszSocks5Init; char *pszSocks5 = pszSocks5Init;
ssize_t nSize = sizeof(pszSocks5Init) - 1; ssize_t nSize = sizeof(pszSocks5Init) - 1;
ssize_t ret = send(hSocket, pszSocks5, nSize, MSG_NOSIGNAL); ssize_t ret = send(hSocket, pszSocks5, nSize, MSG_NOSIGNAL);
if (ret != nSize) { if (ret != nSize) {
closesocket(hSocket); closesocket(hSocket);
return error("Error sending to proxy"); return error("Error sending to proxy");
} }
char pchRet1[2]; char pchRet1[2];
if (recv(hSocket, pchRet1, 2, 0) != 2) { if (recv(hSocket, pchRet1, 2, 0) != 2) {
closesocket(hSocket); closesocket(hSocket);
return error("Error reading proxy response"); return error("Error reading proxy response");
} }
if (pchRet1[0] != 0x05 || pchRet1[1] != 0x00) { if (pchRet1[0] != 0x05 || pchRet1[1] != 0x00) {
closesocket(hSocket); closesocket(hSocket);
return error("Proxy failed to initialize"); return error("Proxy failed to initialize");
} }
string strSocks5("\5\1"); std::string strSocks5("\5\1");
strSocks5 += '\000'; strSocks5 += '\000';
strSocks5 += '\003'; strSocks5 += '\003';
strSocks5 += static_cast<char>(std::min((int)strDest.size(), 255)); strSocks5 += static_cast<char>(std::min((int)strDest.size(), 255));
strSocks5 += strDest; strSocks5 += strDest;
strSocks5 += static_cast<char>((port >> 8) & 0xFF); strSocks5 += static_cast<char>((port >> 8) & 0xFF);
strSocks5 += static_cast<char>((port >> 0) & 0xFF); strSocks5 += static_cast<char>((port >> 0) & 0xFF);
ret = send(hSocket, strSocks5.c_str(), strSocks5.size(), MSG_NOSIGNAL); ret = send(hSocket, strSocks5.c_str(), strSocks5.size(), MSG_NOSIGNAL);
if (ret != (ssize_t)strSocks5.size()) { if (ret != (ssize_t)strSocks5.size()) {
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linesstatic bool Socks5(std::string strDest, int port, SOCKET &hSocket) {
if (recv(hSocket, pchRet3, 2, 0) != 2) { if (recv(hSocket, pchRet3, 2, 0) != 2) {
closesocket(hSocket); closesocket(hSocket);
return error("Error reading from proxy"); return error("Error reading from proxy");
} }
printf("SOCKS5 connected %s\n", strDest.c_str()); printf("SOCKS5 connected %s\n", strDest.c_str());
return true; return true;
} }
bool static ConnectSocketDirectly(const CService &addrConnect, static bool ConnectSocketDirectly(const CService &addrConnect,
SOCKET &hSocketRet, int nTimeout) { SOCKET &hSocketRet, int nTimeout) {
hSocketRet = INVALID_SOCKET; hSocketRet = INVALID_SOCKET;
struct sockaddr_storage sockaddr; struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr); socklen_t len = sizeof(sockaddr);
if (!addrConnect.GetSockAddr((struct sockaddr *)&sockaddr, &len)) { if (!addrConnect.GetSockAddr((struct sockaddr *)&sockaddr, &len)) {
printf("Cannot connect to %s: unsupported network\n", printf("Cannot connect to %s: unsupported network\n",
addrConnect.ToString().c_str()); addrConnect.ToString().c_str());
Show All 27 Lines if (connect(hSocket, (struct sockaddr *)&sockaddr, len) == SOCKET_ERROR) {
WSAGetLastError() == WSAEINVAL) { WSAGetLastError() == WSAEINVAL) {
struct timeval timeout; struct timeval timeout;
timeout.tv_sec = nTimeout / 1000; timeout.tv_sec = nTimeout / 1000;
timeout.tv_usec = (nTimeout % 1000) * 1000; timeout.tv_usec = (nTimeout % 1000) * 1000;
fd_set fdset; fd_set fdset;
FD_ZERO(&fdset); FD_ZERO(&fdset);
FD_SET(hSocket, &fdset); FD_SET(hSocket, &fdset);
int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout); int nRet = select(hSocket + 1, nullptr, &fdset, nullptr, &timeout);
if (nRet == 0) { if (nRet == 0) {
printf("connection timeout\n"); printf("connection timeout\n");
closesocket(hSocket); closesocket(hSocket);
return false; return false;
} }
if (nRet == SOCKET_ERROR) { if (nRet == SOCKET_ERROR) {
printf("select() for connection failed: %i\n", printf("select() for connection failed: %i\n",
WSAGetLastError()); WSAGetLastError());
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Linesbool ConnectSocket(const CService &addrDest, SOCKET &hSocketRet, int nTimeout) {
} }
hSocketRet = hSocket; hSocketRet = hSocket;
return true; return true;
} }
bool ConnectSocketByName(CService &addr, SOCKET &hSocketRet, bool ConnectSocketByName(CService &addr, SOCKET &hSocketRet,
const char *pszDest, int portDefault, int nTimeout) { const char *pszDest, int portDefault, int nTimeout) {
string strDest; std::string strDest;
int port = portDefault; int port = portDefault;
SplitHostPort(string(pszDest), port, strDest); SplitHostPort(std::string(pszDest), port, strDest);
SOCKET hSocket = INVALID_SOCKET; SOCKET hSocket = INVALID_SOCKET;
CService addrResolved( CService addrResolved(
CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port); CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port);
if (addrResolved.IsValid()) { if (addrResolved.IsValid()) {
addr = addrResolved; addr = addrResolved;
return ConnectSocket(addr, hSocketRet, nTimeout); return ConnectSocket(addr, hSocketRet, nTimeout);
} }
Show All 18 Lines
void CNetAddr::Init() { void CNetAddr::Init() {
memset(ip, 0, 16); memset(ip, 0, 16);
} }
void CNetAddr::SetIP(const CNetAddr &ipIn) { void CNetAddr::SetIP(const CNetAddr &ipIn) {
memcpy(ip, ipIn.ip, sizeof(ip)); memcpy(ip, ipIn.ip, sizeof(ip));
} }
static const unsigned char pchOnionCat[] = {0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43}; static const uint8_t pchOnionCat[] = {0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43};
static const unsigned char pchGarliCat[] = {0xFD, 0x60, 0xDB, 0x4D, 0xDD, 0xB5}; static const uint8_t pchGarliCat[] = {0xFD, 0x60, 0xDB, 0x4D, 0xDD, 0xB5};
bool CNetAddr::SetSpecial(const std::string &strName) { bool CNetAddr::SetSpecial(const std::string &strName) {
if (strName.size() > 6 && if (strName.size() > 6 &&
strName.substr(strName.size() - 6, 6) == ".onion") { strName.substr(strName.size() - 6, 6) == ".onion") {
std::vector<unsigned char> vchAddr = std::vector<uint8_t> vchAddr =
DecodeBase32(strName.substr(0, strName.size() - 6).c_str()); DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
if (vchAddr.size() != 16 - sizeof(pchOnionCat)) return false; if (vchAddr.size() != 16 - sizeof(pchOnionCat)) return false;
memcpy(ip, pchOnionCat, sizeof(pchOnionCat)); memcpy(ip, pchOnionCat, sizeof(pchOnionCat));
for (unsigned int i = 0; i < 16 - sizeof(pchOnionCat); i++) for (unsigned int i = 0; i < 16 - sizeof(pchOnionCat); i++)
ip[i + sizeof(pchOnionCat)] = vchAddr[i]; ip[i + sizeof(pchOnionCat)] = vchAddr[i];
return true; return true;
} }
if (strName.size() > 11 && if (strName.size() > 11 &&
strName.substr(strName.size() - 11, 11) == ".oc.b32.i2p") { strName.substr(strName.size() - 11, 11) == ".oc.b32.i2p") {
std::vector<unsigned char> vchAddr = std::vector<uint8_t> vchAddr =
DecodeBase32(strName.substr(0, strName.size() - 11).c_str()); DecodeBase32(strName.substr(0, strName.size() - 11).c_str());
if (vchAddr.size() != 16 - sizeof(pchGarliCat)) return false; if (vchAddr.size() != 16 - sizeof(pchGarliCat)) return false;
memcpy(ip, pchOnionCat, sizeof(pchGarliCat)); memcpy(ip, pchOnionCat, sizeof(pchGarliCat));
for (unsigned int i = 0; i < 16 - sizeof(pchGarliCat); i++) for (unsigned int i = 0; i < 16 - sizeof(pchGarliCat); i++)
ip[i + sizeof(pchGarliCat)] = vchAddr[i]; ip[i + sizeof(pchGarliCat)] = vchAddr[i];
return true; return true;
} }
return false; return false;
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D &&
GetByte(12) == 0xB8; GetByte(12) == 0xB8;
} }
bool CNetAddr::IsRFC3964() const { bool CNetAddr::IsRFC3964() const {
return (GetByte(15) == 0x20 && GetByte(14) == 0x02); return (GetByte(15) == 0x20 && GetByte(14) == 0x02);
} }
bool CNetAddr::IsRFC6052() const { bool CNetAddr::IsRFC6052() const {
static const unsigned char pchRFC6052[] = {0, 0x64, 0xFF, 0x9B, 0, 0, static const uint8_t pchRFC6052[] = {0, 0x64, 0xFF, 0x9B, 0, 0,
0, 0, 0, 0, 0, 0}; 0, 0, 0, 0, 0, 0};
return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0); return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0);
} }
bool CNetAddr::IsRFC4380() const { bool CNetAddr::IsRFC4380() const {
return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 &&
GetByte(12) == 0); GetByte(12) == 0);
} }
bool CNetAddr::IsRFC4862() const { bool CNetAddr::IsRFC4862() const {
static const unsigned char pchRFC4862[] = {0xFE, 0x80, 0, 0, 0, 0, 0, 0}; static const uint8_t pchRFC4862[] = {0xFE, 0x80, 0, 0, 0, 0, 0, 0};
return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0); return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0);
} }
bool CNetAddr::IsRFC4193() const { bool CNetAddr::IsRFC4193() const {
return ((GetByte(15) & 0xFE) == 0xFC); return ((GetByte(15) & 0xFE) == 0xFC);
} }
bool CNetAddr::IsRFC6145() const { bool CNetAddr::IsRFC6145() const {
static const unsigned char pchRFC6145[] = {0, 0, 0, 0, 0, 0, static const uint8_t pchRFC6145[] = {0, 0, 0, 0, 0, 0,
0, 0, 0xFF, 0xFF, 0, 0}; 0, 0, 0xFF, 0xFF, 0, 0};
return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0); return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0);
} }
bool CNetAddr::IsRFC4843() const { bool CNetAddr::IsRFC4843() const {
return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 &&
(GetByte(12) & 0xF0) == 0x10); (GetByte(12) & 0xF0) == 0x10);
} }
bool CNetAddr::IsTor() const { bool CNetAddr::IsTor() const {
return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0); return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);
} }
bool CNetAddr::IsI2P() const { bool CNetAddr::IsI2P() const {
return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0); return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0);
} }
bool CNetAddr::IsLocal() const { bool CNetAddr::IsLocal() const {
// IPv4 loopback // IPv4 loopback
if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0)) return true; if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0)) return true;
// IPv6 loopback (::1/128) // IPv6 loopback (::1/128)
static const unsigned char pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0, static const uint8_t pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1}; 0, 0, 0, 0, 0, 0, 0, 1};
if (memcmp(ip, pchLocal, 16) == 0) return true; if (memcmp(ip, pchLocal, 16) == 0) return true;
return false; return false;
} }
bool CNetAddr::IsMulticast() const { bool CNetAddr::IsMulticast() const {
return (IsIPv4() && (GetByte(3) & 0xF0) == 0xE0) || (GetByte(15) == 0xFF); return (IsIPv4() && (GetByte(3) & 0xF0) == 0xE0) || (GetByte(15) == 0xFF);
} }
bool CNetAddr::IsValid() const { bool CNetAddr::IsValid() const {
// Cleanup 3-byte shifted addresses caused by garbage in size field // Cleanup 3-byte shifted addresses caused by garbage in size field
// of addr messages from versions before 0.2.9 checksum. // of addr messages from versions before 0.2.9 checksum.
// Two consecutive addr messages look like this: // Two consecutive addr messages look like this:
// header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26
// addr26 addr26... // addr26 addr26...
// so if the first length field is garbled, it reads the second batch // so if the first length field is garbled, it reads the second batch
// of addr misaligned by 3 bytes. // of addr misaligned by 3 bytes.
if (memcmp(ip, pchIPv4 + 3, sizeof(pchIPv4) - 3) == 0) return false; if (memcmp(ip, pchIPv4 + 3, sizeof(pchIPv4) - 3) == 0) return false;
// unspecified IPv6 address (::/128) // unspecified IPv6 address (::/128)
unsigned char ipNone[16] = {}; uint8_t ipNone[16] = {};
if (memcmp(ip, ipNone, 16) == 0) return false; if (memcmp(ip, ipNone, 16) == 0) return false;
// documentation IPv6 address // documentation IPv6 address
if (IsRFC3849()) return false; if (IsRFC3849()) return false;
if (IsIPv4()) { if (IsIPv4()) {
// INADDR_NONE // INADDR_NONE
uint32_t ipNone = INADDR_NONE; uint32_t ipNone = INADDR_NONE;
Show All 29 Linesstd::string CNetAddr::ToStringIP() const {
if (IsTor()) return EncodeBase32(&ip[6], 10) + ".onion"; if (IsTor()) return EncodeBase32(&ip[6], 10) + ".onion";
if (IsI2P()) return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p"; if (IsI2P()) return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p";
CService serv(*this, 0); CService serv(*this, 0);
struct sockaddr_storage sockaddr; struct sockaddr_storage sockaddr;
socklen_t socklen = sizeof(sockaddr); socklen_t socklen = sizeof(sockaddr);
if (serv.GetSockAddr((struct sockaddr *)&sockaddr, &socklen)) { if (serv.GetSockAddr((struct sockaddr *)&sockaddr, &socklen)) {
char name[1025] = ""; char name[1025] = "";
if (!getnameinfo((const struct sockaddr *)&sockaddr, socklen, name, if (!getnameinfo((const struct sockaddr *)&sockaddr, socklen, name,
sizeof(name), NULL, 0, NI_NUMERICHOST)) sizeof(name), nullptr, 0, NI_NUMERICHOST))
return std::string(name); return std::string(name);
} }
if (IsIPv4())
if (IsIPv4()) {
return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1),
GetByte(0)); GetByte(0));
else }
return strprintf(
"%x:%x:%x:%x:%x:%x:%x:%x", GetByte(15) << 8 | GetByte(14), return strprintf("%x:%x:%x:%x:%x:%x:%x:%x", GetByte(15) << 8 | GetByte(14),
GetByte(13) << 8 | GetByte(12), GetByte(11) << 8 | GetByte(10), GetByte(13) << 8 | GetByte(12),
GetByte(11) << 8 | GetByte(10),
GetByte(9) << 8 | GetByte(8), GetByte(7) << 8 | GetByte(6), GetByte(9) << 8 | GetByte(8), GetByte(7) << 8 | GetByte(6),
GetByte(5) << 8 | GetByte(4), GetByte(3) << 8 | GetByte(2), GetByte(5) << 8 | GetByte(4), GetByte(3) << 8 | GetByte(2),
GetByte(1) << 8 | GetByte(0)); GetByte(1) << 8 | GetByte(0));
} }
std::string CNetAddr::ToString() const { std::string CNetAddr::ToString() const {
return ToStringIP(); return ToStringIP();
} }
bool operator==(const CNetAddr &a, const CNetAddr &b) { bool operator==(const CNetAddr &a, const CNetAddr &b) {
return (memcmp(a.ip, b.ip, 16) == 0); return (memcmp(a.ip, b.ip, 16) == 0);
Show All 15 Lines
bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const { bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const {
memcpy(pipv6Addr, ip, 16); memcpy(pipv6Addr, ip, 16);
return true; return true;
} }
// get canonical identifier of an address' group // get canonical identifier of an address' group
// no two connections will be attempted to addresses with the same group // no two connections will be attempted to addresses with the same group
std::vector<unsigned char> CNetAddr::GetGroup() const { std::vector<uint8_t> CNetAddr::GetGroup() const {
std::vector<unsigned char> vchRet; std::vector<uint8_t> vchRet;
int nClass = NET_IPV6; int nClass = NET_IPV6;
int nStartByte = 0; int nStartByte = 0;
int nBits = 16; int nBits = 16;
// all local addresses belong to the same group // all local addresses belong to the same group
if (IsLocal()) { if (IsLocal()) {
nClass = 255; nClass = 255;
nBits = 0; nBits = 0;
Show All 24 Linesstd::vector<uint8_t> CNetAddr::GetGroup() const {
} else if (IsTor()) { } else if (IsTor()) {
nClass = NET_TOR; nClass = NET_TOR;
nStartByte = 6; nStartByte = 6;
nBits = 4; nBits = 4;
} else if (IsI2P()) { } else if (IsI2P()) {
nClass = NET_I2P; nClass = NET_I2P;
nStartByte = 6; nStartByte = 6;
nBits = 4; nBits = 4;
} } else if (GetByte(15) == 0x20 && GetByte(14) == 0x11 &&
GetByte(13) == 0x04 && GetByte(12) == 0x70) {
// for he.net, use /36 groups // for he.net, use /36 groups
else if (GetByte(15) == 0x20 && GetByte(14) == 0x11 &&
GetByte(13) == 0x04 && GetByte(12) == 0x70)
nBits = 36; nBits = 36;
} else {
// for the rest of the IPv6 network, use /32 groups // for the rest of the IPv6 network, use /32 groups
else
nBits = 32; nBits = 32;
}
vchRet.push_back(nClass); vchRet.push_back(nClass);
while (nBits >= 8) { while (nBits >= 8) {
vchRet.push_back(GetByte(15 - nStartByte)); vchRet.push_back(GetByte(15 - nStartByte));
nStartByte++; nStartByte++;
nBits -= 8; nBits -= 8;
} }
if (nBits > 0) if (nBits > 0)
Show All 12 Lines
void CNetAddr::print() const { void CNetAddr::print() const {
printf("CNetAddr(%s)\n", ToString().c_str()); printf("CNetAddr(%s)\n", ToString().c_str());
} }
// private extensions to enum Network, only returned by GetExtNetwork, // private extensions to enum Network, only returned by GetExtNetwork,
// and only used in GetReachabilityFrom // and only used in GetReachabilityFrom
static const int NET_UNKNOWN = NET_MAX + 0; static const int NET_UNKNOWN = NET_MAX + 0;
static const int NET_TEREDO = NET_MAX + 1; static const int NET_TEREDO = NET_MAX + 1;
int static GetExtNetwork(const CNetAddr *addr) { static int GetExtNetwork(const CNetAddr *addr) {
if (addr == NULL) return NET_UNKNOWN; if (addr == nullptr) return NET_UNKNOWN;
if (addr->IsRFC4380()) return NET_TEREDO; if (addr->IsRFC4380()) return NET_TEREDO;
return addr->GetNetwork(); return addr->GetNetwork();
} }
/** Calculates a metric for how reachable (*this) is from a given partner */ /** Calculates a metric for how reachable (*this) is from a given partner */
int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const { int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const {
enum Reachability { enum Reachability {
REACH_UNREACHABLE, REACH_UNREACHABLE,
Show All 23 Lines switch (theirNet) {
switch (ourNet) { switch (ourNet) {
default: default:
return REACH_DEFAULT; return REACH_DEFAULT;
case NET_TEREDO: case NET_TEREDO:
return REACH_TEREDO; return REACH_TEREDO;
case NET_IPV4: case NET_IPV4:
return REACH_IPV4; return REACH_IPV4;
case NET_IPV6: case NET_IPV6:
return fTunnel ? REACH_IPV6_WEAK // only prefer giving our IPv6 address if it's not tunnelled
: REACH_IPV6_STRONG; // only prefer giving return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
// our IPv6 address if
// it's not tunnelled
} }
case NET_TOR: case NET_TOR:
switch (ourNet) { switch (ourNet) {
default: default:
return REACH_DEFAULT; return REACH_DEFAULT;
case NET_IPV4: case NET_IPV4:
return REACH_IPV4; // Tor users can connect to IPv4 as well // Tor users can connect to IPv4 as well
return REACH_IPV4;
case NET_TOR: case NET_TOR:
return REACH_PRIVATE; return REACH_PRIVATE;
} }
case NET_I2P: case NET_I2P:
switch (ourNet) { switch (ourNet) {
default: default:
return REACH_DEFAULT; return REACH_DEFAULT;
case NET_I2P: case NET_I2P:
Show All 18 Lines switch (theirNet) {
return REACH_DEFAULT; return REACH_DEFAULT;
case NET_TEREDO: case NET_TEREDO:
return REACH_TEREDO; return REACH_TEREDO;
case NET_IPV6: case NET_IPV6:
return REACH_IPV6_WEAK; return REACH_IPV6_WEAK;
case NET_IPV4: case NET_IPV4:
return REACH_IPV4; return REACH_IPV4;
case NET_I2P: case NET_I2P:
return REACH_PRIVATE; // assume connections from unroutable // assume connections from unroutable addresses are
// addresses are return REACH_PRIVATE;
case NET_TOR: case NET_TOR:
return REACH_PRIVATE; // either from Tor/I2P, or don't care // either from Tor/I2P, or don't care about our address
// about our address return REACH_PRIVATE;
} }
} }
} }
void CService::Init() { void CService::Init() {
port = 0; port = 0;
} }
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines if (IsIPv6()) {
if (!GetIn6Addr(&paddrin6->sin6_addr)) return false; if (!GetIn6Addr(&paddrin6->sin6_addr)) return false;
paddrin6->sin6_family = AF_INET6; paddrin6->sin6_family = AF_INET6;
paddrin6->sin6_port = htons(port); paddrin6->sin6_port = htons(port);
return true; return true;
} }
return false; return false;
} }
std::vector<unsigned char> CService::GetKey() const { std::vector<uint8_t> CService::GetKey() const {
std::vector<unsigned char> vKey; std::vector<uint8_t> vKey;
vKey.resize(18); vKey.resize(18);
memcpy(&vKey[0], ip, 16); memcpy(&vKey[0], ip, 16);
vKey[16] = port / 0x100; vKey[16] = port / 0x100;
vKey[17] = port & 0x0FF; vKey[17] = port & 0x0FF;
return vKey; return vKey;
} }
std::string CService::ToStringPort() const { std::string CService::ToStringPort() const {
Show All 22 Lines