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

Massive commit - changing from sockaddr_in => sockaddr_storage.

Browse source 
In preparation for making RS support IPv6.

NB: This breaks the build of retroshare-gui, as the
sockaddr_storage_xxx fns are only defined as prototypes for now.

All the aux libraries like udp / stun / tcponudp / dht have still to be converted.

These changes will probably break various things and need to be tested thoroughly.




git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-initdev@6735 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2013-09-13 14:35:19 +00:00
parent fd071161bf
commit 6290d8fed9
66 changed files with 1182 additions and 1046 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -37,8 +37,6 @@
#include <iostream>
// For transition.
RsPeerNetItem *convertToNetItem(RsPeerOldNetItem *old);
/*************************************************************************/
@ -683,16 +681,11 @@ RsPeerConfigSerialiser::~RsPeerConfigSerialiser()
uint32_t RsPeerConfigSerialiser::size(RsItem *i)
{
RsPeerOldNetItem *oldpni;
RsPeerStunItem *psi;
RsPeerNetItem *pni;
RsPeerGroupItem *pgi;
RsPeerServicePermissionItem *pri;
if (NULL != (oldpni = dynamic_cast<RsPeerOldNetItem *>(i)))
{
return sizeOldNet(oldpni);
}
if (NULL != (pni = dynamic_cast<RsPeerNetItem *>(i)))
{
return sizeNet(pni);
@ -716,16 +709,11 @@ uint32_t RsPeerConfigSerialiser::size(RsItem *i)
/* serialise the data to the buffer */
bool RsPeerConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsPeerOldNetItem *oldpni;
RsPeerNetItem *pni;
RsPeerStunItem *psi;
RsPeerGroupItem *pgi;
RsPeerServicePermissionItem *pri;
if (NULL != (oldpni = dynamic_cast<RsPeerOldNetItem *>(i)))
{
return serialiseOldNet(oldpni, data, pktsize);
}
if (NULL != (pni = dynamic_cast<RsPeerNetItem *>(i)))
{
return serialiseNet(pni, data, pktsize);
@ -761,13 +749,8 @@ RsItem *RsPeerConfigSerialiser::deserialise(void *data, uint32_t *pktsize)
return NULL; /* wrong type */
}
RsPeerOldNetItem *old = NULL;
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_PEER_OLD_NET:
old = deserialiseOldNet(data, pktsize);
/* upgrade mechanism */
return convertToNetItem(old);
case RS_PKT_SUBTYPE_PEER_NET:
return deserialiseNet(data, pktsize);
case RS_PKT_SUBTYPE_PEER_STUN:
@ -783,260 +766,6 @@ RsItem *RsPeerConfigSerialiser::deserialise(void *data, uint32_t *pktsize)
}
/*************************************************************************/
RsPeerOldNetItem::~RsPeerOldNetItem()
{
return;
}
void RsPeerOldNetItem::clear()
{
pid.clear();
gpg_id.clear();
location.clear();
netMode = 0;
visState = 0;
lastContact = 0;
sockaddr_clear(&currentlocaladdr);
sockaddr_clear(&currentremoteaddr);
dyndns.clear();
}
std::ostream &RsPeerOldNetItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsPeerOldNetItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "PeerId: " << pid << std::endl;
printIndent(out, int_Indent);
out << "GPGid: " << gpg_id << std::endl;
printIndent(out, int_Indent);
out << "location: " << location << std::endl;
printIndent(out, int_Indent);
out << "netMode: " << netMode << std::endl;
printIndent(out, int_Indent);
out << "visState: " << visState << std::endl;
printIndent(out, int_Indent);
out << "lastContact: " << lastContact << std::endl;
printIndent(out, int_Indent);
out << "currentlocaladdr: " << rs_inet_ntoa(currentlocaladdr.sin_addr);
out << ":" << htons(currentlocaladdr.sin_port) << std::endl;
printIndent(out, int_Indent);
out << "currentremoteaddr: " << rs_inet_ntoa(currentremoteaddr.sin_addr);
out << ":" << htons(currentremoteaddr.sin_port) << std::endl;
printIndent(out, int_Indent);
out << "DynDNS: " << dyndns << std::endl;
printIndent(out, int_Indent);
out << "ipAdressList: size : " << ipAddressList.size() << ", adresses : " << std::endl;
for (std::list<IpAddressTimed>::iterator ipListIt = ipAddressList.begin(); ipListIt!=(ipAddressList.end()); ipListIt++) {
printIndent(out, int_Indent);
out << rs_inet_ntoa(ipListIt->ipAddr.sin_addr) << ":" << ntohs(ipListIt->ipAddr.sin_port) << " seenTime : " << ipListIt->seenTime << std::endl;
}
printRsItemEnd(out, "RsPeerOldNetItem", indent);
return out;
}
/*************************************************************************/
uint32_t RsPeerConfigSerialiser::sizeOldNet(RsPeerOldNetItem *i)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(i->pid); /* peerid */
s += GetTlvStringSize(i->gpg_id);
s += GetTlvStringSize(i->location);
s += 4; /* netMode */
s += 4; /* visState */
s += 4; /* lastContact */
s += GetTlvIpAddrPortV4Size(); /* localaddr */
s += GetTlvIpAddrPortV4Size(); /* remoteaddr */
s += GetTlvStringSize(i->dyndns);
//add the size of the ip list
int ipListSize = i->ipAddressList.size();
s += ipListSize * GetTlvIpAddrPortV4Size();
s += ipListSize * 8; //size of an uint64
return s;
}
bool RsPeerConfigSerialiser::serialiseOldNet(RsPeerOldNetItem *item, void *data, uint32_t *size)
{
uint32_t tlvsize = RsPeerConfigSerialiser::sizeOldNet(item);
uint32_t offset = 0;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialiseOldNet() ERROR should never use this function" << std::endl;
#endif
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
// serialise header
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialiseOldNet() Header: " << ok << std::endl;
std::cerr << "RsPeerConfigSerialiser::serialiseOldNet() Header test: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->visState); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->currentlocaladdr));
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->currentremoteaddr));
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
//store the ip list
std::list<IpAddressTimed>::iterator ipListIt;
for (ipListIt = item->ipAddressList.begin(); ipListIt!=(item->ipAddressList.end()); ipListIt++) {
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_REMOTE, &(ipListIt->ipAddr));
ok &= setRawUInt64(data, tlvsize, &offset, ipListIt->seenTime);
}
if(offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialise() Size Error! " << std::endl;
#endif
}
return ok;
}
RsPeerOldNetItem *RsPeerConfigSerialiser::deserialiseOldNet(void *data, uint32_t *size)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialiseOldNet() ERROR should never use this function" << std::endl;
#endif
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_PEER_OLD_NET != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*size < rssize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*size = rssize;
bool ok = true;
RsPeerOldNetItem *item = new RsPeerOldNetItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->visState)); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact)); /* Mandatory */
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->currentlocaladdr));
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->currentremoteaddr));
//ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); //use this line for backward compatibility
//get the ip adress list
std::list<IpAddressTimed> ipTimedList;
while (offset < rssize) {
IpAddressTimed ipTimed;
sockaddr_clear(&ipTimed.ipAddr);
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_REMOTE, &ipTimed.ipAddr);
if (!ok) { break;}
uint64_t time = 0;
ok &= getRawUInt64(data, rssize, &offset, &time);
if (!ok) { break;}
ipTimed.seenTime = time;
ipTimedList.push_back(ipTimed);
}
item->ipAddressList = ipTimedList;
//if (offset != rssize)
if (false) //use this line for backward compatibility
{
/* error */
delete item;
return NULL;
}
return item;
}
/****************************************************************************/
RsPeerNetItem *convertToNetItem(RsPeerOldNetItem *old)
{
RsPeerNetItem *item = new RsPeerNetItem();
/* copy over data */
item->pid = old->pid;
item->gpg_id = old->gpg_id;
item->location = old->location;
item->netMode = old->netMode;
item->visState = old->visState;
item->lastContact = old->lastContact;
item->currentlocaladdr = old->currentlocaladdr;
item->currentremoteaddr = old->currentremoteaddr;
item->dyndns = old->dyndns;
std::list<IpAddressTimed>::iterator it;
for(it = old->ipAddressList.begin(); it != old->ipAddressList.end(); it++)
{
RsTlvIpAddressInfo info;
info.addr = it->ipAddr;
info.seenTime = it->seenTime;
info.source = 0;
item->extAddrList.addrs.push_back(info);
}
/* delete old data */
delete old;
return item;
}
/****************************************************************************/
@ -1054,9 +783,9 @@ void RsPeerNetItem::clear()
visState = 0;
lastContact = 0;
sockaddr_clear(&currentlocaladdr);
sockaddr_clear(&currentremoteaddr);
dyndns.clear();
localAddr.TlvClear();
extAddr.TlvClear();
dyndns.clear();
localAddrList.TlvClear();
extAddrList.TlvClear();
@ -1089,15 +818,16 @@ std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent)
out << "lastContact: " << lastContact << std::endl;
printIndent(out, int_Indent);
out << "currentlocaladdr: " << rs_inet_ntoa(currentlocaladdr.sin_addr);
out << ":" << htons(currentlocaladdr.sin_port) << std::endl;
out << "localAddr: " << std::endl;
localAddr.print(out, int_Indent);
printIndent(out, int_Indent);
out << "currentremoteaddr: " << rs_inet_ntoa(currentremoteaddr.sin_addr);
out << ":" << htons(currentremoteaddr.sin_port) << std::endl;
out << "extAddr: " << std::endl;
extAddr.print(out, int_Indent);
printIndent(out, int_Indent);
out << "DynDNS: " << dyndns << std::endl;
printIndent(out, int_Indent);
out << "DynDNS: " << dyndns << std::endl;
localAddrList.print(out, int_Indent);
extAddrList.print(out, int_Indent);
@ -1117,9 +847,9 @@ uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i)
s += 4; /* netMode */
s += 4; /* visState */
s += 4; /* lastContact */
s += GetTlvIpAddrPortV4Size(); /* localaddr */
s += GetTlvIpAddrPortV4Size(); /* remoteaddr */
s += GetTlvStringSize(i->dyndns);
s += i->localAddr.TlvSize(); /* localaddr */
s += i->extAddr.TlvSize(); /* remoteaddr */
s += GetTlvStringSize(i->dyndns);
//add the size of the ip list
s += i->localAddrList.TlvSize();
@ -1166,21 +896,22 @@ bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint3
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->visState); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->currentlocaladdr));
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->currentremoteaddr));
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddr.SetTlv(data, tlvsize, &offset);
ok &= item->extAddr.SetTlv(data, tlvsize, &offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddrList.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrList.SetTlv(data, tlvsize, &offset);
// New for V0.6.
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr);
ok &= setRawUInt16(data, tlvsize, &offset, item->domain_port); /* Mandatory */
if(offset != tlvsize)
@ -1239,15 +970,17 @@ RsPeerNetItem *RsPeerConfigSerialiser::deserialiseNet(void *data, uint32_t *size
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->visState)); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact)); /* Mandatory */
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->currentlocaladdr));
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->currentremoteaddr));
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddr.GetTlv(data, rssize, &offset);
ok &= item->extAddr.GetTlv(data, rssize, &offset);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddrList.GetTlv(data, rssize, &offset);
ok &= item->extAddrList.GetTlv(data, rssize, &offset);

