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

Merging branches/v0.6-initdev into trunk.

Browse source 
These split at 6672 -> 7075, so quite a bit merge.
libretroshare compiles - but untested.
retroshare-gui needs GenCertDialog.ui and IdEditDialog.ui to be properly merged. (compile errors).
some plugins will be broken.
retroshare-nogui is untested.



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7078 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2014-02-01 14:16:15 +00:00
commit c0738eec7f
407 changed files with 23716 additions and 50779 deletions
Download patch file Download diff file Expand all files Collapse all files

13
libretroshare/src/serialiser/itempriorities.h
View file

@ -71,6 +71,15 @@ const uint8_t QOS_PRIORITY_RS_DISC_ASK_INFO = 2 ;
const uint8_t QOS_PRIORITY_RS_DISC_REPLY = 1 ;
const uint8_t QOS_PRIORITY_RS_DISC_VERSION = 1 ;
const uint8_t QOS_PRIORITY_RS_DISC_CONTACT = 2 ; // CONTACT and PGPLIST must have
const uint8_t QOS_PRIORITY_RS_DISC_PGP_LIST = 2 ; // same priority.
const uint8_t QOS_PRIORITY_RS_DISC_SERVICES = 2 ;
const uint8_t QOS_PRIORITY_RS_DISC_PGP_CERT = 1 ;
// Heartbeat.
//
const uint8_t QOS_PRIORITY_RS_HEARTBEAT_PULSE = 8 ;
// Chat/Msgs
//
const uint8_t QOS_PRIORITY_RS_CHAT_ITEM = 7 ;
@ -78,9 +87,9 @@ const uint8_t QOS_PRIORITY_RS_CHAT_AVATAR_ITEM = 2 ;
const uint8_t QOS_PRIORITY_RS_MSG_ITEM = 2 ;
const uint8_t QOS_PRIORITY_RS_STATUS_ITEM = 2 ;
// VOIP
// RTT
//
const uint8_t QOS_PRIORITY_RS_VOIP_PING = 9 ;
const uint8_t QOS_PRIORITY_RS_RTT_PING = 9 ;
// BanList
//

1519
libretroshare/src/serialiser/rsbaseitems.cc
View file

File diff suppressed because it is too large Load diff

331
libretroshare/src/serialiser/rsbaseitems.h
View file

@ -1,331 +0,0 @@
#ifndef RS_BASE_ITEMS_H
#define RS_BASE_ITEMS_H
/*
* libretroshare/src/serialiser: rsbaseitems.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 "retroshare/rstypes.h"
#include "serialiser/rsserial.h"
#include "serialiser/rstlvtypes.h"
const uint8_t RS_PKT_TYPE_FILE = 0x01;
const uint8_t RS_PKT_TYPE_CACHE = 0x02;
const uint8_t RS_PKT_SUBTYPE_FI_REQUEST = 0x01;
const uint8_t RS_PKT_SUBTYPE_FI_DATA = 0x02;
const uint8_t RS_PKT_SUBTYPE_FI_TRANSFER = 0x03;
const uint8_t RS_PKT_SUBTYPE_FI_CHUNK_MAP_REQUEST = 0x04;
const uint8_t RS_PKT_SUBTYPE_FI_CHUNK_MAP = 0x05;
const uint8_t RS_PKT_SUBTYPE_FI_CRC32_MAP_REQUEST = 0x06;
const uint8_t RS_PKT_SUBTYPE_FI_CRC32_MAP = 0x07;
const uint8_t RS_PKT_SUBTYPE_FI_CHUNK_CRC_REQUEST = 0x08;
const uint8_t RS_PKT_SUBTYPE_FI_CHUNK_CRC = 0x09;
const uint8_t RS_PKT_SUBTYPE_CACHE_ITEM = 0x01;
const uint8_t RS_PKT_SUBTYPE_CACHE_REQUEST = 0x02;
/**************************************************************************/
class RsFileRequest: public RsItem
{
public:
RsFileRequest()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_FILE,
RS_PKT_SUBTYPE_FI_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_REQUEST) ;
}
virtual ~RsFileRequest();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint64_t fileoffset; /* start of data requested */
uint32_t chunksize; /* size of data requested */
RsTlvFileItem file; /* file information */
};
/**************************************************************************/
class RsFileData: public RsItem
{
public:
RsFileData()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_FILE,
RS_PKT_SUBTYPE_FI_DATA)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_DATA) ;
}
virtual ~RsFileData();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsTlvFileData fd;
};
class RsFileChunkMapRequest: public RsItem
{
public:
RsFileChunkMapRequest()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CHUNK_MAP_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP_REQUEST) ;
}
virtual ~RsFileChunkMapRequest() {}
virtual void clear() {}
bool is_client ; // is the request for a client, or a server ?
std::string hash ; // hash of the file for which we request the chunk map
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsFileChunkMap: public RsItem
{
public:
RsFileChunkMap()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CHUNK_MAP)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP) ;
}
virtual ~RsFileChunkMap() {}
virtual void clear() {}
bool is_client ; // is the request for a client, or a server ?
std::string hash ; // hash of the file for which we request the chunk map
CompressedChunkMap compressed_map ; // Chunk map of the file.
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsFileCRC32MapRequest: public RsItem
{
public:
RsFileCRC32MapRequest()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CRC32_MAP_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_CRC_REQUEST) ;
}
virtual ~RsFileCRC32MapRequest() {}
virtual void clear() {}
std::string hash ; // hash of the file for which we request the chunk map
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsFileSingleChunkCrcRequest: public RsItem
{
public:
RsFileSingleChunkCrcRequest()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CHUNK_CRC_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC_REQUEST) ;
}
virtual ~RsFileSingleChunkCrcRequest() {}
virtual void clear() {}
std::string hash ; // hash of the file for which we request the crc
uint32_t chunk_number ; // chunk number
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsFileCRC32Map: public RsItem
{
public:
RsFileCRC32Map()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CRC32_MAP)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_CRC) ;
}
virtual ~RsFileCRC32Map() {}
virtual void clear() {}
std::string hash ; // hash of the file for which we request the chunk map
CRC32Map crc_map ; // CRC32 map of the file.
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsFileSingleChunkCrc: public RsItem
{
public:
RsFileSingleChunkCrc()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE, RS_PKT_TYPE_FILE, RS_PKT_SUBTYPE_FI_CHUNK_CRC)
{
setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC) ;
}
virtual ~RsFileSingleChunkCrc() {}
virtual void clear() {}
std::string hash ; // hash of the file for which we request the chunk map
uint32_t chunk_number ;
Sha1CheckSum check_sum ; // CRC32 map of the file.
std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
/**************************************************************************/
class RsFileItemSerialiser: public RsSerialType
{
public:
RsFileItemSerialiser()
:RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_FILE)
{ return; }
virtual ~RsFileItemSerialiser() { 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:
/* sub types */
virtual uint32_t sizeReq(RsFileRequest *);
virtual uint32_t sizeData(RsFileData *);
virtual uint32_t sizeChunkMapReq(RsFileChunkMapRequest *);
virtual uint32_t sizeChunkMap(RsFileChunkMap *);
virtual uint32_t sizeChunkCrcReq(RsFileSingleChunkCrcRequest *);
virtual uint32_t sizeChunkCrc(RsFileSingleChunkCrc *);
virtual uint32_t sizeCRC32MapReq(RsFileCRC32MapRequest *);
virtual uint32_t sizeCRC32Map(RsFileCRC32Map *);
virtual bool serialiseReq (RsFileRequest *item, void *data, uint32_t *size);
virtual bool serialiseData (RsFileData *item, void *data, uint32_t *size);
virtual bool serialiseChunkMapReq(RsFileChunkMapRequest *item, void *data, uint32_t *size);
virtual bool serialiseChunkMap(RsFileChunkMap *item, void *data, uint32_t *size);
virtual bool serialiseCRC32MapReq(RsFileCRC32MapRequest *item, void *data, uint32_t *size);
virtual bool serialiseCRC32Map(RsFileCRC32Map *item, void *data, uint32_t *size);
virtual bool serialiseChunkCrcReq(RsFileSingleChunkCrcRequest *item, void *data, uint32_t *size);
virtual bool serialiseChunkCrc(RsFileSingleChunkCrc *item, void *data, uint32_t *size);
virtual RsFileRequest *deserialiseReq(void *data, uint32_t *size);
virtual RsFileData *deserialiseData(void *data, uint32_t *size);
virtual RsFileChunkMapRequest *deserialiseChunkMapReq(void *data, uint32_t *size);
virtual RsFileChunkMap *deserialiseChunkMap(void *data, uint32_t *size);
virtual RsFileCRC32MapRequest *deserialiseCRC32MapReq(void *data, uint32_t *size);
virtual RsFileCRC32Map *deserialiseCRC32Map(void *data, uint32_t *size);
virtual RsFileSingleChunkCrcRequest *deserialiseChunkCrcReq(void *data, uint32_t *size);
virtual RsFileSingleChunkCrc *deserialiseChunkCrc(void *data, uint32_t *size);
};
/**************************************************************************/
class RsCacheRequest: public RsItem
{
public:
RsCacheRequest()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_CACHE,
RS_PKT_SUBTYPE_CACHE_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_CACHE_REQUEST);
}
virtual ~RsCacheRequest();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint16_t cacheType;
uint16_t cacheSubId;
RsTlvFileItem file; /* file information */
};
/**************************************************************************/
class RsCacheItem: public RsItem
{
public:
RsCacheItem()
:RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_CACHE,
RS_PKT_SUBTYPE_CACHE_ITEM)
{
setPriorityLevel(QOS_PRIORITY_RS_CACHE_ITEM);
}
virtual ~RsCacheItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint16_t cacheType;
uint16_t cacheSubId;
RsTlvFileItem file; /* file information */
};
/**************************************************************************/
class RsCacheItemSerialiser: public RsSerialType
{
public:
RsCacheItemSerialiser()
:RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_BASE,
RS_PKT_TYPE_CACHE)
{ return; }
virtual ~RsCacheItemSerialiser() { 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:
/* sub types */
virtual uint32_t sizeReq(RsCacheRequest *);
virtual bool serialiseReq (RsCacheRequest *item, void *data, uint32_t *size);
virtual RsCacheRequest * deserialiseReq(void *data, uint32_t *size);
virtual uint32_t sizeItem(RsCacheItem *);
virtual bool serialiseItem (RsCacheItem *item, void *data, uint32_t *size);
virtual RsCacheItem * deserialiseItem(void *data, uint32_t *size);
};
/**************************************************************************/
class RsServiceSerialiser: public RsSerialType
{
public:
RsServiceSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, 0, 0)
{ return; }
virtual ~RsServiceSerialiser()
{ return; }
virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
};
/**************************************************************************/
#endif

255
libretroshare/src/serialiser/rsblogitems.cc
View file

@ -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);
}
/*************************************************************************/

91
libretroshare/src/serialiser/rsblogitems.h
View file

@ -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 */

627
libretroshare/src/serialiser/rschannelitems.cc
View file

@ -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;
}
/*************************************************************************/

141
libretroshare/src/serialiser/rschannelitems.h
View file

@ -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 */

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

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

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

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

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

