added new individual config saving system

global signature file format will be converted


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

libretroshare/src/pqi/authssl.cc

@@ -1039,13 +1039,19 @@ bool    AuthSSLimpl::decrypt(void *&out, int &outlen, const void *in, int inlen)
         int in_offset = 0, out_currOffset = 0;
         int size_net_ekl = sizeof(net_ekl);
 
+        if(size_net_ekl > inlen) return false;
+
         memcpy(&net_ekl, (unsigned char*)in, size_net_ekl);
         eklen = ntohl(net_ekl);
         in_offset += size_net_ekl;
 
+        if(eklen > (inlen-in_offset)) return false;
+
         memcpy(ek, (unsigned char*)in + in_offset, eklen);
         in_offset += eklen;
 
+        if(EVP_MAX_IV_LENGTH > (inlen-in_offset)) return false;
+
         memcpy(iv, (unsigned char*)in + in_offset, EVP_MAX_IV_LENGTH);
         in_offset += EVP_MAX_IV_LENGTH;
 
@@ -1064,6 +1070,7 @@ bool    AuthSSLimpl::decrypt(void *&out, int &outlen, const void *in, int inlen)
 
         outlen += out_currOffset;
 
+        if(ek != NULL)
         	free(ek);
 
         #ifdef AUTHSSL_DEBUG

libretroshare/src/pqi/p3cfgmgr.cc

@@ -45,6 +45,11 @@ p3ConfigMgr::p3ConfigMgr(std::string dir, std::string fname, std::string signame
         :basedir(dir), metafname(fname), metasigfname(signame),
 	mConfigSaveActive(true)
 {
+	oldConfigType = checkForGlobalSigConfig();
+
+	// configuration to load correct global types
+	pqiConfig::globalConfigType = oldConfigType;
+
 }
 
 void	p3ConfigMgr::tick()
@@ -90,10 +95,59 @@ void	p3ConfigMgr::saveConfiguration()
 	if(!RsDiscSpace::checkForDiscSpace(RS_CONFIG_DIRECTORY))
 		return ;
 
+	saveConfig();
+
+
+}
+
+void p3ConfigMgr::saveConfig()
+{
+
+	bool ok= true;
+
+	RsStackMutex stack(cfgMtx);  /***** LOCK STACK MUTEX ****/
+
+	std::map<uint32_t, pqiConfig *>::iterator it;
+	for(it = configs.begin(); it != configs.end(); it++)
+	{
+		if (it->second->HasConfigChanged(1))
+		{
+#ifdef CONFIG_DEBUG
+			std::cerr << "p3ConfigMgr::globalSaveConfig() Saving Element: ";
+			std::cerr << it->first;
+			std::cerr << std::endl;
+#endif
+			ok &= it->second->saveConfiguration();
+		}
+		/* save metaconfig */
+	}
+
+	if(ok && oldConfigType)
+		removeOldConfigType();
+	return;
+}
+
+
+void p3ConfigMgr::removeOldConfigType()
+{
+	std::string fName = basedir + "/" + metafname;
+	std::string sigfName = basedir + "/" + metasigfname;
+
+	remove(fName.c_str());
+	remove(sigfName.c_str());
+
+	//now set globalconfig type to false so mgr saves
+	oldConfigType = false;
+	pqiConfig::globalConfigType = oldConfigType;
+
+}
+void p3ConfigMgr::globalSaveConfig()
+{
+
 	RsStackMutex stack(cfgMtx); /***** LOCK STACK MUTEX ****/
 
 #ifdef CONFIG_DEBUG
-	std::cerr << "p3ConfigMgr::saveConfiguration()";
+	std::cerr << "p3ConfigMgr::globalSaveConfig()";
 	std::cerr << std::endl;
 #endif
 
@@ -105,7 +159,7 @@ void	p3ConfigMgr::saveConfiguration()
 		if (it->second->HasConfigChanged(1))
 		{
 #ifdef CONFIG_DEBUG
-			std::cerr << "p3ConfigMgr::saveConfiguration() Saving Element: ";
+			std::cerr << "p3ConfigMgr::globalSaveConfig() Saving Element: ";
 			std::cerr << it->first;
 			std::cerr << std::endl;
 #endif
@@ -114,7 +168,7 @@ void	p3ConfigMgr::saveConfiguration()
 		/* save metaconfig */
 
 #ifdef CONFIG_DEBUG
-		std::cerr << "p3ConfigMgr::saveConfiguration() Element: ";
+		std::cerr << "p3ConfigMgr::globalSaveConfig() Element: ";
 		std::cerr << it->first << " Hash: " << it->second->Hash();
 		std::cerr << std::endl;
 #endif
@@ -135,7 +189,7 @@ void	p3ConfigMgr::saveConfiguration()
 	}
 
 #ifdef CONFIG_DEBUG
-	std::cerr << "p3ConfigMgr::saveConfiguration() Complete MetaConfigItem: ";
+	std::cerr << "p3ConfigMgr::globalSaveConfig() Complete MetaConfigItem: ";
 	std::cerr << std::endl;
 	item->print(std::cerr, 20);
 
@@ -174,7 +228,7 @@ void	p3ConfigMgr::saveConfiguration()
     		signature.length(), BIN_FLAGS_READABLE);
 
 #ifdef CONFIG_DEBUG
