Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-05-29 02:51:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Lots of little changes to libretroshare. Improvements mainly focused

Browse source 
on configuration storage and loading:
 * Improved Configuration Manager (almost finished)
 * Mutex protections for Configuration system
 * added Configuration storage to p3ConnectMgr.
 * added Configuration storage to p3MsgService.
 * bugfixes in p3GeneralConfig.
 * Added Config Save notification where necessary.
 * added safe FinalConfigSave before exit().
 * added RsPeerNetItem + RsPeerStunItem (serialiser)
 * reordered startup for correct config loading.
 * enabled Loading of certs in AuthXPGP.
 * move sockaddr_clear() to util/rsnet.h
 * switched p3MsgService sendMessage checking to pqiMonitor syste,.
 * corrected pqiarchive saving of PeerIds.
 * added setNetworkMode() & setVisState() to p3ConnectMgr.
 * added Mutex protection to p3ranking.



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@336 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2008-02-07 16:18:34 +00:00
parent 2c69fd7eaf
commit 806b8285f2
36 changed files with 1712 additions and 599 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -477,171 +477,374 @@ RsConfigKeyValueSet *RsGeneralConfigSerialiser::deserialiseKeyValueSet(void *dat
}
/*************************************************************************/
RsPeerConfig::~RsPeerConfig()
{
return;
}
void RsPeerConfig::clear()
{
status = 0;
lastconn_ts = 0;
lastrecv_ts = 0;
nextconn_ts = 0;
nextconn_period = 0;
}
std::ostream &RsPeerConfig::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsPeerConfig", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "status: " << status << std::endl;
printIndent(out, int_Indent);
out << "lastconn_ts: " << lastconn_ts << std::endl;
printIndent(out, int_Indent);
out << "lastrecv_ts: " << lastrecv_ts << std::endl;
printIndent(out, int_Indent);
out << "nextconn_ts: " << nextconn_ts << std::endl;
printIndent(out, int_Indent);
out << "nextconn_period: " << nextconn_period << std::endl;
return out;
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
RsPeerConfigSerialiser::~RsPeerConfigSerialiser()
{
return;
}
uint32_t RsPeerConfigSerialiser::size(RsItem *i)
uint32_t RsPeerConfigSerialiser::size(RsItem *i)
{
RsPeerNetItem *pni;
RsPeerStunItem *psi;
if (NULL != (pni = dynamic_cast<RsPeerNetItem *>(i)))
{
return sizeNet(pni);
}
else if (NULL != (psi = dynamic_cast<RsPeerStunItem *>(i)))
{
return sizeStun(psi);
}
return 0;
}
/* serialise the data to the buffer */
bool RsPeerConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsPeerNetItem *pni;
RsPeerStunItem *psi;
if (NULL != (pni = dynamic_cast<RsPeerNetItem *>(i)))
{
return serialiseNet(pni, data, pktsize);
}
else if (NULL != (psi = dynamic_cast<RsPeerStunItem *>(i)))
{
return serialiseStun(psi, data, pktsize);
}
return false;
}
RsItem *RsPeerConfigSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)))
{
std::cerr << "RsPeerConfigSerialiser::deserialise() Wrong Type" << std::endl;
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_PEER_NET:
return deserialiseNet(data, pktsize);
break;
case RS_PKT_SUBTYPE_PEER_STUN:
return deserialiseStun(data, pktsize);
break;
default:
return NULL;
break;
}
return NULL;
}
/*************************************************************************/
RsPeerNetItem::~RsPeerNetItem()
{
return;
}
void RsPeerNetItem::clear()
{
pid.clear();
netMode = 0;
visState = 0;
lastContact = 0;
sockaddr_clear(&localaddr);
sockaddr_clear(&remoteaddr);
}
std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsPeerNetItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "PeerId: " << pid << 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 << "localaddr: " << inet_ntoa(localaddr.sin_addr);
out << ":" << htons(localaddr.sin_port) << std::endl;
printIndent(out, int_Indent);
out << "remoteaddr: " << inet_ntoa(remoteaddr.sin_addr);
out << ":" << htons(remoteaddr.sin_port) << std::endl;
printRsItemEnd(out, "RsPeerNetItem", indent);
return out;
}
/*************************************************************************/
uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i)
{
uint32_t s = 8; /* header */
s += 2; /* status */
s += 2; /* lastconnect_ts */
s += 2; /* lastrecv_ts */
s += 2; /* nextconn_ts */
s += 2; /* nextperiod */
s += GetTlvStringSize(i->pid); /* peerid */
s += 4; /* netMode */
s += 4; /* visState */
s += 4; /* lastContact */
s += GetTlvIpAddrPortV4Size(); /* localaddr */
s += GetTlvIpAddrPortV4Size(); /* remoteaddr */
return s;
}
bool RsPeerConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size)
{
RsPeerConfig *item = (RsPeerConfig *) i;
bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint32_t *size)
{
uint32_t tlvsize = RsPeerConfigSerialiser::sizeNet(item);
uint32_t offset = 0;
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
// serialise header
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header: " << ok << std::endl;
std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header: " << tlvsize << std::endl;
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialiseNet() pid: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialiseNet() netMode: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->visState); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialiseNet() visState: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialiseNet() lastContact: " << ok << std::endl;
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->localaddr));
std::cerr << "RsPeerConfigSerialiser::serialiseNet() localaddr: " << ok << std::endl;
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->remoteaddr));
std::cerr << "RsPeerConfigSerialiser::serialiseNet() remoteaddr: " << ok << std::endl;
if(offset != tlvsize)
{
ok = false;
std::cerr << "RsPeerConfigSerialiser::serialise() Size Error! " << std::endl;
}
return ok;
}
RsPeerNetItem *RsPeerConfigSerialiser::deserialiseNet(void *data, uint32_t *size)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_PEER_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;
RsPeerNetItem *item = new RsPeerNetItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() pid: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() netMode: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->visState)); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() visState: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact)); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() lastContact: " << ok << std::endl;
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_LOCAL, &(item->localaddr));
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() localaddr: " << ok << std::endl;
ok &= GetTlvIpAddrPortV4(data, rssize, &offset, TLV_TYPE_IPV4_REMOTE, &(item->remoteaddr));
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() remoteaddr: " << ok << std::endl;
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
return item;
}
/****************************************************************************/
RsPeerStunItem::~RsPeerStunItem()
{
return;
}
void RsPeerStunItem::clear()
{
stunList.TlvClear();
}
std::ostream &RsPeerStunItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsPeerStunItem", indent);
uint16_t int_Indent = indent + 2;
stunList.print(out, int_Indent);
printRsItemEnd(out, "RsPeerStunItem", indent);
return out;
}
/*************************************************************************/
uint32_t RsPeerConfigSerialiser::sizeStun(RsPeerStunItem *i)
{
uint32_t s = 8; /* header */
s += i->stunList.TlvSize(); /* stunList */
return s;
}
bool RsPeerConfigSerialiser::serialiseStun(RsPeerStunItem *item, void *data, uint32_t *size)
{
uint32_t tlvsize = RsPeerConfigSerialiser::sizeStun(item);
uint32_t offset = 0;
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
// serialise header
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
std::cerr << "RsPeerConfigSerialiser::serialiseStun() Header: " << ok << std::endl;
std::cerr << "RsPeerConfigSerialiser::serialiseStun() Header: " << tlvsize << std::endl;
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->stunList.SetTlv(data, tlvsize, &offset); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialiseStun() stunList: " << ok << std::endl;
if(offset != tlvsize)
{
ok = false;
std::cerr << "RsPeerConfigSerialiser::serialiseStun() Size Error! " << std::endl;
}
return ok;
}
RsPeerStunItem *RsPeerConfigSerialiser::deserialiseStun(void *data, uint32_t *size)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_PEER_STUN != 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;
RsPeerStunItem *item = new RsPeerStunItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= item->stunList.GetTlv(data, rssize, &offset); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::deserialiseStun() stunList: " << ok << std::endl;
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
return item;
}
uint32_t tlvsize = RsPeerConfigSerialiser::size(item);
uint32_t offset = 0;
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
// serialise header
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
std::cerr << "RsConfigSerialiser::serialise() Header: " << ok << std::endl;
std::cerr << "RsConfigSerialiser::serialise() Header: " << tlvsize << std::endl;
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastconn_ts); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialise() lastconn_ts: " << ok << std::endl; /* WRITE error check */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastrecv_ts); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialise() lastrecv_ts: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->nextconn_ts); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialise() nextconn_ts: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->nextconn_period); /* Mandatory */
std::cerr << "RsPeerConfigSerialiser::serialise() nextconn_period: " << ok << std::endl;
if(offset != tlvsize)
{
ok = false;
std::cerr << "RsPeerConfigSerialiser::serialise() Size Error! " << std::endl;
}
return ok;
}
RsItem *RsPeerConfigSerialiser::deserialise(void *data, uint32_t *size)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_DEFAULT != 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;
RsPeerConfig *item = new RsPeerConfig();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &(item->lastconn_ts));
std::cerr << "RsFileTransferSerialiser::deserilise() lastconn_ts: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->lastconn_ts));
std::cerr << "RsFileTransferSerialiser::deserilise() lastrecv_ts: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->lastconn_ts));
std::cerr << "RsFileTransferSerialiser::deserilise() nextconn_ts: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->lastconn_ts));
std::cerr << "RsFileTransferSerialiser::deserilise() nextconn_period: " << ok << std::endl;
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
return item;
}
/****************************************************************************/
RsCacheConfig::~RsCacheConfig()
{

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

@ -40,35 +40,48 @@ const uint8_t RS_PKT_TYPE_FILE_CONFIG = 0x04;
/* GENERAL CONFIG SUBTYPES */
const uint8_t RS_PKT_SUBTYPE_KEY_VALUE = 0x01;
/* PEER CONFIG SUBTYPES */
const uint8_t RS_PKT_SUBTYPE_PEER_NET = 0x01;
const uint8_t RS_PKT_SUBTYPE_PEER_STUN = 0x02;
/**************************************************************************/
class RsPeerConfig: public RsItem
class RsPeerNetItem: public RsItem
{
public:
RsPeerConfig()
RsPeerNetItem()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG,
RS_PKT_TYPE_PEER_CONFIG,
RS_PKT_SUBTYPE_DEFAULT)
RS_PKT_SUBTYPE_PEER_NET)
{ return; }
virtual ~RsPeerConfig();
virtual ~RsPeerNetItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
//RsTlvPeerId peerid; /* Mandatory */
//RsTlvPeerFingerprint fpr; /* Mandatory */
/* networking information */
std::string pid; /* Mandatory */
uint32_t netMode; /* Mandatory */
uint32_t visState; /* Mandatory */
uint32_t lastContact; /* Mandatory */
//struct sockaddr_in lastaddr; /* Mandatory */
//struct sockaddr_in localaddr; /* Mandatory */
//struct sockaddr_in serveraddr; /* Mandatory */
uint32_t status; /* Mandatory */
uint32_t lastconn_ts; /* Mandatory */
uint32_t lastrecv_ts; /* Mandatory */
uint32_t nextconn_ts; /* Mandatory */
uint32_t nextconn_period; /* Mandatory */
struct sockaddr_in localaddr; /* Mandatory */
struct sockaddr_in remoteaddr; /* Mandatory */
};
class RsPeerStunItem: public RsItem
{
public:
RsPeerStunItem()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG,
RS_PKT_TYPE_PEER_CONFIG,
RS_PKT_SUBTYPE_PEER_STUN)
{ return; }
virtual ~RsPeerStunItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsTlvPeerIdSet stunList; /* Mandatory */
};
class RsPeerConfigSerialiser: public RsSerialType
{
@ -84,8 +97,21 @@ virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
private:
virtual uint32_t sizeNet(RsPeerNetItem *);
virtual bool serialiseNet (RsPeerNetItem *item, void *data, uint32_t *size);
virtual RsPeerNetItem *deserialiseNet(void *data, uint32_t *size);
virtual uint32_t sizeStun(RsPeerStunItem *);
virtual bool serialiseStun (RsPeerStunItem *item, void *data, uint32_t *size);
virtual RsPeerStunItem * deserialiseStun(void *data, uint32_t *size);
};
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
class RsCacheConfig: public RsItem

