#include "netbase.h"

#include "hash.h"

#include "sync.h"

#include "uint256.h"

#include "util.h"

#ifndef WIN32

#include <fcntl.h>

#endif

#include <boost/algorithm/string/case_conv.hpp> // for to_lower()

#include <boost/algorithm/string/predicate.hpp> // for startswith() and endswith()

#if !defined(HAVE_MSG_NOSIGNAL) && !defined(MSG_NOSIGNAL)

#define MSG_NOSIGNAL 0

#endif

using namespace std;

static proxyType proxyInfo[NET_MAX];

static proxyType nameproxyInfo;

static CCriticalSection cs_proxyInfos;

int nConnectTimeout = 5000;

bool fNameLookup = false;

static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };

enum Network ParseNetwork(std::string net) {

}

void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {

}

bool static LookupIntern(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)

}

bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)

}

bool LookupHostNumeric(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions)

{

return LookupHost(pszName, vIP, nMaxSolutions, false);

}

bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)

}

bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup)

}

bool LookupNumeric(const char *pszName, CService& addr, int portDefault)

{

return Lookup(pszName, addr, portDefault, false);

}

bool static Socks4(const CService &addrDest, SOCKET& hSocket)

}

bool static Socks5(string strDest, int port, SOCKET& hSocket)

}

bool static ConnectSocketDirectly(const CService &addrConnect, SOCKET& hSocketRet, int nTimeout)

{

hSocketRet = INVALID_SOCKET;

#ifdef USE_IPV6

struct sockaddr_storage sockaddr;

#else

struct sockaddr sockaddr;

#endif

socklen_t len = sizeof(sockaddr);

if (!addrConnect.GetSockAddr((struct sockaddr*)&sockaddr, &len)) {

LogPrintf("Cannot connect to %s: unsupported network\n", addrConnect.ToString());

return false;

}

SOCKET hSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);

if (hSocket == INVALID_SOCKET)

return false;

#ifdef SO_NOSIGPIPE

int set = 1;

setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));

#endif

#ifdef WIN32

u_long fNonblock = 1;

if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)

#else

int fFlags = fcntl(hSocket, F_GETFL, 0);

if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)

#endif

{

closesocket(hSocket);

return false;

}

if (connect(hSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)

{

// WSAEINVAL is here because some legacy version of winsock uses it

if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)

{

struct timeval timeout;

timeout.tv_sec = nTimeout / 1000;

timeout.tv_usec = (nTimeout % 1000) * 1000;

fd_set fdset;

FD_ZERO(&fdset);

FD_SET(hSocket, &fdset);

int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);

if (nRet == 0)

{

LogPrint("net", "connection to %s timeout\n", addrConnect.ToString());

closesocket(hSocket);

return false;

}

if (nRet == SOCKET_ERROR)

{

LogPrintf("select() for %s failed: %i\n", addrConnect.ToString(), WSAGetLastError());

closesocket(hSocket);

return false;

}

socklen_t nRetSize = sizeof(nRet);

#ifdef WIN32

if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)

#else

if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)

#endif

{

LogPrintf("getsockopt() for %s failed: %i\n", addrConnect.ToString(), WSAGetLastError());

closesocket(hSocket);

return false;

}

if (nRet != 0)

{

LogPrintf("connect() to %s failed after select(): %s\n", addrConnect.ToString(), strerror(nRet));

closesocket(hSocket);

return false;

}

}

#ifdef WIN32

else if (WSAGetLastError() != WSAEISCONN)

#else

else

#endif

{

LogPrintf("connect() to %s failed: %i\n", addrConnect.ToString(), WSAGetLastError());

closesocket(hSocket);

return false;

}

}

// this isn't even strictly necessary

// CNode::ConnectNode immediately turns the socket back to non-blocking

// but we'll turn it back to blocking just in case

#ifdef WIN32

fNonblock = 0;

if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)

#else

fFlags = fcntl(hSocket, F_GETFL, 0);

if (fcntl(hSocket, F_SETFL, fFlags & ~O_NONBLOCK) == SOCKET_ERROR)

#endif

{

closesocket(hSocket);

return false;

}

hSocketRet = hSocket;

return true;

}

bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion) {

}

