Improvement of the plugin system:

- Added configuration saving for plugin manager and serialization methods
	- added a list of accepted plugin hashes
	- added plugin widget for each plugin in settings, to allow enabling/disabling plugins
	- updated LinkCloud plugin to new rsPlugin class
	- put the addconfiguration for plugin manager in rsinit.cc a bit earlier to allow to load 
		the list of accepted hashes early enough
	- added icon for disabled plugins



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4393 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/serialiser/rsconfigitems.h

@@ -41,6 +41,7 @@ const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01;
 const uint8_t RS_PKT_TYPE_PEER_CONFIG    = 0x02;
 const uint8_t RS_PKT_TYPE_CACHE_CONFIG   = 0x03;
 const uint8_t RS_PKT_TYPE_FILE_CONFIG    = 0x04;
+const uint8_t RS_PKT_TYPE_PLUGIN_CONFIG  = 0x05;
 
 	/* GENERAL CONFIG SUBTYPES */
 const uint8_t RS_PKT_SUBTYPE_KEY_VALUE = 0x01;

libretroshare/src/serialiser/rspluginitems.cc

@@ -0,0 +1,132 @@
+#include "rspluginitems.h"
+
+#ifndef WINDOWS_SYS
+#include <stdexcept>
+#endif
+
+bool RsPluginHashSetItem::serialise(void *data,uint32_t& pktsize) 
+{
+	uint32_t tlvsize = serial_size();
+	uint32_t offset = 0;
+
+#ifdef P3TURTLE_DEBUG
+	std::cerr << "RsPluginSerialiser::serialising HashSet packet (size=" << tlvsize << ")" << std::endl;
+#endif
+	if (pktsize < tlvsize)
+		return false; /* not enough space */
+
+	pktsize = tlvsize;
+
+	bool ok = true;
+
+	ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize);
+
+	/* skip the header */
+	offset += 8;
+
+	/* add mandatory parts first */
+
+	ok &= hashes.SetTlv(data,tlvsize,&offset) ;
+
+	if (offset != tlvsize)
+	{
+		ok = false;
+#ifdef P3TURTLE_DEBUG
+		std::cerr << "RsPluginHashSetItem::serialise() Size Error! (offset=" << offset << ", tlvsize=" << tlvsize << ")" << std::endl;
+#endif
+	}
+
+	return ok ;
+}
+
+RsPluginHashSetItem::RsPluginHashSetItem(void *data,uint32_t size)
+	: RsPluginItem(RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET)
+{
+	uint32_t offset = 8; // skip the header 
+	uint32_t rssize = getRsItemSize(data);
+	bool ok = true ;
+
+	hashes.ids.clear() ;
+
+	ok &= hashes.GetTlv(data,size,&offset) ;
+
+	if (offset != rssize)
+	{
+#ifdef TLV_DEBUG
+		std::cerr << "RsTlvPeerIdSet::GetTlv() Warning extra bytes at end of item";
+		std::cerr << std::endl;
+#endif
+		ok = false ;
+	}
+
+#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs).
+	UNREFERENCED_LOCAL_VARIABLE(rssize);
+#else
+	if (!ok)
+		throw std::runtime_error("Unknown error while deserializing.") ;
+#endif
+
+}
+
+RsItem *RsPluginSerialiser::deserialise(void *data, uint32_t *size) 
+{
+	// look what we have...
+
+	/* get the type */
+	uint32_t rstype = getRsItemId(data);
+#ifdef P3TURTLE_DEBUG
+	std::cerr << "p3turtle: deserialising packet: " << std::endl ;
+#endif
+	if (	(RS_PKT_VERSION1 				!= getRsItemVersion(rstype)) 
+			|| (RS_PKT_CLASS_CONFIG 		!= getRsItemClass(rstype)) 
+			|| (RS_PKT_TYPE_PLUGIN_CONFIG != getRsItemType(rstype))) 
+	{
+#ifdef P3TURTLE_DEBUG
+		std::cerr << "  Wrong type !!" << std::endl ;
+#endif
+		return NULL; /* wrong type */
+	}
+
+#ifndef WINDOWS_SYS
+	try
+	{
+#endif
+		switch(getRsItemSubType(rstype))
+		{
+			case RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET	:	return new RsPluginHashSetItem(data,*size) ;
+
+			default:
+																		std::cerr << "Unknown packet type in RsPluginSerialiser. Type = " << rstype << std::endl;
+																		return NULL ;
+		}
+#ifndef WINDOWS_SYS
+	}
+	catch(std::exception& e)
+	{
+		std::cerr << "Exception raised: " << e.what() << std::endl ;
+		return NULL ;
+	}
+#endif
+}
+
+uint32_t RsPluginHashSetItem::serial_size() 
+{
+	uint32_t size = 8 ;
+
+	size += hashes.TlvSize() ;
+
+	return size ;
+}
+
+std::ostream& RsPluginHashSetItem::print(std::ostream& o, uint16_t) 
+{
+	o << "Item type: RsPluginHashSetItem" << std::endl;
+	o << "  Hash list: " << std::endl;
+
+	for(std::list<std::string>::const_iterator it(hashes.ids.begin());it!=hashes.ids.end();++it)
+		o << "       " << *it << std::endl;
+
+	return o ;
+}
+
+

libretroshare/src/serialiser/rspluginitems.h

@@ -0,0 +1,80 @@
+/*
+ * libretroshare/src/services: p3turtle.h
+ *
+ * Services for RetroShare.
+ *
+ * Copyright 2009 by Cyril Soler
+ *
+ * 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 "csoler@users.sourceforge.net".
+ *
+ */
+
+
+#pragma once
+
+#include "serialiser/rsserial.h"
+#include "serialiser/rstlvbase.h"
+#include "serialiser/rstlvtypes.h"
+#include "serialiser/rsconfigitems.h"
+#include "serialiser/rsbaseserial.h"
+
+const uint8_t RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET = 0x01 ;
+
+class RsPluginItem: public RsItem
+{
+	public:
+		RsPluginItem(uint8_t plugin_item_subtype): RsItem(RS_PKT_VERSION1,RS_PKT_CLASS_CONFIG,RS_PKT_TYPE_PLUGIN_CONFIG,plugin_item_subtype) {}
+		virtual ~RsPluginItem() {}
+
+		virtual bool serialise(void *data,uint32_t& size) = 0 ;	// Isn't it better that items can serialise themselves ?
+		virtual uint32_t serial_size() = 0 ; 							// deserialise is handled using a constructor
+
+		virtual void clear() {} 
+};
+
+class RsPluginSerialiser: public RsSerialType
+{
+	public:
+		RsPluginSerialiser() : RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PLUGIN_CONFIG) {}
+
+		virtual uint32_t 	size (RsItem *item) 
+		{ 
+			return dynamic_cast<RsPluginItem *>(item)->serial_size() ;
+		}
+		virtual bool serialise(RsItem *item, void *data, uint32_t *size) 
+		{ 
+			return dynamic_cast<RsPluginItem *>(item)->serialise(data,*size) ;
+		}
+		virtual RsItem *deserialise (void *data, uint32_t *size) ;
+};
+
+class RsPluginHashSetItem: public RsPluginItem
+{
+	public:
+		RsPluginHashSetItem() : RsPluginItem(RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET) {}
+		RsPluginHashSetItem(void *data,uint32_t size) ;
+
+		RsTlvHashSet hashes ;
+
+		virtual std::ostream& print(std::ostream& o, uint16_t) ;
+
+	protected:
+		virtual bool serialise(void *data,uint32_t& size) ;
+		virtual uint32_t serial_size() ;
+};
+
+