@ -1,770 +0,0 @@
/*
* libretroshare/src/serialiser: rsdiscitems.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/rsbaseserial.h"
#include "serialiser/rsserviceids.h"
#include "serialiser/rsdiscitems.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
/***
* #define RSSERIAL_DEBUG 1
* #define RSSERIAL_ERROR_DEBUG 1
***/
#define RSSERIAL_ERROR_DEBUG 1
#include <iostream>
/*************************************************************************/
uint32_t RsDiscSerialiser::size(RsItem *i)
{
RsDiscAskInfo *inf;
RsDiscReply *rdr;
RsDiscVersion *rdv;
RsDiscHeartbeat *rdt;
/* do reply first - as it is derived from Item */
if (NULL != (rdr = dynamic_cast<RsDiscReply *>(i)))
{
return sizeReply(rdr);
}
else if (NULL != (inf = dynamic_cast<RsDiscAskInfo *>(i)))
{
return sizeAskInfo(inf);
}
else if (NULL != (rdv = dynamic_cast<RsDiscVersion *>(i)))
{
return sizeVersion(rdv);
}
else if (NULL != (rdt = dynamic_cast<RsDiscHeartbeat *>(i)))
{
return sizeHeartbeat(rdt);
}
return 0;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsDiscAskInfo *inf;
RsDiscReply *rdr;
RsDiscVersion *rdv;
RsDiscHeartbeat *rdt;
/* do reply first - as it is derived from Item */
if (NULL != (rdr = dynamic_cast<RsDiscReply *>(i)))
{
return serialiseReply(rdr, data, pktsize);
}
else if (NULL != (inf = dynamic_cast<RsDiscAskInfo *>(i)))
{
return serialiseAskInfo(inf, data, pktsize);
}
else if (NULL != (rdv = dynamic_cast<RsDiscVersion *>(i)))
{
return serialiseVersion(rdv, data, pktsize);
}
else if (NULL != (rdt = dynamic_cast<RsDiscHeartbeat *>(i)))
{
return serialiseHeartbeat(rdt, data, pktsize);
}
return false;
}
RsItem *RsDiscSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_DISC != getRsItemService(rstype)))
{
std::cerr << "RsDiscSerialiser::deserialise() Wrong Type" << std::endl;
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_DISC_REPLY:
return deserialiseReply(data, pktsize);
break;
case RS_PKT_SUBTYPE_DISC_ASK_INFO:
return deserialiseAskInfo(data, pktsize);
break;
case RS_PKT_SUBTYPE_DISC_VERSION:
return deserialiseVersion(data, pktsize);
break;
case RS_PKT_SUBTYPE_DISC_HEARTBEAT:
return deserialiseHeartbeat(data, pktsize);
break;
default:
return NULL;
break;
}
return NULL;
}
/*************************************************************************/
RsDiscAskInfo::~RsDiscAskInfo()
{
return;
}
void RsDiscAskInfo::clear()
{
gpg_id.clear();
}
std::ostream &RsDiscAskInfo::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscAskInfo", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "gpg_id: " << gpg_id << std::endl;
printRsItemEnd(out, "RsDiscAskInfo", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeAskInfo(RsDiscAskInfo *item)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(item->gpg_id);
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseAskInfo(RsDiscAskInfo *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeAskInfo(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 << "RsDiscSerialiser::serialiseAskInfo() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseAskInfo() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->gpg_id);
if (offset != tlvsize) {
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseAskInfo() Size Error! " << std::endl;
#endif
}
return ok;
}
RsDiscAskInfo *RsDiscSerialiser::deserialiseAskInfo(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_ASK_INFO != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseAskInfo() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseAskInfo() Not Enough Space" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscAskInfo *item = new RsDiscAskInfo();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->gpg_id);
if (offset != rssize) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseAskInfo() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseAskInfo() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsDiscReply::~RsDiscReply()
{
return;
}
void RsDiscReply::clear()
{
aboutId.clear();
certGPG.clear();
rsPeerList.clear();
}
std::ostream &RsDiscReply::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscReply", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "AboutId: " << aboutId << std::endl;
printIndent(out, int_Indent);
out << "certGPG: " << certGPG << std::endl;
printIndent(out, int_Indent);
out << "RsDiscReply::print() RsPeerNetItem list : " << std::endl;
for (std::list<RsPeerNetItem>::iterator pitemIt = rsPeerList.begin(); pitemIt!=(rsPeerList.end()); pitemIt++) {
printIndent(out, int_Indent);
pitemIt->print(std::cerr, indent);
}
printRsItemEnd(out, "RsDiscReply", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeReply(RsDiscReply *item)
{
uint32_t s = 8; /* header */
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeReply() Header Size: " << s << std::endl;
#endif
s += GetTlvStringSize(item->aboutId);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeReply() +AboutId Size: " << s << std::endl;
#endif
s += GetTlvStringSize(item->certGPG);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeReply() +certGPG Size: " << s << std::endl;
#endif
RsPeerConfigSerialiser rss ;
for (std::list<RsPeerNetItem>::iterator it = item->rsPeerList.begin(); it != item->rsPeerList.end(); it++)
{
s += rss.size(&(*it)) ;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeReply() +RsPeerNetItem Size: " << s << std::endl;
#endif
}
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeReply() Total Size: " << s << std::endl;
#endif
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseReply(RsDiscReply *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeReply(item);
uint32_t offset = 0;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() tlvsize: " << tlvsize;
std::cerr << std::endl;
#endif
if (*pktsize < tlvsize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() ERROR not enough space" << std::endl;
std::cerr << "RsDiscSerialiser::serialiseReply() ERROR *pktsize: " << *pktsize << " tlvsize: " << tlvsize;
std::cerr << std::endl;
#endif
return false; /* not enough space */
}
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseReply() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->aboutId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CERT_GPG, item->certGPG);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() Offset After Strings: " << offset << std::endl;
#endif
//store the ip list
RsPeerConfigSerialiser rss ;
std::list<RsPeerNetItem>::iterator pitemIt;
for (pitemIt = item->rsPeerList.begin(); pitemIt!=(item->rsPeerList.end()) && ok; ++pitemIt)
{
uint32_t size = *pktsize - offset ;//~(uint32_t)0; // we must be conservative otherwise the serialiser returns false !!
ok &= rss.serialise(&(*pitemIt), (void *) (((char *) data) + offset), &size);
// The size has been updated to its exact value.
offset += size;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() RsPeerNetItem ok?: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseReply() Offset After RsPeerNetItem: " << offset << std::endl;
#endif
}
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseReply() Size Error: " << tlvsize << " != " << offset << std::endl;
#endif
}
return ok;
}
RsDiscReply *RsDiscSerialiser::deserialiseReply(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() Pkt Type: " << std::hex << rstype << std::dec;
std::cerr << "RsDiscSerialiser::deserialiseReply() Pkt Size: " << rssize << std::endl;
#endif
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_REPLY != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() pktsize != rssize" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscReply *item = new RsDiscReply();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->aboutId);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CERT_GPG, item->certGPG);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() offset after Strings: " << offset << std::endl;
#endif
//get the peernet address list
RsPeerConfigSerialiser rss ;
while (offset < rssize)
{
uint32_t peerNetSize = rssize - offset ;
RsPeerNetItem *rsPeerNetItem = (RsPeerNetItem*)rss.deserialise((void *) (((char *) data) + offset), &peerNetSize);
offset += peerNetSize;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() offset aft PeerNetItem: " << offset << std::endl;
#endif
if(rsPeerNetItem == NULL)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() ERROR deserialise PeerNetItem Failed" << std::endl;
#endif
break ;
}
item->rsPeerList.push_back(*rsPeerNetItem);
delete rsPeerNetItem ;
}
if (offset != rssize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseReply() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsDiscVersion::~RsDiscVersion()
{
return;
}
void RsDiscVersion::clear()
{
version = "";
}
std::ostream &RsDiscVersion::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscVersion", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "Version String: " << version << std::endl;
printRsItemEnd(out, "RsDiscVersion", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeVersion(RsDiscVersion *item)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(item->version);
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseVersion(RsDiscVersion *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeVersion(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
return false; /* not enough space */
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, *pktsize, item->PacketId(), *pktsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseVersion() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseVersion() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, item->version);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseVersion() Size Error! " << std::endl;
std::cerr << "Offset: " << offset << " tlvsize: " << tlvsize << std::endl;
#endif
}
return ok;
}
RsDiscVersion *RsDiscSerialiser::deserialiseVersion(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_VERSION != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseVersion() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseVersion() pktsize != rssize" << std::endl;
std::cerr << "Pktsize: " << *pktsize << " Rssize: " << rssize << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscVersion *item = new RsDiscVersion();
item->clear();
/* skip the header */
offset += 8;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->version);
if (offset != rssize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseVersion() offset != rssize" << std::endl;
std::cerr << "Offset: " << offset << " Rssize: " << rssize << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseVersion() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsDiscHeartbeat::~RsDiscHeartbeat()
{
return;
}
void RsDiscHeartbeat::clear()
{
}
std::ostream &RsDiscHeartbeat::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscHeartbeat", indent);
printRsItemEnd(out, "RsDiscHeartbeat", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeHeartbeat(RsDiscHeartbeat */*item*/)
{
uint32_t s = 8; /* header */
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseHeartbeat(RsDiscHeartbeat *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeHeartbeat(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
return false; /* not enough space */
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, *pktsize, item->PacketId(), *pktsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseHeartbeat() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseHeartbeat() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseHeartbeat() Size Error! " << std::endl;
std::cerr << "Offset: " << offset << " tlvsize: " << tlvsize << std::endl;
#endif
}
return ok;
}
RsDiscHeartbeat *RsDiscSerialiser::deserialiseHeartbeat(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_HEARTBEAT != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseHeartbeat() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseHeartbeat() pktsize != rssize" << std::endl;
std::cerr << "Pktsize: " << *pktsize << " Rssize: " << rssize << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscHeartbeat *item = new RsDiscHeartbeat();
item->clear();
/* skip the header */
offset += 8;
if (offset != rssize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseHeartbeat() offset != rssize" << std::endl;
std::cerr << "Offset: " << offset << " Rssize: " << rssize << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseHeartbeat() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/

193
libretroshare/src/serialiser/rsdiscitems.h
View file

@ -1,193 +0,0 @@
/*
* libretroshare/src/serialiser: rsdiscitems.h
*
* Serialiser for RetroShare.
*
* Copyright 2004-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".
*
*/
#ifndef RS_DISC_ITEMS_H
#define RS_DISC_ITEMS_H
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
#include "serialiser/rsserviceids.h"
#include "serialiser/rsconfigitems.h"
//const uint8_t RS_PKT_SUBTYPE_DISC_OWN = 0x01;
const uint8_t RS_PKT_SUBTYPE_DISC_REPLY = 0x02;
const uint8_t RS_PKT_SUBTYPE_DISC_ASK_INFO = 0x03;
const uint8_t RS_PKT_SUBTYPE_DISC_VERSION = 0x05;
const uint8_t RS_PKT_SUBTYPE_DISC_HEARTBEAT = 0x06;
class RsDiscItem: public RsItem
{
protected:
RsDiscItem(uint8_t subtype) :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC, subtype) {}
};
//class RsDiscOwnItem: public RsDiscItem
//{
// public:
//
// RsDiscOwnItem() :RsDiscItem(RS_PKT_SUBTYPE_DISC_OWN ) {}
//
//
// virtual ~RsDiscOwnItem();
//
// virtual void clear();
// virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
//
// //use for transmitting ip address list
// std::list<IpAddressTimed> ipAddressList;
//
// //use for transmitting my own adress list
// struct sockaddr_in laddr;
// struct sockaddr_in saddr;
//
// // time frame of recent connections.
// uint16_t contact_tf;
// // flags...
// uint32_t discFlags;
//};
class RsDiscReply: public RsDiscItem
{
public:
RsDiscReply()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_REPLY)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_REPLY);
}
virtual ~RsDiscReply();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
//use for transmitting ip address list
std::list<RsPeerNetItem> rsPeerList;
//use for transmitting my own adress list
// struct sockaddr_in currentladdr;
// struct sockaddr_in currentsaddr;
// time frame of recent connections.
//uint16_t contact_tf;
// flags...
//uint32_t discFlags;
std::string aboutId;
std::string certGPG;
};
class RsDiscAskInfo: public RsDiscItem
{
public:
RsDiscAskInfo()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_ASK_INFO)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_ASK_INFO);
}
virtual ~RsDiscAskInfo();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string gpg_id;
};
class RsDiscVersion: public RsDiscItem
{
public:
RsDiscVersion() :RsDiscItem(RS_PKT_SUBTYPE_DISC_VERSION)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_VERSION);
}
virtual ~RsDiscVersion();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string version;
};
class RsDiscHeartbeat: public RsDiscItem
{
public:
RsDiscHeartbeat() :RsDiscItem(RS_PKT_SUBTYPE_DISC_HEARTBEAT)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_HEART_BEAT) ;
}
virtual ~RsDiscHeartbeat();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsDiscSerialiser: public RsSerialType
{
public:
RsDiscSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC)
{ return; }
virtual ~RsDiscSerialiser() { 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 sizeAskInfo(RsDiscAskInfo *);
virtual bool serialiseAskInfo(RsDiscAskInfo *item, void *data, uint32_t *size);
virtual RsDiscAskInfo *deserialiseAskInfo(void *data, uint32_t *size);
virtual uint32_t sizeReply(RsDiscReply *);
virtual bool serialiseReply (RsDiscReply *item, void *data, uint32_t *size);
virtual RsDiscReply *deserialiseReply(void *data, uint32_t *size);
//virtual uint32_t sizeIssuer(RsDiscIssuer *);
//virtual bool serialiseIssuer (RsDiscIssuer *item, void *data, uint32_t *size);
//virtual RsDiscIssuer *deserialiseIssuer(void *data, uint32_t *size);
virtual uint32_t sizeVersion(RsDiscVersion *);
virtual bool serialiseVersion(RsDiscVersion *item, void *data, uint32_t *size);
virtual RsDiscVersion *deserialiseVersion(void *data, uint32_t *size);
virtual uint32_t sizeHeartbeat(RsDiscHeartbeat *);
virtual bool serialiseHeartbeat(RsDiscHeartbeat *item, void *data, uint32_t *size);
virtual RsDiscHeartbeat *deserialiseHeartbeat(void *data, uint32_t *size);
};
#endif // RS_DISC_ITEMS_H

890
libretroshare/src/serialiser/rsdiscovery2items.cc Normal file
View file

