diff --git a/libretroshare/src/serialiser/rsgxsitems.h b/libretroshare/src/serialiser/rsgxsitems.h index 89e18457e..f13ca774b 100644 --- a/libretroshare/src/serialiser/rsgxsitems.h +++ b/libretroshare/src/serialiser/rsgxsitems.h @@ -118,22 +118,22 @@ class RsGxsGrpItem : public RsItem public: - RsGxsGrpItem() : RsItem(0) { return; } + RsGxsGrpItem(uint16_t service, uint8_t subtype) + : RsItem(RS_PKT_VERSION_SERVICE, service, subtype) { return; } virtual ~RsGxsGrpItem(){} RsGroupMetaData meta; - }; class RsGxsMsgItem : public RsItem { public: - RsGxsMsgItem() : RsItem(0) { return; } + RsGxsMsgItem(uint16_t service, uint8_t subtype) + : RsItem(RS_PKT_VERSION_SERVICE, service, subtype) { return; } virtual ~RsGxsMsgItem(){} RsMsgMetaData meta; - }; diff --git a/libretroshare/src/serialiser/rsphotov2items.cc b/libretroshare/src/serialiser/rsphotov2items.cc index 8dbf98703..921deca22 100644 --- a/libretroshare/src/serialiser/rsphotov2items.cc +++ b/libretroshare/src/serialiser/rsphotov2items.cc @@ -1,45 +1,491 @@ /* - * rsphotov2items.cc + * libretroshare/src/retroshare: rsphoto.h + * + * RetroShare C++ Interface. + * + * Copyright 2012-2012 by Christopher Evi-Parker, 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". * - * Created on: 22 Jul 2012 - * Author: crispy */ + #include "rsphotov2items.h" +#define GXS_PHOTO_SERIAL_DEBUG +uint32_t RsGxsPhotoSerialiser::size(RsItem* item) +{ -uint32_t RsGxsPhotoSerialiser::size(RsItem* item) { + RsGxsPhotoPhotoItem* ppItem = NULL; + RsGxsPhotoAlbumItem* paItem = NULL; + + if((ppItem = dynamic_cast(item)) != NULL) + { + return sizeGxsPhotoPhotoItem(ppItem); + } + else if((paItem = dynamic_cast(item)) != NULL) + { + return sizeGxsPhotoAlbumItem(paItem); + } + else + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + +#endif + return NULL; + } } -bool RsGxsPhotoSerialiser::serialise(RsItem* item, void* data, uint32_t* size) { +bool RsGxsPhotoSerialiser::serialise(RsItem* item, void* data, uint32_t* size) +{ + + RsGxsPhotoPhotoItem* ppItem = NULL; + RsGxsPhotoAlbumItem* paItem = NULL; + + if((ppItem = dynamic_cast(item)) != NULL) + { + return serialiseGxsPhotoPhotoItem(ppItem, data, size); + } + else if((paItem = dynamic_cast(item)) != NULL) + { + return serialiseGxsPhotoAlbumItem(paItem, data, size); + } + else + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + +#endif + return false; + } + } -RsItem* RsGxsPhotoSerialiser::deserialise(void* data, uint32_t* size) { +RsItem* RsGxsPhotoSerialiser::deserialise(void* data, uint32_t* size) +{ + +#ifdef RSSERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialise()" << std::endl; +#endif + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + + if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || + (RS_SERVICE_TYPE_PHOTO != getRsItemService(rstype))) + { + return NULL; /* wrong type */ + } + + switch(getRsItemSubType(rstype)) + { + + case RS_PKT_SUBTYPE_NXS_SYNC_GRP: + return deserialiseGxsPhotoPhotoItem(data, size); + case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM: + return deserialiseGxsPhotoAlbumItem(data, size); + default: + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialise(): subtype could not be dealt with" + << std::endl; +#endif + break; + } + } + return NULL; } -uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item) { +uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item) +{ + const RsPhotoAlbum& album = item->album; + uint32_t s = 8; // header + s += GetTlvStringSize(album.mCaption); + s += GetTlvStringSize(album.mCategory); + s += GetTlvStringSize(album.mDescription); + s += GetTlvStringSize(album.mHashTags); + s += GetTlvStringSize(album.mOther); + s += GetTlvStringSize(album.mPhotoPath); + s += GetTlvStringSize(album.mPhotographer); + s += GetTlvStringSize(album.mWhen); + s += GetTlvStringSize(album.mWhere); + + RsTlvBinaryData b(item->PacketService()); // TODO, need something more persisitent + b.setBinData(album.mThumbnail.data, album.mThumbnail.size); + s += GetTlvStringSize(album.mThumbnail.type); + s += b.TlvSize(); + + return s; } bool RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item, void* data, - uint32_t* size) { + uint32_t* size) +{ + +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem()" << std::endl; +#endif + + uint32_t tlvsize = sizeGxsPhotoAlbumItem(item); + uint32_t offset = 0; + + if(*size < tlvsize){ +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem()" << std::endl; +#endif + return false; + } + + *size = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + + /* skip the header */ + offset += 8; + + /* GxsPhotoAlbumItem */ + + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mCaption); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mCategory); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mDescription); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mHashTags); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mOther); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mPhotoPath); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mPhotographer); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mWhen); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mWhere); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->album.mThumbnail.type); + RsTlvBinaryData b(item->PacketService()); // TODO, need something more persisitent + b.setBinData(item->album.mThumbnail.data, item->album.mThumbnail.size); + b.SetTlv(item->album.mThumbnail.data, tlvsize, &offset); + + if(offset != tlvsize) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem() FAIL Size Error! " << std::endl; +#endif + ok = false; + } + +#ifdef GXS_PHOTO_SERIAL_DEBUG + if (!ok) + { + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem() NOK" << std::endl; + } +#endif + + return ok; } RsGxsPhotoAlbumItem* RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem(void* data, - uint32_t* size) { + uint32_t* size) +{ + + +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem()" << 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)) || + (RS_SERVICE_TYPE_PHOTO != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_PHOTO_ITEM != getRsItemSubType(rstype))) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL wrong type" << std::endl; +#endif + return NULL; /* wrong type */ + } + + if (*size < rssize) /* check size */ + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL wrong size" << std::endl; +#endif + return NULL; /* not enough data */ + } + + /* set the packet length */ + *size = rssize; + + bool ok = true; + + RsGxsPhotoAlbumItem* item = new RsGxsPhotoAlbumItem(); + /* skip the header */ + offset += 8; + + + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mCaption); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mCategory); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mDescription); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mHashTags); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mOther); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mPhotoPath); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mPhotographer); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mWhen); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mWhere); + ok &= GetTlvString(data, rssize, &offset, 1, item->album.mThumbnail.type); + + RsTlvBinaryData b(RS_SERVICE_TYPE_PHOTO); // TODO, need something more persisitent + ok &= b.GetTlv(data, rssize, &offset); + item->album.mThumbnail.data = (uint8_t*)b.bin_data; + item->album.mThumbnail.size = b.bin_len; + b.TlvShallowClear(); + + if (offset != rssize) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL size mismatch" << std::endl; +#endif + /* error */ + delete item; + return NULL; + } + + if (!ok) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() NOK" << std::endl; +#endif + delete item; + return NULL; + } + + return item; } -uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item) { +uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item) +{ + + const RsPhotoPhoto& photo = item->photo; + + uint32_t s = 8; // header size + s += GetTlvStringSize(photo.mCaption); + s += GetTlvStringSize(photo.mCategory); + s += GetTlvStringSize(photo.mDescription); + s += GetTlvStringSize(photo.mHashTags); + s += GetTlvStringSize(photo.mOther); + s += GetTlvStringSize(photo.mPhotographer); + s += GetTlvStringSize(photo.mWhen); + s += GetTlvStringSize(photo.mWhere); + + RsTlvBinaryData b(item->PacketService()); // TODO, need something more persisitent + b.setBinData(photo.mThumbnail.data, photo.mThumbnail.size); + s += GetTlvStringSize(photo.mThumbnail.type); + s += b.TlvSize(); + + return s; } bool RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item, void* data, - uint32_t* size) { + uint32_t* size) +{ + + +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem()" << std::endl; +#endif + + uint32_t tlvsize = sizeGxsPhotoPhotoItem(item); + uint32_t offset = 0; + + if(*size < tlvsize){ +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem()" << std::endl; +#endif + return false; + } + + *size = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + + /* skip the header */ + offset += 8; + + /* GxsPhotoAlbumItem */ + + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mCaption); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mCategory); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mDescription); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mHashTags); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mOther); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mPhotographer); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mWhen); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mWhere); + ok &= SetTlvString(data, tlvsize, &offset, 1, item->photo.mThumbnail.type); + RsTlvBinaryData b(RS_SERVICE_TYPE_PHOTO); // TODO, need something more persisitent + b.setBinData(item->photo.mThumbnail.data, item->photo.mThumbnail.size); + b.SetTlv(item->photo.mThumbnail.data, tlvsize, &offset); + + if(offset != tlvsize) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem() FAIL Size Error! " << std::endl; +#endif + ok = false; + } + +#ifdef GXS_PHOTO_SERIAL_DEBUG + if (!ok) + { + std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem() NOK" << std::endl; + } +#endif + + return ok; } RsGxsPhotoPhotoItem* RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem(void* data, - uint32_t* size) { + uint32_t* size) +{ + + +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem()" << 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)) || + (RS_SERVICE_TYPE_PHOTO != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM != getRsItemSubType(rstype))) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL wrong type" << std::endl; +#endif + return NULL; /* wrong type */ + } + + if (*size < rssize) /* check size */ + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL wrong size" << std::endl; +#endif + return NULL; /* not enough data */ + } + + /* set the packet length */ + *size = rssize; + + bool ok = true; + + RsGxsPhotoPhotoItem* item = new RsGxsPhotoPhotoItem(); + /* skip the header */ + offset += 8; + + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mCaption); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mCategory); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mDescription); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mHashTags); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mOther); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mPhotographer); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mWhen); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mWhere); + ok &= GetTlvString(data, rssize, &offset, 1, item->photo.mThumbnail.type); + + RsTlvBinaryData b(RS_SERVICE_TYPE_PHOTO); // TODO, need something more persisitent + ok &= b.GetTlv(data, rssize, &offset); + item->photo.mThumbnail.data = (uint8_t*)(b.bin_data); + item->photo.mThumbnail.size = b.bin_len; + b.TlvShallowClear(); + + if (offset != rssize) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL size mismatch" << std::endl; +#endif + /* error */ + delete item; + return NULL; + } + + if (!ok) + { +#ifdef GXS_PHOTO_SERIAL_DEBUG + std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() NOK" << std::endl; +#endif + delete item; + return NULL; + } + + return item; } + +void RsGxsPhotoAlbumItem::clear() +{ + album.mCaption.clear(); + album.mCategory.clear(); + album.mDescription.clear(); + album.mHashTags.clear(); + album.mOther.clear(); + album.mPhotoPath.clear(); + album.mPhotographer.clear(); + album.mWhen.clear(); + album.mWhere.clear(); + album.mThumbnail.deleteImage(); +} + +std::ostream& RsGxsPhotoAlbumItem::print(std::ostream& out, uint16_t indent) +{ + printRsItemBase(out, "RsGxsPhotoAlbumItem", indent); + uint16_t int_Indent = indent + 2; + + + printRsItemEnd(out ,"RsGxsPhotoAlbumItem", indent); + return out; +} + +void RsGxsPhotoPhotoItem::clear() +{ + photo.mCaption.clear(); + photo.mCategory.clear(); + photo.mDescription.clear(); + photo.mHashTags.clear(); + photo.mOther.clear(); + photo.mPhotographer.clear(); + photo.mWhen.clear(); + photo.mWhere.clear(); + photo.mThumbnail.deleteImage(); +} + +std::ostream& RsGxsPhotoPhotoItem::print(std::ostream& out, uint16_t indent) +{ + printRsItemBase(out, "RsGxsPhotoPhotoItem", indent); + uint16_t int_Indent = indent + 2; + + + printRsItemEnd(out ,"RsGxsPhotoPhotoItem", indent); + return out; +} + diff --git a/libretroshare/src/serialiser/rsphotov2items.h b/libretroshare/src/serialiser/rsphotov2items.h index b44ceee62..89cc9c4f9 100644 --- a/libretroshare/src/serialiser/rsphotov2items.h +++ b/libretroshare/src/serialiser/rsphotov2items.h @@ -33,6 +33,7 @@ #include "serialiser/rstlvtypes.h" #include "rsgxsitems.h" +#include "rsphotoitems.h" #include "retroshare/rsphotoV2.h" @@ -41,7 +42,13 @@ class RsGxsPhotoAlbumItem : public RsGxsGrpItem public: - RsGxsPhotoAlbumItem() {} + RsGxsPhotoAlbumItem(): RsGxsGrpItem(RS_SERVICE_TYPE_PHOTO, + RS_PKT_SUBTYPE_PHOTO_ITEM) { return;} + + virtual void clear(); + std::ostream &print(std::ostream &out, uint16_t indent = 0); + + RsPhotoAlbum album; }; @@ -49,7 +56,11 @@ class RsGxsPhotoPhotoItem : public RsGxsMsgItem { public: - RsGxsPhotoPhotoItem() {} + RsGxsPhotoPhotoItem(): RsGxsMsgItem(RS_SERVICE_TYPE_PHOTO, + RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM) {return; } + + virtual void clear(); + std::ostream &print(std::ostream &out, uint16_t indent = 0); RsPhotoPhoto photo; };