-	std::cerr << "p3ConfigMgr::saveConfiguration() MetaFile Signature:";
+	std::cerr << "p3ConfigMgr::globalSaveConfig() MetaFile Signature:";
 	std::cerr << std::endl;
 	std::cerr << signature;
 	std::cerr << std::endl;
@@ -184,6 +238,7 @@ void	p3ConfigMgr::saveConfiguration()
 	backedUpFileSave(fname, fname_backup, sign_fname, sign_fname_backup, configbio, signbio);
 
 	delete signbio;
+
 }
 
 bool p3ConfigMgr::backedUpFileSave(const std::string& fname, const std::string& fname_backup, const std::string& sign_fname,
@@ -293,6 +348,38 @@ bool p3ConfigMgr::backedUpFileSave(const std::string& fname, const std::string&
 }
 
 void p3ConfigMgr::loadConfiguration()
+{
+	if(oldConfigType)
+		globalLoadConfig();
+	else
+		loadConfig();
+
+	return;
+}
+
+void p3ConfigMgr::loadConfig()
+{
+	std::map<uint32_t, pqiConfig *>::iterator cit;
+	std::string dummyHash = "dummyHash";
+	for (cit = configs.begin(); cit != configs.end(); cit++)
+	{
+#ifdef CONFIG_DEBUG
+		std::cerr << "p3ConfigMgr::loadConfig() Element: ";
+		std::cerr << cit->first <<"Dummy Hash: " << dummyHash;
+		std::cerr << std::endl;
+#endif
+
+		cit->second->loadConfiguration(dummyHash);
+
+		/* force config to NOT CHANGED */
+		cit->second->HasConfigChanged(0);
+		cit->second->HasConfigChanged(1);
+	}
+
+	return;
+}
+
+void	p3ConfigMgr::globalLoadConfig()
 {
 	RsStackMutex stack(cfgMtx); /***** LOCK STACK MUTEX ****/
 
@@ -395,9 +482,11 @@ void	p3ConfigMgr::loadConfiguration()
 			std::cerr << std::endl;
 #endif
 			(cit->second)->loadConfiguration(hashin);
-			/* force config to NOT CHANGED */
+
-			cit->second->HasConfigChanged(0);
+			/* force config to CHANGED to force saving into new non-global sig format */
-			cit->second->HasConfigChanged(1);
+			cit->second->IndicateConfigChanged();
+	//		cit->second->HasConfigChanged(0);
+	//		cit->second->HasConfigChanged(1);
 		}
 	}
 
@@ -532,6 +621,33 @@ void    p3ConfigMgr::completeConfiguration()
 	mConfigSaveActive = false;
 }
 
