* Removed old DHT Code, removed other references too.

* Added interface class to bitDHT. (p3bitdht.h)
 * Added Optional section in libretroshare.pro



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

libretroshare/src/dht/p3bitdht.cc

@@ -0,0 +1,324 @@
+/*
+ * libretroshare/src/dht: p3bitdht.h
+ *
+ * BitDht interface for RetroShare.
+ *
+ * Copyright 2009-2010 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 "dht/p3bitdht.h"
+
+#include "bitdht/bdstddht.h"
+
+#include <openssl/sha.h>
+
+
+/* This is a conversion callback class between pqi interface
+ * and the BitDht Interface.
+ *
+ */
+
+class p3BdCallback: public BitDhtCallback
+{
+	public:
+
+	p3BdCallback(p3BitDht *parent)
+	:mParent(parent) { return; }
+
+virtual int dhtNodeCallback(const bdId *id, uint32_t peerflags)
+{
+	return mParent->NodeCallback(id, peerflags);
+}
+
+virtual int dhtPeerCallback(const bdNodeId *id, uint32_t status)
+{
+	return mParent->PeerCallback(id, status);
+}
+
+virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t status)
+{
+	return mParent->ValueCallback(id, key, status);
+}
+
+	private:
+
+	p3BitDht *mParent;
+};
+
+
+p3BitDht::p3BitDht(std::string id, pqiConnectCb *cb, UdpStack *udpstack, std::string bootstrapfile)
+	:pqiNetAssistConnect(id, cb)
+{
+	std::string dhtVersion = "RS51"; // should come from elsewhere!
+	bdNodeId ownId;
+
+	/* setup ownId */
+	storeTranslation(id);
+	lookupNodeId(id, &ownId);
+
+	/* standard dht behaviour */
+	bdDhtFunctions *stdfns = new bdStdDht();
+
+	/* create dht */
+	mUdpBitDht = new UdpBitDht(udpstack, &ownId, dhtVersion, bootstrapfile, stdfns);
+
+	/* setup callback to here */
+	p3BdCallback *bdcb = new p3BdCallback(this);
+	mUdpBitDht->addCallback(bdcb);
+
+}
+
+p3BitDht::~p3BitDht()
+{
+	delete mUdpBitDht;
+}
+
+	/* pqiNetAssist - external interface functions */
+void    p3BitDht::enable(bool on)
+{
+	//mUdpBitDht->enable(on);
+}
+	
+void    p3BitDht::shutdown() /* blocking call */
+{
+	//mUdpBitDht->shutdown();
+}
+
+
+void	p3BitDht::restart()
+{
+	//mUdpBitDht->restart();
+}
+
+bool    p3BitDht::getEnabled()
+{
+	return false;
+}
+
+bool    p3BitDht::getActive()
+{
+	return false;
+}
+
+	/* pqiNetAssistConnect - external interface functions */
+	/* add / remove peers */
+bool 	p3BitDht::findPeer(std::string pid)
+{
+	/* convert id -> NodeId */
+	if (!storeTranslation(pid))
+	{
+		/* error */
+		return false;
+	}
+
+	bdNodeId nid;
+	if (!lookupNodeId(pid, &nid))
+	{
+		/* error */
+		return false;
+	}
+
+	/* add in peer */
+	mUdpBitDht->addFindNode(&nid, 0);
+
+}
+
+bool 	p3BitDht::dropPeer(std::string pid)
+{
+	/* convert id -> NodeId */
+	bdNodeId nid;
+	if (!lookupNodeId(pid, &nid))
+	{
+		/* error */
+		return false;
+	}
+
+	/* remove in peer */
+	mUdpBitDht->removeFindNode(&nid);
+
+	/* remove from translation */
+	if (!removeTranslation(pid))
+	{
+		/* error */
+		return false;
+	}
+}
+
+	/* extract current peer status */
+bool 	p3BitDht::getPeerStatus(std::string id, 
+			struct sockaddr_in &raddr, uint32_t &mode)
+{
+
+
+	return false;
+}
+
+bool 	p3BitDht::getExternalInterface(struct sockaddr_in &raddr, 
+					uint32_t &mode)
+{
+
+
+	return false;
+}
+
+
+/* Adding a little bit of fixed test...
+ * This allows us to ensure that only compatible peers will find each other
+ */
+
+const	uint8_t RS_DHT_VERSION_LEN = 17;
+const	uint8_t rs_dht_version_data[RS_DHT_VERSION_LEN] = "RS_VERSION_0.5.1";
+
+/******************** Conversion Functions **************************/
+int p3BitDht::calculateNodeId(const std::string pid, bdNodeId *id)
+{
+	/* generate node id from pid */
+
+	/* use a hash to make it impossible to reverse */
+
+        uint8_t sha_hash[SHA_DIGEST_LENGTH];
+        memset(sha_hash,0,SHA_DIGEST_LENGTH*sizeof(uint8_t)) ;
+        SHA_CTX *sha_ctx = new SHA_CTX;
+        SHA1_Init(sha_ctx);
+
+        SHA1_Update(sha_ctx, rs_dht_version_data, RS_DHT_VERSION_LEN);
+        SHA1_Update(sha_ctx, pid.c_str(), pid.length());
+        SHA1_Final(sha_hash, sha_ctx);
+
+        for(int i = 0; i < SHA_DIGEST_LENGTH && (i < BITDHT_KEY_LEN); i++)
+        {
+		id->data[i] = sha_hash[i];
+        }
+	delete sha_ctx;
+	return 1;
+}
+
+int p3BitDht::lookupNodeId(const std::string pid, bdNodeId *id)
+{
+	RsStackMutex stack(dhtMtx);
+
+	std::map<std::string, bdNodeId>::iterator it;
+	it = mTransToNodeId.find(pid);
+	if (it == mTransToNodeId.end())
+	{
+		return 0;
+	}
+	*id = it->second;
+
+	return 1;
+}
+
+
+int p3BitDht::lookupRsId(const bdNodeId *id, std::string &pid)
+{
+	RsStackMutex stack(dhtMtx);
+
+	std::map<bdNodeId, std::string>::iterator nit;
+	nit = mTransToRsId.find(*id);
+	if (nit == mTransToRsId.end())
+	{
+		return 0;
+	}
+	pid = nit->second;
+
+	return 1;
+}
+
+int p3BitDht::storeTranslation(const std::string pid)
+{
+	bdNodeId nid;
+	calculateNodeId(pid, &nid);
+
+	RsStackMutex stack(dhtMtx);
+
+	mTransToNodeId[pid] = nid;
+	mTransToRsId[nid] = pid;
+
+	return 1;
+}
+
+int p3BitDht::removeTranslation(const std::string pid)
+{
+	RsStackMutex stack(dhtMtx);
+
+	std::map<std::string, bdNodeId>::iterator it = mTransToNodeId.find(pid);
+	it = mTransToNodeId.find(pid);
+	if (it == mTransToNodeId.end())
+	{
+		/* missing */
+		return 0;
+	}
+
+	bdNodeId nid = it->second;
+	std::map<bdNodeId, std::string>::iterator nit;
+	nit = mTransToRsId.find(nid);
+	if (nit == mTransToRsId.end())
+	{
+		/* inconsistent!!! */
+		return 0;
+	}
+
+	mTransToNodeId.erase(it);
+	mTransToRsId.erase(nit);
+
+	return 1;
+}
+
+
+/********************** Callback Functions **************************/
+int p3BitDht::NodeCallback(const bdId *id, uint32_t peerflags)
+{
+	/* is it one that we are interested in? */
+	std::string pid;
+	/* check for translation */
+	if (lookupRsId(&(id->id), pid))
+	{
+		/* we found it ... do callback to p3connmgr */
+		//uint32_t cbflags = ONLINE | UNREACHABLE;
+
+		return 1;
+	}
+
+	return 0;
+}
+
+int p3BitDht::PeerCallback(const bdNodeId *id, uint32_t status)
+{
+	/* is it one that we are interested in? */
+	std::string pid;
+	/* check for translation */
+	if (lookupRsId(id, pid))
+	{
+		/* we found it ... do callback to p3connmgr */
+		//uint32_t cbflags = ONLINE | REACHABLE;
+
+		return 1;
+	}
+
+	return 0;
+}
+
+int p3BitDht::ValueCallback(const bdNodeId *id, std::string key, uint32_t status)
+{
+	/* ignore for now */
+	return 0;
+}
+