@ -0,0 +1,890 @@
/*
* libretroshare/src/serialiser: rsdiscitems.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/rsbaseserial.h"
#include "serialiser/rsserviceids.h"
#include "serialiser/rsdiscovery2items.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
/***
* #define RSSERIAL_DEBUG 1
* #define RSSERIAL_ERROR_DEBUG 1
***/
#define RSSERIAL_ERROR_DEBUG 1
#include <iostream>
/*************************************************************************/
uint32_t RsDiscSerialiser::size(RsItem *i)
{
RsDiscPgpListItem *pgplist;
RsDiscPgpCertItem *pgpcert;
RsDiscContactItem *contact;
//RsDiscServicesItem *services;
if (NULL != (pgplist = dynamic_cast<RsDiscPgpListItem *>(i)))
{
return sizePgpList(pgplist);
}
else if (NULL != (pgpcert = dynamic_cast<RsDiscPgpCertItem *>(i)))
{
return sizePgpCert(pgpcert);
}
else if (NULL != (contact = dynamic_cast<RsDiscContactItem *>(i)))
{
return sizeContact(contact);
}
#if 0
else if (NULL != (services = dynamic_cast<RsDiscServicesItem *>(i)))
{
return sizeServices(services);
}
#endif
return 0;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsDiscPgpListItem *pgplist;
RsDiscPgpCertItem *pgpcert;
RsDiscContactItem *contact;
//RsDiscServicesItem *services;
if (NULL != (pgplist = dynamic_cast<RsDiscPgpListItem *>(i)))
{
return serialisePgpList(pgplist, data, pktsize);
}
else if (NULL != (pgpcert = dynamic_cast<RsDiscPgpCertItem *>(i)))
{
return serialisePgpCert(pgpcert, data, pktsize);
}
else if (NULL != (contact = dynamic_cast<RsDiscContactItem *>(i)))
{
return serialiseContact(contact, data, pktsize);
}
#if 0
else if (NULL != (services = dynamic_cast<RsDiscServicesItem *>(i)))
{
return serialiseServices(services, data, pktsize);
}
#endif
return false;
}
RsItem *RsDiscSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_DISC != getRsItemService(rstype)))
{
std::cerr << "RsDiscSerialiser::deserialise() Wrong Type" << std::endl;
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_DISC_PGP_LIST:
return deserialisePgpList(data, pktsize);
break;
case RS_PKT_SUBTYPE_DISC_PGP_CERT:
return deserialisePgpCert(data, pktsize);
break;
case RS_PKT_SUBTYPE_DISC_CONTACT:
return deserialiseContact(data, pktsize);
break;
#if 0
case RS_PKT_SUBTYPE_DISC_SERVICES:
return deserialiseServices(data, pktsize);
break;
#endif
default:
return NULL;
break;
}
return NULL;
}
/*************************************************************************/
RsDiscPgpListItem::~RsDiscPgpListItem()
{
return;
}
void RsDiscPgpListItem::clear()
{
mode = DISC_PGP_LIST_MODE_NONE;
pgpIdSet.TlvClear();
}
std::ostream &RsDiscPgpListItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscPgpListItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "mode: " << mode << std::endl;
pgpIdSet.print(out, int_Indent);
printRsItemEnd(out, "RsDiscPgpList", indent);
return out;
}
uint32_t RsDiscSerialiser::sizePgpList(RsDiscPgpListItem *item)
{
uint32_t s = 8; /* header */
s += 4; /* mode */
s += item->pgpIdSet.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialisePgpList(RsDiscPgpListItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizePgpList(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 << "RsDiscSerialiser::serialisePgpList() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialisePgpList() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->mode);
ok &= item->pgpIdSet.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize) {
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialisePgpList() Size Error! " << std::endl;
#endif
}
return ok;
}
RsDiscPgpListItem *RsDiscSerialiser::deserialisePgpList(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_PGP_LIST != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpList() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpList() Not Enough Space" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscPgpListItem *item = new RsDiscPgpListItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &(item->mode));
ok &= item->pgpIdSet.GetTlv(data, rssize, &offset);
if (offset != rssize) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpList() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpList() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
/*************************************************************************/
#if 0
RsDiscServicesItem::~RsDiscServicesItem()
{
return;
}
void RsDiscServicesItem::clear()
{
version.clear();
mServiceIdMap.TlvClear();
}
std::ostream &RsDiscServicesItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscServicesItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "version: " << version << std::endl;
mServiceIdMap.print(out, int_Indent);
printRsItemEnd(out, "RsDiscServicesItem", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeServices(RsDiscServicesItem *item)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(item->version); /* version */
s += item->mServiceIdMap.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseServices(RsDiscServicesItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeServices(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 << "RsDiscSerialiser::serialiseServices() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseServices() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VERSION, item->version);
ok &= item->mServiceIdMap.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize) {
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseServices() Size Error! " << std::endl;
#endif
}
return ok;
}
RsDiscServicesItem *RsDiscSerialiser::deserialiseServices(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_PGP_LIST != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseServices() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseServices() Not Enough Space" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscServicesItem *item = new RsDiscServicesItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VERSION, item->version);
ok &= item->mServiceIdMap.GetTlv(data, rssize, &offset);
if (offset != rssize) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseServices() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseServices() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
#endif
/*************************************************************************/
RsDiscPgpCertItem::~RsDiscPgpCertItem()
{
return;
}
void RsDiscPgpCertItem::clear()
{
pgpId.clear();
pgpCert.clear();
}
std::ostream &RsDiscPgpCertItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscPgpCertItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "pgpId: " << pgpId << std::endl;
printIndent(out, int_Indent);
out << "pgpCert: " << pgpCert << std::endl;
printRsItemEnd(out, "RsDiscPgpCert", indent);
return out;
}
uint32_t RsDiscSerialiser::sizePgpCert(RsDiscPgpCertItem *item)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(item->pgpId);
s += GetTlvStringSize(item->pgpCert);
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialisePgpCert(RsDiscPgpCertItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizePgpCert(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 << "RsDiscSerialiser::serialisePgpCert() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialisePgpCert() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert);
if (offset != tlvsize) {
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialisePgpCert() Size Error! " << std::endl;
#endif
}
return ok;
}
RsDiscPgpCertItem *RsDiscSerialiser::deserialisePgpCert(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_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_PGP_CERT != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpCert() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpCert() Not Enough Space" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscPgpCertItem *item = new RsDiscPgpCertItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert);
if (offset != rssize) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpCert() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok) {
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialisePgpCert() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsDiscContactItem::~RsDiscContactItem()
{
return;
}
void RsDiscContactItem::clear()
{
pgpId.clear();
sslId.clear();
location.clear();
version.clear();
netMode = 0;
vs_disc = 0;
vs_dht = 0;
lastContact = 0;
isHidden = false;
hiddenAddr.clear();
hiddenPort = 0;
localAddrV4.TlvClear();
extAddrV4.TlvClear();
localAddrV6.TlvClear();
extAddrV6.TlvClear();
dyndns.clear();
localAddrList.TlvClear();
extAddrList.TlvClear();
}
std::ostream &RsDiscContactItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsDiscContact", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "pgpId: " << pgpId << std::endl;
printIndent(out, int_Indent);
out << "sslId: " << sslId << std::endl;
printIndent(out, int_Indent);
out << "location: " << location << std::endl;
printIndent(out, int_Indent);
out << "version: " << version << std::endl;
printIndent(out, int_Indent);
out << "netMode: " << netMode << std::endl;
printIndent(out, int_Indent);
out << "vs_disc: " << vs_disc << std::endl;
printIndent(out, int_Indent);
out << "vs_dht: " << vs_dht << std::endl;
printIndent(out, int_Indent);
out << "lastContact: " << lastContact << std::endl;
if (isHidden)
{
printIndent(out, int_Indent);
out << "hiddenAddr: " << hiddenAddr << std::endl;
printIndent(out, int_Indent);
out << "hiddenPort: " << hiddenPort << std::endl;
}
else
{
printIndent(out, int_Indent);
out << "localAddrV4: " << std::endl;
localAddrV4.print(out, int_Indent);
printIndent(out, int_Indent);
out << "extAddrV4: " << std::endl;
extAddrV4.print(out, int_Indent);
printIndent(out, int_Indent);
out << "localAddrV6: " << std::endl;
localAddrV6.print(out, int_Indent);
printIndent(out, int_Indent);
out << "extAddrV6: " << std::endl;
extAddrV6.print(out, int_Indent);
printIndent(out, int_Indent);
out << "DynDNS: " << dyndns << std::endl;
printIndent(out, int_Indent);
out << "localAddrList: " << std::endl;
localAddrList.print(out, int_Indent);
printIndent(out, int_Indent);
out << "extAddrList: " << std::endl;
extAddrList.print(out, int_Indent);
}
printRsItemEnd(out, "RsDiscContact", indent);
return out;
}
uint32_t RsDiscSerialiser::sizeContact(RsDiscContactItem *item)
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(item->pgpId);
s += GetTlvStringSize(item->sslId);
s += GetTlvStringSize(item->location);
s += GetTlvStringSize(item->version);
s += 4; // netMode
s += 2; // vs_disc
s += 2; // vs_dht
s += 4; // last contact
if (item->isHidden)
{
s += GetTlvStringSize(item->hiddenAddr);
s += 2; /* hidden port */
}
else
{
s += item->localAddrV4.TlvSize(); /* localaddr */
s += item->extAddrV4.TlvSize(); /* remoteaddr */
s += item->localAddrV6.TlvSize(); /* localaddr */
s += item->extAddrV6.TlvSize(); /* remoteaddr */
s += GetTlvStringSize(item->dyndns);
//add the size of the ip list
s += item->localAddrList.TlvSize();
s += item->extAddrList.TlvSize();
}
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::sizeContact() Total Size: " << s << std::endl;
#endif
return s;
}
/* serialise the data to the buffer */
bool RsDiscSerialiser::serialiseContact(RsDiscContactItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeContact(item);
uint32_t offset = 0;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseContact() tlvsize: " << tlvsize;
std::cerr << std::endl;
#endif
if (*pktsize < tlvsize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseContact() ERROR not enough space" << std::endl;
std::cerr << "RsDiscSerialiser::serialiseContact() ERROR *pktsize: " << *pktsize << " tlvsize: " << tlvsize;
std::cerr << std::endl;
#endif
return false; /* not enough space */
}
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::serialiseContact() Header: " << ok << std::endl;
std::cerr << "RsDiscSerialiser::serialiseContact() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->sslId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VERSION, item->version);
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode);
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc);
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht);
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
if (item->isHidden)
{
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DOMADDR, item->hiddenAddr);
ok &= setRawUInt16(data, tlvsize, &offset, item->hiddenPort);
}
else
{
ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddrList.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrList.SetTlv(data, tlvsize, &offset);
}
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::serialiseContact() Size Error: " << tlvsize << " != " << offset << std::endl;
#endif
}
return ok;
}
RsDiscContactItem *RsDiscSerialiser::deserialiseContact(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset = 0;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() Pkt Type: " << std::hex << rstype << std::dec;
std::cerr << "RsDiscSerialiser::deserialiseContact() Pkt Size: " << rssize << std::endl;
#endif
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_DISC != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DISC_CONTACT != getRsItemSubType(rstype)))
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() Not enough space" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsDiscContactItem *item = new RsDiscContactItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->sslId);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VERSION, item->version);
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
ok &= getRawUInt16(data, rssize, &offset, &(item->vs_disc)); /* Mandatory */
ok &= getRawUInt16(data, rssize, &offset, &(item->vs_dht)); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact));
if (rssize < offset + TLV_HEADER_SIZE)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() missized" << std::endl;
#endif
/* no extra */
delete item;
return NULL;
}
uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[offset]) );
if (tlvtype == TLV_TYPE_STR_DOMADDR)
{
item->isHidden = true;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DOMADDR, item->hiddenAddr);
ok &= getRawUInt16(data, rssize, &offset, &(item->hiddenPort)); /* Mandatory */
}
else
{
item->isHidden = false;
ok &= item->localAddrV4.GetTlv(data, rssize, &offset);
ok &= item->extAddrV4.GetTlv(data, rssize, &offset);
ok &= item->localAddrV6.GetTlv(data, rssize, &offset);
ok &= item->extAddrV6.GetTlv(data, rssize, &offset);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddrList.GetTlv(data, rssize, &offset);
ok &= item->extAddrList.GetTlv(data, rssize, &offset);
}
if (offset != rssize)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() offset != rssize" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok)
{
#ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsDiscSerialiser::deserialiseContact() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/

203
libretroshare/src/serialiser/rsdiscovery2items.h Normal file
View file

@ -0,0 +1,203 @@
/*
* libretroshare/src/serialiser: rsdiscitems.h
*
* Serialiser for RetroShare.
*
* Copyright 2004-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".
*
*/
#ifndef RS_DISC_ITEMS_H
#define RS_DISC_ITEMS_H
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
#include "serialiser/rsserviceids.h"
#include "serialiser/rsconfigitems.h"
const uint8_t RS_PKT_SUBTYPE_DISC_PGP_LIST = 0x01;
const uint8_t RS_PKT_SUBTYPE_DISC_PGP_CERT = 0x02;
const uint8_t RS_PKT_SUBTYPE_DISC_CONTACT = 0x03;
const uint8_t RS_PKT_SUBTYPE_DISC_SERVICES = 0x04;
class RsDiscItem: public RsItem
{
protected:
RsDiscItem(uint8_t subtype) :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC, subtype) {}
};
#define DISC_PGP_LIST_MODE_NONE 0x00
#define DISC_PGP_LIST_MODE_FRIENDS 0x01
#define DISC_PGP_LIST_MODE_GETCERT 0x02
class RsDiscPgpListItem: public RsDiscItem
{
public:
RsDiscPgpListItem()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_LIST)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_PGP_LIST);
}
virtual ~RsDiscPgpListItem();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint32_t mode;
RsTlvPgpIdSet pgpIdSet;
};
class RsDiscPgpCertItem: public RsDiscItem
{
public:
RsDiscPgpCertItem()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_CERT)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_PGP_CERT);
}
virtual ~RsDiscPgpCertItem();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string pgpId;
std::string pgpCert;
};
class RsDiscContactItem: public RsDiscItem
{
public:
RsDiscContactItem()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_CONTACT)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_CONTACT);
}
virtual ~RsDiscContactItem();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string pgpId;
std::string sslId;
// COMMON
std::string location;
std::string version;
uint32_t netMode; /* Mandatory */
uint16_t vs_disc; /* Mandatory */
uint16_t vs_dht; /* Mandatory */
uint32_t lastContact;
bool isHidden; /* not serialised */
// HIDDEN.
std::string hiddenAddr;
uint16_t hiddenPort;
// STANDARD.
RsTlvIpAddress localAddrV4; /* Mandatory */
RsTlvIpAddress extAddrV4; /* Mandatory */
RsTlvIpAddress localAddrV6; /* Mandatory */
RsTlvIpAddress extAddrV6; /* Mandatory */
std::string dyndns;
RsTlvIpAddrSet localAddrList;
RsTlvIpAddrSet extAddrList;
};
#if 0
class RsDiscServicesItem: public RsDiscItem
{
public:
RsDiscServicesItem()
:RsDiscItem(RS_PKT_SUBTYPE_DISC_SERVICES)
{
setPriorityLevel(QOS_PRIORITY_RS_DISC_SERVICES);
}
virtual ~RsDiscServicesItem();
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string version;
RsTlvServiceIdMap mServiceIdMap;
};
#endif
class RsDiscSerialiser: public RsSerialType
{
public:
RsDiscSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC)
{ return; }
virtual ~RsDiscSerialiser() { 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 sizePgpList(RsDiscPgpListItem *);
virtual bool serialisePgpList(RsDiscPgpListItem *item, void *data, uint32_t *size);
virtual RsDiscPgpListItem *deserialisePgpList(void *data, uint32_t *size);
virtual uint32_t sizePgpCert(RsDiscPgpCertItem *);
virtual bool serialisePgpCert(RsDiscPgpCertItem *item, void *data, uint32_t *size);
virtual RsDiscPgpCertItem *deserialisePgpCert(void *data, uint32_t *size);
virtual uint32_t sizeContact(RsDiscContactItem *);
virtual bool serialiseContact(RsDiscContactItem *item, void *data, uint32_t *size);
virtual RsDiscContactItem *deserialiseContact(void *data, uint32_t *size);
#if 0
virtual uint32_t sizeServices(RsDiscServicesItem *);
virtual bool serialiseServices(RsDiscServicesItem *item, void *data, uint32_t *size);
virtual RsDiscServicesItem *deserialiseServices(void *data, uint32_t *size);
#endif
};
#endif // RS_DISC_ITEMS_H

958
libretroshare/src/serialiser/rsdistribitems.cc
View file

@ -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;
}
/*************************************************************************/
/*************************************************************************/

260
libretroshare/src/serialiser/rsdistribitems.h
View file

@ -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 */

800
libretroshare/src/serialiser/rsfiletransferitems.cc Normal file
View file