bool GetProxy(enum Network net, proxyType &proxyInfoOut) {

}

bool SetNameProxy(CService addrProxy, int nSocksVersion) {

}

bool GetNameProxy(proxyType &nameproxyInfoOut) {

}

bool HaveNameProxy() {

LOCK(cs_proxyInfos);

return nameproxyInfo.second != 0;

}

bool IsProxy(const CNetAddr &addr) {

}

bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)

}

bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout)

}

void CNetAddr::Init()

{

memset(ip, 0, sizeof(ip));

}

void CNetAddr::SetIP(const CNetAddr& ipIn)

{

memcpy(ip, ipIn.ip, sizeof(ip));

}

static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};

bool CNetAddr::SetSpecial(const std::string &strName)

}

CNetAddr::CNetAddr()

{

Init();

}

CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)

}

#ifdef USE_IPV6

CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr)

{

memcpy(ip, &ipv6Addr, 16);

}

#endif

CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup)

}

CNetAddr::CNetAddr(const std::string &strIp, bool fAllowLookup)

}

unsigned int CNetAddr::GetByte(int n) const

{

return ip[15-n];

}

bool CNetAddr::IsIPv4() const

{

return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0);

}

bool CNetAddr::IsIPv6() const

{

return (!IsIPv4() && !IsTor());

}

bool CNetAddr::IsRFC1918() const

}

bool CNetAddr::IsRFC3927() const

{

return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);

}

bool CNetAddr::IsRFC3849() const

{

return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D && GetByte(12) == 0xB8;

}

bool CNetAddr::IsRFC3964() const

{

return (GetByte(15) == 0x20 && GetByte(14) == 0x02);

}

bool CNetAddr::IsRFC6052() const

}

bool CNetAddr::IsRFC4380() const

{

return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && GetByte(12) == 0);

}

bool CNetAddr::IsRFC4862() const

}

bool CNetAddr::IsRFC4193() const

{

return ((GetByte(15) & 0xFE) == 0xFC);

}

bool CNetAddr::IsRFC6145() const

}

bool CNetAddr::IsRFC4843() const

{

return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x10);

}

bool CNetAddr::IsTor() const

{

return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);

}

bool CNetAddr::IsLocal() const

}

bool CNetAddr::IsMulticast() const

}

bool CNetAddr::IsValid() const

}

bool CNetAddr::IsRoutable() const

{

return IsValid() && !(IsRFC1918() || IsRFC3927() || IsRFC4862() || (IsRFC4193() && !IsTor()) || IsRFC4843() || IsLocal());

}

enum Network CNetAddr::GetNetwork() const

}

std::string CNetAddr::ToStringIP() const

}

std::string CNetAddr::ToString() const

{

return ToStringIP();

}

bool operator==(const CNetAddr& a, const CNetAddr& b)

{

return (memcmp(a.ip, b.ip, 16) == 0);

}

bool operator!=(const CNetAddr& a, const CNetAddr& b)

{

return (memcmp(a.ip, b.ip, 16) != 0);

}

bool operator<(const CNetAddr& a, const CNetAddr& b)

{

return (memcmp(a.ip, b.ip, 16) < 0);

}

bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const

}

#ifdef USE_IPV6

bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const

}

#endif

std::vector<unsigned char> CNetAddr::GetGroup() const

}

uint64_t CNetAddr::GetHash() const

}

void CNetAddr::print() const

{

LogPrintf("CNetAddr(%s)\n", ToString());

}

static const int NET_UNKNOWN = NET_MAX + 0;

static const int NET_TEREDO = NET_MAX + 1;

int static GetExtNetwork(const CNetAddr *addr)

}

int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const

}

void CService::Init()

{

port = 0;

}

CService::CService()

{

Init();

}

CService::CService(const CNetAddr& cip, unsigned short portIn) : CNetAddr(cip), port(portIn)

{

}

CService::CService(const struct in_addr& ipv4Addr, unsigned short portIn) : CNetAddr(ipv4Addr), port(portIn)

{

}

#ifdef USE_IPV6

CService::CService(const struct in6_addr& ipv6Addr, unsigned short portIn) : CNetAddr(ipv6Addr), port(portIn)

{

}

#endif

CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))

{

assert(addr.sin_family == AF_INET);