Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-08-06 05:14:21 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

0004 Enable IPv6 listening (Patch from G10H4ck)

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-IPv6@8028 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2015-03-15 15:29:18 +00:00
parent f4fa3a2fc0
commit f63c705263
12 changed files with 171 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

3
libretroshare/src/dht/p3bitdht_peers.cc
View file

@ -226,12 +226,15 @@ int p3BitDht::addKnownPeer(const RsPeerId &pid, const struct sockaddr_storage &a
std::cerr << std::endl;
sockaddr_clear(&addrv4);
#if 0
if (flags & NETASSIST_KNOWN_PEER_ONLINE)
{
std::cerr << "p3BitDht::addKnownPeer() Non IPv4 Address & ONLINE. Abort()ing.";
std::cerr << std::endl;
abort();
}
#endif
}
else
{

4
libretroshare/src/pqi/p3netmgr.cc
View file

@ -908,7 +908,7 @@ void p3NetMgrIMPL::netExtCheck()
************************************** Interfaces *****************************************
**********************************************************************************************/
bool p3NetMgrIMPL::checkNetAddress()
bool p3NetMgrIMPL::checkNetAddress()
{
bool addrChanged = false;
bool validAddr = false;
@ -920,7 +920,7 @@ bool p3NetMgrIMPL::checkNetAddress()
{
std::cerr << "p3NetMgrIMPL::checkNetAddress() LOOPBACK ... forcing to 127.0.0.1";
std::cerr << std::endl;
sockaddr_storage_ipv4_aton(prefAddr, "127.0.0.1");
sockaddr_storage_inet_pton(prefAddr, "127.0.0.1");
validAddr = true;
}
else

16
libretroshare/src/pqi/p3peermgr.cc
View file

@ -130,9 +130,9 @@ p3PeerMgrIMPL::p3PeerMgrIMPL(const RsPeerId& ssl_own_id, const RsPgpId& gpg_own_
// setup default ProxyServerAddress.
sockaddr_storage_clear(mProxyServerAddress);
sockaddr_storage_ipv4_aton(mProxyServerAddress,
sockaddr_storage_inet_pton(mProxyServerAddress,
kConfigDefaultProxyServerIpAddr.c_str());
sockaddr_storage_ipv4_setport(mProxyServerAddress,
sockaddr_storage_setport(mProxyServerAddress,
kConfigDefaultProxyServerPort);
mProxyServerStatus = RS_NET_PROXY_STATUS_UNKNOWN ;
@ -190,8 +190,8 @@ bool p3PeerMgrIMPL::forceHiddenNode()
// force external address - otherwise its invalid.
sockaddr_storage_clear(mOwnState.serveraddr);
sockaddr_storage_ipv4_aton(mOwnState.serveraddr, "0.0.0.0");
sockaddr_storage_ipv4_setport(mOwnState.serveraddr, 0);
sockaddr_storage_inet_pton(mOwnState.serveraddr, "0.0.0.0");
sockaddr_storage_setport(mOwnState.serveraddr, 0);
}
setOwnNetworkMode(RS_NET_MODE_HIDDEN);
@ -202,7 +202,7 @@ bool p3PeerMgrIMPL::forceHiddenNode()
// Force the Port.
struct sockaddr_storage loopback;
sockaddr_storage_clear(loopback);
sockaddr_storage_ipv4_aton(loopback, "127.0.0.1");
sockaddr_storage_inet_pton(loopback, "127.0.0.1");
uint16_t port = sockaddr_storage_port(mOwnState.localaddr);
sockaddr_storage_ipv4_setport(loopback, port);
@ -1880,13 +1880,11 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
// Configure Proxy Server.
struct sockaddr_storage proxy_addr;
sockaddr_storage_clear(proxy_addr);
sockaddr_storage_ipv4_aton(proxy_addr, proxyIpAddress.c_str());
sockaddr_storage_ipv4_setport(proxy_addr, proxyPort);
sockaddr_storage_inet_pton(proxy_addr, proxyIpAddress.c_str());
sockaddr_storage_setport(proxy_addr, proxyPort);
if (sockaddr_storage_isValidNet(proxy_addr))
{
setProxyServerAddress(proxy_addr);
}
return true;
}

4
libretroshare/src/pqi/pqinetwork.cc
View file

@ -560,7 +560,7 @@ int inaddr_cmp(struct sockaddr_in addr1, unsigned long addr2)
return 1;
}
bool getPreferredInterface_ipv4(in_addr &routeAddr, struct in_addr &prefAddr) // returns best addr.
bool getPreferredInterface_ipv4(in_addr &routeAddr, struct in_addr &prefAddr) // returns best addr.
{
std::list<struct in_addr> addrs;
std::list<struct in_addr>::iterator it;
@ -691,7 +691,7 @@ bool getPreferredInterface_ipv4(in_addr &routeAddr, struct in_addr &prefAddr) /
bool getPreferredInterface(struct sockaddr_storage &existAddr, struct sockaddr_storage &prefAddr)
bool getPreferredInterface(const struct sockaddr_storage & existAddr, struct sockaddr_storage & prefAddr)
{
struct in_addr existing_addr;
struct in_addr pref_addr;

2
libretroshare/src/pqi/pqinetwork.h
View file

@ -102,7 +102,7 @@ int sockaddr_cmp(struct sockaddr_in &addr1, struct sockaddr_in &addr2 );
int inaddr_cmp(struct sockaddr_in addr1, struct sockaddr_in addr2 );
int inaddr_cmp(struct sockaddr_in addr1, unsigned long);
bool getPreferredInterface(struct sockaddr_storage &existAddr, struct sockaddr_storage &prefAddr); // returns best addr.
bool getPreferredInterface(const struct sockaddr_storage &existAddr, struct sockaddr_storage &prefAddr); // returns best addr.
bool getLocalInterfaces(struct sockaddr_storage &existAddr, std::list<struct sockaddr_storage> &addrs); // returns all possible addrs.
in_addr_t pqi_inet_netof(struct in_addr addr); // our implementation.

76
libretroshare/src/pqi/pqissllistener.cc
View file

@ -94,22 +94,28 @@ int pqissllistenbase::status()
int pqissllistenbase::setuplisten()
{
int err;
if (active)
return -1;
int err;
if (active) return -1;
lsock = socket(PF_INET6, SOCK_STREAM, 0);
#ifdef IPV6_V6ONLY
int no = 0;
err = setsockopt(lsock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&no, sizeof(no));
if (err) std::cerr << "pqissl::Initiate_Connection: Error setting IPv6 socket dual stack" << std::endl;
else std::cerr << "pqissl::Initiate_Connection: Setting IPv6 socket dual stack" << std::endl;
#endif // IPV6_V6ONLY
lsock = socket(PF_INET, SOCK_STREAM, 0);
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef WINDOWS_SYS // ie UNIX
if (lsock < 0)
{
pqioutput(PQL_ALERT, pqissllistenzone,
"pqissllistenbase::setuplisten() Cannot Open Socket!");
if (lsock < 0)
{
pqioutput(PQL_ALERT, pqissllistenzone, "pqissllistenbase::setuplisten() Cannot Open Socket!");
return -1;
}
err = fcntl(lsock, F_SETFL, O_NONBLOCK);
err = fcntl(lsock, F_SETFL, O_NONBLOCK);
if (err < 0)
{
std::string out;
@ -118,14 +124,12 @@ int pqissllistenbase::setuplisten()
return -1;
}
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
#else //WINDOWS_SYS
if ((unsigned) lsock == INVALID_SOCKET)
{
std::string out = "pqissllistenbase::setuplisten() Cannot Open Socket!\n";
out += "Socket Error: "+ socket_errorType(WSAGetLastError());
pqioutput(PQL_ALERT, pqissllistenzone, out);
#else // WINDOWS_SYS
if ((unsigned) lsock == INVALID_SOCKET)
{
std::string out = "pqissllistenbase::setuplisten() Cannot Open Socket!\n";
out += "Socket Error: "+ socket_errorType(WSAGetLastError());
pqioutput(PQL_ALERT, pqissllistenzone, out);
return -1;
}
@ -141,8 +145,8 @@ int pqissllistenbase::setuplisten()
return -1;
}
#endif
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
#endif // WINDOWS_SYS
// setup listening address.
@ -151,7 +155,7 @@ int pqissllistenbase::setuplisten()
out += "\t FAMILY: " + sockaddr_storage_familytostring(laddr);
out += "\t ADDRESS: " + sockaddr_storage_tostring(laddr);
pqioutput(PQL_DEBUG_BASIC, pqissllistenzone, out);
pqioutput(PQL_DEBUG_BASIC, pqissllistenzone, out);
//std::cerr << out.str() << std::endl;
}
@ -159,28 +163,28 @@ int pqissllistenbase::setuplisten()
* when we restart_listener.
*/
{
int on = 1;
{
int on = 1;
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef WINDOWS_SYS // ie UNIX
if (setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
#else //WINDOWS_SYS
#else // WINDOWS_SYS
if (setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on)) < 0)
#endif
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
{
std::string out = "pqissllistenbase::setuplisten() Cannot setsockopt SO_REUSEADDR!\n";
showSocketError(out);
pqioutput(PQL_ALERT, pqissllistenzone, out);
std::cerr << out << std::endl;
#endif // WINDOWS_SYS
exit(1);
}
}
{
std::string out = "pqissllistenbase::setuplisten() Cannot setsockopt SO_REUSEADDR!\n";
showSocketError(out);
pqioutput(PQL_ALERT, pqissllistenzone, out);
std::cerr << out << std::endl;
exit(1);
}
}
#ifdef OPEN_UNIVERSAL_PORT
struct sockaddr_storage tmpaddr = laddr;
tmpaddr.ss_family = PF_INET6;
sockaddr_storage_zeroip(tmpaddr);
if (0 != (err = universal_bind(lsock, (struct sockaddr *) &tmpaddr, sizeof(tmpaddr))))
#else

43
libretroshare/src/rsserver/p3peers.cc
View file

@ -812,56 +812,31 @@ bool p3Peers::setHiddenNode(const RsPeerId &id, const std::string &address, uin
return true;
}
bool p3Peers::setLocalAddress(const RsPeerId &id, const std::string &addr_str, uint16_t port)
bool p3Peers::setLocalAddress(const RsPeerId &id, const std::string &addr_str, uint16_t port)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::setLocalAddress() " << id << std::endl;
std::cerr << "p3Peers::setLocalAddress() " << id << std::endl;
#endif
struct sockaddr_storage addr;
struct sockaddr_in *addrv4p = (struct sockaddr_in *) &addr;
addrv4p->sin_family = AF_INET;
addrv4p->sin_port = htons(port);
if ( sockaddr_storage_inet_pton(addr, addr_str.c_str()) )
if ( sockaddr_storage_setport(addr, port) )
return mPeerMgr->setLocalAddress(id, addr);
int ret = 1;
/********************************** WINDOWS/UNIX SPECIFIC PART *******************/
#ifndef WINDOWS_SYS
if (ret && (0 != inet_aton(addr_str.c_str(), &(addrv4p->sin_addr))))
#else
addrv4p->sin_addr.s_addr = inet_addr(addr_str.c_str());
if (ret)
#endif
/********************************** WINDOWS/UNIX SPECIFIC PART *******************/
{
return mPeerMgr->setLocalAddress(id, addr);
}
return false;
}
bool p3Peers::setExtAddress(const RsPeerId &id, const std::string &addr_str, uint16_t port)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::setExtAddress() " << id << std::endl;
std::cerr << "p3Peers::setExtAddress() " << id << std::endl;
#endif
// NOTE THIS IS IPV4 FOR NOW.
struct sockaddr_storage addr;
struct sockaddr_in *addrv4p = (struct sockaddr_in *) &addr;
addrv4p->sin_family = AF_INET;
addrv4p->sin_port = htons(port);
if ( sockaddr_storage_inet_pton(addr, addr_str.c_str()) )
if ( sockaddr_storage_setport(addr, port) )
return mPeerMgr->setExtAddress(id, addr);
int ret = 1;
/********************************** WINDOWS/UNIX SPECIFIC PART *******************/
#ifndef WINDOWS_SYS
if (ret && (0 != inet_aton(addr_str.c_str(), &(addrv4p->sin_addr))))
#else
addrv4p->sin_addr.s_addr = inet_addr(addr_str.c_str());
if (ret)
#endif
/********************************** WINDOWS/UNIX SPECIFIC PART *******************/
{
return mPeerMgr->setExtAddress(id, addr);
}
return false;
}

6
libretroshare/src/serialiser/rsconfigitems.cc
View file

@ -924,9 +924,9 @@ bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint3
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc); /* Mandatory */
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset);
ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
@ -941,7 +941,7 @@ bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint3
if(offset != tlvsize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << std::endl;
std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << offset << " != " << tlvsize << std::endl;
#endif
ok = false;
}

