mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-06-28 08:07:31 -04:00
Removing old services, serialisers and other references for:
- forums - channels - tunnel - blog - gamelauncher. - distrib. Note this majorly breaks the GUI, for the moment. git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-initdev@6683 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob
parent
212b4c44c9
commit
a6cf738371
47 changed files with 15 additions and 14890 deletions
|
|
@ -1,255 +0,0 @@
|
|||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsblogitems.cc
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2010 by Cyril, Chris 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 "serialiser/rsblogitems.h"
|
||||
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
|
||||
#define RSSERIAL_DEBUG 1
|
||||
#include <iostream>
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsBlogMsg::clear()
|
||||
{
|
||||
RsDistribMsg::clear();
|
||||
|
||||
subject.clear();
|
||||
message.clear();
|
||||
|
||||
std::list<RsTlvImage >::iterator it = graphic_set.begin();
|
||||
|
||||
for(; it != graphic_set.end(); it++)
|
||||
{
|
||||
it->TlvClear();
|
||||
}
|
||||
|
||||
graphic_set.clear();
|
||||
}
|
||||
|
||||
std::ostream &RsBlogMsg::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsBlogMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribMsg::print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_subject(subject.begin(), subject.end());
|
||||
out << "subject: " << cnv_subject << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_message(message.begin(), message.end());
|
||||
out << "message: " << cnv_message << std::endl;
|
||||
|
||||
std::list<RsTlvImage >::iterator it = graphic_set.begin();
|
||||
|
||||
for(; it != graphic_set.end(); it++)
|
||||
{
|
||||
it->print(out, int_Indent);
|
||||
}
|
||||
|
||||
|
||||
printRsItemEnd(out, "RsBlogMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsBlogSerialiser::sizeMsg(RsBlogMsg *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribMsg stuff */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->parentId);
|
||||
s += GetTlvStringSize(item->threadId);
|
||||
s += 4; /* timestamp */
|
||||
|
||||
/* RsBlogMsg stuff */
|
||||
s += GetTlvWideStringSize(item->subject);
|
||||
s += GetTlvWideStringSize(item->message);
|
||||
|
||||
std::list<RsTlvImage >::iterator it = item->graphic_set.begin();
|
||||
|
||||
for(; it != item->graphic_set.end(); it++)
|
||||
{
|
||||
s += it->TlvSize();
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsBlogSerialiser::serialiseMsg(RsBlogMsg *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeMsg(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() Header: " << ok << std::endl;
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() Size: " << tlvsize << std::endl;
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() grpId: " << ok << std::endl;
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PARENTID, item->parentId);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() parentId: " << ok << std::endl;
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_THREADID, item->threadId);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() threadpId: " << ok << std::endl;
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->timestamp);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() timestamp: " << ok << std::endl;
|
||||
|
||||
/* RsBlogMsg */
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_SUBJECT, item->subject);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() subject: " << ok << std::endl;
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, item->message);
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() msg: " << ok << std::endl;
|
||||
|
||||
std::list<RsTlvImage >::iterator it = item->graphic_set.begin();
|
||||
|
||||
for(; it != item->graphic_set.end(); it++)
|
||||
{
|
||||
ok &= it->SetTlv(data, tlvsize, &offset);
|
||||
}
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsBlogSerialiser::serialiseMsg() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
RsBlogMsg *RsBlogSerialiser::deserialiseMsg(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) ||
|
||||
(RS_SERVICE_TYPE_QBLOG != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_BLOG_MSG != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsBlogMsg *item = new RsBlogMsg();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PARENTID, item->parentId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_THREADID, item->threadId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->timestamp));
|
||||
|
||||
/* RsBlogMsg */
|
||||
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_SUBJECT, item->subject);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->message);
|
||||
|
||||
RsTlvImage image;
|
||||
image.TlvClear();
|
||||
|
||||
while(offset != rssize)
|
||||
{
|
||||
image.GetTlv(data, rssize, &offset);
|
||||
item->graphic_set.push_back(image);
|
||||
image.TlvClear();
|
||||
}
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
uint32_t RsBlogSerialiser::size(RsItem *item)
|
||||
{
|
||||
return sizeMsg((RsBlogMsg *) item);
|
||||
}
|
||||
|
||||
bool RsBlogSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
return serialiseMsg((RsBlogMsg *) item, data, pktsize);
|
||||
}
|
||||
|
||||
RsItem *RsBlogSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
{
|
||||
return deserialiseMsg(data, pktsize);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
#ifndef RS_BLOG_ITEMS_H
|
||||
#define RS_BLOG_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsblogitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Cyril, Chris 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 <map>
|
||||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
#include "serialiser/rsdistribitems.h"
|
||||
|
||||
const uint8_t RS_PKT_SUBTYPE_BLOG_MSG = 0x01;
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
class RsBlogMsg: public RsDistribMsg
|
||||
{
|
||||
public:
|
||||
RsBlogMsg()
|
||||
:RsDistribMsg(RS_SERVICE_TYPE_QBLOG, RS_PKT_SUBTYPE_BLOG_MSG) { return; }
|
||||
virtual ~RsBlogMsg() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
/*
|
||||
* RsDistribMsg has:
|
||||
* grpId, timestamp.
|
||||
* Not Used: parentId, threadId
|
||||
*/
|
||||
std::wstring subject;
|
||||
std::wstring message;
|
||||
|
||||
/// for adding images to graphics
|
||||
std::list<RsTlvImage > graphic_set;
|
||||
|
||||
};
|
||||
|
||||
class RsBlogSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
RsBlogSerialiser()
|
||||
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_QBLOG)
|
||||
{ return; }
|
||||
virtual ~RsBlogSerialiser()
|
||||
{ return; }
|
||||
|
||||
virtual uint32_t size(RsItem *);
|
||||
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
|
||||
virtual RsItem * deserialise(void *data, uint32_t *size);
|
||||
|
||||
private:
|
||||
|
||||
/* For RS_PKT_SUBTYPE_CHANNEL_MSG */
|
||||
virtual uint32_t sizeMsg(RsBlogMsg *);
|
||||
virtual bool serialiseMsg(RsBlogMsg *item, void *data, uint32_t *size);
|
||||
virtual RsBlogMsg *deserialiseMsg(void *data, uint32_t *size);
|
||||
|
||||
};
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#endif /* RS_BLOG_ITEMS_H */
|
||||
|
||||
|
||||
|
|
@ -1,627 +0,0 @@
|
|||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rschannelitems.cc
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2008 by Robert Fernie.
|
||||
*
|
||||
* 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 "serialiser/rschannelitems.h"
|
||||
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
|
||||
//#define RSSERIAL_DEBUG 0
|
||||
#include <iostream>
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsChannelMsg::clear()
|
||||
{
|
||||
RsDistribMsg::clear();
|
||||
|
||||
subject.clear();
|
||||
message.clear();
|
||||
|
||||
attachment.TlvClear();
|
||||
thumbnail.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream &RsChannelMsg::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsChannelMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribMsg::print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_subject(subject.begin(), subject.end());
|
||||
out << "subject: " << cnv_subject << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_message(message.begin(), message.end());
|
||||
out << "message: " << cnv_message << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "Attachment: " << std::endl;
|
||||
attachment.print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "Thumbnail: " << std::endl;
|
||||
thumbnail.print(out, int_Indent);
|
||||
|
||||
printRsItemEnd(out, "RsChannelMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsChannelReadStatus::clear()
|
||||
{
|
||||
|
||||
RsDistribChildConfig::clear();
|
||||
|
||||
channelId.clear();
|
||||
msgReadStatus.clear();
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
std::ostream& RsChannelDestDirConfigItem::print(std::ostream &out, uint16_t indent = 0)
|
||||
{
|
||||
|
||||
printRsItemBase(out, "RsChannelDestDirConfigItem", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribChildConfig::print(out, int_Indent);
|
||||
|
||||
for(uint32_t i=0;i<dest_dirs.size();++i)
|
||||
{
|
||||
printIndent(out, int_Indent); out << "channel id : " << dest_dirs[i].first ;
|
||||
out << ". Dir = " << dest_dirs[i].second << std::endl;
|
||||
}
|
||||
|
||||
printRsItemEnd(out, "RsChannelDestDirConfigItem", indent);
|
||||
return out;
|
||||
}
|
||||
std::ostream& RsChannelReadStatus::print(std::ostream &out, uint16_t indent = 0)
|
||||
{
|
||||
|
||||
printRsItemBase(out, "RsChannelMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribChildConfig::print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "ChannelId: " << channelId << std::endl;
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = msgReadStatus.begin();
|
||||
|
||||
for(; mit != msgReadStatus.end(); mit++)
|
||||
{
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "msgId : " << mit->first << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << " status : " << mit->second << std::endl;
|
||||
|
||||
}
|
||||
|
||||
printRsItemEnd(out, "RsChannelMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsChannelSerialiser::sizeMsg(RsChannelMsg *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribMsg stuff */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += 4; /* timestamp */
|
||||
|
||||
/* RsChannelMsg stuff */
|
||||
s += GetTlvWideStringSize(item->subject);
|
||||
s += GetTlvWideStringSize(item->message);
|
||||
s += item->attachment.TlvSize();
|
||||
s += item->thumbnail.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsChannelSerialiser::serialiseMsg(RsChannelMsg *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeMsg(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Header: " << ok << std::endl;
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() grpId: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->timestamp);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() timestamp: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
/* RsChannelMsg */
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_SUBJECT, item->subject);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Title: " << ok << std::endl;
|
||||
#endif
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, item->message);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Msg: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= item->attachment.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Attachment: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= item->thumbnail.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() thumbnail: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsChannelSerialiser::serialiseMsg() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
RsChannelMsg *RsChannelSerialiser::deserialiseMsg(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) ||
|
||||
(RS_SERVICE_TYPE_CHANNEL != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_CHANNEL_MSG != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsChannelMsg *item = new RsChannelMsg();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->timestamp));
|
||||
|
||||
/* RsChannelMsg */
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_SUBJECT, item->subject);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->message);
|
||||
ok &= item->attachment.GetTlv(data, rssize, &offset);
|
||||
ok &= item->thumbnail.GetTlv(data, rssize, &offset);
|
||||
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
uint32_t RsChannelSerialiser::sizeDestDirConfig(RsChannelDestDirConfigItem *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribChildConfig stuff */
|
||||
|
||||
s += 4; /* save_type */
|
||||
|
||||
/* RsChannelReadStatus stuff */
|
||||
|
||||
s += 4; /* size */
|
||||
|
||||
for(uint32_t i=0;i<item->dest_dirs.size();++i)
|
||||
{
|
||||
s += GetTlvStringSize(item->dest_dirs[i].first) ;
|
||||
s += GetTlvStringSize(item->dest_dirs[i].second) ;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
uint32_t RsChannelSerialiser::sizeReadStatus(RsChannelReadStatus *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribChildConfig stuff */
|
||||
|
||||
s += 4; /* save_type */
|
||||
|
||||
/* RsChannelReadStatus stuff */
|
||||
|
||||
s += GetTlvStringSize(item->channelId);
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = item->msgReadStatus.begin();
|
||||
|
||||
for(; mit != item->msgReadStatus.end(); mit++)
|
||||
{
|
||||
s += GetTlvStringSize(mit->first); /* key */
|
||||
s += 4; /* value */
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsChannelSerialiser::serialiseDestDirConfig(RsChannelDestDirConfigItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeDestDirConfig(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseDestDirConfig() Header: " << ok << std::endl;
|
||||
std::cerr << "RsChannelSerialiser::serialiseDestDirConfig() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->save_type);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseDestDirConfig() save_type: " << ok << std::endl;
|
||||
#endif
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->dest_dirs.size()); /* value */
|
||||
|
||||
for(uint32_t i=0;i<item->dest_dirs.size();++i)
|
||||
{
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->dest_dirs[i].first) ;
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PATH, item->dest_dirs[i].second) ;
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseDestDirConfig() msgReadStatus: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsChannelSerialiser::serialiseDestDirConfig() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
/* serialise the data to the buffer */
|
||||
bool RsChannelSerialiser::serialiseReadStatus(RsChannelReadStatus *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeReadStatus(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() Header: " << ok << std::endl;
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->save_type);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() save_type: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* RsChannelMsg */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->channelId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() channelId: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = item->msgReadStatus.begin();
|
||||
|
||||
for(; mit != item->msgReadStatus.end(); mit++)
|
||||
{
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, mit->first); /* key */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, mit->second); /* value */
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() msgReadStatus: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsChannelSerialiser::serialiseReadStatus() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
RsChannelDestDirConfigItem *RsChannelSerialiser::deserialiseDestDirConfig(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) || (RS_SERVICE_TYPE_CHANNEL != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_CHANNEL_DEST_DIR != getRsItemSubType(rstype)))
|
||||
return NULL; /* wrong type */
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsChannelDestDirConfigItem *item = new RsChannelDestDirConfigItem();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->save_type));
|
||||
|
||||
uint32_t size ;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &size) ;
|
||||
|
||||
for(uint32_t i=0;i<size;++i)
|
||||
{
|
||||
std::string chid, path ;
|
||||
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, chid) ;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PATH , path) ;
|
||||
|
||||
item->dest_dirs.push_back(std::pair<std::string,std::string>(chid,path)) ;
|
||||
}
|
||||
|
||||
if(offset != rssize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsChannelSerialiser::deserialiseDestDirConfig() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
RsChannelReadStatus *RsChannelSerialiser::deserialiseReadStatus(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) ||
|
||||
(RS_SERVICE_TYPE_CHANNEL != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_CHANNEL_READ_STATUS != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsChannelReadStatus *item = new RsChannelReadStatus();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->save_type));
|
||||
|
||||
/* RschannelMsg */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->channelId);
|
||||
|
||||
std::string key;
|
||||
uint32_t value;
|
||||
|
||||
while(offset != rssize)
|
||||
{
|
||||
key.clear();
|
||||
value = 0;
|
||||
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSGID, key); /* key */
|
||||
|
||||
/* incomplete key value pair? then fail*/
|
||||
if(offset == rssize)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ok &= getRawUInt32(data, rssize, &offset, &value); /* value */
|
||||
|
||||
item->msgReadStatus.insert(std::pair<std::string, uint32_t>(key, value));
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
/************************************************************/
|
||||
|
||||
uint32_t RsChannelSerialiser::size(RsItem *item)
|
||||
{
|
||||
RsChannelMsg* dcm;
|
||||
RsChannelReadStatus* drs;
|
||||
RsChannelDestDirConfigItem* dd;
|
||||
|
||||
if( NULL != ( dcm = dynamic_cast<RsChannelMsg*>(item)))
|
||||
{
|
||||
return sizeMsg(dcm);
|
||||
}
|
||||
else if(NULL != (drs = dynamic_cast<RsChannelReadStatus* >(item)))
|
||||
{
|
||||
return sizeReadStatus(drs);
|
||||
}
|
||||
else if(NULL != (dd = dynamic_cast<RsChannelDestDirConfigItem* >(item)))
|
||||
{
|
||||
return sizeDestDirConfig(dd);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RsChannelSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
RsChannelMsg* dcm;
|
||||
RsChannelReadStatus* drs;
|
||||
RsChannelDestDirConfigItem* dd;
|
||||
|
||||
if( NULL != ( dcm = dynamic_cast<RsChannelMsg*>(item)))
|
||||
{
|
||||
return serialiseMsg(dcm, data, pktsize);
|
||||
}
|
||||
else if(NULL != (drs = dynamic_cast<RsChannelReadStatus* >(item)))
|
||||
{
|
||||
return serialiseReadStatus(drs, data, pktsize);
|
||||
}
|
||||
else if(NULL != (dd = dynamic_cast<RsChannelDestDirConfigItem* >(item)))
|
||||
{
|
||||
return serialiseDestDirConfig(dd, data, pktsize);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
RsItem *RsChannelSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
{
|
||||
if(data == NULL)
|
||||
return NULL ;
|
||||
|
||||
/* get the type and size */
|
||||
uint32_t rstype = getRsItemId(data);
|
||||
|
||||
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
||||
(RS_SERVICE_TYPE_CHANNEL != getRsItemService(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
switch(getRsItemSubType(rstype))
|
||||
{
|
||||
case RS_PKT_SUBTYPE_CHANNEL_MSG:
|
||||
return deserialiseMsg(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_CHANNEL_READ_STATUS:
|
||||
return deserialiseReadStatus(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_CHANNEL_DEST_DIR:
|
||||
return deserialiseDestDirConfig(data, pktsize);
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
|
|
@ -1,141 +0,0 @@
|
|||
#ifndef RS_CHANNEL_ITEMS_H
|
||||
#define RS_CHANNEL_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rschannelitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 <map>
|
||||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
#include "serialiser/rsdistribitems.h"
|
||||
|
||||
const uint8_t RS_PKT_SUBTYPE_CHANNEL_MSG = 0x01;
|
||||
const uint8_t RS_PKT_SUBTYPE_CHANNEL_READ_STATUS = 0x02;
|
||||
const uint8_t RS_PKT_SUBTYPE_CHANNEL_DEST_DIR = 0x03;
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
class RsChannelMsg: public RsDistribMsg
|
||||
{
|
||||
public:
|
||||
RsChannelMsg()
|
||||
:RsDistribMsg(RS_SERVICE_TYPE_CHANNEL, RS_PKT_SUBTYPE_CHANNEL_MSG) { return; }
|
||||
virtual ~RsChannelMsg() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
/*
|
||||
* RsDistribMsg has:
|
||||
* grpId, timestamp.
|
||||
* Not Used: parentId, threadId
|
||||
*/
|
||||
|
||||
std::wstring subject;
|
||||
std::wstring message;
|
||||
|
||||
RsTlvFileSet attachment;
|
||||
RsTlvImage thumbnail;
|
||||
|
||||
};
|
||||
|
||||
/*!
|
||||
* This is used to keep track of whether a message has been read
|
||||
* by client
|
||||
*/
|
||||
class RsChannelReadStatus : public RsDistribChildConfig
|
||||
{
|
||||
public:
|
||||
RsChannelReadStatus()
|
||||
: RsDistribChildConfig(RS_SERVICE_TYPE_CHANNEL, RS_PKT_SUBTYPE_CHANNEL_READ_STATUS)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsChannelReadStatus() {return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string channelId;
|
||||
|
||||
/// a map which contains the read for messages within a forum
|
||||
std::map<std::string, uint32_t> msgReadStatus;
|
||||
|
||||
std::string destination_directory ;
|
||||
};
|
||||
/*!
|
||||
* This is used to store the destination directories of each channel
|
||||
*/
|
||||
class RsChannelDestDirConfigItem : public RsDistribChildConfig
|
||||
{
|
||||
public:
|
||||
RsChannelDestDirConfigItem()
|
||||
: RsDistribChildConfig(RS_SERVICE_TYPE_CHANNEL, RS_PKT_SUBTYPE_CHANNEL_DEST_DIR)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsChannelDestDirConfigItem() {}
|
||||
|
||||
virtual void clear() { dest_dirs.clear() ; }
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::vector<std::pair<std::string, std::string> > dest_dirs;
|
||||
};
|
||||
class RsChannelSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
RsChannelSerialiser()
|
||||
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_CHANNEL)
|
||||
{ return; }
|
||||
virtual ~RsChannelSerialiser()
|
||||
{ return; }
|
||||
|
||||
virtual uint32_t size(RsItem *);
|
||||
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
|
||||
virtual RsItem * deserialise(void *data, uint32_t *size);
|
||||
|
||||
private:
|
||||
|
||||
/* For RS_PKT_SUBTYPE_CHANNEL_MSG */
|
||||
virtual uint32_t sizeMsg(RsChannelMsg *);
|
||||
virtual bool serialiseMsg(RsChannelMsg *item, void *data, uint32_t *size);
|
||||
virtual RsChannelMsg *deserialiseMsg(void *data, uint32_t *size);
|
||||
|
||||
virtual uint32_t sizeReadStatus(RsChannelReadStatus* );
|
||||
virtual bool serialiseReadStatus(RsChannelReadStatus* item, void* data, uint32_t *size);
|
||||
virtual RsChannelReadStatus *deserialiseReadStatus(void* data, uint32_t *size);
|
||||
|
||||
virtual uint32_t sizeDestDirConfig(RsChannelDestDirConfigItem* );
|
||||
virtual bool serialiseDestDirConfig(RsChannelDestDirConfigItem* item, void* data, uint32_t *size);
|
||||
virtual RsChannelDestDirConfigItem *deserialiseDestDirConfig(void* data, uint32_t *size);
|
||||
};
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#endif /* RS_CHANNEL_ITEMS_H */
|
||||
|
||||
|
||||
|
|
@ -1,958 +0,0 @@
|
|||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsforumitems.cc
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 "serialiser/rsdistribitems.h"
|
||||
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
|
||||
//#define RSSERIAL_DEBUG 1
|
||||
#include <iostream>
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsDistribMsg::clear()
|
||||
{
|
||||
grpId.clear();
|
||||
parentId.clear();
|
||||
threadId.clear();
|
||||
timestamp = 0;
|
||||
childTS = 0;
|
||||
|
||||
msgId.clear();
|
||||
publishSignature.TlvClear();
|
||||
personalSignature.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream &RsDistribMsg::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpId: " << grpId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "parentId: " << parentId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "threadId: " << threadId << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "timestamp: " << timestamp << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "<<<<<<<< Not Serialised >>>>>>>>" << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "msgId: " << msgId << std::endl;
|
||||
publishSignature.print(out, int_Indent);
|
||||
personalSignature.print(out, int_Indent);
|
||||
|
||||
out << "<<<<<<<< Not Serialised >>>>>>>>" << std::endl;
|
||||
|
||||
printRsItemEnd(out, "RsDistribMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsDistribChildConfig::clear()
|
||||
{
|
||||
save_type = 0;
|
||||
}
|
||||
|
||||
std::ostream& RsDistribChildConfig::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribChildConfig", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "save_type: " << save_type << std::endl;
|
||||
|
||||
printRsItemEnd(out, "RsDistribChildConfig", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsDistribConfigData::clear()
|
||||
{
|
||||
service_data.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream& RsDistribConfigData::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribConfigData", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
service_data.print(out, int_Indent);
|
||||
|
||||
printRsItemEnd(out, "RsDistribChildConfig", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsDistribSignedMsg::clear()
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSignedMsg::clear()" << std::endl;
|
||||
#endif
|
||||
|
||||
grpId.clear();
|
||||
msgId.clear();
|
||||
flags = 0;
|
||||
timestamp = 0;
|
||||
packet.TlvClear();
|
||||
publishSignature.TlvClear();
|
||||
personalSignature.TlvClear();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
std::ostream &RsDistribSignedMsg::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribSignedMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpId: " << grpId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "msgId: " << msgId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "flags: " << flags << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "timestamp: " << timestamp << std::endl;
|
||||
packet.print(out, 10);
|
||||
publishSignature.print(out, 10);
|
||||
personalSignature.print(out, 10);
|
||||
|
||||
printRsItemEnd(out, "RsDistribSignedMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsDistribGrp::clear()
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribGrp::clear()" << std::endl;
|
||||
#endif
|
||||
|
||||
grpId.clear();
|
||||
timestamp = 0;
|
||||
grpFlags = 0;
|
||||
grpName.clear();
|
||||
grpDesc.clear();
|
||||
grpCategory.clear();
|
||||
|
||||
grpControlFlags = 0;
|
||||
grpControlList.TlvClear();
|
||||
|
||||
grpPixmap.TlvClear();
|
||||
|
||||
adminKey.TlvClear();
|
||||
publishKeys.TlvClear();
|
||||
|
||||
adminSignature.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream &RsDistribGrp::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribGrp", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpId: " << grpId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "timestamp: " << timestamp << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpFlags: " << grpFlags << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_name(grpName.begin(), grpName.end());
|
||||
out << "grpName: " << cnv_name << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_desc(grpDesc.begin(), grpDesc.end());
|
||||
out << "grpDesc: " << cnv_desc << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
std::string cnv_category(grpCategory.begin(), grpCategory.end());
|
||||
out << "grpCategory: " << cnv_category << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpControlFlags: " << grpControlFlags << std::endl;
|
||||
|
||||
grpControlList.print(out, int_Indent);
|
||||
|
||||
grpPixmap.print(out, int_Indent);
|
||||
|
||||
adminKey.print(out, int_Indent);
|
||||
publishKeys.print(out, int_Indent);
|
||||
adminSignature.print(out, int_Indent);
|
||||
|
||||
printRsItemEnd(out, "RsDistribGrp", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsDistribGrpKey::clear()
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribGrpKey::clear()" << std::endl;
|
||||
#endif
|
||||
|
||||
grpId.clear();
|
||||
key.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream &RsDistribGrpKey::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsDistribGrpKey", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
printIndent(out, int_Indent);
|
||||
out << "grpId: " << grpId << std::endl;
|
||||
|
||||
key.print(out, int_Indent);
|
||||
|
||||
printRsItemEnd(out, "RsDistribGrpKey", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsDistribSerialiser::sizeGrp(RsDistribGrp *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribMsg stuff */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += 4; /* timestamp */
|
||||
s += 4; /* grpFlags */
|
||||
s += GetTlvWideStringSize(item->grpName);
|
||||
s += GetTlvWideStringSize(item->grpDesc);
|
||||
s += GetTlvWideStringSize(item->grpCategory);
|
||||
|
||||
s += 4; /* grpControlFlags */
|
||||
s += item->grpControlList.TlvSize();
|
||||
|
||||
s += item->grpPixmap.TlvSize();
|
||||
|
||||
s += item->adminKey.TlvSize();
|
||||
s += item->publishKeys.TlvSize();
|
||||
s += item->adminSignature.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsDistribSerialiser::serialiseGrp(RsDistribGrp *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp()" << std::endl;
|
||||
#endif
|
||||
|
||||
uint32_t tlvsize = sizeGrp(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() FAIL no space" << std::endl;
|
||||
#endif
|
||||
|
||||
return false; /* not enough space */
|
||||
}
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->timestamp);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlags);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() Id/Flags NOK" << std::endl;
|
||||
#endif
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_NAME, item->grpName);
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_COMMENT, item->grpDesc);
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_CATEGORY, item->grpCategory);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() Strings NOK" << std::endl;
|
||||
#endif
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->grpControlFlags);
|
||||
ok &= item->grpControlList.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
ok &= item->grpPixmap.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() List/Pix NOK" << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= item->adminKey.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() AdminKey NOK" << std::endl;
|
||||
#endif
|
||||
ok &= item->publishKeys.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() PubKey NOK" << std::endl;
|
||||
#endif
|
||||
ok &= item->adminSignature.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() AdminSign NOK" << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrp() NOK" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
RsDistribGrp *RsDistribSerialiser::deserialiseGrp(void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrp()" << 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_DISTRIB_GRP != getRsItemSubType(rstype)))
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrp() FAIL wrong type" << std::endl;
|
||||
#endif
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrp() FAIL wrong size" << std::endl;
|
||||
#endif
|
||||
return NULL; /* not enough data */
|
||||
}
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsDistribGrp *item = new RsDistribGrp();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->timestamp));
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->grpFlags));
|
||||
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_NAME, item->grpName);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_COMMENT, item->grpDesc);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_CATEGORY, item->grpCategory);
|
||||
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->grpControlFlags));
|
||||
ok &= item->grpControlList.GetTlv(data, rssize, &offset);
|
||||
|
||||
ok &= item->grpPixmap.GetTlv(data, rssize, &offset);
|
||||
|
||||
ok &= item->adminKey.GetTlv(data, rssize, &offset);
|
||||
ok &= item->publishKeys.GetTlv(data, rssize, &offset);
|
||||
ok &= item->adminSignature.GetTlv(data, rssize, &offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrp() FAIL size mismatch" << std::endl;
|
||||
#endif
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrp() NOK" << std::endl;
|
||||
#endif
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsDistribSerialiser::sizeGrpKey(RsDistribGrpKey *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += item->key.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsDistribSerialiser::serialiseGrpKey(RsDistribGrpKey *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey()" << std::endl;
|
||||
#endif
|
||||
/* error */
|
||||
uint32_t tlvsize = sizeGrpKey(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() FAIL no space" << std::endl;
|
||||
#endif
|
||||
return false; /* not enough space */
|
||||
}
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() HEADER FAILED" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() GROUPID FAILED" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
ok &= item->key.SetTlv(data, tlvsize, &offset);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() KEY FAILED" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseGrpKey() NOK" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
RsDistribGrpKey *RsDistribSerialiser::deserialiseGrpKey(void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrpKey()" << 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_DISTRIB_GRP_KEY != getRsItemSubType(rstype)))
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrpKey() FAIL wrong type" << std::endl;
|
||||
#endif
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrpKey() FAIL no space" << std::endl;
|
||||
#endif
|
||||
return NULL; /* not enough data */
|
||||
}
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsDistribGrpKey *item = new RsDistribGrpKey();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->key.GetTlv(data, rssize, &offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrpKey() FAIL size mismatch" << std::endl;
|
||||
#endif
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseGrpKey() FAIL not Okay" << std::endl;
|
||||
#endif
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsDistribSerialiser::sizeSignedMsg(RsDistribSignedMsg *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribSignedMsg stuff */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->msgId);
|
||||
s += 4; /* flags */
|
||||
s += 4; /* timestamp */
|
||||
s += item->packet.TlvSize();
|
||||
s += item->publishSignature.TlvSize();
|
||||
s += item->personalSignature.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsDistribSerialiser::serialiseSignedMsg(RsDistribSignedMsg *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseSignedMsg()" << std::endl;
|
||||
#endif
|
||||
uint32_t tlvsize = sizeSignedMsg(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseSignedMsg() FAIL no space" << std::endl;
|
||||
#endif
|
||||
return false; /* not enough space */
|
||||
}
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribSignedMsg */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->flags);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->timestamp);
|
||||
|
||||
ok &= item->packet.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
ok &= item->publishSignature.SetTlv(data, tlvsize, &offset);
|
||||
ok &= item->personalSignature.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseSignedMsg() FAIL Size Error! " << std::endl;
|
||||
#endif
|
||||
ok = false;
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseSignedMsg() NOK" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
RsDistribSignedMsg *RsDistribSerialiser::deserialiseSignedMsg(void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg()" << 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_DISTRIB_SIGNED_MSG != getRsItemSubType(rstype)))
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() Wrong Type" << std::endl;
|
||||
#endif
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() Wrong Size" << std::endl;
|
||||
#endif
|
||||
return NULL; /* not enough data */
|
||||
}
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsDistribSignedMsg *item = new RsDistribSignedMsg();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->flags));
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->timestamp));
|
||||
|
||||
ok &= item->packet.GetTlv(data, rssize, &offset);
|
||||
|
||||
ok &= item->publishSignature.GetTlv(data, rssize, &offset);
|
||||
ok &= item->personalSignature.GetTlv(data, rssize, &offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() size mismatch" << std::endl;
|
||||
#endif
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() NOK" << std::endl;
|
||||
#endif
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*********************** save data *******************************/
|
||||
|
||||
|
||||
uint32_t RsDistribSerialiser::sizeConfigData(RsDistribConfigData *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
|
||||
/* RsDistribSignedMsg stuff */
|
||||
s += item->service_data.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsDistribSerialiser::serialiseConfigData(RsDistribConfigData *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseConfigData()" << std::endl;
|
||||
#endif
|
||||
uint32_t tlvsize = sizeConfigData(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseConfigData() FAIL no space" << std::endl;
|
||||
#endif
|
||||
return false; /* not enough space */
|
||||
}
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribSignedMsg */
|
||||
ok &= item->service_data.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialiseConfigData() FAIL Size Error! " << std::endl;
|
||||
#endif
|
||||
ok = false;
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "RsDistribSerialiser::serialiseConfigData() NOK" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
RsDistribConfigData *RsDistribSerialiser::deserialiseConfigData(void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseConfigData()" << 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_DISTRIB_CONFIG_DATA != getRsItemSubType(rstype)))
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() Wrong Type" << std::endl;
|
||||
#endif
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() Wrong Size" << std::endl;
|
||||
#endif
|
||||
return NULL; /* not enough data */
|
||||
}
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsDistribConfigData *item = new RsDistribConfigData();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribGrp */
|
||||
ok &= item->service_data.GetTlv(data, rssize, &offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() size mismatch" << std::endl;
|
||||
#endif
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::deserialiseSignedMsg() NOK" << std::endl;
|
||||
#endif
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
uint32_t RsDistribSerialiser::size(RsItem *i)
|
||||
{
|
||||
RsDistribGrp *dg;
|
||||
RsDistribGrpKey *dgk;
|
||||
RsDistribSignedMsg *dsm;
|
||||
RsDistribConfigData *dsd;
|
||||
|
||||
/* in order of frequency */
|
||||
if (NULL != (dsm = dynamic_cast<RsDistribSignedMsg *>(i)))
|
||||
{
|
||||
return sizeSignedMsg(dsm);
|
||||
}
|
||||
else if (NULL != (dg = dynamic_cast<RsDistribGrp *>(i)))
|
||||
{
|
||||
return sizeGrp(dg);
|
||||
}
|
||||
else if (NULL != (dgk = dynamic_cast<RsDistribGrpKey *>(i)))
|
||||
{
|
||||
return sizeGrpKey(dgk);
|
||||
}
|
||||
else if(NULL != (dsd = dynamic_cast<RsDistribConfigData *>(i)))
|
||||
{
|
||||
return sizeConfigData(dsd);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool RsDistribSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::serialise()" << std::endl;
|
||||
#endif
|
||||
RsDistribGrp *dg;
|
||||
RsDistribGrpKey *dgk;
|
||||
RsDistribSignedMsg *dsm;
|
||||
RsDistribConfigData *dsd;
|
||||
|
||||
if (NULL != (dsm = dynamic_cast<RsDistribSignedMsg *>(i)))
|
||||
{
|
||||
return serialiseSignedMsg(dsm, data, pktsize);
|
||||
}
|
||||
else if (NULL != (dg = dynamic_cast<RsDistribGrp *>(i)))
|
||||
{
|
||||
return serialiseGrp(dg, data, pktsize);
|
||||
}
|
||||
else if (NULL != (dgk = dynamic_cast<RsDistribGrpKey *>(i)))
|
||||
{
|
||||
return serialiseGrpKey(dgk, data, pktsize);
|
||||
}
|
||||
else if(NULL != (dsd = dynamic_cast<RsDistribConfigData *>(i)))
|
||||
{
|
||||
return serialiseConfigData(dsd, data, pktsize);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
RsItem *RsDistribSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
{
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsDistribSerialiser::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_DISTRIB_GRP:
|
||||
return deserialiseGrp(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_DISTRIB_GRP_KEY:
|
||||
return deserialiseGrpKey(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_DISTRIB_SIGNED_MSG:
|
||||
return deserialiseSignedMsg(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_DISTRIB_CONFIG_DATA:
|
||||
return deserialiseConfigData(data, pktsize);
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
|
@ -1,260 +0,0 @@
|
|||
#ifndef RS_DISTRIB_ITEMS_H
|
||||
#define RS_DISTRIB_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsdistribitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 <map>
|
||||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
const uint8_t RS_PKT_SUBTYPE_DISTRIB_GRP = 0x01;
|
||||
const uint8_t RS_PKT_SUBTYPE_DISTRIB_GRP_KEY = 0x02;
|
||||
const uint8_t RS_PKT_SUBTYPE_DISTRIB_SIGNED_MSG = 0x03;
|
||||
const uint8_t RS_PKT_SUBTYPE_DISTRIB_CONFIG_DATA = 0x04;
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
/*!
|
||||
* This should be subclassed by p3distrib subclass's to store their data
|
||||
* save data
|
||||
*/
|
||||
class RsDistribChildConfig: public RsItem
|
||||
{
|
||||
public:
|
||||
RsDistribChildConfig(uint16_t servtype, uint8_t subtype)
|
||||
: RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype),save_type(0) {return;}
|
||||
|
||||
virtual ~RsDistribChildConfig() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
/// use this to id the type of data you want to save
|
||||
uint32_t save_type;
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
* This should be used to save the service data such as settings
|
||||
*/
|
||||
class RsDistribConfigData: public RsItem
|
||||
{
|
||||
public:
|
||||
RsDistribConfigData()
|
||||
: RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISTRIB, RS_PKT_SUBTYPE_DISTRIB_CONFIG_DATA), service_data(TLV_TYPE_BIN_SERIALISE)
|
||||
{return;}
|
||||
|
||||
virtual ~RsDistribConfigData() { return; }
|
||||
|
||||
virtual void clear();
|
||||
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
// this is where a derived distrib service saves its data
|
||||
RsTlvBinaryData service_data;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
* This is used by p3Distrib for storing messages
|
||||
* of derived services, attributes are given for writing
|
||||
* personal signatures (confirms user) and publish signatures (to
|
||||
* confirm consistency source)
|
||||
*/
|
||||
class RsDistribMsg: public RsItem
|
||||
{
|
||||
public:
|
||||
RsDistribMsg(uint16_t servtype, uint8_t subtype)
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype) { return; }
|
||||
|
||||
virtual ~RsDistribMsg() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string grpId; /* Grp Id */
|
||||
|
||||
/// Parent Msg Id, msgs above a thread
|
||||
std::string parentId;
|
||||
|
||||
/// Thread Msg Id: useful identifyingfor responses
|
||||
///to a forum msg and replies in general
|
||||
std::string threadId;
|
||||
uint32_t timestamp;
|
||||
|
||||
/* Not Serialised */
|
||||
|
||||
std::string msgId; /* Msg Id */
|
||||
time_t childTS; /* timestamp of most recent child */
|
||||
|
||||
/// used to confirm the message is from a group author, or someone with valid publish key
|
||||
RsTlvKeySignature publishSignature;
|
||||
|
||||
/// used to confirm message is from a particular peer
|
||||
RsTlvKeySignature personalSignature;
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
* This is used as a storage container for messages from a service
|
||||
* via the binary data container (packet)
|
||||
*/
|
||||
class RsDistribSignedMsg: public RsItem
|
||||
{
|
||||
public:
|
||||
RsDistribSignedMsg()
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISTRIB, RS_PKT_SUBTYPE_DISTRIB_SIGNED_MSG),
|
||||
packet(TLV_TYPE_BIN_SERIALISE)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsDistribSignedMsg() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string grpId;
|
||||
|
||||
/// should be taken publishSignature
|
||||
std::string msgId;
|
||||
uint32_t flags;
|
||||
uint32_t timestamp;
|
||||
|
||||
/// in order to tranfer messages from service level to distrib level
|
||||
RsTlvBinaryData packet;
|
||||
RsTlvKeySignature publishSignature;
|
||||
RsTlvKeySignature personalSignature;
|
||||
};
|
||||
|
||||
|
||||
class RsDistribGrp: public RsItem
|
||||
{
|
||||
public:
|
||||
// RsDistribGrp(uint16_t servtype, uint8_t subtype)
|
||||
// :RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype) { return; }
|
||||
|
||||
RsDistribGrp()
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISTRIB, RS_PKT_SUBTYPE_DISTRIB_GRP)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsDistribGrp() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string grpId; /* Grp Id */
|
||||
uint32_t timestamp;
|
||||
uint32_t grpFlags;
|
||||
std::wstring grpName;
|
||||
std::wstring grpDesc;
|
||||
std::wstring grpCategory;
|
||||
|
||||
RsTlvImage grpPixmap;
|
||||
|
||||
uint32_t grpControlFlags;
|
||||
RsTlvPeerIdSet grpControlList;
|
||||
|
||||
RsTlvSecurityKey adminKey;
|
||||
RsTlvSecurityKeySet publishKeys;
|
||||
|
||||
RsTlvKeySignature adminSignature;
|
||||
};
|
||||
|
||||
|
||||
class RsDistribGrpKey: public RsItem
|
||||
{
|
||||
public:
|
||||
|
||||
RsDistribGrpKey(uint16_t service_type)
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, service_type, RS_PKT_SUBTYPE_DISTRIB_GRP_KEY)
|
||||
{ return; }
|
||||
|
||||
RsDistribGrpKey()
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISTRIB, RS_PKT_SUBTYPE_DISTRIB_GRP_KEY)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsDistribGrpKey() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string grpId; /* Grp Id */
|
||||
RsTlvSecurityKey key;
|
||||
};
|
||||
|
||||
|
||||
class RsDistribSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
|
||||
// optional to allow use in p3service/sockets
|
||||
RsDistribSerialiser(uint16_t service_type = RS_SERVICE_TYPE_DISTRIB)
|
||||
: RsSerialType(RS_PKT_VERSION_SERVICE, service_type), SERVICE_TYPE(service_type)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsDistribSerialiser()
|
||||
{ return; }
|
||||
|
||||
virtual uint32_t size(RsItem *);
|
||||
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
|
||||
virtual RsItem * deserialise(void *data, uint32_t *size);
|
||||
|
||||
private:
|
||||
|
||||
/* For RS_PKT_SUBTYPE_DISTRIB_GRP */
|
||||
virtual uint32_t sizeGrp(RsDistribGrp *);
|
||||
virtual bool serialiseGrp (RsDistribGrp *item, void *data, uint32_t *size);
|
||||
virtual RsDistribGrp *deserialiseGrp(void *data, uint32_t *size);
|
||||
|
||||
/* For RS_PKT_SUBTYPE_DISTRIB_GRP_KEY */
|
||||
virtual uint32_t sizeGrpKey(RsDistribGrpKey *);
|
||||
virtual bool serialiseGrpKey (RsDistribGrpKey *item, void *data, uint32_t *size);
|
||||
virtual RsDistribGrpKey *deserialiseGrpKey(void *data, uint32_t *size);
|
||||
|
||||
/* For RS_PKT_SUBTYPE_DISTRIB_SIGNED_MSG */
|
||||
virtual uint32_t sizeSignedMsg(RsDistribSignedMsg *);
|
||||
virtual bool serialiseSignedMsg (RsDistribSignedMsg *item, void *data, uint32_t *size);
|
||||
virtual RsDistribSignedMsg *deserialiseSignedMsg(void *data, uint32_t *size);
|
||||
|
||||
/* For RS_PKT_SUBTYPE_DISTRIB_SAVE_DATA */
|
||||
virtual uint32_t sizeConfigData(RsDistribConfigData *);
|
||||
virtual bool serialiseConfigData(RsDistribConfigData *item, void *data, uint32_t *size);
|
||||
virtual RsDistribConfigData *deserialiseConfigData(void* data, uint32_t *size);
|
||||
|
||||
|
||||
const uint16_t SERVICE_TYPE;
|
||||
|
||||
};
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#endif /* RS_FORUM_ITEMS_H */
|
||||
|
||||
|
||||
|
|
@ -1,493 +0,0 @@
|
|||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsforumitems.cc
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 "serialiser/rsforumitems.h"
|
||||
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
|
||||
// #define RSSERIAL_DEBUG 1
|
||||
#include <iostream>
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
void RsForumMsg::clear()
|
||||
{
|
||||
RsDistribMsg::clear();
|
||||
|
||||
srcId.clear();
|
||||
title.clear();
|
||||
msg.clear();
|
||||
}
|
||||
|
||||
std::ostream &RsForumMsg::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsForumMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribMsg::print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "srcId: " << srcId << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_title(title.begin(), title.end());
|
||||
out << "title: " << cnv_title << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
|
||||
std::string cnv_msg(msg.begin(), msg.end());
|
||||
out << "msg: " << cnv_msg << std::endl;
|
||||
|
||||
printRsItemEnd(out, "RsForumMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsForumReadStatus::clear()
|
||||
{
|
||||
|
||||
RsDistribChildConfig::clear();
|
||||
|
||||
forumId.clear();
|
||||
msgReadStatus.clear();
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
std::ostream& RsForumReadStatus::print(std::ostream &out, uint16_t indent = 0)
|
||||
{
|
||||
|
||||
printRsItemBase(out, "RsForumMsg", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
RsDistribChildConfig::print(out, int_Indent);
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "ForumId: " << forumId << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "ForumId: " << forumId << std::endl;
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = msgReadStatus.begin();
|
||||
|
||||
for(; mit != msgReadStatus.end(); mit++)
|
||||
{
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "msgId : " << mit->first << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << " status : " << mit->second << std::endl;
|
||||
|
||||
}
|
||||
|
||||
printRsItemEnd(out, "RsForumMsg", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsForumSerialiser::sizeMsg(RsForumMsg *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribMsg stuff */
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->parentId);
|
||||
s += GetTlvStringSize(item->threadId);
|
||||
s += 4; /* timestamp */
|
||||
|
||||
/* RsForumMsg stuff */
|
||||
s += GetTlvStringSize(item->srcId);
|
||||
s += GetTlvWideStringSize(item->title);
|
||||
s += GetTlvWideStringSize(item->msg);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsForumSerialiser::serialiseMsg(RsForumMsg *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeMsg(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() Header: " << ok << std::endl;
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() grpId: " << ok << std::endl;
|
||||
#endif
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PARENTID, item->parentId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() parentId: " << ok << std::endl;
|
||||
#endif
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_THREADID, item->threadId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() threadId: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->timestamp);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() timestamp: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
/* RsForumMsg */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->srcId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() srcId: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_TITLE, item->title);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() Title: " << ok << std::endl;
|
||||
#endif
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, item->msg);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() Msg: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsForumSerialiser::serialiseMsg() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
RsForumMsg *RsForumSerialiser::deserialiseMsg(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) ||
|
||||
(RS_SERVICE_TYPE_FORUM != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_FORUM_MSG != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsForumMsg *item = new RsForumMsg();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PARENTID, item->parentId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_THREADID, item->threadId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->timestamp));
|
||||
|
||||
/* RsForumMsg */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->srcId);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_TITLE, item->title);
|
||||
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->msg);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
uint32_t RsForumSerialiser::sizeReadStatus(RsForumReadStatus *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
/* RsDistribChildConfig stuff */
|
||||
|
||||
s += 4; /* save_type */
|
||||
|
||||
/* RsForumReadStatus stuff */
|
||||
|
||||
s += GetTlvStringSize(item->forumId);
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = item->msgReadStatus.begin();
|
||||
|
||||
for(; mit != item->msgReadStatus.end(); mit++)
|
||||
{
|
||||
s += GetTlvStringSize(mit->first); /* key */
|
||||
s += 4; /* value */
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsForumSerialiser::serialiseReadStatus(RsForumReadStatus *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeReadStatus(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() Header: " << ok << std::endl;
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->save_type);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() save_type: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* RsForumMsg */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->forumId);
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() forumId: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
std::map<std::string, uint32_t>::iterator mit = item->msgReadStatus.begin();
|
||||
|
||||
for(; mit != item->msgReadStatus.end(); mit++)
|
||||
{
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, mit->first); /* key */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, mit->second); /* value */
|
||||
}
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() msgReadStatus: " << ok << std::endl;
|
||||
#endif
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialiseReadStatus() Size Error! " << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
RsForumReadStatus *RsForumSerialiser::deserialiseReadStatus(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* 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)) ||
|
||||
(RS_SERVICE_TYPE_FORUM != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_FORUM_READ_STATUS != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsForumReadStatus *item = new RsForumReadStatus();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* RsDistribMsg first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->save_type));
|
||||
|
||||
/* RsForumMsg */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, item->forumId);
|
||||
|
||||
std::string key;
|
||||
uint32_t value;
|
||||
|
||||
while(offset != rssize)
|
||||
{
|
||||
key.clear();
|
||||
value = 0;
|
||||
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSGID, key); /* key */
|
||||
|
||||
/* incomplete key value pair? then fail*/
|
||||
if(offset == rssize)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ok &= getRawUInt32(data, rssize, &offset, &value); /* value */
|
||||
|
||||
item->msgReadStatus.insert(std::pair<std::string, uint32_t>(key, value));
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
/************************************************************/
|
||||
|
||||
uint32_t RsForumSerialiser::size(RsItem *item)
|
||||
{
|
||||
RsForumMsg* dfm;
|
||||
RsForumReadStatus* drs;
|
||||
|
||||
if( NULL != ( dfm = dynamic_cast<RsForumMsg*>(item)))
|
||||
{
|
||||
return sizeMsg(dfm);
|
||||
}
|
||||
else if(NULL != (drs = dynamic_cast<RsForumReadStatus* >(item)))
|
||||
{
|
||||
return sizeReadStatus(drs);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool RsForumSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::serialise()" << std::endl;
|
||||
#endif
|
||||
|
||||
RsForumMsg* dfm;
|
||||
RsForumReadStatus* drs;
|
||||
|
||||
if( NULL != ( dfm = dynamic_cast<RsForumMsg*>(item)))
|
||||
{
|
||||
return serialiseMsg(dfm, data, pktsize);
|
||||
}
|
||||
else if(NULL != (drs = dynamic_cast<RsForumReadStatus* >(item)))
|
||||
{
|
||||
return serialiseReadStatus(drs, data, pktsize);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
RsItem *RsForumSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
{
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsForumSerialiser::deserialise()" << std::endl;
|
||||
#endif
|
||||
|
||||
/* get the type and size */
|
||||
uint32_t rstype = getRsItemId(data);
|
||||
|
||||
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
||||
(RS_SERVICE_TYPE_FORUM != getRsItemService(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
switch(getRsItemSubType(rstype))
|
||||
{
|
||||
case RS_PKT_SUBTYPE_FORUM_MSG:
|
||||
return deserialiseMsg(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_FORUM_READ_STATUS:
|
||||
return deserialiseReadStatus(data, pktsize);
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
break;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
#ifndef RS_FORUM_ITEMS_H
|
||||
#define RS_FORUM_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsforumitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 <map>
|
||||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
#include "serialiser/rsdistribitems.h"
|
||||
|
||||
const uint8_t RS_PKT_SUBTYPE_FORUM_GRP = 0x01;
|
||||
const uint8_t RS_PKT_SUBTYPE_FORUM_MSG = 0x02;
|
||||
const uint8_t RS_PKT_SUBTYPE_FORUM_READ_STATUS = 0x03;
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
class RsForumMsg: public RsDistribMsg
|
||||
{
|
||||
public:
|
||||
RsForumMsg()
|
||||
:RsDistribMsg(RS_SERVICE_TYPE_FORUM, RS_PKT_SUBTYPE_FORUM_MSG) { return; }
|
||||
virtual ~RsForumMsg() { return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
/*
|
||||
* RsDistribMsg has:
|
||||
* grpId, parentId, threadId & timestamp.
|
||||
*/
|
||||
|
||||
std::string srcId;
|
||||
|
||||
std::wstring title;
|
||||
std::wstring msg;
|
||||
|
||||
};
|
||||
|
||||
/*!
|
||||
* This is used to keep track of whether a message has been read
|
||||
* by client
|
||||
*/
|
||||
class RsForumReadStatus : public RsDistribChildConfig
|
||||
{
|
||||
public:
|
||||
RsForumReadStatus()
|
||||
: RsDistribChildConfig(RS_SERVICE_TYPE_FORUM, RS_PKT_SUBTYPE_FORUM_READ_STATUS)
|
||||
{ return; }
|
||||
|
||||
virtual ~RsForumReadStatus() {return; }
|
||||
|
||||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string forumId;
|
||||
|
||||
/// a map which contains the read for messages within a forum
|
||||
std::map<std::string, uint32_t> msgReadStatus;
|
||||
|
||||
};
|
||||
|
||||
class RsForumSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
RsForumSerialiser()
|
||||
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FORUM)
|
||||
{ return; }
|
||||
virtual ~RsForumSerialiser()
|
||||
{ return; }
|
||||
|
||||
virtual uint32_t size(RsItem *);
|
||||
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
|
||||
virtual RsItem * deserialise(void *data, uint32_t *size);
|
||||
|
||||
private:
|
||||
|
||||
/* For RS_PKT_SUBTYPE_FORUM_GRP */
|
||||
//virtual uint32_t sizeGrp(RsForumGrp *);
|
||||
//virtual bool serialiseGrp (RsForumGrp *item, void *data, uint32_t *size);
|
||||
//virtual RsForumGrp *deserialiseGrp(void *data, uint32_t *size);
|
||||
|
||||
/* For RS_PKT_SUBTYPE_FORUM_MSG */
|
||||
virtual uint32_t sizeMsg(RsForumMsg *);
|
||||
virtual bool serialiseMsg(RsForumMsg *item, void *data, uint32_t *size);
|
||||
virtual RsForumMsg *deserialiseMsg(void *data, uint32_t *size);
|
||||
|
||||
virtual uint32_t sizeReadStatus(RsForumReadStatus* );
|
||||
virtual bool serialiseReadStatus(RsForumReadStatus* item, void* data, uint32_t *size);
|
||||
virtual RsForumReadStatus *deserialiseReadStatus(void* data, uint32_t *size);
|
||||
|
||||
};
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#endif /* RS_FORUM_ITEMS_H */
|
||||
|
||||
|
||||
|
|
@ -1,212 +0,0 @@
|
|||
/*
|
||||
* libretroshare/src/serialiser: rsgameitems.cc
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rsgameitems.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
|
||||
/***
|
||||
#define RSSERIAL_DEBUG 1
|
||||
***/
|
||||
|
||||
#include <iostream>
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
RsGameItem::~RsGameItem()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void RsGameItem::clear()
|
||||
{
|
||||
serviceId = 0;
|
||||
numPlayers = 0;
|
||||
msg = 0;
|
||||
|
||||
gameId.clear();
|
||||
gameComment.clear();
|
||||
players.TlvClear();
|
||||
}
|
||||
|
||||
std::ostream &RsGameItem::print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsGameItem", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
printIndent(out, int_Indent);
|
||||
out << "serviceId: " << serviceId << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "numPlayers: " << numPlayers << std::endl;
|
||||
printIndent(out, int_Indent);
|
||||
out << "msg: " << msg << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "gameId: " << gameId << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
std::string cnv_comment(gameComment.begin(), gameComment.end());
|
||||
out << "msg: " << cnv_comment << std::endl;
|
||||
|
||||
printIndent(out, int_Indent);
|
||||
out << "Players Ids: " << std::endl;
|
||||
players.print(out, int_Indent);
|
||||
|
||||
printRsItemEnd(out, "RsGameItem", indent);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
uint32_t RsGameSerialiser::sizeItem(RsGameItem *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += 4; /* serviceId */
|
||||
s += 4; /* numPlayers */
|
||||
s += 4; /* msg */
|
||||
s += GetTlvStringSize(item->gameId);
|
||||
s += GetTlvWideStringSize(item->gameComment);
|
||||
s += item->players.TlvSize();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* serialise the data to the buffer */
|
||||
bool RsGameSerialiser::serialiseItem(RsGameItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
uint32_t tlvsize = sizeItem(item);
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (*pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsGameSerialiser::serialiseItem() Header: " << ok << std::endl;
|
||||
std::cerr << "RsGameSerialiser::serialiseItem() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->serviceId);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->numPlayers);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->msg);
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GENID, item->gameId);
|
||||
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_COMMENT, item->gameComment);
|
||||
ok &= item->players.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsGameSerialiser::serialiseItem() Size Error! " << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
RsGameItem *RsGameSerialiser::deserialiseItem(void *data, uint32_t *pktsize)
|
||||
{
|
||||
/* get the type and size */
|
||||
uint32_t rstype = getRsItemId(data);
|
||||
uint32_t tlvsize = getRsItemSize(data);
|
||||
|
||||
uint32_t offset = 0;
|
||||
|
||||
|
||||
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
||||
(RS_SERVICE_TYPE_GAME_LAUNCHER != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < tlvsize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsGameItem *item = new RsGameItem();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &(item->serviceId));
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &(item->numPlayers));
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &(item->msg));
|
||||
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GENID, item->gameId);
|
||||
ok &= GetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_COMMENT, item->gameComment);
|
||||
ok &= item->players.GetTlv(data, tlvsize, &offset);
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
/* error */
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
uint32_t RsGameSerialiser::size(RsItem *item)
|
||||
{
|
||||
return sizeItem((RsGameItem *) item);
|
||||
}
|
||||
|
||||
bool RsGameSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize)
|
||||
{
|
||||
return serialiseItem((RsGameItem *) item, data, pktsize);
|
||||
}
|
||||
|
||||
RsItem *RsGameSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
{
|
||||
return deserialiseItem(data, pktsize);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#ifndef RS_GAME_ITEMS_H
|
||||
#define RS_GAME_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rsgameitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 <map>
|
||||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
class RsGameItem: public RsItem
|
||||
{
|
||||
public:
|
||||
RsGameItem()
|
||||
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GAME_LAUNCHER,
|
||||
RS_PKT_SUBTYPE_DEFAULT)
|
||||
{ return; }
|
||||
virtual ~RsGameItem();
|
||||
virtual void clear();
|
||||
std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
uint32_t serviceId;
|
||||
uint32_t numPlayers;
|
||||
uint32_t msg; /* RS_GAME_MSG_XXX */
|
||||
|
||||
std::string gameId;
|
||||
std::wstring gameComment;
|
||||
|
||||
RsTlvPeerIdSet players;
|
||||
};
|
||||
|
||||
class RsGameSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
RsGameSerialiser()
|
||||
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GAME_LAUNCHER)
|
||||
{ return; }
|
||||
virtual ~RsGameSerialiser()
|
||||
{ return; }
|
||||
|
||||
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 sizeItem(RsGameItem *);
|
||||
virtual bool serialiseItem (RsGameItem *item, void *data, uint32_t *size);
|
||||
virtual RsGameItem *deserialiseItem(void *data, uint32_t *size);
|
||||
|
||||
|
||||
};
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#endif /* RS_GAME_ITEMS_H */
|
||||
|
||||
|
||||
|
|
@ -1,304 +0,0 @@
|
|||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include "rstunnelitems.h"
|
||||
#include "util/rsstring.h"
|
||||
|
||||
// -----------------------------------------------------------------------------------//
|
||||
// -------------------------------- Serialization. --------------------------------- //
|
||||
// -----------------------------------------------------------------------------------//
|
||||
//
|
||||
|
||||
//
|
||||
// ---------------------------------- Packet sizes -----------------------------------//
|
||||
//
|
||||
|
||||
uint32_t RsTunnelDataItem::serial_size()
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem::serial_size() called." << std::endl ;
|
||||
#endif
|
||||
uint32_t s = 0 ;
|
||||
|
||||
s += 8 ; // header
|
||||
s += GetTlvStringSize(sourcePeerId) ;
|
||||
s += GetTlvStringSize(relayPeerId) ;
|
||||
s += GetTlvStringSize(destPeerId) ;
|
||||
|
||||
s += 4 ; //encoded_data_len
|
||||
s += encoded_data_len;
|
||||
|
||||
return s ;
|
||||
}
|
||||
|
||||
uint32_t RsTunnelHandshakeItem::serial_size()
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelHandshakeItem::serial_size() called." << std::endl ;
|
||||
#endif
|
||||
uint32_t s = 0 ;
|
||||
|
||||
s += 8 ; // header
|
||||
s += GetTlvStringSize(sourcePeerId) ;
|
||||
s += GetTlvStringSize(relayPeerId) ;
|
||||
s += GetTlvStringSize(destPeerId) ;
|
||||
s += GetTlvStringSize(sslCertPEM) ;
|
||||
s += 4 ; //connection_accept
|
||||
|
||||
|
||||
return s ;
|
||||
}
|
||||
|
||||
//
|
||||
// ---------------------------------- Serialization ----------------------------------//
|
||||
//
|
||||
RsItem *RsTunnelSerialiser::deserialise(void *data, uint32_t *size)
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelSerialiser::deserialise() called." << std::endl ;
|
||||
#endif
|
||||
// look what we have...
|
||||
|
||||
/* get the type */
|
||||
uint32_t rstype = getRsItemId(data);
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "p3tunnel: deserialising packet: " << std::endl ;
|
||||
#endif
|
||||
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_TUNNEL != getRsItemService(rstype)))
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << " Wrong type !!" << std::endl ;
|
||||
#endif
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
switch(getRsItemSubType(rstype))
|
||||
{
|
||||
case RS_TUNNEL_SUBTYPE_DATA : return RsTunnelDataItem::deserialise(data,*size) ;
|
||||
case RS_TUNNEL_SUBTYPE_HANDSHAKE : return RsTunnelHandshakeItem::deserialise(data,*size) ;
|
||||
|
||||
default:
|
||||
std::cerr << "Unknown packet type in Rstunnel!" << std::endl ;
|
||||
return NULL ;
|
||||
}
|
||||
}
|
||||
|
||||
RsTunnelDataItem::~RsTunnelDataItem()
|
||||
{
|
||||
if(encoded_data != NULL)
|
||||
free(encoded_data) ;
|
||||
}
|
||||
|
||||
bool RsTunnelDataItem::serialize(void *data,uint32_t& pktsize)
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem::serialize() called." << std::endl ;
|
||||
#endif
|
||||
uint32_t tlvsize = serial_size();
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem::serialize() tlvsize : " << tlvsize << std::endl ;
|
||||
#endif
|
||||
|
||||
ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize);
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, encoded_data_len) ;
|
||||
|
||||
if(encoded_data != NULL)
|
||||
memcpy((void*)((unsigned char*)data+offset),encoded_data,encoded_data_len) ;
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem::serialise() (offset + encoded_data_len) " << (offset + encoded_data_len) << std::endl;
|
||||
std::cerr << "RsTunnelDataItem::serialise() tlvsize " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
if ((offset + encoded_data_len) != tlvsize )
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsTunnelDataItem::serialiseTransfer() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem::serialize() packet size inside serialised data : " << getRsItemSize(data) << std::endl ;
|
||||
#endif
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool RsTunnelHandshakeItem::serialize(void *data,uint32_t& pktsize)
|
||||
{
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelHandshakeItem::serialize() called." << std::endl ;
|
||||
#endif
|
||||
uint32_t tlvsize = serial_size();
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelHandshakeItem::serialize() tlvsize : " << tlvsize << std::endl ;
|
||||
#endif
|
||||
|
||||
ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize);
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CERT_SSL, sslCertPEM);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, connection_accepted);
|
||||
|
||||
if (offset != tlvsize )
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsTunnelHandshakeItem::serialiseTransfer() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
void displayRawPacket(std::ostream &out, void *data, uint32_t size)
|
||||
{
|
||||
uint32_t i;
|
||||
std::string sout;
|
||||
rs_sprintf(sout, "DisplayRawPacket: Size: %ld", size);
|
||||
|
||||
for(i = 0; i < size; i++)
|
||||
{
|
||||
if (i % 16 == 0)
|
||||
{
|
||||
sout += "\n";
|
||||
}
|
||||
rs_sprintf_append(sout, "%02x:", (int) (((unsigned char *) data)[i]));
|
||||
}
|
||||
|
||||
out << sout << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
//deserialize in constructor
|
||||
RsTunnelDataItem *RsTunnelDataItem::deserialise(void *data,uint32_t pktsize)
|
||||
{
|
||||
RsTunnelDataItem *item = new RsTunnelDataItem ;
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem constructor called : deserializing packet." << std::endl ;
|
||||
#endif
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelDataItem constructor rssize : " << rssize << std::endl ;
|
||||
#endif
|
||||
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->sourcePeerId);
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->relayPeerId);
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->destPeerId);
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->encoded_data_len) ;
|
||||
|
||||
if(!ok) // return early to avoid calling malloc with invalid size
|
||||
return NULL ;
|
||||
|
||||
if(item->encoded_data_len > 0)
|
||||
{
|
||||
item->encoded_data = (void*)malloc(item->encoded_data_len) ;
|
||||
memcpy(item->encoded_data, (void*)((unsigned char*)data+offset), item->encoded_data_len);
|
||||
}
|
||||
else
|
||||
item->encoded_data = NULL ;
|
||||
|
||||
if ((offset + item->encoded_data_len) != rssize)
|
||||
{
|
||||
std::cerr << "Size error while deserializing a RsTunnelHandshakeItem." << std::endl;
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
displayRawPacket(std::cerr,data,rssize) ;
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "Error while deserializing a RstunnelDataItem." << std::endl ;
|
||||
return NULL ;
|
||||
}
|
||||
return item ;
|
||||
}
|
||||
|
||||
//deserialize in constructor
|
||||
RsTunnelHandshakeItem *RsTunnelHandshakeItem::deserialise(void *data,uint32_t pktsize)
|
||||
{
|
||||
RsTunnelHandshakeItem *item = new RsTunnelHandshakeItem ;
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelHandshakeItem constructor called : deserializing packet." << std::endl ;
|
||||
#endif
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
#ifdef P3TUNNEL_DEBUG
|
||||
std::cerr << "RsTunnelHandshakeItem constructor rssize : " << rssize << std::endl ;
|
||||
#endif
|
||||
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->sourcePeerId);
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->relayPeerId);
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, item->destPeerId);
|
||||
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_CERT_SSL, item->sslCertPEM);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->connection_accepted);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
std::cerr << "Size error while deserializing a RsTunnelHandshakeItem." << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "Unknown error while deserializing a RsTunnelHandshakeItem." << std::endl ;
|
||||
return NULL ;
|
||||
}
|
||||
return item ;
|
||||
}
|
||||
|
||||
std::ostream& RsTunnelDataItem::print(std::ostream& o, uint16_t)
|
||||
{
|
||||
o << "RsTunnelDataItem :" << std::endl ;
|
||||
o << " sourcePeerId : " << sourcePeerId << std::endl ;
|
||||
o << " relayPeerId : " << relayPeerId << std::endl ;
|
||||
o << " destPeerId : " << destPeerId << std::endl ;
|
||||
o << " encoded_data_len : " << encoded_data_len << std::endl ;
|
||||
return o ;
|
||||
}
|
||||
|
||||
std::ostream& RsTunnelHandshakeItem::print(std::ostream& o, uint16_t)
|
||||
{
|
||||
o << "RsTunnelHandshakeItem :" << std::endl ;
|
||||
o << " sourcePeerId : " << sourcePeerId << std::endl ;
|
||||
o << " relayPeerId : " << relayPeerId << std::endl ;
|
||||
o << " destPeerId : " << destPeerId << std::endl ;
|
||||
o << " sslCertPEM : " << sslCertPEM << std::endl ;
|
||||
o << " connection_accepted : " << connection_accepted << std::endl ;
|
||||
return o ;
|
||||
}
|
||||
|
|
@ -1,132 +0,0 @@
|
|||
#ifndef RS_TUNNEL_ITEMS_H
|
||||
#define RS_TUNNEL_ITEMS_H
|
||||
|
||||
/*
|
||||
* libretroshare/src/serialiser: rschannelitems.h
|
||||
*
|
||||
* RetroShare Serialiser.
|
||||
*
|
||||
* Copyright 2007-2008 by Robert Fernie.
|
||||
*
|
||||
* 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 <map>
|
||||
|
||||
#include "serialiser/rstlvbase.h"
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
const uint8_t RS_TUNNEL_SUBTYPE_DATA = 0x01 ;
|
||||
const uint8_t RS_TUNNEL_SUBTYPE_HANDSHAKE = 0x02 ;
|
||||
|
||||
/***********************************************************************************/
|
||||
/* Basic Tunnel Item Class */
|
||||
/***********************************************************************************/
|
||||
|
||||
class RsTunnelItem: public RsItem
|
||||
{
|
||||
public:
|
||||
RsTunnelItem(uint8_t tunnel_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TUNNEL,tunnel_subtype) {}
|
||||
|
||||
virtual ~RsTunnelItem() {}
|
||||
|
||||
virtual bool serialize(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialize themselves ?
|
||||
virtual uint32_t serial_size() { return 0;}
|
||||
|
||||
virtual void clear() {}
|
||||
};
|
||||
|
||||
class RsTunnelDataItem: public RsTunnelItem
|
||||
{
|
||||
public:
|
||||
RsTunnelDataItem() : RsTunnelItem(RS_TUNNEL_SUBTYPE_DATA)
|
||||
{
|
||||
encoded_data = NULL ; // To comply with the destructor below.
|
||||
}
|
||||
virtual ~RsTunnelDataItem() ;
|
||||
|
||||
static RsTunnelDataItem *deserialise(void *data,uint32_t size) ; // deserialization
|
||||
|
||||
uint32_t encoded_data_len;
|
||||
void *encoded_data;
|
||||
|
||||
std::string sourcePeerId ;
|
||||
std::string relayPeerId ;
|
||||
std::string destPeerId ;
|
||||
|
||||
std::ostream& print(std::ostream& o, uint16_t) ;
|
||||
|
||||
bool serialize(void *data,uint32_t& size) ;
|
||||
uint32_t serial_size() ;
|
||||
};
|
||||
|
||||
class RsTunnelHandshakeItem: public RsTunnelItem
|
||||
{
|
||||
public:
|
||||
RsTunnelHandshakeItem() : RsTunnelItem(RS_TUNNEL_SUBTYPE_HANDSHAKE) {}
|
||||
virtual ~RsTunnelHandshakeItem() {}
|
||||
|
||||
static RsTunnelHandshakeItem *deserialise(void *data,uint32_t size) ; // deserialization
|
||||
|
||||
std::string sourcePeerId ;
|
||||
std::string relayPeerId ;
|
||||
std::string destPeerId ;
|
||||
std::string sslCertPEM ;
|
||||
uint32_t connection_accepted;
|
||||
|
||||
std::ostream& print(std::ostream& o, uint16_t) ;
|
||||
|
||||
bool serialize(void *data,uint32_t& size) ;
|
||||
uint32_t serial_size() ;
|
||||
};
|
||||
|
||||
class RsTunnelSerialiser: public RsSerialType
|
||||
{
|
||||
public:
|
||||
RsTunnelSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_TUNNEL) {}
|
||||
|
||||
virtual uint32_t size(RsItem *item)
|
||||
{
|
||||
RsTunnelItem * rst;
|
||||
if (NULL != (rst = dynamic_cast<RsTunnelItem *>(item)))
|
||||
{
|
||||
return rst->serial_size() ;
|
||||
} else {
|
||||
std::cerr << "RsTunnelSerialiser::size() problem, not a RsTunnelItem." << std::endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
virtual bool serialise(RsItem *item, void *data, uint32_t *size)
|
||||
{
|
||||
RsTunnelItem * rst;
|
||||
if (NULL != (rst = dynamic_cast<RsTunnelItem *>(item)))
|
||||
{
|
||||
return rst->serialize(data,*size) ;
|
||||
} else {
|
||||
std::cerr << "RsTunnelSerialiser::serialise() problem, not a RsTunnelItem." << std::endl;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
virtual RsItem *deserialise (void *data, uint32_t *size) ;
|
||||
};
|
||||
|
||||
#endif /* RS_TUNNEL_ITEMS_H */
|
||||
Loading…
Add table
Add a link
Reference in a new issue