44
libretroshare/src/serialiser/rsconfigitems.h
View file

@ -48,9 +48,8 @@ const uint8_t RS_PKT_TYPE_HISTORY_CONFIG = 0x06;
const uint8_t RS_PKT_SUBTYPE_KEY_VALUE = 0x01;
/* PEER CONFIG SUBTYPES */
const uint8_t RS_PKT_SUBTYPE_PEER_OLD_NET = 0x01;
const uint8_t RS_PKT_SUBTYPE_PEER_STUN = 0x02;
const uint8_t RS_PKT_SUBTYPE_PEER_NET = 0x03; /* replacement for OLD_NET */
const uint8_t RS_PKT_SUBTYPE_PEER_NET = 0x03;
const uint8_t RS_PKT_SUBTYPE_PEER_GROUP = 0x04;
const uint8_t RS_PKT_SUBTYPE_PEER_PERMISSIONS = 0x05;
@ -60,38 +59,6 @@ const uint8_t RS_PKT_SUBTYPE_FILE_ITEM = 0x02;
/**************************************************************************/
struct IpAddressTimed {
struct sockaddr_in ipAddr;
time_t seenTime;
};
class RsPeerOldNetItem: public RsItem
{
public:
RsPeerOldNetItem()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG,
RS_PKT_TYPE_PEER_CONFIG,
RS_PKT_SUBTYPE_PEER_OLD_NET)
{ return; }
virtual ~RsPeerOldNetItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
/* networking information */
std::string pid; /* Mandatory */
std::string gpg_id; /* Mandatory */
std::string location; /* not Mandatory */
uint32_t netMode; /* Mandatory */
uint32_t visState; /* Mandatory */
uint32_t lastContact; /* Mandatory */
struct sockaddr_in currentlocaladdr; /* Mandatory */
struct sockaddr_in currentremoteaddr; /* Mandatory */
std::string dyndns;
std::list<IpAddressTimed> ipAddressList;
};
class RsPeerNetItem: public RsItem
{
public:
@ -112,8 +79,8 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint32_t visState; /* Mandatory */
uint32_t lastContact; /* Mandatory */
struct sockaddr_in currentlocaladdr; /* Mandatory */
struct sockaddr_in currentremoteaddr; /* Mandatory */
RsTlvIpAddress localAddr; /* Mandatory */
RsTlvIpAddress extAddr; /* Mandatory */
std::string dyndns;
RsTlvIpAddrSet localAddrList;
@ -195,11 +162,6 @@ virtual RsItem * deserialise(void *data, uint32_t *size);
private:
/* These are depreciated ... conversion functions used to seemlessly ungrade.
*/
virtual uint32_t sizeOldNet(RsPeerOldNetItem *);
virtual bool serialiseOldNet (RsPeerOldNetItem *item, void *data, uint32_t *size);
virtual RsPeerOldNetItem *deserialiseOldNet(void *data, uint32_t *size);
virtual uint32_t sizeNet(RsPeerNetItem *);
virtual bool serialiseNet (RsPeerNetItem *item, void *data, uint32_t *size);

157
libretroshare/src/serialiser/rstlvaddrs.cc
View file

@ -35,18 +35,161 @@
#include <iostream>
/************************************* RsTlvIpAddress ************************************/
RsTlvIpAddress::RsTlvIpAddress()
:RsTlvItem()
{
sockaddr_storage_clear(addr);
return;
}
void RsTlvIpAddress::TlvClear()
{
sockaddr_storage_clear(addr);
}
uint32_t RsTlvIpAddress::TlvSize()
{
uint32_t s = TLV_HEADER_SIZE;
switch(addr.ss_family)
{
default:
case 0:
break;
case AF_INET:
s += GetTlvIpAddrPortV4Size();
break;
case AF_INET6:
s += GetTlvIpAddrPortV6Size();
break;
}
return s;
}
bool RsTlvIpAddress::SetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
{
/* must check sizes */
uint32_t tlvsize = TlvSize();
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend)
return false; /* not enough space */
bool ok = true;
/* start at data[offset] */
/* add mandatory parts first */
ok &= SetTlvBase(data, tlvend, offset, TLV_TYPE_ADDRESS, tlvsize);
switch(addr.ss_family)
{
default:
case 0:
break;
case AF_INET:
ok &= SetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4, (struct sockaddr_in *) &addr);
break;
case AF_INET6:
ok &= SetTlvIpAddrPortV6(data, tlvend, offset, TLV_TYPE_IPV6, (struct sockaddr_in6 *) &addr);
break;
}
return ok;
}
bool RsTlvIpAddress::GetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
{
if (size < *offset + TLV_HEADER_SIZE)
return false;
uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) );
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend) /* check size */
return false; /* not enough space */
if (tlvtype != TLV_TYPE_ADDRESS) /* check type */
return false;
bool ok = true;
/* ready to load */
TlvClear();
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
if (*offset == tlvend)
{
/* empty address */
return ok;
}
uint16_t iptype = GetTlvType( &(((uint8_t *) data)[*offset]) );
switch(iptype)
{
case TLV_TYPE_IPV4:
ok &= GetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4, (struct sockaddr_in *) &addr);
break;
case TLV_TYPE_IPV6:
ok &= GetTlvIpAddrPortV6(data, tlvend, offset, TLV_TYPE_IPV6, (struct sockaddr_in6 *) &addr);
break;
default:
break;
}
/***************************************************************************
* NB: extra components could be added (for future expansion of the type).
* or be present (if this code is reading an extended version).
*
* We must chew up the extra characters to conform with TLV specifications
***************************************************************************/
if (*offset != tlvend)
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvIpAddress::GetTlv() Warning extra bytes at end of item";
std::cerr << std::endl;
#endif
*offset = tlvend;
}
return ok;
}
std::ostream &RsTlvIpAddress::print(std::ostream &out, uint16_t indent)
{
printBase(out, "RsTlvIpAddress", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "Address:" << sockaddr_storage_tostring(addr) << std::endl;
printEnd(out, "RsTlvIpAddress", indent);
return out;
}
/************************************* RsTlvIpAddressInfo ************************************/
RsTlvIpAddressInfo::RsTlvIpAddressInfo()
:RsTlvItem(), seenTime(0), source(0)
{
sockaddr_clear(&addr);
addr.TlvClear();
return;
}
void RsTlvIpAddressInfo::TlvClear()
{
sockaddr_clear(&addr);
addr.TlvClear();
seenTime = 0;
source = 0;
}
@ -55,7 +198,7 @@ uint32_t RsTlvIpAddressInfo::TlvSize()
{
uint32_t s = TLV_HEADER_SIZE; /* header + IpAddr + 8 for time & 4 for size */
s += GetTlvIpAddrPortV4Size();
s += addr.TlvSize();
s += 8; // seenTime
s += 4; // source
@ -79,7 +222,7 @@ bool RsTlvIpAddressInfo::SetTlv(void *data, uint32_t size, uint32_t *offset) /*
ok &= SetTlvBase(data, tlvend, offset, TLV_TYPE_ADDRESS_INFO, tlvsize);
ok &= SetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4_LAST, &addr);
ok &= addr.SetTlv(data, tlvend, offset);
ok &= setRawUInt64(data, tlvend, offset, seenTime);
ok &= setRawUInt32(data, tlvend, offset, source);
@ -111,7 +254,7 @@ bool RsTlvIpAddressInfo::GetTlv(void *data, uint32_t size, uint32_t *offset) /*
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
ok &= GetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4_LAST, &addr);
ok &= addr.GetTlv(data, tlvend, offset);
ok &= getRawUInt64(data, tlvend, offset, &(seenTime));
ok &= getRawUInt32(data, tlvend, offset, &(source));
@ -141,9 +284,7 @@ std::ostream &RsTlvIpAddressInfo::print(std::ostream &out, uint16_t indent)
printBase(out, "RsTlvIpAddressInfo", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "Address:" << rs_inet_ntoa(addr.sin_addr);
out << ":" << htons(addr.sin_port) << std::endl;
addr.print(out, int_Indent);
printIndent(out, int_Indent);
out << "SeenTime:" << seenTime;

16
libretroshare/src/serialiser/rstlvaddrs.h
View file

@ -34,6 +34,20 @@
#include "serialiser/rstlvtypes.h"
#include "util/rsnet.h"
class RsTlvIpAddress: public RsTlvItem
{
public:
RsTlvIpAddress();
virtual ~RsTlvIpAddress() { return; }
virtual uint32_t TlvSize();
virtual void TlvClear();
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* serialise */
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */
virtual std::ostream &print(std::ostream &out, uint16_t indent);
struct sockaddr_storage addr; // Mandatory :
};
class RsTlvIpAddressInfo: public RsTlvItem
{
@ -46,7 +60,7 @@ virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* seriali
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */
virtual std::ostream &print(std::ostream &out, uint16_t indent);
struct sockaddr_in addr; // Mandatory :
RsTlvIpAddress addr; // Mandatory :
uint64_t seenTime; // Mandatory :
uint32_t source; // Mandatory :
};

12
libretroshare/src/serialiser/rstlvbanlist.cc
View file

@ -45,7 +45,7 @@ RsTlvBanListEntry::RsTlvBanListEntry()
void RsTlvBanListEntry::TlvClear()
{
sockaddr_clear(&addr);
addr.TlvClear();
level = 0;
reason = 0;
age = 0;
@ -55,7 +55,7 @@ uint32_t RsTlvBanListEntry::TlvSize()
{
uint32_t s = TLV_HEADER_SIZE;
s += GetTlvIpAddrPortV4Size();
s += addr.TlvSize();
s += 4; // level;
s += 4; // reason;
s += 4; // age;
@ -80,7 +80,7 @@ bool RsTlvBanListEntry::SetTlv(void *data, uint32_t size, uint32_t *offset) /*
ok &= SetTlvBase(data, tlvend, offset, TLV_TYPE_BAN_ENTRY, tlvsize);
ok &= SetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4_REMOTE, &addr);
ok &= addr.SetTlv(data, tlvend, offset);
ok &= setRawUInt32(data, tlvend, offset, level);
ok &= setRawUInt32(data, tlvend, offset, reason);
ok &= setRawUInt32(data, tlvend, offset, age);
@ -112,7 +112,7 @@ bool RsTlvBanListEntry::GetTlv(void *data, uint32_t size, uint32_t *offset) /*
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
ok &= GetTlvIpAddrPortV4(data, tlvend, offset, TLV_TYPE_IPV4_REMOTE, &addr);
ok &= addr.GetTlv(data, tlvend, offset);
ok &= getRawUInt32(data, tlvend, offset, &(level));
ok &= getRawUInt32(data, tlvend, offset, &(reason));
ok &= getRawUInt32(data, tlvend, offset, &(age));
@ -143,8 +143,8 @@ std::ostream &RsTlvBanListEntry::print(std::ostream &out, uint16_t indent)
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "addr:" << rs_inet_ntoa(addr.sin_addr) << ":" << htons(addr.sin_port);
out << std::endl;
out << "addr:" << std::endl;
addr.print(out, int_Indent);
printIndent(out, int_Indent);
out << "level:" << level;

3
libretroshare/src/serialiser/rstlvbanlist.h
View file

@ -32,6 +32,7 @@
#include <map>
#include "serialiser/rstlvtypes.h"
#include "serialiser/rstlvaddrs.h"
#include "util/rsnet.h"
#define RSDSDV_MAX_ROUTE_TABLE 1000
@ -47,7 +48,7 @@ virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* seriali
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */
virtual std::ostream &print(std::ostream &out, uint16_t indent);
struct sockaddr_in addr;
RsTlvIpAddress addr;
uint32_t level;
uint32_t reason;
uint32_t age;

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

@ -697,7 +697,7 @@ bool SetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset,
{
ok &= setRawUInt32(data, tlvend, offset, ip6addr[i]);
}
ok &= setRawUInt16(data, tlvend, offset, out->sin_port6);
ok &= setRawUInt16(data, tlvend, offset, out->sin6_port);
return ok;
}
@ -752,7 +752,7 @@ bool GetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset,
uint32_t *ip6addr = (uint32_t *) in->sin6_addr.s6_addr;
for(int i = 0; i < 4; i++)
{
ok &= getRawUInt32(data, tlvend, offset, ip6addr[i]);
ok &= getRawUInt32(data, tlvend, offset, &(ip6addr[i]));
}
in->sin6_family = AF_INET6; /* set FAMILY */

8
libretroshare/src/serialiser/rstlvbase.h
View file

@ -159,6 +159,10 @@ const uint16_t TLV_TYPE_IPV4_LAST = 0x0082;
const uint16_t TLV_TYPE_STR_DYNDNS = 0x0083;
const uint16_t TLV_TYPE_STR_DOMADDR = 0x0084;
// rearrange these in the future.
const uint16_t TLV_TYPE_IPV4 = 0x0085;
const uint16_t TLV_TYPE_IPV6 = 0x0086;
/*** MORE STRING IDS ****/
const uint16_t TLV_TYPE_STR_GROUPID = 0x00a0;
const uint16_t TLV_TYPE_STR_MSGID = 0x00a1;
@ -202,6 +206,9 @@ const uint16_t TLV_TYPE_WKEYVALUESET = 0x1013;
const uint16_t TLV_TYPE_STRINGSET = 0x1020; /* dummy non-existant */
const uint16_t TLV_TYPE_PEERSET = 0x1021;
const uint16_t TLV_TYPE_HASHSET = 0x1022;
const uint16_t TLV_TYPE_PGPIDSET = 0x1023;
const uint16_t TLV_TYPE_SERVICESET = 0x1030;
const uint16_t TLV_TYPE_SECURITYKEY = 0x1040;
@ -215,6 +222,7 @@ const uint16_t TLV_TYPE_IMAGE = 0x1060;
const uint16_t TLV_TYPE_ADDRESS_INFO = 0x1070;
const uint16_t TLV_TYPE_ADDRESS_SET = 0x1071;
const uint16_t TLV_TYPE_ADDRESS = 0x1072;
const uint16_t TLV_TYPE_DSDV_ENDPOINT = 0x1080;
const uint16_t TLV_TYPE_DSDV_ENTRY = 0x1081;