@ -0,0 +1,800 @@
/*
* libretroshare/src/serialiser: rsbaseitems.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/rstlvbase.h"
#include "serialiser/rsfiletransferitems.h"
/***
* #define RSSERIAL_DEBUG 1
* #define DEBUG_TRANSFERS 1
***/
#ifdef DEBUG_TRANSFERS
#include "util/rsprint.h"
#endif
#include <iostream>
/**********************************************************************************************/
/* SERIALISER STUFF */
/**********************************************************************************************/
RsFileTransferItem *RsFileTransferSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemService(rstype))
{
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_FT_CACHE_ITEM: return deserialise_RsFileTransferCacheItem(data, *pktsize);
case RS_PKT_SUBTYPE_FT_DATA_REQUEST: return deserialise_RsFileTransferDataRequestItem(data, *pktsize);
case RS_PKT_SUBTYPE_FT_DATA: return deserialise_RsFileTransferDataItem(data, *pktsize);
case RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST: return deserialise_RsFileTransferChunkMapRequestItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_FT_CHUNK_MAP: return deserialise_RsFileTransferChunkMapItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST: return deserialise_RsFileTransferSingleChunkCrcRequestItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_FT_CHUNK_CRC: return deserialise_RsFileTransferSingleChunkCrcItem(data,*pktsize) ;
default:
std::cerr << "RsFileTransferSerialiser::deserialise(): Could not de-serialise item. SubPacket id = " << std::hex << getRsItemSubType(rstype) << " id = " << rstype << std::dec << std::endl;
return NULL;
}
return NULL;
}
/**********************************************************************************************/
/* OUTPUTS */
/**********************************************************************************************/
std::ostream& RsFileTransferCacheItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferCacheItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "CacheId: " << cacheType << "/" << cacheSubId << std::endl;
file.print(out, int_Indent);
printRsItemEnd(out, "RsFileTransferCacheItem", indent);
return out;
}
std::ostream& RsFileTransferDataRequestItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferDataRequestItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "FileOffset: " << fileoffset;
out << " ChunkSize: " << chunksize << std::endl;
file.print(out, int_Indent);
printRsItemEnd(out, "RsFileTransferDataRequestItem", indent);
return out;
}
std::ostream& RsFileTransferChunkMapItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferChunkMapItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ;
printIndent(out, int_Indent); out << " hash: " << hash << std::endl ;
printIndent(out, int_Indent); out << "chunks: " << std::hex << compressed_map._map[0] << std::dec << "..." << std::endl ;
printRsItemEnd(out, "RsFileTransferChunkMapItem", indent);
return out;
}
std::ostream& RsFileTransferChunkMapRequestItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferChunkMapRequestItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ;
printIndent(out, int_Indent); out << " hash: " << hash << std::endl ;
printRsItemEnd(out, "RsFileTransferChunkMapRequestItem", indent);
return out;
}
std::ostream& RsFileTransferSingleChunkCrcRequestItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferSingleChunkCrcRequestItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ;
printIndent(out, int_Indent); out << " hash: " << hash << std::endl ;
printIndent(out, int_Indent); out << " chunk: " << chunk_number << "..." << std::endl ;
printRsItemEnd(out, "RsFileTransferSingleChunkCrcRequestItem", indent);
return out;
}
std::ostream& RsFileTransferSingleChunkCrcItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferSingleChunkCrcItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ;
printIndent(out, int_Indent); out << " hash: " << hash << std::endl ;
printIndent(out, int_Indent); out << " chunk: " << chunk_number << "..." << std::endl ;
printIndent(out, int_Indent); out << " sha1: " << check_sum.toStdString() << "..." << std::endl ;
printRsItemEnd(out, "RsFileTransferSingleChunkCrcItem", indent);
return out;
}
std::ostream& RsFileTransferDataItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsFileTransferDataItem", indent);
uint16_t int_Indent = indent + 2;
fd.print(out, int_Indent);
printRsItemEnd(out, "RsFileTransferDataItem", indent);
return out;
}
/**********************************************************************************************/
/* SERIAL SIZE */
/**********************************************************************************************/
uint32_t RsFileTransferDataRequestItem::serial_size()
{
uint32_t s = 8; /* header */
s += 8; /* offset */
s += 4; /* chunksize */
s += file.TlvSize();
return s;
}
uint32_t RsFileTransferCacheItem::serial_size()
{
uint32_t s = 8; /* header */
s += 4; /* type/subid */
s += file.TlvSize();
return s;
}
uint32_t RsFileTransferDataItem::serial_size()
{
uint32_t s = 8; /* header */
s += fd.TlvSize();
return s;
}
uint32_t RsFileTransferChunkMapRequestItem::serial_size()
{
uint32_t s = 8; /* header */
s += 1 ; // is_client
s += GetTlvStringSize(hash) ; // hash
return s;
}
uint32_t RsFileTransferChunkMapItem::serial_size()
{
uint32_t s = 8; /* header */
s += 1 ; // is_client
s += GetTlvStringSize(hash) ; // hash
s += 4 ; // compressed map size
s += 4 * compressed_map._map.size() ; // compressed chunk map
return s;
}
uint32_t RsFileTransferSingleChunkCrcItem::serial_size()
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(hash) ; // hash
s += 4 ; // chunk number
s += 20 ; // sha1
return s;
}
uint32_t RsFileTransferSingleChunkCrcRequestItem::serial_size()
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(hash) ; // hash
s += 4 ; // chunk number
return s;
}
/*************************************************************************/
void RsFileTransferDataRequestItem::clear()
{
file.TlvClear();
fileoffset = 0;
chunksize = 0;
}
void RsFileTransferCacheItem::clear()
{
cacheType = 0;
cacheSubId = 0;
file.TlvClear();
}
void RsFileTransferDataItem::clear()
{
fd.TlvClear();
}
/**********************************************************************************************/
/* SERIALISATION */
/**********************************************************************************************/
bool RsFileTransferItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset)
{
tlvsize = serial_size() ;
offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
pktsize = tlvsize;
bool ok = true;
if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize))
{
std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl;
return false ;
}
#ifdef RSSERIAL_DEBUG
std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl;
#endif
offset += 8;
return true ;
}
/* serialise the data to the buffer */
bool RsFileTransferChunkMapRequestItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= setRawUInt8(data, tlvsize, &offset, is_client);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
}
return ok;
}
bool RsFileTransferSingleChunkCrcRequestItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ;
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
}
return ok;
}
bool RsFileTransferSingleChunkCrcItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ;
ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[0]) ;
ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[1]) ;
ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[2]) ;
ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[3]) ;
ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[4]) ;
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
}
return ok;
}
bool RsFileTransferChunkMapItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= setRawUInt8(data, tlvsize, &offset, is_client);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
ok &= setRawUInt32(data, tlvsize, &offset, compressed_map._map.size());
for(uint32_t i=0;i<compressed_map._map.size();++i)
ok &= setRawUInt32(data, tlvsize, &offset, compressed_map._map[i]);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
}
return ok;
}
/* serialise the data to the buffer */
bool RsFileTransferDataItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= fd.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
}
#ifdef DEBUG_TRANSFERS
std::cerr << "RsFileItemSerialiser::serialiseData() at: " << RsUtil::AccurateTimeString() << std::endl;
print(std::cerr, 10);
#endif
return ok;
}
/* serialise the data to the buffer */
bool RsFileTransferDataRequestItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, fileoffset);
ok &= setRawUInt32(data, tlvsize, &offset, chunksize);
ok &= file.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsFileTransferDataRequestItem::serialise() Size Error! " << std::endl;
}
/*** Debugging Transfer rates.
* print timestamp, and file details so we can workout packet lags.
***/
#ifdef DEBUG_TRANSFERS
std::cerr << "RsFileTransferDataRequestItem::serialise() at: " << RsUtil::AccurateTimeString() << std::endl;
print(std::cerr, 10);
#endif
return ok;
}
/* serialise the data to the buffer */
bool RsFileTransferCacheItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
/* add mandatory parts first */
ok &= setRawUInt16(data, tlvsize, &offset, cacheType);
ok &= setRawUInt16(data, tlvsize, &offset, cacheSubId);
ok &= file.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsFileItemSerialiser::serialiseItem() Size Error! " << std::endl;
#endif
}
return ok;
}
/**********************************************************************************************/
/* DESERIALISATION */
/**********************************************************************************************/
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CACHE_ITEM != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(): wong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferCacheItem *item = new RsFileTransferCacheItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt16(data, rssize, &offset, &(item->cacheType));
ok &= getRawUInt16(data, rssize, &offset, &(item->cacheSubId));
ok &= item->file.GetTlv(data, rssize, &offset);
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(): wong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferChunkMapRequestItem *item = new RsFileTransferChunkMapRequestItem();
item->clear();
/* skip the header */
offset += 8;
uint8_t tmp ;
ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_DATA != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(): wong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferDataItem *item = new RsFileTransferDataItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= item->fd.GetTlv(data, rssize, &offset);
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
#ifdef DEBUG_TRANSFERS
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem() at: " << RsUtil::AccurateTimeString() << std::endl;
item->print(std::cerr, 10);
#endif
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_DATA_REQUEST != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(): wrong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
RsFileTransferDataRequestItem *item = new RsFileTransferDataRequestItem() ;
bool ok = true;
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt64(data, rssize, &offset, &item->fileoffset);
ok &= getRawUInt32(data, rssize, &offset, &item->chunksize);
ok &= item->file.GetTlv(data, rssize, &offset);
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
/*** Debugging Transfer rates.
* print timestamp, and file details so we can workout packet lags.
***/
#ifdef DEBUG_TRANSFERS
std::cerr << "RsFileItemSerialiser::deserialise_RsFileTransferDataRequestItem() at: " << RsUtil::AccurateTimeString() << std::endl;
item->print(std::cerr, 10);
#endif
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_MAP != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(): wrong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferChunkMapItem *item = new RsFileTransferChunkMapItem();
item->clear();
/* skip the header */
offset += 8;
uint8_t tmp ;
ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
uint32_t size =0;
ok &= getRawUInt32(data, rssize, &offset, &size);
if(ok)
{
item->compressed_map._map.resize(size) ;
for(uint32_t i=0;i<size && ok;++i)
ok &= getRawUInt32(data, rssize, &offset, &(item->compressed_map._map[i]));
}
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(): wrong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferSingleChunkCrcRequestItem *item = new RsFileTransferSingleChunkCrcRequestItem();
item->clear();
/* skip the header */
offset += 8;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number));
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(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_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_CRC != getRsItemSubType(rstype))
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(): wrong subtype!" << std::endl;
return NULL; /* wrong type */
}
if (pktsize < rssize) /* check size */
{
std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(): size inconsistency!" << std::endl;
return NULL; /* not enough data */
}
bool ok = true;
/* ready to load */
RsFileTransferSingleChunkCrcItem *item = new RsFileTransferSingleChunkCrcItem();
item->clear();
/* skip the header */
offset += 8;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number));
ok &= getRawUInt32(data, rssize, &offset, &(item->check_sum.fourbytes[0]));
ok &= getRawUInt32(data, rssize, &offset, &(item->check_sum.fourbytes[1]));
ok &= getRawUInt32(data, rssize, &offset, &(item->check_sum.fourbytes[2]));
ok &= getRawUInt32(data, rssize, &offset, &(item->check_sum.fourbytes[3]));
ok &= getRawUInt32(data, rssize, &offset, &(item->check_sum.fourbytes[4]));
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/

250
libretroshare/src/serialiser/rsfiletransferitems.h Normal file
View file

@ -0,0 +1,250 @@
#pragma once
/*
* libretroshare/src/serialiser: rsbaseitems.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 "retroshare/rstypes.h"
#include "serialiser/rsserial.h"
#include "serialiser/rstlvtypes.h"
#include "serialiser/rsserviceids.h"
const uint8_t RS_PKT_SUBTYPE_FT_DATA_REQUEST = 0x01;
const uint8_t RS_PKT_SUBTYPE_FT_DATA = 0x02;
const uint8_t RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST = 0x04;
const uint8_t RS_PKT_SUBTYPE_FT_CHUNK_MAP = 0x05;
const uint8_t RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST = 0x08;
const uint8_t RS_PKT_SUBTYPE_FT_CHUNK_CRC = 0x09;
const uint8_t RS_PKT_SUBTYPE_FT_CACHE_ITEM = 0x0A;
const uint8_t RS_PKT_SUBTYPE_FT_CACHE_REQUEST = 0x0B;
//const uint8_t RS_PKT_SUBTYPE_FT_TRANSFER = 0x03;
//const uint8_t RS_PKT_SUBTYPE_FT_CRC32_MAP_REQUEST = 0x06;
//const uint8_t RS_PKT_SUBTYPE_FT_CRC32_MAP = 0x07;
/**************************************************************************/
class RsFileTransferItem: public RsItem
{
public:
RsFileTransferItem(uint8_t ft_subtype)
: RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_FILE_TRANSFER,ft_subtype)
{}
virtual ~RsFileTransferItem() {}
virtual bool serialise(void *data,uint32_t& size) = 0 ;
virtual uint32_t serial_size() = 0 ;
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0;
virtual void clear() = 0 ;
protected:
bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) ;
};
class RsFileTransferDataRequestItem: public RsFileTransferItem
{
public:
RsFileTransferDataRequestItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_DATA_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_REQUEST) ;
}
virtual ~RsFileTransferDataRequestItem() {}
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
uint64_t fileoffset; /* start of data requested */
uint32_t chunksize; /* size of data requested */
RsTlvFileItem file; /* file information */
};
/**************************************************************************/
class RsFileTransferDataItem: public RsFileTransferItem
{
public:
RsFileTransferDataItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_DATA)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_DATA) ;
}
virtual ~RsFileTransferDataItem() { clear() ; }
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear();
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
RsTlvFileData fd;
};
class RsFileTransferChunkMapRequestItem: public RsFileTransferItem
{
public:
RsFileTransferChunkMapRequestItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP_REQUEST) ;
}
virtual ~RsFileTransferChunkMapRequestItem() {}
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear() {}
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
bool is_client ; // is the request for a client, or a server ?
std::string hash ; // hash of the file for which we request the chunk map
};
class RsFileTransferChunkMapItem: public RsFileTransferItem
{
public:
RsFileTransferChunkMapItem()
:RsFileTransferItem(RS_PKT_SUBTYPE_FT_CHUNK_MAP)
{
setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP) ;
}
virtual ~RsFileTransferChunkMapItem() {}
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear() {}
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
bool is_client ; // is the request for a client, or a server ?
std::string hash ; // hash of the file for which we request the chunk map
CompressedChunkMap compressed_map ; // Chunk map of the file.
};
class RsFileTransferSingleChunkCrcRequestItem: public RsFileTransferItem
{
public:
RsFileTransferSingleChunkCrcRequestItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST)
{
setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC_REQUEST) ;
}
virtual ~RsFileTransferSingleChunkCrcRequestItem() {}
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear() {}
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
std::string hash ; // hash of the file for which we request the crc
uint32_t chunk_number ; // chunk number
};
class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem
{
public:
RsFileTransferSingleChunkCrcItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_CHUNK_CRC)
{
setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC) ;
}
virtual ~RsFileTransferSingleChunkCrcItem() {}
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear() {}
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
// Private data part.
//
std::string hash ; // hash of the file for which we request the chunk map
uint32_t chunk_number ;
Sha1CheckSum check_sum ; // CRC32 map of the file.
};
class RsFileTransferCacheItem: public RsFileTransferItem
{
public:
RsFileTransferCacheItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_CACHE_ITEM)
{
setPriorityLevel(QOS_PRIORITY_RS_CACHE_ITEM);
}
virtual ~RsFileTransferCacheItem(){ clear() ; }
virtual bool serialise(void *data,uint32_t& size) ;
virtual uint32_t serial_size() ;
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
// private part.
//
uint16_t cacheType;
uint16_t cacheSubId;
RsTlvFileItem file; /* file information */
};
/**************************************************************************/
class RsFileTransferSerialiser: public RsSerialType
{
public:
RsFileTransferSerialiser(): RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FILE_TRANSFER) {}
virtual ~RsFileTransferSerialiser() {}
virtual uint32_t size(RsItem *item)
{
return dynamic_cast<RsFileTransferItem*>(item)->serial_size() ;
}
virtual bool serialise(RsItem *item, void *data, uint32_t *size)
{
return dynamic_cast<RsFileTransferItem*>(item)->serialise(data,*size) ;
}
virtual RsFileTransferItem *deserialise(void *data, uint32_t *size);
private:
RsFileTransferItem *deserialise_RsFileTransferCacheItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferChunkMapRequestItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferChunkMapItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferDataRequestItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferDataItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferSingleChunkCrcItem(void *data, uint32_t pktsize);
RsFileTransferItem *deserialise_RsFileTransferSingleChunkCrcRequestItem(void *data, uint32_t pktsize);
};
/**************************************************************************/

493
libretroshare/src/serialiser/rsforumitems.cc
View file

@ -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;
}
/*************************************************************************/

124
libretroshare/src/serialiser/rsforumitems.h
View file

@ -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 */

212
libretroshare/src/serialiser/rsgameitems.cc
View file

@ -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);
}
/*************************************************************************/

84
libretroshare/src/serialiser/rsgameitems.h
View file

@ -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 */

20
libretroshare/src/serialiser/rsgxsiditems.cc
View file