+bool p3ConfigMgr::checkForGlobalSigConfig()
+{
+	bool oldTypeExists;
+	FILE *metaFile = NULL, *metaSig = NULL;
+	std::string fName = basedir + "/" + metafname;
+	std::string sigName = basedir + "/" + metasigfname;
+
+	metaFile = fopen(fName.c_str(), "r");
+	metaSig = fopen(sigName.c_str(), "r");
+
+	// check if files exist
+	if((metaFile != NULL) && (metaSig != NULL))
+	{
+		oldTypeExists = true;
+		fclose(metaFile);
+		fclose(metaSig);
+	}
+	else
+		oldTypeExists =  false;
+
+
+
+	return oldTypeExists;
+
+
+}
+
 p3Config::p3Config(uint32_t t)
 	:pqiConfig(t)
 {
@@ -540,6 +656,120 @@ p3Config::p3Config(uint32_t t)
 
 
 bool p3Config::loadConfiguration(std::string &loadHash)
+{
+	if(globalConfigType)
+		return loadGlobalConfig(loadHash);
+	else
+		return loadConfig();
+}
+
+bool p3Config::loadConfig()
+{
+
+#ifdef CONFIG_DEBUG
+		std::cerr << "p3Config::loadConfig() loading Configuration\n File: " << Filename() << std::endl;
+#endif
+
+	bool pass = true;
+	std::string cfgFname = Filename();
+	std::string cfgFnameBackup = cfgFname + ".tmp";
+
+	std::string signFname = Filename() +".sgn";
+	std::string signFnameBackup = signFname + ".tmp";
+
+	std::list<RsItem *> load;
+	std::list<RsItem *>::iterator it;
+
+	// try 1st attempt
+	if(!loadAttempt(cfgFname, signFname, load))
+	{
+
+#ifdef CONFIG_DEBUG
+		std::cerr << "p3Config::loadConfig() Failed to Load" << std::endl;
+#endif
+
+		/* bad load */
+		for(it = load.begin(); it != load.end(); it++)
+		{
+			delete (*it);
+		}
+		pass = false;
+	}
+
+	// try 2nd attempt with backup files if first failed
+	if(!pass)
+	{
+		if(!loadAttempt(cfgFnameBackup, signFnameBackup, load))
+		{
+
+#ifdef CONFIG_DEBUG
+			std::cerr << "p3Config::loadConfig() Failed on 2nd Pass" << std::endl;
+#endif
+
+			/* bad load */
+			for(it = load.begin(); it != load.end(); it++)
+			{
+				delete (*it);
+			}
+			pass = false;
+		}
+	}
+
+
+
+	if(pass)
+		loadList(load);
+	else
+		return false;
+
+	return pass;
+}
+
+bool p3Config::loadAttempt(const std::string& cfgFname,const std::string& signFname, std::list<RsItem *>& load)
+{
+
+#ifdef CONFIG_DEBUG
+	std::cerr << "p3Config::loadAttempt() \nFilename: " << cfgFname <<  std::endl;
+#endif
+
+
+	uint32_t bioflags = BIN_FLAGS_HASH_DATA | BIN_FLAGS_READABLE;
+	uint32_t stream_flags = BIN_FLAGS_READABLE;
+
+	BinEncryptedFileInterface *bio = new BinEncryptedFileInterface(cfgFname.c_str(), bioflags);
+	pqiSSLstore stream(setupSerialiser(), "CONFIG", bio, stream_flags);
+
+	if(!stream.getEncryptedItems(load))
+	{
+#ifdef CONFIG_DEBUG
+		std::cerr << "p3Config::loadAttempt() Error occurred trying to load Item" << std::endl;
+#endif
+		return false;
+	}
+
+	/* set hash */
+	setHash(bio->gethash());
+
+	BinMemInterface *signbio = new BinMemInterface(1000, BIN_FLAGS_READABLE);
+
+	if(!signbio->readfromfile(signFname.c_str()))
+		return false;
+
+	std::string signatureStored((char *) signbio->memptr(), signbio->memsize());
+
+	std::string signatureRead;
+	std::string strHash(Hash());
+	AuthSSL::getAuthSSL()->SignData(strHash.c_str(), strHash.length(), signatureRead);
+
+	if(signatureRead != signatureStored)
+		return false;
+
+	delete signbio;
+
+	return true;
+}
+
+bool	p3Config::loadGlobalConfig(std::string &loadHash)
 {
 	bool pass = false;
 	std::string cfg_fname = Filename();
@@ -638,6 +868,93 @@ bool p3Config::getHashAttempt(const std::string& loadHash, std::string& hashstr,
 
 
 bool p3Config::saveConfiguration()
+{
+		return saveConfig();
+}
+
+bool p3Config::saveConfig()
+{
+
+	bool cleanup = true;
+	std::list<RsItem *> toSave = saveList(cleanup);
+
+	// temporarily append new to files as these will replace current configuration
+	std::string newCfgFname = Filename() + "_new";
+	std::string newSignFname = Filename() + ".sgn" + "_new";
+
+	std::string tmpCfgFname = Filename() + ".tmp";
+	std::string tmpSignFname = Filename() + ".sgn" + ".tmp";
+
+	std::string cfgFname = Filename();
+	std::string signFname = Filename() + ".sgn";
+
+
+	uint32_t bioflags = BIN_FLAGS_HASH_DATA | BIN_FLAGS_WRITEABLE;
+	uint32_t stream_flags = BIN_FLAGS_WRITEABLE;
+	bool written = true;
+
+	if (!cleanup)
+		stream_flags |= BIN_FLAGS_NO_DELETE;
+
+	BinEncryptedFileInterface *cfg_bio = new BinEncryptedFileInterface(newCfgFname.c_str(), bioflags);
+	pqiSSLstore *stream = new pqiSSLstore(setupSerialiser(), "CONFIG", cfg_bio, stream_flags);
+
+	written = written && stream->encryptedSendItems(toSave);
+
+	/* store the hash */
+	setHash(cfg_bio->gethash());
+
+	// bio is taken care of in stream's destructor, also forces file to close
+	delete stream;
+
+	/* sign data */
+	std::string signature;
+	std::string strHash(Hash());
+	AuthSSL::getAuthSSL()->SignData(strHash.c_str(),strHash.length(), signature);
+
+    /* write signature to configuration */
+    BinMemInterface *signbio = new BinMemInterface(signature.c_str(),
+    		signature.length(), BIN_FLAGS_READABLE);
+
+    signbio->writetofile(newSignFname.c_str());
+
+    delete signbio;
+
+    // now rewrite current files to temp files
+	// rename back-up to current file
+	if(!RsDirUtil::renameFile(cfgFname, tmpCfgFname)  || !RsDirUtil::renameFile(signFname, tmpSignFname)){
+#ifdef CONFIG_DEBUG
+		std::cerr << "p3Config::backedUpFileSave() Failed to rename backup meta files: " << std::endl
+				<< cfgFname << " to " << tmpCfgFname << std::endl
+				<< signFname << " to " << tmpSignFname << std::endl;
+#endif
+			written = false;
+		}
+
+
+
+	// now rewrite current files to temp files
+	// rename back-up to current file
+	if(!RsDirUtil::renameFile(newCfgFname, cfgFname)  || !RsDirUtil::renameFile(newSignFname, signFname)){
+	#ifdef CONFIG_DEBUG
+				std::cerr << "p3Config::() Failed to rename meta files: " << std::endl
+						<< newCfgFname << " to " << cfgFname << std::endl
+						<< newSignFname << " to " << signFname << std::endl;
+	#endif
+
+				written = false;
+			}
+
+
+
+	saveDone(); // callback to inherited class to unlock any Mutexes protecting saveList() data
+
+	return written;
+
+}
+
+
+bool	p3Config::saveGlobalConfig()
 {
 
 	bool cleanup = true;
@@ -945,6 +1262,8 @@ bool    p3GeneralConfig::loadList(std::list<RsItem *> load)
  * only the Indication and hash really need it
  */
 
+bool pqiConfig::globalConfigType = false;
+
 pqiConfig::pqiConfig(uint32_t t)
 	:ConfInd(2), type(t)
 {

libretroshare/src/pqi/p3cfgmgr.h

@@ -150,6 +150,8 @@ void	setHash(std::string h);
 
 	RsMutex cfgMtx;
 
+	static bool globalConfigType;
+
 	private:
 
 	/**
@@ -168,10 +170,13 @@ void	setHash(std::string h);
 	std::string filename;
 	std::string hash;
 
+
 	friend class p3ConfigMgr;
 	/* so it can access:
 	 * setFilename() and HasConfigChanged()
 	 */
+
+
 };
 
 
@@ -223,8 +228,45 @@ class p3ConfigMgr
 		 */
 		void	completeConfiguration();
 
+
+
 	private:
 
+		/**
+		 * this checks for the global config file and signature and determines class's mode of operation
+		 * @return global file rs-v0.#.cfg and rs-v0.#.sgn are present
+		 * @deprecated
+		 */
+		bool 	checkForGlobalSigConfig();
+
+		/**
+		 * removes theoldconfiguration type
+		 * @deprecated
+		 */
+		void removeOldConfigType();
+
+		/**
+		 * to save old style global-signature configuration files
+		 * @deprecated
+		 */
+		void globalSaveConfig();
+
+		/**
+		 * to load up old style global-signature config files
+		 * @deprecated
+		 */
+		void globalLoadConfig();
+
+		/**
+		 * saves configuration of pqiconfigs in object configs
+		 */
+		void saveConfig();
+
+		/**
+		 *
+		 */
+		void loadConfig();
+
 		/**
 		 * checks if signature and configuration file's signature matches
 		 * @return false if signature file does not match configuration file's signature
@@ -251,10 +293,13 @@ const std::string metasigfname;
 
 	RsMutex cfgMtx; /* below is protected */
 
+bool oldConfigType;
 bool	mConfigSaveActive;
 std::map<uint32_t, pqiConfig *> configs;
 };
 
+
+
 /***************************************************************************************************/
 
 
@@ -272,6 +317,7 @@ class p3Config: public pqiConfig
 virtual bool	loadConfiguration(std::string &loadHash);
 virtual bool	saveConfiguration();
 
+
 	protected:
 
 	/* Key Functions to be overloaded for Full Configuration */
@@ -311,6 +357,13 @@ bool backedUpFileSave(const std::string& fname, const std::string& fname_backup,
  */
 bool getHashAttempt(const std::string& loadHash, std::string& hashstr, const std::string& fname, std::list<RsItem *>& load);
 
+bool loadConfig();
+bool saveConfig();
+
+bool loadGlobalConfig(std::string& hash);
+bool saveGlobalConfig();
+
+bool loadAttempt(const std::string&,const std::string&, std::list<RsItem *>& load);
 
 }; /* end of p3Config */
 

libretroshare/src/pqi/pqi_base.h

@@ -114,7 +114,14 @@ public:
 	PQInterface(std::string id) :peerId(id) { return; }
 virtual	~PQInterface() { return; }
 
+/*!
+ * allows user to send RsItems to a particular facility  (file, network)
+ */
 virtual int	SendItem(RsItem *) = 0;
+
+/*!
+ * Retrieve RsItem from a facility
+ */
 virtual RsItem *GetItem() = 0;
 
 /**

libretroshare/src/pqi/pqibin.cc

@@ -26,7 +26,9 @@
 
 
 
+
 #include "pqi/pqibin.h"
+#include "pqi/authssl.h"
 #include "util/rsnet.h"
 
 
@@ -160,6 +162,141 @@ uint64_t BinFileInterface::bytecount()
 	return 0;
 }
 
+int BinFileInterface::getFileSize()
+{
+	return size;
+}
+
+
+
+BinEncryptedFileInterface::BinEncryptedFileInterface(const char* fname, int flags)
+	: BinFileInterface(fname, flags), data(NULL), haveData(false), sizeData(0), cpyCount(0)
+{
+}
+
+BinEncryptedFileInterface::~BinEncryptedFileInterface()
+{
+	if((sizeData > 0) && data != NULL)
+	{
+		delete[] data;
+	}
+
+}
+
+int BinEncryptedFileInterface::senddata(void* data, int len)
+{
+
+	char* encrytedData = NULL;
+	int encDataLen = 0;
+
+	// encrypt using own ssl public key
+	if(len > 0)
+		AuthSSL::getAuthSSL()->encrypt((void*&)encrytedData, encDataLen, data, len, AuthSSL::getAuthSSL()->OwnId());
+	else
+		return -1;
+
+
+	if((encDataLen > 0) && (encrytedData != NULL))
+	{
+		BinFileInterface::senddata(encrytedData, encDataLen);
+		delete[] encrytedData;
+	}
+	else
+	{
+		return -1;
+	}
+
+	return len;
+}
+
+
+int BinEncryptedFileInterface::readdata(void* data, int len)
+{
+	// to respect the inherited behavior of BinInterface
+	// the whole file is read and decryped and store to be read by subsequent calls
+	char* encryptedData = NULL;
+	int encrypDataLen = 0;
+
+
+	if(!haveData) // read whole data for first call, or first call after close()
+	{
+
+		encrypDataLen = BinFileInterface::getFileSize();
+		encryptedData = new char[encrypDataLen];
+
+		// make sure assign was successful
+		if(encryptedData == NULL)
+			return -1;
+
+
+		if(-1 == BinFileInterface::readdata(encryptedData, encrypDataLen))
+			return -1;
+
+		if((encrypDataLen > 0) && (encryptedData != NULL))
+		{
+
+				if(!AuthSSL::getAuthSSL()->decrypt((void*&)(this->data), sizeData, encryptedData, encrypDataLen))
+					return -1;
+
+				haveData = true;
+				delete[] encryptedData;
+		}
+
+
+		if(len <= sizeData)
+		{
+			memcpy(data, this->data, len);
+			cpyCount += len;
+		}
+		else
+		{
+			std::cerr << "BinEncryptedFileInterface::readData(): Error, Asking for more data than present" << std::endl;
+			return -1;
+		}
+	}
+	else
+	{
+
+		if((cpyCount + len) <= sizeData)
+		{
+			memcpy(data, (void *) ((this->data) + cpyCount), len);
+			cpyCount += len;
+		}
+		else
+		{
+			std::cerr << "BinEncryptedFileInterface::readData(): Error, Asking for more data than present" << std::endl;
+			return -1;
+		}
+	}
+
+	return len;
+}
+
+int BinEncryptedFileInterface::close()
+{
+	if(data != NULL)
+	{
+		delete[] data;
+		sizeData = 0;
+		haveData = false;
+		cpyCount = 0;
+	}
+
+	return BinFileInterface::close();
+}
+
+uint64_t BinEncryptedFileInterface::bytecount()
+{
+	return cpyCount;
+}
+
+bool BinEncryptedFileInterface::moretoread()
+{
+	if(haveData)
+		return (cpyCount < sizeData);
+	else
+		return cpyCount < getFileSize();
+}
 
 BinMemInterface::BinMemInterface(int defsize, int flags)
 	:bin_flags(flags), buf(NULL), size(defsize), 

libretroshare/src/pqi/pqibin.h

@@ -28,8 +28,10 @@
 #ifndef PQI_BIN_INTERFACE_HEADER
 #define PQI_BIN_INTERFACE_HEADER
 
+
 #include "pqi/pqi_base.h"
 #include "pqi/pqihash.h"
+
 #include <stdio.h>
 
 
@@ -70,6 +72,9 @@ virtual bool    bandwidthLimited() { return false; }
 virtual std::string gethash();
 virtual uint64_t bytecount();
 
+protected:
+	virtual int getFileSize();
+
 private:
 	int   bin_flags;
 	FILE *buf;
@@ -78,6 +83,52 @@ private:
 	uint64_t bcount;
 };
 
+/*!
+ * use this for writing encrypted data to file using user's (ownid) ssl key
+ * hash for encrypted data is calculated, not the unencrypted data
+ */
+class BinEncryptedFileInterface : public BinFileInterface
+{
+public:
+
+	BinEncryptedFileInterface(const char *fname, int flags);
+	virtual ~BinEncryptedFileInterface();
+
+	/*!
+	 * pls note if hashing is on, it is the hash of the encrypted data that is calculated
+	 * also note, sif data is sent more than once, in a single instance of this object, then you will need to store the
+	 * encrypted file size for each send externally as they are encrypted with different random keys.
+	 * @param data data to be sent
+	 * @param len length of data in bytes
+	 * @return -1 if failed to write data, if not number bytes sent to file is returned
+	 */
+	int	senddata(void *data, int len);
+
+	/*!
+	 * uses the hash of the encrypted data
+	 * @param location to place data
+	 * @param the length of data to be read
+	 * @return -1 if failed to write data, if not number of bytes read is returned
+	 */
+	int	readdata(void *data, int len);
+
+	/*!
+	 * this releases resources held by an instance
+	 */
+	int	close();
+
+	uint64_t bytecount();
+	bool	moretoread();
+
+private:
+
+	char* data;
+	bool haveData;
+	int sizeData;
+	uint64_t cpyCount;
+
+};
+
 //! handles writing to reading/writing to memory
 /*!
  * This provide a memory interface for storing/retrieving information in memory

libretroshare/src/pqi/pqistore.cc

@@ -181,6 +181,9 @@ RsItem *pqistore::GetItem()
 	return outPkt;
 }
 
+
+
+
 // // PQInterface
 int	pqistore::tick()
 {
@@ -386,5 +389,190 @@ std::string pqistore::gethash()
 	return bio->gethash();
 }
 
+pqiSSLstore::pqiSSLstore(RsSerialiser *rss, std::string srcId, BinEncryptedFileInterface* bio_in, int bio_flagsin)
+: pqistore(rss, srcId, bio_in, bio_flagsin), enc_bio(bio_in)
+{
+	return;
+}
+
+pqiSSLstore::~pqiSSLstore()
+{
+	return;
+}
+
+bool pqiSSLstore::encryptedSendItems(const std::list<RsItem*>& rsItemList)
+{
+
+	std::list<RsItem*>::const_iterator it;
+	uint32_t sizeItems = 0, sizeItem = 0;
+	uint32_t offset = 0;
+	char* data = NULL;
+
+	for(it = rsItemList.begin(); it != rsItemList.end(); it++)
+		sizeItems += rsSerialiser->size(*it);
+
+	data = new char[sizeItems];
+
+	for(it = rsItemList.begin(); it != rsItemList.end(); it++)
+	{
+		sizeItem = rsSerialiser->size(*it);
+		if(!rsSerialiser->serialise(*it, (data+offset),&sizeItem))
+			return false;
+		offset += sizeItem;
+
+	}
+
+	if(sizeItems == offset)
+		enc_bio->senddata(data, sizeItems);
+	else
+		return false;
+
+	if(data != NULL)
+		delete[] data;
+
+	return true;
+}
+	
+bool pqiSSLstore::getEncryptedItems(std::list<RsItem* >& rsItemList)
+{
+	RsItem* item;
+
+	while(NULL != (item = GetItem()))
+	{
+		rsItemList.push_back(item);
+	}
+
+	return true;
+}
 
 
+RsItem *pqiSSLstore::GetItem()
+{
+        {
+	  std::ostringstream out;
+	  out << "pqistore::GetItem()";
+	  pqioutput(PQL_DEBUG_ALL, pqistorezone, out.str());
+	}
+
+	// check if this is a reading bio.
+	if (!(bio_flags & BIN_FLAGS_READABLE))
+	{
+		std::ostringstream out;
+		out << "pqistore::GetItem()";
+        	out << "Error Not Readable" << std::endl;
+		pqioutput(PQL_DEBUG_BASIC, pqistorezone, out.str());
+		return NULL;
+	}
+
+	// load if we dont have a packet.
+	if (!nextPkt)
+	{
+		if (!readPkt(&nextPkt))
+		{
+			std::ostringstream out;
+			out << "pqistore::GetItem()";
+        		out << "Failed to ReadPkt" << std::endl;
+			pqioutput(PQL_DEBUG_BASIC, pqistorezone, out.str());
+			return NULL;
+		}
+	}
+
+	if (!nextPkt) return NULL;
+
+	RsItem *outPkt = nextPkt;
+	nextPkt = NULL;
+
+	if (outPkt != NULL)
+        {
+	  std::ostringstream out;
+	  out << "pqistore::GetItem() Returning:" << std::endl;
+	  outPkt -> print(out);
+	  pqioutput(PQL_DEBUG_BASIC, pqistorezone, out.str());
+	}
+	return outPkt;
+}
+
+
+int     pqiSSLstore::readPkt(RsItem **item_out)
+{
+        {
+	  std::ostringstream out;
+	  out << "pqistore::readPkt()";
+	  pqioutput(PQL_DEBUG_ALL, pqistorezone, out.str());
+	}
+
+	if ((!(enc_bio->isactive())) || (!(enc_bio->moretoread())))
+	{
+		return 0;
+	}
+
+	// enough space to read any packet.
+	int maxlen = getRsPktMaxSize();
+	void *block = malloc(maxlen);
+
+	// initial read size: basic packet.
+	int blen = getRsPktBaseSize();
+
+	int tmplen;
+	/* we have the header */
+
+	// read the basic block (minimum packet size)
+	if (blen != (tmplen = enc_bio->readdata(block, blen)))
+	{
+	  	pqioutput(PQL_WARNING, pqistorezone,
+	  		"pqistore::readPkt() bad read(2)");
+
+		free(block);
+		return 0;
+	}
+
+	// workout how much more to read.
+	int extralen = getRsItemSize(block) - blen;
+
+	if(extralen+blen > maxlen)
+		std::cerr << "***** ERROR: trying to read a packet of length " << extralen+blen << ", while the maximum length is " << maxlen << std::endl ;
+
+	if (extralen > 0)
+	{
+	   if(extralen > blen + maxlen)
+	   {
+		  std::cerr << "pqistore: ERROR: Inconsistency in packet format (extralen=" << extralen << ", maxlen=" << maxlen << "). Wasting the whole file." << std::endl ;
+		  free(block) ;
+		  return 0 ;
+	   }
+
+		void *extradata = (void *) (((char *) block) + blen);
+
+		if (extralen != (tmplen = enc_bio->readdata(extradata, extralen)))
+		{
+
+	  		std::ostringstream out;
+	  		out << "pqistore::readPkt() ";
+			out << "Error Completing Read (read ";
+			out << tmplen << "/" << extralen << ")" << std::endl;
+	  		pqioutput(PQL_ALERT, pqistorezone, out.str());
+
+			free(block);
+			return 0;
+		}
+	}
+
+	// create packet, based on header.
+        //std::cerr << "Read Data Block -> Incoming Pkt(";
+        //std::cerr << blen + extralen << ")" << std::endl;
+	uint32_t readbytes = extralen + blen;
+
+	RsItem *item = rsSerialiser->deserialise(block, &readbytes);
+	free(block);
+
+	if (item == NULL)
+	{
+	  	pqioutput(PQL_ALERT, pqistorezone,
+		  "pqistore::readPkt() Failed to create Item from store!");
+		return 0;
+	}
+
+	item->PeerId(mSrcId);
+	*item_out = item;
+	return 1;
+}

libretroshare/src/pqi/pqistore.h

@@ -28,7 +28,7 @@
 #ifndef MRK_PQI_STORE_STREAMER_HEADER
 #define MRK_PQI_STORE_STREAMER_HEADER
 
-#include "pqi/pqi.h"
+#include "pqi/pqibin.h"
 
 #include <list>
 
@@ -53,19 +53,59 @@ virtual int     status();
 
 std::string     gethash();
 
-	private:
+protected:
-int     writePkt(RsItem *item);
-int     readPkt(RsItem **item_out);
 
 // Serialiser
 RsSerialiser *rsSerialiser;
-	// Binary Interface for IO, initialisated at startup.
-	BinInterface *bio;
 unsigned int  bio_flags; // only BIN_NO_CLOSE at the moment.
 
 // Temp Storage for transient data.....
 RsItem *nextPkt;
 std::string mSrcId;
+
+private:
+
+	int     writePkt(RsItem *item);
+	int     readPkt(RsItem **item_out);
+
+
+
+	// Binary Interface for IO, initialisated at startup.
+	BinInterface *bio;
+
+};
+
+
+/*!
+ * provdes an ssl encrypted stream to file storage
+ */
+class pqiSSLstore: public pqistore
+{
+
+public:
+
+	pqiSSLstore(RsSerialiser *rss, std::string srcId, BinEncryptedFileInterface *bio_in, int bio_flagsin);
+
+	virtual ~pqiSSLstore();
+
+	/*!
+	 * send items encrypted to file using client's ssl key
+	 */
+	bool encryptedSendItems(const std::list<RsItem* >&);
+
+	/*!
+	 * retrieve encrypted file using client's ssl key
+	 */
+	bool getEncryptedItems(std::list<RsItem*>&);
+
+private:
+
+	RsItem *GetItem();
+	int     readPkt(RsItem **item_out);
+
+	BinEncryptedFileInterface* enc_bio;
+
+
 };
 
 

libretroshare/src/rsserver/rsinit.cc

@@ -1784,9 +1784,13 @@ bool  RsInit::RsTryAutoLogin()
 
 	fclose(helpFile);
 
+
 	delete[] indata;
 	delete[] outdata;
+
+	if(key != NULL)
 		delete key;
+
 	return true;
 #else