8
libretroshare/src/serialiser/rsdiscitems.cc
View file

@ -179,7 +179,7 @@ bool RsDiscSerialiser::serialiseItem(RsDiscItem *item, void *data, uint32_t
TLV_TYPE_IPV4_LOCAL, &(item->laddr));
std::cerr << "RsDiscSerialiser::serialiseItem() laddress: " << ok << std::endl;
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset,
TLV_TYPE_IPV4_SERVER, &(item->saddr));
TLV_TYPE_IPV4_REMOTE, &(item->saddr));
std::cerr << "RsDiscSerialiser::serialiseItem() saddress: " << ok << std::endl;
ok &= setRawUInt16(data, tlvsize, &offset, item->contact_tf);
std::cerr << "RsDiscSerialiser::serialiseItem() contact_tf: " << ok << std::endl;
@ -235,7 +235,7 @@ RsDiscItem *RsDiscSerialiser::deserialiseItem(void *data, uint32_t *pktsize)
TLV_TYPE_IPV4_LOCAL, &(item->laddr));
std::cerr << "RsDiscSerialiser::deserialiseItem() laddress: " << ok << std::endl;
ok &= GetTlvIpAddrPortV4(data, rssize, &offset,
TLV_TYPE_IPV4_SERVER, &(item->saddr));
TLV_TYPE_IPV4_REMOTE, &(item->saddr));
std::cerr << "RsDiscSerialiser::deserialiseItem() saddress: " << ok << std::endl;
ok &= getRawUInt16(data, rssize, &offset, &(item->contact_tf));
std::cerr << "RsDiscSerialiser::deserialiseItem() contact_tf: " << ok << std::endl;
@ -347,7 +347,7 @@ bool RsDiscSerialiser::serialiseReply(RsDiscReply *item, void *data, uint32_
TLV_TYPE_IPV4_LOCAL, &(item->laddr));
std::cerr << "RsDiscSerialiser::serialiseReply() laddress: " << ok << std::endl;
ok &= SetTlvIpAddrPortV4(data, tlvsize, &offset,
TLV_TYPE_IPV4_SERVER, &(item->saddr));
TLV_TYPE_IPV4_REMOTE, &(item->saddr));
std::cerr << "RsDiscSerialiser::serialiseReply() saddress: " << ok << std::endl;
ok &= setRawUInt16(data, tlvsize, &offset, item->contact_tf);
std::cerr << "RsDiscSerialiser::serialiseReply() contact_tf: " << ok << std::endl;
@ -410,7 +410,7 @@ RsDiscReply *RsDiscSerialiser::deserialiseReply(void *data, uint32_t *pktsize)
TLV_TYPE_IPV4_LOCAL, &(item->laddr));
std::cerr << "RsDiscSerialiser::deserialiseReply() laddress: " << ok << std::endl;
ok &= GetTlvIpAddrPortV4(data, rssize, &offset,
TLV_TYPE_IPV4_SERVER, &(item->saddr));
TLV_TYPE_IPV4_REMOTE, &(item->saddr));
std::cerr << "RsDiscSerialiser::deserialiseReply() saddress: " << ok << std::endl;
ok &= getRawUInt16(data, rssize, &offset, &(item->contact_tf));
std::cerr << "RsDiscSerialiser::deserialiseReply() contact_tf: " << ok << std::endl;

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

@ -126,7 +126,7 @@ const uint16_t TLV_TYPE_STR_HASH_SHA1 = 0x0070;
const uint16_t TLV_TYPE_STR_HASH_ED2K = 0x0071;
const uint16_t TLV_TYPE_IPV4_LOCAL = 0x0080;
const uint16_t TLV_TYPE_IPV4_SERVER = 0x0081;
const uint16_t TLV_TYPE_IPV4_REMOTE = 0x0081;
const uint16_t TLV_TYPE_IPV4_LAST = 0x0082;