2
libretroshare/src/serialiser/rstlvbase.cc
View file

@ -832,7 +832,7 @@ bool SetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset,
if (!data)
return false;
uint32_t tlvsize = GetTlvIpAddrPortV4Size();
uint32_t tlvsize = GetTlvIpAddrPortV6Size();
uint32_t tlvend = *offset + tlvsize; /* where the data will extend to */
if (size < tlvend)

2
libretroshare/src/util/extaddrfinder.cc
View file

@ -167,7 +167,7 @@ void* doExtAddrSearch(void *p)
if(!sockaddr_storage_ipv4_aton(af->mAddr, res[res.size()/2].c_str()))
if(!sockaddr_storage_inet_pton(af->mAddr, res[res.size()/2].c_str()))
{
std::cerr << "ExtAddrFinder: Could not convert " << res[res.size()/2] << " into an address." << std::endl ;
{

3
libretroshare/src/util/rsnet.h
View file

@ -92,7 +92,7 @@ bool sockaddr_storage_setport(struct sockaddr_storage &addr, uint16_t port);
bool sockaddr_storage_setipv4(struct sockaddr_storage &addr, const sockaddr_in *addr_ipv4);
bool sockaddr_storage_setipv6(struct sockaddr_storage &addr, const sockaddr_in6 *addr_ipv6);
bool sockaddr_storage_ipv4_aton(struct sockaddr_storage &addr, const char *name);
bool sockaddr_storage_inet_pton(struct sockaddr_storage &addr, const char * ip_str);
bool sockaddr_storage_ipv4_setport(struct sockaddr_storage &addr, const uint16_t port);
bool sockaddr_storage_ipv4_to_ipv6(sockaddr_storage &addr);
@ -109,6 +109,7 @@ std::string sockaddr_storage_tostring(const struct sockaddr_storage &addr);
std::string sockaddr_storage_familytostring(const struct sockaddr_storage &addr);
std::string sockaddr_storage_iptostring(const struct sockaddr_storage &addr);
std::string sockaddr_storage_porttostring(const struct sockaddr_storage &addr);
void sockaddr_storage_dump(const sockaddr_storage & addr);
// output
//void sockaddr_storage_output(const struct sockaddr_storage &addr, std::ostream &out);

145
libretroshare/src/util/rsnet_ss.cc
View file

@ -23,6 +23,8 @@
*
*/
#include <sstream>
#include "util/rsnet.h"
#include "util/rsstring.h"
#include "pqi/pqinetwork.h"
@ -84,7 +86,7 @@ bool sockaddr_storage_ipv6_isExternalNet(const struct sockaddr_storage &addr);
/******************************** Socket Fns ***********************************/
// Standard bind, on OSX anyway will not accept a longer socklen for IPv4.
// so hidding details behind function.
int universal_bind(int fd, const struct sockaddr *addr, socklen_t socklen)
int universal_bind(int fd, const struct sockaddr *addr, socklen_t socklen)
{
#ifdef SS_DEBUG
std::cerr << "universal_bind()";
@ -192,6 +194,7 @@ uint16_t sockaddr_storage_port(const struct sockaddr_storage &addr)
default:
std::cerr << "sockaddr_storage_port() invalid addr.ss_family";
std::cerr << std::endl;
sockaddr_storage_dump(addr);
break;
}
return 0;
@ -252,16 +255,27 @@ bool sockaddr_storage_setipv6(struct sockaddr_storage &addr, const sockaddr_in6
return true;
}
bool sockaddr_storage_ipv4_aton(struct sockaddr_storage &addr, const char *name)
bool sockaddr_storage_inet_pton(struct sockaddr_storage &addr, const char * ip_str)
{
#ifdef SS_DEBUG
std::cerr << "sockaddr_storage_ipv4_aton()";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_inet_pton" << std::endl;
#endif
struct sockaddr_in *ipv4_ptr = to_ipv4_ptr(addr);
ipv4_ptr->sin_family = AF_INET;
return (1 == inet_aton(name, &(ipv4_ptr->sin_addr)));
struct sockaddr_in6 * addrv6p = (struct sockaddr_in6 *) &addr;
struct sockaddr_in * addrv4p = (struct sockaddr_in *) &addr;
if ( 1 == inet_pton(AF_INET6, ip_str, &(addrv6p->sin6_addr)) )
{
addr.ss_family = AF_INET6;
return true;
}
else if ( 1 == inet_pton(AF_INET, ip_str, &(addrv4p->sin_addr)) )
{
addr.ss_family = AF_INET;
return sockaddr_storage_ipv4_to_ipv6(addr);
}
return false;
}
bool sockaddr_storage_ipv4_to_ipv6(sockaddr_storage &addr)
@ -418,24 +432,6 @@ std::string sockaddr_storage_familytostring(const struct sockaddr_storage &addr)
return output;
}
std::string sockaddr_storage_iptostring(const struct sockaddr_storage &addr)
{
std::string output;
switch(addr.ss_family)
{
case AF_INET:
output = sockaddr_storage_ipv4_iptostring(addr);
break;
case AF_INET6:
output = sockaddr_storage_ipv6_iptostring(addr);
break;
default:
output = "INVALID_IP";
break;
}
return output;
}
std::string sockaddr_storage_porttostring(const struct sockaddr_storage &addr)
{
std::string output;
@ -487,8 +483,8 @@ bool sockaddr_storage_isValidNet(const struct sockaddr_storage &addr)
return sockaddr_storage_ipv6_isValidNet(addr);
break;
default:
std::cerr << "sockaddr_storage_isValidNet() INVALID Family - error";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_isValidNet() INVALID Family"
<< addr.ss_family << " - error"<< std::endl;
break;
}
return false;
@ -678,9 +674,10 @@ bool sockaddr_storage_ipv6_copyip(struct sockaddr_storage &dst, const struct soc
uint16_t sockaddr_storage_ipv6_port(const struct sockaddr_storage &addr)
{
#ifdef SS_DEBUG
std::cerr << "sockaddr_storage_ipv6_port()";
std::cerr << std::endl;
#endif
const struct sockaddr_in6 *ipv6_ptr = to_const_ipv6_ptr(addr);
uint16_t port = ntohs(ipv6_ptr->sin6_port);
return port;
@ -809,13 +806,75 @@ std::string sockaddr_storage_ipv4_iptostring(const struct sockaddr_storage &addr
return output;
}
std::string sockaddr_storage_ipv6_iptostring(const struct sockaddr_storage & /* addr */)
std::string sockaddr_storage_iptostring(const struct sockaddr_storage & addr)
{
std::string output;
output += "IPv6-ADDRESS-TODO";
switch (addr.ss_family){
case AF_INET:
{
output = sockaddr_storage_ipv4_iptostring(addr);
break;
}
case AF_INET6:
{
char addrStr[INET6_ADDRSTRLEN+1];
struct sockaddr_in6 * addrv6p = (struct sockaddr_in6 *) &addr;
inet_ntop(addr.ss_family, &(addrv6p->sin6_addr), addrStr, INET6_ADDRSTRLEN);
output = addrStr;
break;
}
default:
{
output = "INVALID_IP";
sockaddr_storage_dump(addr);
}}
return output;
}
void sockaddr_storage_dump(const sockaddr_storage & addr)
{
// This function must not rely on others sockaddr_storage_*
std::stringstream output;
output << "sockaddr_storage_dump(addr) ";
switch (addr.ss_family){
case AF_INET:
{
const sockaddr_in * in = (const sockaddr_in *) & addr;
output << "addr.ss_family = AF_INET";
output << " in->sin_addr = ";
output << inet_ntoa(in->sin_addr);
output << " in->sin_port = ";
output << in->sin_port;
break;
}
case AF_INET6:
{
char addrStr[INET6_ADDRSTRLEN+1];
struct sockaddr_in6 * in6 = (struct sockaddr_in6 *) & addr;
inet_ntop(addr.ss_family, &(in6->sin6_addr), addrStr, INET6_ADDRSTRLEN);
output << "addr.ss_family = AF_INET6";
output << " in6->sin6_addr = ";
output << addrStr;
output << " in6->sin6_port = ";
output << in6->sin6_port;
break;
}
default:
{
output << "unknown addr.ss_family = ";
output << addr.ss_family;
output << " addr.__ss_align = ";
output << addr.__ss_align;
output << " addr.__ss_padding = ";
output << addr.__ss_padding;
}}
std::cout << output.str() << std::endl;
}
@ -904,23 +963,21 @@ bool sockaddr_storage_ipv4_isExternalNet(const struct sockaddr_storage &addr)
}
bool sockaddr_storage_ipv6_isnull(const struct sockaddr_storage &addr)
bool sockaddr_storage_ipv6_isnull(const struct sockaddr_storage & )
{
std::cerr << "sockaddr_storage_ipv6_isnull() TODO";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_ipv6_isnull() TODO" << std::endl;
return false;
}
bool sockaddr_storage_ipv6_isValidNet(const struct sockaddr_storage &addr)
bool sockaddr_storage_ipv6_isValidNet(const struct sockaddr_storage & )
{
std::cerr << "sockaddr_storage_ipv6_isValidNet() TODO";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_ipv6_isValidNet() TODO" << std::endl;
return false;
return true;
}
bool sockaddr_storage_ipv6_isLoopbackNet(const struct sockaddr_storage &addr)
bool sockaddr_storage_ipv6_isLoopbackNet(const struct sockaddr_storage & )
{
std::cerr << "sockaddr_storage_ipv6_isLoopbackNet() TODO";
std::cerr << std::endl;
@ -928,20 +985,18 @@ bool sockaddr_storage_ipv6_isLoopbackNet(const struct sockaddr_storage &addr)
return false;
}
bool sockaddr_storage_ipv6_isPrivateNet(const struct sockaddr_storage &addr)
bool sockaddr_storage_ipv6_isPrivateNet(const struct sockaddr_storage &)
{
std::cerr << "sockaddr_storage_ipv6_isPrivateNet() TODO";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_ipv6_isPrivateNet() TODO" << std::endl;
return false;
}
bool sockaddr_storage_ipv6_isExternalNet(const struct sockaddr_storage &addr)
bool sockaddr_storage_ipv6_isExternalNet(const struct sockaddr_storage &)
{
std::cerr << "sockaddr_storage_ipv6_isExternalNet() TODO";
std::cerr << std::endl;
std::cerr << "sockaddr_storage_ipv6_isExternalNet() TODO" << std::endl;
return false;
return true;
}