mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-10-01 02:35:48 -04:00
8a8f9fc528
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7896 b45a01b8-16f6-495d-af2f-9b41ad6348cc
731 lines
19 KiB
C++
731 lines
19 KiB
C++
/*
|
|
* libretroshare/src/serialiser: rsgxsupdateitems.h
|
|
*
|
|
* RetroShare Serialiser.
|
|
*
|
|
* Copyright 2012 Christopher Evi-Parker
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License Version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
* USA.
|
|
*
|
|
* Please report all bugs and problems to "retroshare@lunamutt.com".
|
|
*
|
|
*/
|
|
|
|
#include "rsgxsupdateitems.h"
|
|
#include "rsbaseserial.h"
|
|
|
|
void RsGxsGrpUpdateItem::clear()
|
|
{
|
|
grpUpdateTS = 0;
|
|
peerId.clear();
|
|
}
|
|
std::ostream& RsGxsGrpUpdateItem::print(std::ostream& out, uint16_t indent)
|
|
{
|
|
printRsItemBase(out, "RsGxsGrpUpdateItem", indent);
|
|
uint16_t int_Indent = indent + 2;
|
|
out << "peerId: " << peerId << std::endl;
|
|
printIndent(out, int_Indent);
|
|
out << "grpUpdateTS: " << grpUpdateTS << std::endl;
|
|
printIndent(out, int_Indent);
|
|
return out ;
|
|
}
|
|
|
|
|
|
|
|
void RsGxsMsgUpdateItem::clear()
|
|
{
|
|
msgUpdateInfos.clear();
|
|
peerId.clear();
|
|
}
|
|
|
|
std::ostream& RsGxsMsgUpdateItem::print(std::ostream& out, uint16_t indent)
|
|
{
|
|
RsPeerId peerId;
|
|
std::map<RsGxsGroupId, uint32_t> msgUpdateTS;
|
|
|
|
printRsItemBase(out, "RsGxsMsgUpdateItem", indent);
|
|
uint16_t int_Indent = indent + 2;
|
|
out << "peerId: " << peerId << std::endl;
|
|
printIndent(out, int_Indent);
|
|
|
|
std::map<RsGxsGroupId, MsgUpdateInfo>::const_iterator cit = msgUpdateInfos.begin();
|
|
out << "msgUpdateTS map:" << std::endl;
|
|
int_Indent += 2;
|
|
for(; cit != msgUpdateInfos.end(); ++cit)
|
|
{
|
|
out << "grpId: " << cit->first << std::endl;
|
|
printIndent(out, int_Indent);
|
|
out << "Msg time stamp: " << cit->second.time_stamp << std::endl;
|
|
printIndent(out, int_Indent);
|
|
out << "posts available: " << cit->second.message_count << std::endl;
|
|
printIndent(out, int_Indent);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
|
|
|
|
void RsGxsServerMsgUpdateItem::clear()
|
|
{
|
|
msgUpdateTS = 0;
|
|
grpId.clear();
|
|
}
|
|
|
|
std::ostream& RsGxsServerMsgUpdateItem::print(std::ostream& out, uint16_t indent)
|
|
{
|
|
printRsItemBase(out, "RsGxsServerMsgUpdateItem", indent);
|
|
uint16_t int_Indent = indent + 2;
|
|
out << "grpId: " << grpId << std::endl;
|
|
printIndent(out, int_Indent);
|
|
out << "msgUpdateTS: " << msgUpdateTS << std::endl;
|
|
printIndent(out, int_Indent);
|
|
return out;
|
|
}
|
|
|
|
|
|
void RsGxsServerGrpUpdateItem::clear()
|
|
{
|
|
grpUpdateTS = 0;
|
|
}
|
|
|
|
std::ostream& RsGxsServerGrpUpdateItem::print(std::ostream& out, uint16_t indent)
|
|
{
|
|
printRsItemBase(out, "RsGxsServerGrpUpdateItem", indent);
|
|
uint16_t int_Indent = indent + 2;
|
|
out << "grpUpdateTS: " << grpUpdateTS << std::endl;
|
|
printIndent(out, int_Indent);
|
|
|
|
return out;
|
|
}
|
|
|
|
|
|
|
|
uint32_t RsGxsUpdateSerialiser::size(RsItem* item)
|
|
{
|
|
RsGxsMsgUpdateItem* mui = NULL;
|
|
RsGxsGrpUpdateItem* gui = NULL;
|
|
RsGxsServerGrpUpdateItem* gsui = NULL;
|
|
RsGxsServerMsgUpdateItem* msui = NULL;
|
|
|
|
if((mui = dynamic_cast<RsGxsMsgUpdateItem*>(item)) != NULL)
|
|
{
|
|
return sizeGxsMsgUpdate(mui);
|
|
}else if(( gui = dynamic_cast<RsGxsGrpUpdateItem*>(item)) != NULL){
|
|
return sizeGxsGrpUpdate(gui);
|
|
}else if((gsui = dynamic_cast<RsGxsServerGrpUpdateItem*>(item)) != NULL)
|
|
{
|
|
return sizeGxsServerGrpUpdate(gsui);
|
|
}else if((msui = dynamic_cast<RsGxsServerMsgUpdateItem*>(item)) != NULL)
|
|
{
|
|
return sizeGxsServerMsgUpdate(msui);
|
|
}else
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::size(): Could not find appropriate size function"
|
|
<< std::endl;
|
|
#endif
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
bool RsGxsUpdateSerialiser::serialise(RsItem* item, void* data,
|
|
uint32_t* size)
|
|
{
|
|
RsGxsMsgUpdateItem* mui;
|
|
RsGxsGrpUpdateItem* gui;
|
|
RsGxsServerGrpUpdateItem* gsui;
|
|
RsGxsServerMsgUpdateItem* msui;
|
|
|
|
if((mui = dynamic_cast<RsGxsMsgUpdateItem*>(item)) != NULL)
|
|
return serialiseGxsMsgUpdate(mui, data, size);
|
|
else if((gui = dynamic_cast<RsGxsGrpUpdateItem*>(item)) != NULL)
|
|
return serialiseGxsGrpUpdate(gui, data, size);
|
|
else if((msui = dynamic_cast<RsGxsServerMsgUpdateItem*>(item)) != NULL)
|
|
return serialiseGxsServerMsgUpdate(msui, data, size);
|
|
else if((gsui = dynamic_cast<RsGxsServerGrpUpdateItem*>(item)) != NULL)
|
|
return serialiseGxsServerGrpUpdate(gsui, data, size);
|
|
else
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialise() item does not caste to known type"
|
|
<< std::endl;
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
RsItem* RsGxsUpdateSerialiser::deserialise(void* data, uint32_t* size)
|
|
{
|
|
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialise()" << std::endl;
|
|
#endif
|
|
/* get the type and size */
|
|
uint32_t rstype = getRsItemId(data);
|
|
|
|
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
|
(SERVICE_TYPE != getRsItemService(rstype)))
|
|
{
|
|
return NULL; /* wrong type */
|
|
}
|
|
|
|
switch(getRsItemSubType(rstype))
|
|
{
|
|
|
|
case RS_PKT_SUBTYPE_GXS_MSG_UPDATE:
|
|
return deserialGxsMsgUpdate(data, size);
|
|
case RS_PKT_SUBTYPE_GXS_GRP_UPDATE:
|
|
return deserialGxsGrpUpddate(data, size);
|
|
case RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE:
|
|
return deserialGxsServerGrpUpddate(data, size);
|
|
case RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE:
|
|
return deserialGxsServerMsgUpdate(data, size);
|
|
default:
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialise() : data has no type"
|
|
<< std::endl;
|
|
#endif
|
|
return NULL;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t RsGxsUpdateSerialiser::sizeGxsGrpUpdate(RsGxsGrpUpdateItem* item)
|
|
{
|
|
uint32_t s = 8; // header size
|
|
s += item->peerId.serial_size();
|
|
s += 4; // mUpdateTS
|
|
return s;
|
|
}
|
|
|
|
uint32_t RsGxsUpdateSerialiser::sizeGxsServerGrpUpdate(RsGxsServerGrpUpdateItem* /* item */)
|
|
{
|
|
uint32_t s = 8; // header size
|
|
s += 4; // time stamp
|
|
return s;
|
|
}
|
|
|
|
bool RsGxsUpdateSerialiser::serialiseGxsGrpUpdate(RsGxsGrpUpdateItem* item,
|
|
void* data, uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsGrpUpdate()" << std::endl;
|
|
#endif
|
|
|
|
uint32_t tlvsize = sizeGxsGrpUpdate(item);
|
|
uint32_t offset = 0;
|
|
|
|
if(*size < tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsGrpUpdate() size do not match" << std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
*size = tlvsize;
|
|
|
|
bool ok = true;
|
|
|
|
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
/* RsGxsGrpUpdateItem */
|
|
|
|
|
|
ok &= item->peerId.serialise(data, *size, offset) ;
|
|
ok &= setRawUInt32(data, *size, &offset, item->grpUpdateTS);
|
|
|
|
if(offset != tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsGrpUpdate() FAIL Size Error! " << std::endl;
|
|
#endif
|
|
ok = false;
|
|
}
|
|
|
|
#ifdef RSSERIAL_DEBUG
|
|
if (!ok)
|
|
{
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsGrpUpdate() NOK" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate(RsGxsServerGrpUpdateItem* item,
|
|
void* data, uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate()" << std::endl;
|
|
#endif
|
|
|
|
uint32_t tlvsize = sizeGxsServerGrpUpdate(item);
|
|
uint32_t offset = 0;
|
|
|
|
if(*size < tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate() size do not match" << std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
*size = tlvsize;
|
|
|
|
bool ok = true;
|
|
|
|
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
/* RsGxsServerGrpUpdateItem */
|
|
|
|
ok &= setRawUInt32(data, *size, &offset, item->grpUpdateTS);
|
|
|
|
if(offset != tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate() FAIL Size Error! " << std::endl;
|
|
#endif
|
|
ok = false;
|
|
}
|
|
|
|
#ifdef RSSERIAL_DEBUG
|
|
if (!ok)
|
|
{
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate() NOK" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
return ok;
|
|
}
|
|
RsGxsGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsGrpUpddate(void* data, uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate()" << std::endl;
|
|
#endif
|
|
/* get the type and size */
|
|
uint32_t rstype = getRsItemId(data);
|
|
uint32_t rssize = getRsItemSize(data);
|
|
|
|
uint32_t offset = 0;
|
|
|
|
|
|
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
|
(SERVICE_TYPE != getRsItemService(rstype)) ||
|
|
(RS_PKT_SUBTYPE_GXS_GRP_UPDATE != getRsItemSubType(rstype)))
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong type" << std::endl;
|
|
#endif
|
|
return NULL; /* wrong type */
|
|
}
|
|
|
|
if (*size < rssize) /* check size */
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong size" << std::endl;
|
|
#endif
|
|
return NULL; /* not enough data */
|
|
}
|
|
|
|
/* set the packet length */
|
|
*size = rssize;
|
|
|
|
bool ok = true;
|
|
|
|
RsGxsGrpUpdateItem* item = new RsGxsGrpUpdateItem(getRsItemService(rstype));
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
ok &= item->peerId.deserialise(data, *size, offset) ;
|
|
ok &= getRawUInt32(data, *size, &offset, &(item->grpUpdateTS));
|
|
|
|
if (offset != rssize)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxxGrpUpdate() FAIL size mismatch" << std::endl;
|
|
#endif
|
|
/* error */
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() NOK" << std::endl;
|
|
#endif
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
RsGxsServerGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerGrpUpddate(void* data,
|
|
uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate()" << std::endl;
|
|
#endif
|
|
/* get the type and size */
|
|
uint32_t rstype = getRsItemId(data);
|
|
uint32_t rssize = getRsItemSize(data);
|
|
|
|
uint32_t offset = 0;
|
|
|
|
|
|
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
|
(SERVICE_TYPE != getRsItemService(rstype)) ||
|
|
(RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE != getRsItemSubType(rstype)))
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL wrong type" << std::endl;
|
|
#endif
|
|
return NULL; /* wrong type */
|
|
}
|
|
|
|
if (*size < rssize) /* check size */
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL wrong size" << std::endl;
|
|
#endif
|
|
return NULL; /* not enough data */
|
|
}
|
|
|
|
/* set the packet length */
|
|
*size = rssize;
|
|
|
|
bool ok = true;
|
|
|
|
RsGxsServerGrpUpdateItem* item = new RsGxsServerGrpUpdateItem(getRsItemService(rstype));
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
ok &= getRawUInt32(data, *size, &offset, &(item->grpUpdateTS));
|
|
|
|
if (offset != rssize)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL size mismatch" << std::endl;
|
|
#endif
|
|
/* error */
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() NOK" << std::endl;
|
|
#endif
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
uint32_t RsGxsUpdateSerialiser::sizeGxsMsgUpdate(RsGxsMsgUpdateItem* item)
|
|
{
|
|
uint32_t s = 8; // header size
|
|
s += item->peerId.serial_size() ;//GetTlvStringSize(item->peerId);
|
|
|
|
s += item->msgUpdateInfos.size() * (4 + 4 + RsGxsGroupId::serial_size());
|
|
s += 4; // number of map items
|
|
|
|
return s;
|
|
}
|
|
|
|
uint32_t RsGxsUpdateSerialiser::sizeGxsServerMsgUpdate(RsGxsServerMsgUpdateItem* item)
|
|
{
|
|
uint32_t s = 8; // header size
|
|
s += item->grpId.serial_size();
|
|
s += 4; // grp TS
|
|
|
|
return s;
|
|
}
|
|
|
|
bool RsGxsUpdateSerialiser::serialiseGxsMsgUpdate(RsGxsMsgUpdateItem* item,
|
|
void* data, uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsMsgUpdate()" << std::endl;
|
|
#endif
|
|
|
|
uint32_t tlvsize = sizeGxsMsgUpdate(item);
|
|
uint32_t offset = 0;
|
|
|
|
if(*size < tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsMsgUpdate() size do not match" << std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
*size = tlvsize;
|
|
|
|
bool ok = true;
|
|
|
|
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
/* RsGxsMsgUpdateItem */
|
|
|
|
|
|
ok &= item->peerId.serialise(data, *size, offset) ;
|
|
|
|
std::map<RsGxsGroupId, RsGxsMsgUpdateItem::MsgUpdateInfo>::const_iterator cit(item->msgUpdateInfos.begin());
|
|
|
|
uint32_t numItems = item->msgUpdateInfos.size();
|
|
ok &= setRawUInt32(data, *size, &offset, numItems);
|
|
|
|
for(; cit != item->msgUpdateInfos.end(); ++cit)
|
|
{
|
|
ok &= cit->first.serialise(data, *size, offset);
|
|
ok &= setRawUInt32(data, *size, &offset, cit->second.time_stamp);
|
|
ok &= setRawUInt32(data, *size, &offset, cit->second.message_count);
|
|
}
|
|
|
|
if(offset != tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsMsgUpdate() FAIL Size Error! " << std::endl;
|
|
#endif
|
|
ok = false;
|
|
}
|
|
|
|
#ifdef RSSERIAL_DEBUG
|
|
if (!ok)
|
|
{
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsMsgUpdate() NOK" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate(RsGxsServerMsgUpdateItem* item,
|
|
void* data, uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate()" << std::endl;
|
|
#endif
|
|
|
|
uint32_t tlvsize = sizeGxsServerMsgUpdate(item);
|
|
uint32_t offset = 0;
|
|
|
|
if(*size < tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate() size do not match" << std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
*size = tlvsize;
|
|
|
|
bool ok = true;
|
|
|
|
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
/* RsNxsSyncm */
|
|
|
|
|
|
ok &= item->grpId.serialise(data, *size, offset) ;
|
|
ok &= setRawUInt32(data, *size, &offset, item->msgUpdateTS);
|
|
|
|
if(offset != tlvsize){
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate() FAIL Size Error! " << std::endl;
|
|
#endif
|
|
ok = false;
|
|
}
|
|
|
|
#ifdef RSSERIAL_DEBUG
|
|
if (!ok)
|
|
{
|
|
std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate() NOK" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
return ok;
|
|
}
|
|
|
|
RsGxsMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsMsgUpdate(void* data,
|
|
uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate()" << std::endl;
|
|
#endif
|
|
/* get the type and size */
|
|
uint32_t rstype = getRsItemId(data);
|
|
uint32_t rssize = getRsItemSize(data);
|
|
|
|
uint32_t offset = 0;
|
|
|
|
|
|
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
|
(SERVICE_TYPE != getRsItemService(rstype)) ||
|
|
(RS_PKT_SUBTYPE_GXS_MSG_UPDATE != getRsItemSubType(rstype)))
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL wrong type" << std::endl;
|
|
#endif
|
|
return NULL; /* wrong type */
|
|
}
|
|
|
|
if (*size < rssize) /* check size */
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL wrong size" << std::endl;
|
|
#endif
|
|
return NULL; /* not enough data */
|
|
}
|
|
|
|
/* set the packet length */
|
|
*size = rssize;
|
|
|
|
bool ok = true;
|
|
|
|
RsGxsMsgUpdateItem* item = new RsGxsMsgUpdateItem(getRsItemService(rstype));
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
ok &= item->peerId.deserialise(data, *size, offset) ;
|
|
uint32_t numUpdateItems;
|
|
ok &= getRawUInt32(data, *size, &offset, &(numUpdateItems));
|
|
std::map<RsGxsGroupId, RsGxsMsgUpdateItem::MsgUpdateInfo>& msgUpdateInfos = item->msgUpdateInfos;
|
|
RsGxsGroupId pId;
|
|
|
|
RsGxsMsgUpdateItem::MsgUpdateInfo info ;
|
|
|
|
for(uint32_t i = 0; i < numUpdateItems; i++)
|
|
{
|
|
ok &= pId.deserialise(data, *size, offset);
|
|
|
|
if(!ok)
|
|
break;
|
|
|
|
ok &= getRawUInt32(data, *size, &offset, &(info.time_stamp));
|
|
ok &= getRawUInt32(data, *size, &offset, &(info.message_count));
|
|
|
|
if(!ok)
|
|
break;
|
|
|
|
msgUpdateInfos.insert(std::make_pair(pId, info));
|
|
}
|
|
|
|
if (offset != rssize)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL size mismatch" << std::endl;
|
|
#endif
|
|
/* error */
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() NOK" << std::endl;
|
|
#endif
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
RsGxsServerMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate(void* data,
|
|
uint32_t* size)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate()" << std::endl;
|
|
#endif
|
|
/* get the type and size */
|
|
uint32_t rstype = getRsItemId(data);
|
|
uint32_t rssize = getRsItemSize(data);
|
|
|
|
uint32_t offset = 0;
|
|
|
|
|
|
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
|
(SERVICE_TYPE != getRsItemService(rstype)) ||
|
|
(RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE != getRsItemSubType(rstype)))
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL wrong type" << std::endl;
|
|
#endif
|
|
return NULL; /* wrong type */
|
|
}
|
|
|
|
if (*size < rssize) /* check size */
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL wrong size" << std::endl;
|
|
#endif
|
|
return NULL; /* not enough data */
|
|
}
|
|
|
|
/* set the packet length */
|
|
*size = rssize;
|
|
|
|
bool ok = true;
|
|
|
|
RsGxsServerMsgUpdateItem* item = new RsGxsServerMsgUpdateItem(getRsItemService(rstype));
|
|
|
|
/* skip the header */
|
|
offset += 8;
|
|
|
|
ok &= item->grpId.deserialise(data, *size, offset) ;
|
|
ok &= getRawUInt32(data, *size, &offset, &(item->msgUpdateTS));
|
|
|
|
if (offset != rssize)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL size mismatch" << std::endl;
|
|
#endif
|
|
/* error */
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
#ifdef RSSERIAL_DEBUG
|
|
std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() NOK" << std::endl;
|
|
#endif
|
|
delete item;
|
|
return NULL;
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|