@ -122,20 +122,30 @@ void RsGxsIdGroupItem::clear()
group.mPgpIdHash.clear();
group.mPgpIdSign.clear();
group.mRecognTags.clear();
group.mPgpKnown = false;
group.mPgpId.clear();
}
std::ostream& RsGxsIdGroupItem::print(std::ostream& out, uint16_t indent)
{
printRsItemBase(out, "RsGxsIdGroupItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "MetaData: " << meta << std::endl;
printIndent(out, int_Indent);
out << "PgpIdHash: " << group.mPgpIdHash << std::endl;
printIndent(out, int_Indent);
out << "PgpIdSign: " << group.mPgpIdSign << std::endl;
printIndent(out, int_Indent);
out << "RecognTags:" << std::endl;
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, group.mRecognTags);
set.print(out, int_Indent + 2);
printRsItemEnd(out ,"RsGxsIdGroupItem", indent);
return out;
@ -151,6 +161,9 @@ uint32_t RsGxsIdSerialiser::sizeGxsIdGroupItem(RsGxsIdGroupItem *item)
s += GetTlvStringSize(group.mPgpIdHash);
s += GetTlvStringSize(group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);
s += set.TlvSize();
return s;
}
@ -181,6 +194,9 @@ bool RsGxsIdSerialiser::serialiseGxsIdGroupItem(RsGxsIdGroupItem *item, void *da
/* GxsIdGroupItem */
ok &= SetTlvString(data, tlvsize, &offset, 1, item->group.mPgpIdHash);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);
ok &= set.SetTlv(data, tlvsize, &offset);
if(offset != tlvsize)
{
@ -238,6 +254,10 @@ RsGxsIdGroupItem* RsGxsIdSerialiser::deserialiseGxsIdGroupItem(void *data, uint3
ok &= GetTlvString(data, rssize, &offset, 1, item->group.mPgpIdHash);
ok &= GetTlvString(data, rssize, &offset, 1, item->group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);
ok &= set.GetTlv(data, rssize, &offset);
if (offset != rssize)
{

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

@ -47,6 +47,10 @@
this->mInternalCircle = rGxsMeta.mInternalCircle;
this->mOriginator = rGxsMeta.mOriginator;
this->mAuthenFlags = rGxsMeta.mAuthenFlags;
// std::cout << "rGxsMeta.mParentGrpId= " <<rGxsMeta.mParentGrpId<<"\n";
// std::cout << "rGxsMeta.mParentGrpId.length()= " <<rGxsMeta.mParentGrpId.length()<<"\n";
//std::cout << "this->mParentGrpId= " <<this->mParentGrpId<<"\n";
this->mParentGrpId = rGxsMeta.mParentGrpId;
}

600
libretroshare/src/serialiser/rsgxsrecognitems.cc Normal file
View file

@ -0,0 +1,600 @@
/*
* libretroshare/src/serialiser: rsgxsrecogitems.cc
*
* RetroShare Serialiser.
*
* Copyright 2013-2013 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.1 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/rsgxsrecognitems.h"
/***
#define RSSERIAL_DEBUG 1
***/
#include <iostream>
/*************************************************************************/
RsGxsRecognReqItem::~RsGxsRecognReqItem()
{
return;
}
void RsGxsRecognReqItem::clear()
{
issued_at = 0;
period = 0;
tag_class = 0;
tag_type = 0;
identity.clear();
nickname.clear();
comment.clear();
sign.TlvClear();
}
std::ostream &RsGxsRecognReqItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsGxsRecognReqItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "issued_at: " << issued_at << std::endl;
printIndent(out, int_Indent);
out << "period: " << period << std::endl;
printIndent(out, int_Indent);
out << "tag_class: " << tag_class << std::endl;
printIndent(out, int_Indent);
out << "tag_type: " << tag_type << std::endl;
printIndent(out, int_Indent);
out << "identity: " << identity << std::endl;
printIndent(out, int_Indent);
out << "nickname: " << nickname << std::endl;
printIndent(out, int_Indent);
out << "comment: " << comment << std::endl;
printIndent(out, int_Indent);
out << "signature: " << std::endl;
sign.print(out, int_Indent + 2);
printRsItemEnd(out, "RsGxsRecognReqItem", indent);
return out;
}
uint32_t RsGxsRecognSerialiser::sizeReq(RsGxsRecognReqItem *item)
{
uint32_t s = 8; /* header */
s += 4; // issued_at;
s += 4; // period;
s += 2; // tag_class;
s += 2; // tag_type;
s += GetTlvStringSize(item->identity);
s += GetTlvStringSize(item->nickname);
s += GetTlvStringSize(item->comment);
s += item->sign.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsGxsRecognSerialiser::serialiseReq(RsGxsRecognReqItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeReq(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 << "RsGxsRecognSerialiser::serialiseReq() Header: " << ok << std::endl;
std::cerr << "RsGxsRecognSerialiser::serialiseReq() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->issued_at);
ok &= setRawUInt32(data, tlvsize, &offset, item->period);
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class);
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->identity);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->nickname);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->comment);
ok &= item->sign.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsGxsRecognSerialiser::serialiseReq() Size Error! " << std::endl;
#endif
}
return ok;
}
RsGxsRecognReqItem *RsGxsRecognSerialiser::deserialiseReq(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_GXS_RECOGN != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_RECOGN_REQ != 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 */
RsGxsRecognReqItem *item = new RsGxsRecognReqItem();
item->clear();
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= getRawUInt32(data, tlvsize, &offset, &(item->issued_at));
ok &= getRawUInt32(data, tlvsize, &offset, &(item->period));
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class));
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type));
ok &= GetTlvString(data, tlvsize, &offset, 1, item->identity);
ok &= GetTlvString(data, tlvsize, &offset, 1, item->nickname);
ok &= GetTlvString(data, tlvsize, &offset, 1, item->comment);
ok &= item->sign.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsGxsRecognTagItem::~RsGxsRecognTagItem()
{
return;
}
void RsGxsRecognTagItem::clear()
{
valid_from = 0;
valid_to = 0;
tag_class = 0;
tag_type = 0;
identity.clear();
nickname.clear();
sign.TlvClear();
}
std::ostream &RsGxsRecognTagItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsGxsRecognTagItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "valid_from: " << valid_from << std::endl;
printIndent(out, int_Indent);
out << "valid_to: " << valid_to << std::endl;
printIndent(out, int_Indent);
out << "tag_class: " << tag_class << std::endl;
printIndent(out, int_Indent);
out << "tag_type: " << tag_type << std::endl;
printIndent(out, int_Indent);
out << "identity: " << identity << std::endl;
printIndent(out, int_Indent);
out << "nickname: " << nickname << std::endl;
printIndent(out, int_Indent);
out << "signature: " << std::endl;
sign.print(out, int_Indent + 2);
printRsItemEnd(out, "RsGxsRecognTagItem", indent);
return out;
}
uint32_t RsGxsRecognSerialiser::sizeTag(RsGxsRecognTagItem *item)
{
uint32_t s = 8; /* header */
s += 4; // valid_from;
s += 4; // valid_to;
s += 2; // tag_class;
s += 2; // tag_type;
s += GetTlvStringSize(item->identity);
s += GetTlvStringSize(item->nickname);
s += item->sign.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsGxsRecognSerialiser::serialiseTag(RsGxsRecognTagItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeTag(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 << "RsGxsRecognSerialiser::serialiseTag() Header: " << ok << std::endl;
std::cerr << "RsGxsRecognSerialiser::serialiseTag() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->valid_from);
ok &= setRawUInt32(data, tlvsize, &offset, item->valid_to);
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class);
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->identity);
ok &= SetTlvString(data, tlvsize, &offset, 1, item->nickname);
ok &= item->sign.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsGxsRecognSerialiser::serialiseTag() Size Error! " << std::endl;
#endif
}
return ok;
}
RsGxsRecognTagItem *RsGxsRecognSerialiser::deserialiseTag(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_GXS_RECOGN != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_RECOGN_TAG != 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 */
RsGxsRecognTagItem *item = new RsGxsRecognTagItem();
item->clear();
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= getRawUInt32(data, tlvsize, &offset, &(item->valid_from));
ok &= getRawUInt32(data, tlvsize, &offset, &(item->valid_to));
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class));
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type));
ok &= GetTlvString(data, tlvsize, &offset, 1, item->identity);
ok &= GetTlvString(data, tlvsize, &offset, 1, item->nickname);
ok &= item->sign.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
RsGxsRecognSignerItem::~RsGxsRecognSignerItem()
{
return;
}
void RsGxsRecognSignerItem::clear()
{
signing_classes.TlvClear();
key.TlvClear();
sign.TlvClear();
}
std::ostream &RsGxsRecognSignerItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsGxsRecognSignerItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "signing_classes: " << std::endl;
signing_classes.print(out, int_Indent + 2);
printIndent(out, int_Indent);
out << "key: " << std::endl;
key.print(out, int_Indent + 2);
printIndent(out, int_Indent);
out << "signature: " << std::endl;
sign.print(out, int_Indent + 2);
printRsItemEnd(out, "RsGxsRecognSignerItem", indent);
return out;
}
uint32_t RsGxsRecognSerialiser::sizeSigner(RsGxsRecognSignerItem *item)
{
uint32_t s = 8; /* header */
s += item->signing_classes.TlvSize();
s += item->key.TlvSize();
s += item->sign.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsGxsRecognSerialiser::serialiseSigner(RsGxsRecognSignerItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeSigner(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 << "RsGxsRecognSerialiser::serialiseSigner() Header: " << ok << std::endl;
std::cerr << "RsGxsRecognSerialiser::serialiseSigner() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->signing_classes.SetTlv(data, tlvsize, &offset);
ok &= item->key.SetTlv(data, tlvsize, &offset);
ok &= item->sign.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsGxsRecognSerialiser::serialiseSigner() Size Error! " << std::endl;
#endif
}
return ok;
}
RsGxsRecognSignerItem *RsGxsRecognSerialiser::deserialiseSigner(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_GXS_RECOGN != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_RECOGN_SIGNER != 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 */
RsGxsRecognSignerItem *item = new RsGxsRecognSignerItem();
item->clear();
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->signing_classes.GetTlv(data, tlvsize, &offset);
ok &= item->key.GetTlv(data, tlvsize, &offset);
ok &= item->sign.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
uint32_t RsGxsRecognSerialiser::size(RsItem *i)
{
RsGxsRecognReqItem *rqi;
RsGxsRecognTagItem *rti;
RsGxsRecognSignerItem *rsi;
if (NULL != (rqi = dynamic_cast<RsGxsRecognReqItem *>(i)))
{
return sizeReq(rqi);
}
if (NULL != (rti = dynamic_cast<RsGxsRecognTagItem *>(i)))
{
return sizeTag(rti);
}
if (NULL != (rsi = dynamic_cast<RsGxsRecognSignerItem *>(i)))
{
return sizeSigner(rsi);
}
return 0;
}
bool RsGxsRecognSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsGxsRecognReqItem *rri;
RsGxsRecognTagItem *rti;
RsGxsRecognSignerItem *rsi;
if (NULL != (rri = dynamic_cast<RsGxsRecognReqItem *>(i)))
{
return serialiseReq(rri, data, pktsize);
}
if (NULL != (rti = dynamic_cast<RsGxsRecognTagItem *>(i)))
{
return serialiseTag(rti, data, pktsize);
}
if (NULL != (rsi = dynamic_cast<RsGxsRecognSignerItem *>(i)))
{
return serialiseSigner(rsi, data, pktsize);
}
return false;
}
RsItem *RsGxsRecognSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_GXS_RECOGN != getRsItemService(rstype)))
{
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_RECOGN_REQ:
return deserialiseReq(data, pktsize);
break;
case RS_PKT_SUBTYPE_RECOGN_TAG:
return deserialiseTag(data, pktsize);
break;
case RS_PKT_SUBTYPE_RECOGN_SIGNER:
return deserialiseSigner(data, pktsize);
break;
default:
return NULL;
break;
}
}
/*************************************************************************/

152
libretroshare/src/serialiser/rsgxsrecognitems.h Normal file
View file

@ -0,0 +1,152 @@
#ifndef RS_GXS_RECOG_ITEMS_H
#define RS_GXS_RECOG_ITEMS_H
/*
* libretroshare/src/serialiser: rsgxsrecogitems.h
*
* RetroShare Serialiser.
*
* Copyright 2013-2013 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.1 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"
/**************************************************************************/
#define RS_PKT_SUBTYPE_RECOGN_REQ 0x01
#define RS_PKT_SUBTYPE_RECOGN_TAG 0x02
#define RS_PKT_SUBTYPE_RECOGN_SIGNER 0x03
class RsGxsRecognReqItem: public RsItem
{
public:
RsGxsRecognReqItem()
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN,
RS_PKT_SUBTYPE_RECOGN_REQ)
{
setPriorityLevel(QOS_PRIORITY_DEFAULT);
return;
}
virtual ~RsGxsRecognReqItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint32_t issued_at;
uint32_t period;
uint16_t tag_class;
uint16_t tag_type;
std::string identity;
std::string nickname;
std::string comment;
RsTlvKeySignature sign;
};
class RsGxsRecognTagItem: public RsItem
{
public:
RsGxsRecognTagItem()
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN,
RS_PKT_SUBTYPE_RECOGN_TAG)
{
setPriorityLevel(QOS_PRIORITY_DEFAULT);
return;
}
virtual ~RsGxsRecognTagItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
uint32_t valid_from;
uint32_t valid_to;
uint16_t tag_class;
uint16_t tag_type;
std::string identity;
std::string nickname;
RsTlvKeySignature sign;
};
class RsGxsRecognSignerItem: public RsItem
{
public:
RsGxsRecognSignerItem()
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN,
RS_PKT_SUBTYPE_RECOGN_SIGNER)
{
setPriorityLevel(QOS_PRIORITY_DEFAULT);
return;
}
virtual ~RsGxsRecognSignerItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsTlvServiceIdSet signing_classes;
RsTlvSecurityKey key; // has from->to, and flags.
RsTlvKeySignature sign;
};
class RsGxsRecognSerialiser: public RsSerialType
{
public:
RsGxsRecognSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN)
{ return; }
virtual ~RsGxsRecognSerialiser()
{ 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 sizeReq(RsGxsRecognReqItem *);
virtual bool serialiseReq(RsGxsRecognReqItem *item, void *data, uint32_t *size);
virtual RsGxsRecognReqItem *deserialiseReq(void *data, uint32_t *size);
virtual uint32_t sizeTag(RsGxsRecognTagItem *);
virtual bool serialiseTag(RsGxsRecognTagItem *item, void *data, uint32_t *size);
virtual RsGxsRecognTagItem *deserialiseTag(void *data, uint32_t *size);
virtual uint32_t sizeSigner(RsGxsRecognSignerItem *);
virtual bool serialiseSigner(RsGxsRecognSignerItem *item, void *data, uint32_t *size);
virtual RsGxsRecognSignerItem *deserialiseSigner(void *data, uint32_t *size);
};
/**************************************************************************/
#endif /* RS_GXS_RECOGN_ITEMS_H */

704
libretroshare/src/serialiser/rsgxsupdateitems.cc Normal file
View file

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

149
libretroshare/src/serialiser/rsgxsupdateitems.h Normal file
View file

@ -0,0 +1,149 @@
#ifndef RSGXSUPDATEITEMS_H_
#define RSGXSUPDATEITEMS_H_
/*
* libretroshare/src/serialiser: rsgxsupdateitems.h
*
* RetroShare Serialiser.
*
* Copyright 2012 Christopher Evi-Parker
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "retroshare@lunamutt.com".
*
*/
#include <map>
#include "serialiser/rsserviceids.h"
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
#include "serialiser/rstlvkeys.h"
#include "gxs/rsgxsdata.h"
const uint8_t RS_PKT_SUBTYPE_GXS_GRP_UPDATE = 0x0001;
const uint8_t RS_PKT_SUBTYPE_GXS_MSG_UPDATE = 0x0002;
const uint8_t RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE = 0x0004;
const uint8_t RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE = 0x0008;
class RsGxsGrpUpdateItem : public RsItem {
public:
RsGxsGrpUpdateItem(uint16_t servType) : RsItem(RS_PKT_VERSION_SERVICE, servType,
RS_PKT_SUBTYPE_GXS_GRP_UPDATE)
{clear();}
virtual ~RsGxsGrpUpdateItem() {}
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::string peerId;
uint32_t grpUpdateTS;
};
class RsGxsServerGrpUpdateItem : public RsItem {
public:
RsGxsServerGrpUpdateItem(uint16_t servType) : RsItem(RS_PKT_VERSION_SERVICE, servType,
RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE)
{ clear();}
virtual ~RsGxsServerGrpUpdateItem() {}
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent);
uint32_t grpUpdateTS;
};
class RsGxsMsgUpdateItem : public RsItem
{
public:
RsGxsMsgUpdateItem(uint16_t servType) : RsItem(RS_PKT_VERSION_SERVICE, servType, RS_PKT_SUBTYPE_GXS_MSG_UPDATE)
{ clear();}
virtual ~RsGxsMsgUpdateItem() {}
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::string peerId;
std::map<std::string, uint32_t> msgUpdateTS;
};
class RsGxsServerMsgUpdateItem : public RsItem
{
public:
RsGxsServerMsgUpdateItem(uint16_t servType) : RsItem(RS_PKT_VERSION_SERVICE,
servType, RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE)
{ clear();}
virtual ~RsGxsServerMsgUpdateItem() {}
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::string grpId;
uint32_t msgUpdateTS; // the last time this group received a new msg
};
class RsGxsUpdateSerialiser : public RsSerialType
{
public:
RsGxsUpdateSerialiser(uint16_t servtype) :
RsSerialType(RS_PKT_VERSION_SERVICE, servtype), SERVICE_TYPE(servtype) { return; }
virtual ~RsGxsUpdateSerialiser() { return; }
virtual uint32_t size(RsItem *item);
virtual bool serialise(RsItem *item, void *data, uint32_t *size);
virtual RsItem* deserialise(void *data, uint32_t *size);
private:
/* for RS_PKT_SUBTYPE_GRP_UPDATE_ITEM */
virtual uint32_t sizeGxsGrpUpdate(RsGxsGrpUpdateItem* item);
virtual bool serialiseGxsGrpUpdate(RsGxsGrpUpdateItem *item, void *data, uint32_t *size);
virtual RsGxsGrpUpdateItem* deserialGxsGrpUpddate(void *data, uint32_t *size);
/* for RS_PKT_SUBTYPE_GRP_SERVER_UPDATE_ITEM */
virtual uint32_t sizeGxsServerGrpUpdate(RsGxsServerGrpUpdateItem* item);
virtual bool serialiseGxsServerGrpUpdate(RsGxsServerGrpUpdateItem *item, void *data, uint32_t *size);
virtual RsGxsServerGrpUpdateItem* deserialGxsServerGrpUpddate(void *data, uint32_t *size);
/* for RS_PKT_SUBTYPE_GXS_MSG_UPDATE_ITEM */
virtual uint32_t sizeGxsMsgUpdate(RsGxsMsgUpdateItem* item);
virtual bool serialiseGxsMsgUpdate(RsGxsMsgUpdateItem *item, void *data, uint32_t *size);
virtual RsGxsMsgUpdateItem* deserialGxsMsgUpdate(void *data, uint32_t *size);
/* for RS_PKT_SUBTYPE_GXS_SERVER_UPDATE_ITEM */
virtual uint32_t sizeGxsServerMsgUpdate(RsGxsServerMsgUpdateItem* item);
virtual bool serialiseGxsServerMsgUpdate(RsGxsServerMsgUpdateItem *item, void *data, uint32_t *size);
virtual RsGxsServerMsgUpdateItem* deserialGxsServerMsgUpdate(void *data, uint32_t *size);
private:
const uint16_t SERVICE_TYPE;
};
#endif /* RSGXSUPDATEITEMS_H_ */

206
libretroshare/src/serialiser/rsheartbeatitems.cc Normal file
View file

@ -0,0 +1,206 @@
/*
* libretroshare/src/serialiser: rsheartbeatitems.cc
*
* RetroShare Serialiser.
*
* Copyright 2013-2013 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.1 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/rsserviceids.h"
#include "serialiser/rsheartbeatitems.h"
/***
* #define HEART_DEBUG 1
***/
#define HEART_DEBUG 1
#include <iostream>
/*************************************************************************/
uint32_t RsHeartbeatSerialiser::size(RsItem *i)
{
RsHeartbeatItem *beat;
if (NULL != (beat = dynamic_cast<RsHeartbeatItem *>(i)))
{
return sizeHeartbeat(beat);
}
return 0;
}
/* serialise the data to the buffer */
bool RsHeartbeatSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsHeartbeatItem *beat;
if (NULL != (beat = dynamic_cast<RsHeartbeatItem *>(i)))
{
return serialiseHeartbeat(beat, data, pktsize);
}
return false;
}
RsItem *RsHeartbeatSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_HEARTBEAT != getRsItemService(rstype)))
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::deserialise() Wrong Type" << std::endl;
#endif
return NULL;
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_HEARTBEAT_PULSE:
return deserialiseHeartbeat(data, pktsize);
break;
default:
return NULL;
break;
}
return NULL;
}
/*************************************************************************/
void RsHeartbeatItem::clear()
{
}
std::ostream &RsHeartbeatItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsHeartbeatItem", indent);
printRsItemEnd(out, "RsHeartbeatItem", indent);
return out;
}
uint32_t RsHeartbeatSerialiser::sizeHeartbeat(RsHeartbeatItem */*item*/)
{
uint32_t s = 8; /* header */
return s;
}
/* serialise the data to the buffer */
bool RsHeartbeatSerialiser::serialiseHeartbeat(RsHeartbeatItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeHeartbeat(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::serialiseHeartbeat() Not enough space" << std::endl;
#endif
return false; /* not enough space */
}
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, *pktsize, item->PacketId(), *pktsize);
/* skip the header */
offset += 8;
if (offset != tlvsize)
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::serialiseHeartbeat() size error" << std::endl;
#endif
ok = false;
}
return ok;
}
RsHeartbeatItem *RsHeartbeatSerialiser::deserialiseHeartbeat(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_HEARTBEAT != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_HEARTBEAT_PULSE != getRsItemSubType(rstype)))
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() Wrong Type" << std::endl;
#endif
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() size error" << std::endl;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
bool ok = true;
/* ready to load */
RsHeartbeatItem *item = new RsHeartbeatItem();
item->clear();
/* skip the header */
offset += 8;
if (offset != rssize)
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() size error2" << std::endl;
#endif
/* error */
delete item;
return NULL;
}
if (!ok)
{
#ifdef HEART_DEBUG
std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() ok = false" << std::endl;
#endif
delete item;
return NULL;
}
return item;
}
/*************************************************************************/

72
libretroshare/src/serialiser/rsheartbeatitems.h Normal file
View file

@ -0,0 +1,72 @@
/*
* libretroshare/src/serialiser: rsheartbeatitems.h
*
* Serialiser for RetroShare.
*
* Copyright 2004-2013 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.1 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".
*
*/
#ifndef RS_HEARTBEAT_ITEMS_H
#define RS_HEARTBEAT_ITEMS_H
#include "serialiser/rsserial.h"
#include "serialiser/rsserviceids.h"
const uint8_t RS_PKT_SUBTYPE_HEARTBEAT_PULSE = 0x01;
class RsHeartbeatItem: public RsItem
{
public:
RsHeartbeatItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_HEARTBEAT, RS_PKT_SUBTYPE_HEARTBEAT_PULSE)
{
setPriorityLevel(QOS_PRIORITY_RS_HEARTBEAT_PULSE) ;
}
virtual ~RsHeartbeatItem() {}
virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
};
class RsHeartbeatSerialiser: public RsSerialType
{
public:
RsHeartbeatSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_HEARTBEAT)
{ return; }
virtual ~RsHeartbeatSerialiser() { 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 sizeHeartbeat(RsHeartbeatItem *);
virtual bool serialiseHeartbeat(RsHeartbeatItem *item, void *data, uint32_t *size);
virtual RsHeartbeatItem *deserialiseHeartbeat(void *data, uint32_t *size);
};
#endif // RS_DISC_ITEMS_H

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

@ -147,7 +147,7 @@ bool RsHistorySerialiser::serialiseHistoryMsgItem(RsHistoryMsgItem* item, void*
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->peerName);
ok &= setRawUInt32(data, tlvsize, &offset, item->sendTime);
ok &= setRawUInt32(data, tlvsize, &offset, item->recvTime);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, item->message);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->message);
if (offset != tlvsize)
{
@ -202,7 +202,7 @@ RsHistoryMsgItem *RsHistorySerialiser::deserialiseHistoryMsgItem(void *data, uin
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->peerName);
ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime));
ok &= getRawUInt32(data, rssize, &offset, &(item->recvTime));
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->message);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->message);
if (offset != rssize)
{

24
libretroshare/src/serialiser/rsmsgitems.cc
View file

@ -307,7 +307,7 @@ uint32_t RsChatMsgItem::serial_size()
uint32_t s = 8; /* header */
s += 4; /* chatFlags */
s += 4; /* sendTime */
s += GetTlvWideStringSize(message);
s += GetTlvStringSize(message);
return s;
}
@ -422,7 +422,7 @@ uint32_t RsPrivateChatMsgConfigItem::serial_size()
s += 4; /* chatFlags */
s += 4; /* configFlags */
s += 4; /* sendTime */
s += GetTlvWideStringSize(message);
s += GetTlvStringSize(message);
s += 4; /* recvTime */
return s;
@ -503,7 +503,7 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize)
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, chatFlags);
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message);
#ifdef CHAT_DEBUG
std::cerr << "Serialized the following message:" << std::endl;
std::cerr << "========== BEGIN MESSAGE =========" << std::endl;
@ -811,7 +811,7 @@ bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize)
ok &= setRawUInt32(data, tlvsize, &offset, chatFlags);
ok &= setRawUInt32(data, tlvsize, &offset, configFlags);
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message);
ok &= setRawUInt32(data, tlvsize, &offset, recvTime);
if (offset != tlvsize)
@ -995,7 +995,7 @@ RsChatMsgItem::RsChatMsgItem(void *data,uint32_t /*size*/,uint8_t subtype)
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &chatFlags);
ok &= getRawUInt32(data, rssize, &offset, &sendTime);
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, message);
#ifdef CHAT_DEBUG
std::cerr << "Building new chat msg item." << std::endl ;
@ -1233,7 +1233,7 @@ RsPrivateChatMsgConfigItem::RsPrivateChatMsgConfigItem(void *data,uint32_t /*siz
ok &= getRawUInt32(data, rssize, &offset, &chatFlags);
ok &= getRawUInt32(data, rssize, &offset, &configFlags);
ok &= getRawUInt32(data, rssize, &offset, &sendTime);
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, message);
ok &= getRawUInt32(data, rssize, &offset, &recvTime);
#ifdef CHAT_DEBUG
@ -1511,8 +1511,8 @@ uint32_t RsMsgItem::serial_size(bool m_bConfiguration)
s += 4; /* sendTime */
s += 4; /* recvTime */
s += GetTlvWideStringSize(subject);
s += GetTlvWideStringSize(message);
s += GetTlvStringSize(subject);
s += GetTlvStringSize(message);
s += msgto.TlvSize();
s += msgcc.TlvSize();
@ -1555,8 +1555,8 @@ bool RsMsgItem::serialise(void *data, uint32_t& pktsize,bool config)
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
ok &= setRawUInt32(data, tlvsize, &offset, recvTime);
ok &= SetTlvWideString(data,tlvsize,&offset,TLV_TYPE_WSTR_SUBJECT,subject);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= SetTlvString(data,tlvsize,&offset,TLV_TYPE_STR_SUBJECT,subject);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message);
ok &= msgto.SetTlv(data, tlvsize, &offset);
ok &= msgcc.SetTlv(data, tlvsize, &offset);
@ -1612,8 +1612,8 @@ RsMsgItem *RsMsgSerialiser::deserialiseMsgItem(void *data, uint32_t *pktsize)
ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime));
ok &= getRawUInt32(data, rssize, &offset, &(item->recvTime));
ok &= GetTlvWideString(data,rssize,&offset,TLV_TYPE_WSTR_SUBJECT,item->subject);
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->message);
ok &= GetTlvString(data,rssize,&offset,TLV_TYPE_STR_SUBJECT,item->subject);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->message);
ok &= item->msgto.GetTlv(data, rssize, &offset);
ok &= item->msgcc.GetTlv(data, rssize, &offset);
ok &= item->msgbcc.GetTlv(data, rssize, &offset);

40
libretroshare/src/serialiser/rsmsgitems.h
View file

@ -50,24 +50,24 @@ const uint32_t RS_CHAT_FLAG_ACK_DISTANT_CONNECTION = 0x0800;
const uint32_t RS_CHATMSG_CONFIGFLAG_INCOMING = 0x0001;
const uint8_t RS_PKT_SUBTYPE_CHAT_AVATAR = 0x03 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_STATUS = 0x04 ;
const uint8_t RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG = 0x05 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_MSG_DEPRECATED= 0x06 ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE_DEPREC = 0x07 ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_ACCEPT = 0x08 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_CHALLENGE = 0x09 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE = 0x0A ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_EVENT_DEPREC = 0x0B ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_MSG = 0x0C ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST = 0x0D ;
const uint8_t RS_PKT_SUBTYPE_CHAT_AVATAR = 0x03 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_STATUS = 0x04 ;
const uint8_t RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG = 0x05 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_MSG_DEPRECATED = 0x06 ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE_DEPREC = 0x07 ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_ACCEPT = 0x08 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_CHALLENGE = 0x09 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE = 0x0A ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_EVENT_DEPREC = 0x0B ; // don't use ! Deprecated
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_MSG = 0x0C ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST = 0x0D ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_deprecated = 0x0E ; // to be removed
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE = 0x0F ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_EVENT = 0x10 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE = 0x0F ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_EVENT = 0x10 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_deprecated2 = 0x11 ; // to be removed (deprecated since 02 Dec. 2012)
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST = 0x12 ;
const uint8_t RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG = 0x13 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG = 0x15 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST = 0x12 ;
const uint8_t RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG = 0x13 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG = 0x15 ;
// for defining tags themselves and msg tags
const uint8_t RS_PKT_SUBTYPE_MSG_TAG_TYPE = 0x03;
@ -117,7 +117,7 @@ class RsChatMsgItem: public RsChatItem
uint32_t chatFlags;
uint32_t sendTime;
std::wstring message;
std::string message;
/* not serialised */
uint32_t recvTime;
};
@ -316,7 +316,7 @@ class RsPrivateChatMsgConfigItem: public RsChatItem
uint32_t chatFlags;
uint32_t configFlags;
uint32_t sendTime;
std::wstring message;
std::string message;
uint32_t recvTime;
};
class RsPrivateChatDistantInviteConfigItem: public RsChatItem
@ -478,8 +478,8 @@ class RsMsgItem: public RsMessageItem
uint32_t sendTime;
uint32_t recvTime;
std::wstring subject;
std::wstring message;
std::string subject;
std::string message;
RsTlvPeerIdSet msgto;
RsTlvPeerIdSet msgcc;

38
libretroshare/src/serialiser/rsnxsitems.cc
View file

@ -354,8 +354,9 @@ bool RsNxsSerialiser::serialiseNxsSyncGrp(RsNxsSyncGrp *item, void *data, uint32
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= setRawUInt32(data, *size, &offset, item->syncAge);
ok &= setRawUInt32(data, *size, &offset, item->createdSince);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
ok &= setRawUInt32(data, *size, &offset, item->updateTS);
if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG
@ -403,7 +404,7 @@ bool RsNxsSerialiser::serialiseNxsTrans(RsNxsTransac *item, void *data, uint32_t
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt16(data, *size, &offset, item->transactFlag);
ok &= setRawUInt32(data, *size, &offset, item->nItems);
ok &= setRawUInt32(data, *size, &offset, item->timestamp);
ok &= setRawUInt32(data, *size, &offset, item->updateTS);
@ -501,9 +502,10 @@ bool RsNxsSerialiser::serialiseNxsSyncMsg(RsNxsSyncMsg *item, void *data, uint32
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= setRawUInt32(data, *size, &offset, item->syncAge);
ok &= setRawUInt32(data, *size, &offset, item->createdSince);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= setRawUInt32(data, *size, &offset, item->updateTS);
if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG
@ -710,8 +712,9 @@ RsNxsSyncGrp* RsNxsSerialiser::deserialNxsSyncGrp(void *data, uint32_t *size){
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= getRawUInt8(data, *size, &offset, &(item->flag));
ok &= getRawUInt32(data, *size, &offset, &(item->syncAge));
ok &= getRawUInt32(data, *size, &offset, &(item->createdSince));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
ok &= getRawUInt32(data, *size, &offset, &(item->updateTS));
if (offset != rssize)
{
@ -846,7 +849,7 @@ RsNxsTransac* RsNxsSerialiser::deserialNxsTrans(void *data, uint32_t *size){
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= getRawUInt16(data, *size, &offset, &(item->transactFlag));
ok &= getRawUInt32(data, *size, &offset, &(item->nItems));
ok &= getRawUInt32(data, *size, &offset, &(item->timestamp));
ok &= getRawUInt32(data, *size, &offset, &(item->updateTS));
if (offset != rssize)
{
@ -984,9 +987,10 @@ RsNxsSyncMsg* RsNxsSerialiser::deserialNxsSyncMsg(void *data, uint32_t *size)
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= getRawUInt8(data, *size, &offset, &(item->flag));
ok &= getRawUInt32(data, *size, &offset, &(item->syncAge));
ok &= getRawUInt32(data, *size, &offset, &(item->createdSince));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= getRawUInt32(data, *size, &offset, &(item->updateTS));
if (offset != rssize)
{
@ -1057,6 +1061,7 @@ uint32_t RsNxsSerialiser::sizeNxsSyncGrp(RsNxsSyncGrp *item)
s += 1; // flag
s += 4; // sync age
s += GetTlvStringSize(item->syncHash);
s += 4; // updateTS
return s;
}
@ -1086,6 +1091,7 @@ uint32_t RsNxsSerialiser::sizeNxsSyncMsg(RsNxsSyncMsg *item)
s += 4; // age
s += GetTlvStringSize(item->grpId);
s += GetTlvStringSize(item->syncHash);
s += 4; // updateTS
return s;
}
@ -1111,7 +1117,7 @@ uint32_t RsNxsSerialiser::sizeNxsTrans(RsNxsTransac *item){
s += 4; // transaction number
s += 2; // flag
s += 4; // nMsgs
s += 4; // timeout
s += 4; // updateTS
return s;
}
@ -1141,16 +1147,18 @@ void RsNxsGrp::clear()
void RsNxsSyncGrp::clear()
{
flag = 0;
syncAge = 0;
createdSince = 0;
syncHash.clear();
updateTS = 0;
}
void RsNxsSyncMsg::clear()
{
grpId.clear();
flag = 0;
syncAge = 0;
createdSince = 0;
syncHash.clear();
updateTS = 0;
}
void RsNxsSyncGrpItem::clear()
@ -1172,6 +1180,7 @@ void RsNxsSyncMsgItem::clear()
void RsNxsTransac::clear(){
transactFlag = 0;
nItems = 0;
updateTS = 0;
timestamp = 0;
transactionNumber = 0;
}
@ -1185,10 +1194,11 @@ std::ostream& RsNxsSyncGrp::print(std::ostream &out, uint16_t indent)
printIndent(out , int_Indent);
out << "Hash: " << syncHash << std::endl;
printIndent(out , int_Indent);
out << "Sync Age: " << syncAge << std::endl;
out << "Sync Age: " << createdSince << std::endl;
printIndent(out , int_Indent);
out << "flag" << flag << std::endl;
printIndent(out , int_Indent);
out << "updateTS" << updateTS << std::endl;
printRsItemEnd(out ,"RsNxsSyncGrp", indent);
@ -1217,11 +1227,13 @@ std::ostream& RsNxsSyncMsg::print(std::ostream &out, uint16_t indent)
printIndent(out , int_Indent);
out << "GrpId: " << grpId << std::endl;
printIndent(out , int_Indent);
out << "syncAge: " << syncAge << std::endl;
out << "createdSince: " << createdSince << std::endl;
printIndent(out , int_Indent);
out << "syncHash: " << syncHash << std::endl;
printIndent(out , int_Indent);
out << "flag: " << flag << std::endl;
printIndent(out , int_Indent);
out << "updateTS: " << updateTS << std::endl;
printRsItemEnd(out, "RsNxsSyncMsg", indent);
return out;
@ -1316,6 +1328,8 @@ std::ostream& RsNxsTransac::print(std::ostream &out, uint16_t indent){
printIndent(out , int_Indent);
out << "timeout: " << timestamp << std::endl;
printIndent(out , int_Indent);
out << "updateTS: " << updateTS << std::endl;
printIndent(out , int_Indent);
out << "transactionNumber: " << transactionNumber << std::endl;
printIndent(out , int_Indent);

11
libretroshare/src/serialiser/rsnxsitems.h
View file

@ -70,7 +70,7 @@ public:
RsNxsItem(uint16_t servtype, uint8_t subtype)
: RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype), transactionNumber(0)
{
setPriorityLevel(QOS_PRIORITY_RS_VOIP_PING);
setPriorityLevel(QOS_PRIORITY_RS_GXS_NET);
return;
}
virtual ~RsNxsItem(){ return; }
@ -100,7 +100,8 @@ public:
virtual std::ostream &print(std::ostream &out, uint16_t indent);
uint8_t flag; // advises whether to use sync hash
uint32_t syncAge; // how far back to sync data
uint32_t createdSince; // how far back to sync data
uint32_t updateTS; // time of last group update
std::string syncHash; // use to determine if changes that have occured since last hash
@ -146,6 +147,9 @@ public:
uint16_t transactFlag;
uint32_t nItems;
uint32_t updateTS;
// not serialised
uint32_t timestamp;
};
@ -235,7 +239,8 @@ public:
std::string grpId;
uint8_t flag;
uint32_t syncAge;
uint32_t createdSince;
uint32_t updateTS; // time of last update
std::string syncHash;
};

373
libretroshare/src/serialiser/rsrttitems.cc Normal file
View file

@ -0,0 +1,373 @@
/*
* libretroshare/src/serialiser: rsrttitems.cc
*
* RetroShare Serialiser.
*
* Copyright 2011-2013 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.1 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/rsrttitems.h"
#include "serialiser/rstlvbase.h"
/***
#define RSSERIAL_DEBUG 1
***/
#include <iostream>
/*************************************************************************/
RsRttPingItem::~RsRttPingItem()
{
return;
}
void RsRttPingItem::clear()
{
mSeqNo = 0;
mPingTS = 0;
}
std::ostream& RsRttPingItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsRttPingItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "SeqNo: " << mSeqNo << std::endl;
printIndent(out, int_Indent);
out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl;
printRsItemEnd(out, "RsRttPingItem", indent);
return out;
}
RsRttPongItem::~RsRttPongItem()
{
return;
}
void RsRttPongItem::clear()
{
mSeqNo = 0;
mPingTS = 0;
mPongTS = 0;
}
std::ostream& RsRttPongItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsRttPongItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "SeqNo: " << mSeqNo << std::endl;
printIndent(out, int_Indent);
out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl;
printIndent(out, int_Indent);
out << "PongTS: " << std::hex << mPongTS << std::dec << std::endl;
printRsItemEnd(out, "RsRttPongItem", indent);
return out;
}
/*************************************************************************/
uint32_t RsRttSerialiser::sizeRttPingItem(RsRttPingItem */*item*/)
{
uint32_t s = 8; /* header */
s += 4; /* seqno */
s += 8; /* pingTS */
return s;
}
/* serialise the data to the buffer */
bool RsRttSerialiser::serialiseRttPingItem(RsRttPingItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeRttPingItem(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 << "RsRttSerialiser::serialiseRttPingItem() Header: " << ok << std::endl;
std::cerr << "RsRttSerialiser::serialiseRttPingItem() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->mSeqNo);
ok &= setRawUInt64(data, tlvsize, &offset, item->mPingTS);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsRttSerialiser::serialiseRttPingItem() Size Error! " << std::endl;
}
return ok;
}
RsRttPingItem *RsRttSerialiser::deserialiseRttPingItem(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_RTT != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_RTT_PING != 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 */
RsRttPingItem *item = new RsRttPingItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &(item->mSeqNo));
ok &= getRawUInt64(data, rssize, &offset, &(item->mPingTS));
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
/*************************************************************************/
uint32_t RsRttSerialiser::sizeRttPongItem(RsRttPongItem */*item*/)
{
uint32_t s = 8; /* header */
s += 4; /* seqno */
s += 8; /* pingTS */
s += 8; /* pongTS */
return s;
}
/* serialise the data to the buffer */
bool RsRttSerialiser::serialiseRttPongItem(RsRttPongItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeRttPongItem(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 << "RsRttSerialiser::serialiseRttPongItem() Header: " << ok << std::endl;
std::cerr << "RsRttSerialiser::serialiseRttPongItem() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->mSeqNo);
ok &= setRawUInt64(data, tlvsize, &offset, item->mPingTS);
ok &= setRawUInt64(data, tlvsize, &offset, item->mPongTS);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsRttSerialiser::serialiseRttPongItem() Size Error! " << std::endl;
}
return ok;
}
RsRttPongItem *RsRttSerialiser::deserialiseRttPongItem(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_RTT != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_RTT_PONG != 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 */
RsRttPongItem *item = new RsRttPongItem();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &(item->mSeqNo));
ok &= getRawUInt64(data, rssize, &offset, &(item->mPingTS));
ok &= getRawUInt64(data, rssize, &offset, &(item->mPongTS));
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
uint32_t RsRttSerialiser::size(RsItem *i)
{
RsRttPingItem *ping;
RsRttPongItem *pong;
if (NULL != (ping = dynamic_cast<RsRttPingItem *>(i)))
{
return sizeRttPingItem(ping);
}
else if (NULL != (pong = dynamic_cast<RsRttPongItem *>(i)))
{
return sizeRttPongItem(pong);
}
return 0;
}
bool RsRttSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
#ifdef RSSERIAL_DEBUG
std::cerr << "RsMsgSerialiser::serialise()" << std::endl;
#endif
RsRttPingItem *ping;
RsRttPongItem *pong;
if (NULL != (ping = dynamic_cast<RsRttPingItem *>(i)))
{
return serialiseRttPingItem(ping, data, pktsize);
}
else if (NULL != (pong = dynamic_cast<RsRttPongItem *>(i)))
{
return serialiseRttPongItem(pong, data, pktsize);
}
return false;
}
RsItem* RsRttSerialiser::deserialise(void *data, uint32_t *pktsize)
{
#ifdef RSSERIAL_DEBUG
std::cerr << "RsRttSerialiser::deserialise()" << std::endl;
#endif
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_RTT != getRsItemService(rstype)))
{
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_RTT_PING:
return deserialiseRttPingItem(data, pktsize);
break;
case RS_PKT_SUBTYPE_RTT_PONG:
return deserialiseRttPongItem(data, pktsize);
break;
default:
return NULL;
break;
}
return NULL;
}
/*************************************************************************/

108
libretroshare/src/serialiser/rsrttitems.h Normal file
View file

@ -0,0 +1,108 @@
#ifndef RS_RTT_ITEMS_H
#define RS_RTT_ITEMS_H
/*
* libretroshare/src/serialiser: rsrttitems.h
*
* RetroShare Serialiser.
*
* Copyright 2011-2013 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.1 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"
/**************************************************************************/
const uint8_t RS_PKT_SUBTYPE_RTT_PING = 0x01;
const uint8_t RS_PKT_SUBTYPE_RTT_PONG = 0x02;
class RsRttItem: public RsItem
{
public:
RsRttItem(uint8_t chat_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_RTT,chat_subtype)
{ setPriorityLevel(QOS_PRIORITY_RS_RTT_PING) ;} // should be refined later.
virtual ~RsRttItem() {};
virtual void clear() {};
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ;
};
class RsRttPingItem: public RsRttItem
{
public:
RsRttPingItem() :RsRttItem(RS_PKT_SUBTYPE_RTT_PING) {}
virtual ~RsRttPingItem();
virtual void clear();
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
uint32_t mSeqNo;
uint64_t mPingTS;
};
class RsRttPongItem: public RsRttItem
{
public:
RsRttPongItem() :RsRttItem(RS_PKT_SUBTYPE_RTT_PONG) {}
virtual ~RsRttPongItem();
virtual void clear();
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
uint32_t mSeqNo;
uint64_t mPingTS;
uint64_t mPongTS;
};
class RsRttSerialiser: public RsSerialType
{
public:
RsRttSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_RTT)
{ return; }
virtual ~RsRttSerialiser() { 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 sizeRttPingItem(RsRttPingItem *);
virtual bool serialiseRttPingItem (RsRttPingItem *item, void *data, uint32_t *size);
virtual RsRttPingItem *deserialiseRttPingItem(void *data, uint32_t *size);
virtual uint32_t sizeRttPongItem(RsRttPongItem *);
virtual bool serialiseRttPongItem (RsRttPongItem *item, void *data, uint32_t *size);
virtual RsRttPongItem *deserialiseRttPongItem(void *data, uint32_t *size);
};
/**************************************************************************/
#endif /* RS_RTT_ITEMS_H */

19
libretroshare/src/serialiser/rsserviceids.h
View file

@ -38,14 +38,16 @@
*/
/* These are Cache Only */
const uint16_t RS_SERVICE_TYPE_FILE_INDEX = 0x0001;
const uint16_t RS_SERVICE_TYPE_FILE_INDEX = 0x0001;
/* These are Services only */
const uint16_t RS_SERVICE_TYPE_DISC = 0x0011;
const uint16_t RS_SERVICE_TYPE_CHAT = 0x0012;
const uint16_t RS_SERVICE_TYPE_MSG = 0x0013;
const uint16_t RS_SERVICE_TYPE_TURTLE = 0x0014;
const uint16_t RS_SERVICE_TYPE_TUNNEL = 0x0015;
const uint16_t RS_SERVICE_TYPE_DISC = 0x0011;
const uint16_t RS_SERVICE_TYPE_CHAT = 0x0012;
const uint16_t RS_SERVICE_TYPE_MSG = 0x0013;
const uint16_t RS_SERVICE_TYPE_TURTLE = 0x0014;
const uint16_t RS_SERVICE_TYPE_TUNNEL = 0x0015;
const uint16_t RS_SERVICE_TYPE_HEARTBEAT = 0x0016;
const uint16_t RS_SERVICE_TYPE_FILE_TRANSFER = 0x0017;
/* BanList Still Testing at the moment - Service Only */
const uint16_t RS_SERVICE_TYPE_BANLIST = 0x0101;
@ -103,12 +105,15 @@ const uint16_t RS_SERVICE_TYPE_PROXY = 0xf030;
/* DSDV Testing at the moment - Service Only */
const uint16_t RS_SERVICE_TYPE_DSDV = 0xf050;
/* Latency RTT Measurements */
const uint16_t RS_SERVICE_TYPE_RTT = 0xf051;
/* Bandwidth Testing at the moment - Service Only */
const uint16_t RS_SERVICE_TYPE_BWCTRL = 0xf060;
//const uint16_t RS_SERVICE_TYPE_DISTRIB = 0xf110;
//const uint16_t RS_SERVICE_TYPE_FORUM = 0xf120;
//const uint16_t RS_SERVICE_TYPE_CHANNEL = 0xf130;
@ -149,6 +154,8 @@ const uint16_t RS_SERVICE_GXSV3_TYPE_POSTED = 0xf326;
const uint16_t RS_SERVICE_GXSV3_TYPE_CHANNELS = 0xf327;
const uint16_t RS_SERVICE_GXSV3_TYPE_GXSCIRCLE = 0xf328;
const uint16_t RS_SERVICE_TYPE_GXS_RECOGN = 0xf331;
/***************** IDS ALLOCATED FOR PLUGINS ******************/
const uint16_t RS_SERVICE_TYPE_PLUGIN_ARADO_TEST_ID1 = 0xf401;

99
libretroshare/src/serialiser/rsserviceserialiser.cc Normal file
View file

@ -0,0 +1,99 @@
/*
* libretroshare/src/serialiser: rsserviceserialiser.cc
*
* 3P/PQI network interface for RetroShare.
*
* Copyright 2013-2013 by Cyril Soler & 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 "rsserviceserialiser.h"
uint32_t RsServiceSerialiser::size(RsItem *i)
{
RsRawItem *item = dynamic_cast<RsRawItem *>(i);
if (item)
{
return item->getRawLength();
}
return 0;
}
/* serialise the data to the buffer */
bool RsServiceSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsRawItem *item = dynamic_cast<RsRawItem *>(i);
if (!item)
{
return false;
}
#ifdef RSSERIAL_DEBUG
std::cerr << "RsServiceSerialiser::serialise() serializing raw item. pktsize : " << *pktsize;
#endif
uint32_t tlvsize = item->getRawLength();
#ifdef RSSERIAL_DEBUG
std::cerr << "tlvsize : " << tlvsize << std::endl;
#endif
if (*pktsize < tlvsize)
return false; /* not enough space */
if (tlvsize > getRsPktMaxSize())
return false; /* packet too big */
*pktsize = tlvsize;
/* its serialised already!!! */
memcpy(data, item->getRawData(), tlvsize);
return true;
}
RsItem *RsServiceSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype))
{
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
return NULL; /* not enough data */
if (rssize > getRsPktMaxSize())
return NULL; /* packet too big */
/* set the packet length */
*pktsize = rssize;
RsRawItem *item = new RsRawItem(rstype, rssize);
void *item_data = item->getRawData();
memcpy(item_data, data, rssize);
return item;
}

40
libretroshare/src/serialiser/rsserviceserialiser.h Normal file
View file

@ -0,0 +1,40 @@
/*
* libretroshare/src/serialiser: rsserviceserialiser.h
*
* 3P/PQI network interface for RetroShare.
*
* Copyright 2013-2013 by Cyril Soler & 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".
*
*/
#pragma once
#include "rsserial.h"
class RsServiceSerialiser: public RsSerialType
{
public:
RsServiceSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, 0, 0) { }
virtual ~RsServiceSerialiser() { }
virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
};

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

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

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

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

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

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

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

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

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

@ -626,12 +626,12 @@ bool SetTlvIpAddrPortV4(void *data, uint32_t size, uint32_t *offset,
sockaddr_in addr = *out;
/* now add the data .... (its already in network order) - so flip */
/* now add the data .... (keep in network order) */
uint32_t ipaddr = addr.sin_addr.s_addr;
ok &= setRawUInt32(data, tlvend, offset, ntohl(ipaddr));
ok &= setRawUInt32(data, tlvend, offset, ipaddr);
uint16_t port = addr.sin_port;
ok &= setRawUInt16(data, tlvend, offset, ntohs(port));
ok &= setRawUInt16(data, tlvend, offset, port);
return ok;
}
@ -683,16 +683,16 @@ bool GetTlvIpAddrPortV4(void *data, uint32_t size, uint32_t *offset,
bool ok = true;
/* now get the data .... (its already in network order) - so flip */
/* now get the data .... (keep in network order) */
uint32_t ipaddr;
ok &= getRawUInt32(data, tlvend, offset, &ipaddr);
in->sin_family = AF_INET; /* set FAMILY */
in->sin_addr.s_addr = htonl(ipaddr);
in->sin_addr.s_addr = ipaddr;
uint16_t port;
ok &= getRawUInt16(data, tlvend, offset, &port);
in->sin_port = htons(port);
in->sin_port = port;
return ok;
}
@ -701,3 +701,100 @@ uint32_t GetTlvIpAddrPortV4Size() {
return TLV_HEADER_SIZE + 4 + 2; /* header + 4 (IP) + 2 (Port) */
}
bool SetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset,
uint16_t type, struct sockaddr_in6 *out) {
if (!data)
return false;
uint32_t tlvsize = GetTlvIpAddrPortV4Size();
uint32_t tlvend = *offset + tlvsize; /* where the data will extend to */
if (size < tlvend)
{
#ifdef TLV_BASE_DEBUG
std::cerr << "SetTlvIpAddrPortV6() FAILED - not enough space" << std::endl;
std::cerr << "SetTlvIpAddrPortV6() size: " << size << std::endl;
std::cerr << "SetTlvIpAddrPortV6() tlvsize: " << tlvsize << std::endl;
std::cerr << "SetTlvIpAddrPortV6() tlvend: " << tlvend << std::endl;
#endif
return false;
}
bool ok = true;
ok &= SetTlvBase(data, tlvend, offset, type, tlvsize);
/* now add the data (keep in network order) */
uint32_t *ip6addr = (uint32_t *) out->sin6_addr.s6_addr;
for(int i = 0; i < 4; i++)
{
ok &= setRawUInt32(data, tlvend, offset, ip6addr[i]);
}
ok &= setRawUInt16(data, tlvend, offset, out->sin6_port);
return ok;
}
bool GetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset,
uint16_t type, struct sockaddr_in6 *in) {
if (!data)
return false;
if (size < *offset + TLV_HEADER_SIZE)
{
#ifdef TLV_BASE_DEBUG
std::cerr << "GetIpAddrPortV6() FAILED - not enough space" << std::endl;
std::cerr << "GetIpAddrPortV6() size: " << size << std::endl;
std::cerr << "GetIpAddrPortV6() *offset: " << *offset << std::endl;
#endif
return false;
}
/* extract the type and size */
void *tlvstart = right_shift_void_pointer(data, *offset);
uint16_t tlvtype = GetTlvType(tlvstart);
uint32_t tlvsize = GetTlvSize(tlvstart);
/* check that there is size */
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend)
{
#ifdef TLV_BASE_DEBUG
std::cerr << "GetIpAddrPortV6() FAILED - not enough space" << std::endl;
std::cerr << "GetIpAddrPortV6() size: " << size << std::endl;
std::cerr << "GetIpAddrPortV6() tlvsize: " << tlvsize << std::endl;
std::cerr << "GetIpAddrPortV6() tlvend: " << tlvend << std::endl;
#endif
return false;
}
if (type != tlvtype)
{
#ifdef TLV_BASE_DEBUG
std::cerr << "GetIpAddrPortV6() FAILED - invalid type" << std::endl;
std::cerr << "GetIpAddrPortV6() type: " << type << std::endl;
std::cerr << "GetIpAddrPortV6() tlvtype: " << tlvtype << std::endl;
#endif
return false;
}
*offset += TLV_HEADER_SIZE; /* skip header */
bool ok = true;
/* now get the data (keep in network order) */
uint32_t *ip6addr = (uint32_t *) in->sin6_addr.s6_addr;
for(int i = 0; i < 4; i++)
{
ok &= getRawUInt32(data, tlvend, offset, &(ip6addr[i]));
}
in->sin6_family = AF_INET6; /* set FAMILY */
ok &= getRawUInt16(data, tlvend, offset, &(in->sin6_port));
return ok;
}
uint32_t GetTlvIpAddrPortV6Size() {
return TLV_HEADER_SIZE + 16 + 2; /* header + 16 (IP) + 2 (Port) */
}

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

@ -131,10 +131,13 @@ const uint16_t TLV_TYPE_STR_MSG = 0x0057;
const uint16_t TLV_TYPE_STR_SUBJECT = 0x0058;
const uint16_t TLV_TYPE_STR_LINK = 0x0059;
const uint16_t TLV_TYPE_STR_GENID = 0x005a;
const uint16_t TLV_TYPE_STR_GPGID = 0x005b;
const uint16_t TLV_TYPE_STR_GPGID = 0x005b; /* depreciated */
const uint16_t TLV_TYPE_STR_PGPID = 0x005b; /* same as GPG */
const uint16_t TLV_TYPE_STR_LOCATION = 0x005c;
const uint16_t TLV_TYPE_STR_CERT_GPG = 0x005d;
const uint16_t TLV_TYPE_STR_CERT_GPG = 0x005d;
const uint16_t TLV_TYPE_STR_PGPCERT = 0x005d; /* same as CERT_GPG */
const uint16_t TLV_TYPE_STR_CERT_SSL = 0x005e;
const uint16_t TLV_TYPE_STR_VERSION = 0x005f;
/* Wide Chars (4 bytes per char) for internationalisation */
const uint16_t TLV_TYPE_WSTR_PEERID = 0x0060;
@ -157,6 +160,11 @@ const uint16_t TLV_TYPE_IPV4_LOCAL = 0x0080;
const uint16_t TLV_TYPE_IPV4_REMOTE = 0x0081;
const uint16_t TLV_TYPE_IPV4_LAST = 0x0082;
const uint16_t TLV_TYPE_STR_DYNDNS = 0x0083;
const uint16_t TLV_TYPE_STR_DOMADDR = 0x0084;
// rearrange these in the future.
const uint16_t TLV_TYPE_IPV4 = 0x0085;
const uint16_t TLV_TYPE_IPV6 = 0x0086;
/*** MORE STRING IDS ****/
const uint16_t TLV_TYPE_STR_GROUPID = 0x00a0;
@ -201,6 +209,10 @@ const uint16_t TLV_TYPE_WKEYVALUESET = 0x1013;
const uint16_t TLV_TYPE_STRINGSET = 0x1020; /* dummy non-existant */
const uint16_t TLV_TYPE_PEERSET = 0x1021;
const uint16_t TLV_TYPE_HASHSET = 0x1022;
const uint16_t TLV_TYPE_PGPIDSET = 0x1023;
const uint16_t TLV_TYPE_RECOGNSET = 0x1024;
const uint16_t TLV_TYPE_SERVICESET = 0x1030;
const uint16_t TLV_TYPE_SECURITYKEY = 0x1040;
@ -214,6 +226,7 @@ const uint16_t TLV_TYPE_IMAGE = 0x1060;
const uint16_t TLV_TYPE_ADDRESS_INFO = 0x1070;
const uint16_t TLV_TYPE_ADDRESS_SET = 0x1071;
const uint16_t TLV_TYPE_ADDRESS = 0x1072;
const uint16_t TLV_TYPE_DSDV_ENDPOINT = 0x1080;
const uint16_t TLV_TYPE_DSDV_ENTRY = 0x1081;
@ -272,6 +285,10 @@ bool SetTlvIpAddrPortV4(void *data, uint32_t size, uint32_t *offset, uint16_
bool GetTlvIpAddrPortV4(void *data, uint32_t size, uint32_t *offset, uint16_t type, struct sockaddr_in *in);
uint32_t GetTlvIpAddrPortV4Size();
bool SetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset, uint16_t type, struct sockaddr_in6 *out);
bool GetTlvIpAddrPortV6(void *data, uint32_t size, uint32_t *offset, uint16_t type, struct sockaddr_in6 *in);
uint32_t GetTlvIpAddrPortV6Size();
/* additional function to be added
bool SetTlvBinData(void* data, uint32_t size, uint32_t* offset, uint16_t type, void* data_bin, uint32_t len_tlv)

20
libretroshare/src/serialiser/rstlvfileitem.cc
View file

@ -417,9 +417,9 @@ uint32_t RsTlvFileSet::TlvSize()
/* now add comment and title length of this tlv object */
if (title.length() > 0)
s += GetTlvWideStringSize(title);
s += GetTlvStringSize(title);
if (comment.length() > 0)
s += GetTlvWideStringSize(comment);
s += GetTlvStringSize(comment);
return s;
}
@ -454,9 +454,9 @@ bool RsTlvFileSet::SetTlv(void *data, uint32_t size, uint32_t *offset) /* se
/* now optional ones */
if (title.length() > 0)
ok &= SetTlvWideString(data, tlvend, offset, TLV_TYPE_WSTR_TITLE, title);
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_TITLE, title);
if (comment.length() > 0)
ok &= SetTlvWideString(data, tlvend, offset, TLV_TYPE_WSTR_COMMENT, comment);
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_COMMENT, comment);
return ok;
@ -500,15 +500,15 @@ bool RsTlvFileSet::GetTlv(void *data, uint32_t size, uint32_t *offset)
items.push_back(newitem);
}
}
else if (tlvsubtype == TLV_TYPE_WSTR_TITLE)
else if (tlvsubtype == TLV_TYPE_STR_TITLE)
{
ok &= GetTlvWideString(data, tlvend, offset,
TLV_TYPE_WSTR_TITLE, title);
ok &= GetTlvString(data, tlvend, offset,
TLV_TYPE_STR_TITLE, title);
}
else if (tlvsubtype == TLV_TYPE_WSTR_COMMENT)
else if (tlvsubtype == TLV_TYPE_STR_COMMENT)
{
ok &= GetTlvWideString(data, tlvend, offset,
TLV_TYPE_WSTR_COMMENT, comment);
ok &= GetTlvString(data, tlvend, offset,
TLV_TYPE_STR_COMMENT, comment);
}
else
{

160
libretroshare/src/serialiser/rstlvtypes.cc
View file

@ -247,6 +247,7 @@ std::ostream &RsTlvBinaryData::print(std::ostream &out, uint16_t indent)
RsTlvPeerIdSet::RsTlvPeerIdSet(): RsTlvStringSet(TLV_TYPE_PEERSET) {}
RsTlvHashSet::RsTlvHashSet(): RsTlvStringSet(TLV_TYPE_HASHSET) {}
RsTlvPgpIdSet::RsTlvPgpIdSet(): RsTlvStringSet(TLV_TYPE_PGPIDSET) {}
RsTlvStringSet::RsTlvStringSet(uint16_t type) :mType(type)
@ -428,6 +429,165 @@ std::ostream &RsTlvStringSet::printHex(std::ostream &out, uint16_t indent)
}
/************************************* String Set Ref ************************************/
/* This is exactly the same as StringSet, but it uses an alternative list.
*/
RsTlvStringSetRef::RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids)
:mType(type), ids(refids)
{
}
void RsTlvStringSetRef::TlvClear()
{
ids.clear();
}
uint32_t RsTlvStringSetRef::TlvSize()
{
uint32_t s = TLV_HEADER_SIZE; /* header */
/* determine the total size of ids strings in list */
std::list<std::string>::iterator it;
for(it = ids.begin(); it != ids.end() ; ++it)
{
if (it->length() > 0)
s += GetTlvStringSize(*it);
}
return s;
}
bool RsTlvStringSetRef::SetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
{
/* must check sizes */
uint32_t tlvsize = TlvSize();
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend)
return false; /* not enough space */
bool ok = true;
/* start at data[offset] */
ok &= SetTlvBase(data, tlvend, offset, mType , tlvsize);
/* determine the total size of ids strings in list */
std::list<std::string>::iterator it;
for(it = ids.begin(); it != ids.end() ; ++it)
{
if (it->length() > 0)
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_GENID, *it);
}
return ok;
}
bool RsTlvStringSetRef::GetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
{
if (size < *offset + TLV_HEADER_SIZE)
return false;
uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) );
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend) /* check size */
return false; /* not enough space */
if (tlvtype != mType) /* check type */
return false;
bool ok = true;
/* ready to load */
TlvClear();
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
/* while there is TLV */
while((*offset) + 2 < tlvend)
{
/* get the next type */
uint16_t tlvsubtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
if (tlvsubtype == TLV_TYPE_STR_GENID)
{
std::string newIds;
ok &= GetTlvString(data, tlvend, offset, TLV_TYPE_STR_GENID, newIds);
if(ok)
{
ids.push_back(newIds);
}
}
else
{
/* Step past unknown TLV TYPE */
ok &= SkipUnknownTlv(data, tlvend, offset);
}
if (!ok)
{
break;
}
}
/***************************************************************************
* NB: extra components could be added (for future expansion of the type).
* or be present (if this code is reading an extended version).
*
* We must chew up the extra characters to conform with TLV specifications
***************************************************************************/
if (*offset != tlvend)
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvPeerIdSetRef::GetTlv() Warning extra bytes at end of item";
std::cerr << std::endl;
#endif
*offset = tlvend;
}
return ok;
}
/// print to screen RsTlvStringSet contents
std::ostream &RsTlvStringSetRef::print(std::ostream &out, uint16_t indent)
{
printBase(out, "RsTlvStringSetRef", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "type:" << mType;
out << std::endl;
std::list<std::string>::iterator it;
for(it = ids.begin(); it != ids.end() ; ++it)
{
printIndent(out, int_Indent);
out << "id:" << *it;
out << std::endl;
}
printEnd(out, "RsTlvStringSetRef", indent);
return out;
}
/************************************* Service Id Set ************************************/
void RsTlvServiceIdSet::TlvClear()

51
libretroshare/src/serialiser/rstlvtypes.h
View file

@ -33,6 +33,8 @@
#include <string>
#include <list>
#include <map>
#include <stdlib.h>
#include <stdint.h>
@ -122,6 +124,12 @@ class RsTlvHashSet: public RsTlvStringSet
RsTlvHashSet();
};
class RsTlvPgpIdSet: public RsTlvStringSet
{
public:
RsTlvPgpIdSet();
};
class RsTlvServiceIdSet: public RsTlvItem
{
public:
@ -137,6 +145,22 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent);
};
class RsTlvStringSetRef: public RsTlvItem
{
public:
RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids);
virtual ~RsTlvStringSetRef() { return; }
virtual uint32_t TlvSize();
virtual void TlvClear();
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* serialise */
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */
virtual std::ostream &print(std::ostream &out, uint16_t indent);
uint16_t mType;
std::list<std::string> &ids; /* Mandatory */
};
/**** MORE TLV *****
*
* File Items/Data.
@ -179,8 +203,8 @@ virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deseria
virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::list<RsTlvFileItem> items; /// Mandatory
std::wstring title; /// Optional: title of file set
std::wstring comment; /// Optional: comments for file
std::string title; /// Optional: title of file set
std::string comment; /// Optional: comments for file
};
@ -240,6 +264,29 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent);
};
class RsTlvIntStringMap: public RsTlvItem
{
public:
RsTlvIntStringMap() { return; }
virtual ~RsTlvIntStringMap() { return; }
virtual uint32_t TlvSize();
virtual void TlvClear();
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* serialise */
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */
virtual std::ostream &print(std::ostream &out, uint16_t indent);
uint32_t mapType;
std::map<uint32_t, std::string> map;
};
class RsTlvServiceIdMap: public RsTlvIntStringMap
{
public:
RsTlvServiceIdMap();
};
class RsTlvImage: public RsTlvItem
{
public:

304
libretroshare/src/serialiser/rstunnelitems.cc
View file

@ -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 ;
}

132
libretroshare/src/serialiser/rstunnelitems.h
View file

@ -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 */