* Added another Test UdpLayer: TimedUdpLayer, This simulates the firewalled situation, be only accepting packets after 60 seconds.

* added quick and dirty BitDht Packet check. test against "d1:" for the first 3 bytes. This should not conflict with Stun, Relay or TOU packets.




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

libbitdht/src/bitdht/bdmanager.cc

@@ -1122,11 +1122,24 @@ void bdNodeManager::doValueCallback(const bdNodeId *id, std::string key, uint32_
 }
 
 
+#define BITDHT_IDENTITY_STRING_V1  	"d1:"
+#define BITDHT_IDENTITY_SIZE_V1    	3
+#define BITDHT_PACKET_MIN_SIZE		4
 
         /******************* Internals *************************/
 int     bdNodeManager::isBitDhtPacket(char *data, int size, struct sockaddr_in & from)
 
 {
+
+	/* use a very simple initial check */
+        if (size < BITDHT_PACKET_MIN_SIZE)
+                return 0;
+
+        return (0 == strncmp(data, BITDHT_IDENTITY_STRING_V1, BITDHT_IDENTITY_SIZE_V1));
+
+	/* Below is the old version! */
+
+
 #ifdef DEBUG_MGR_PKT
 	std::cerr << "bdNodeManager::isBitDhtPacket() *******************************";
         std::cerr << " from " << inet_ntoa(from.sin_addr);

libbitdht/src/udp/udplayer.cc

@@ -532,11 +532,11 @@ int LossyUdpLayer::receiveUdpPacket(void *data, int *size, struct sockaddr_in &f
 		if (prob < lossFraction)
 		{
 			/* discard */
-			std::cerr << "LossyUdpLayer::receiveUdpPacket() Dropping packet!";
+			//std::cerr << "LossyUdpLayer::receiveUdpPacket() Dropping packet!";
-			std::cerr << std::endl;
+			//std::cerr << std::endl;
-			std::cerr << printPkt(data, *size);
+			//std::cerr << printPkt(data, *size);
-			std::cerr << std::endl;
+			//std::cerr << std::endl;
-			std::cerr << "LossyUdpLayer::receiveUdpPacket() Packet Dropped!";
+			std::cerr << "LossyUdpLayer::receiveUdpPacket() Packet (" << *size << ") Dropped!";
 			std::cerr << std::endl;
 
 			*size = 0;
@@ -556,11 +556,11 @@ int LossyUdpLayer::sendUdpPacket(const void *data, int size, const struct sockad
 	{
 		/* discard */
 	
-		std::cerr << "LossyUdpLayer::sendUdpPacket() Dropping packet!";
+		//std::cerr << "LossyUdpLayer::sendUdpPacket() Dropping packet!";
-		std::cerr << std::endl;
+		//std::cerr << std::endl;
-		std::cerr << printPkt((void *) data, size);
+		//std::cerr << printPkt((void *) data, size);
-		std::cerr << std::endl;
+		//std::cerr << std::endl;
-		std::cerr << "LossyUdpLayer::sendUdpPacket() Packet Dropped!";
+		std::cerr << "LossyUdpLayer::sendUdpPacket() Packet (" << size << ") Dropped!";
 		std::cerr << std::endl;
 	
 		return size;
@@ -678,3 +678,72 @@ int RestrictedUdpLayer::sendUdpPacket(const void *data, int size, const struct s
 	return UdpLayer::sendUdpPacket(data, size, to);
 }
 
+
+#define STARTUP_PERIOD	60
+
+TimedUdpLayer::TimedUdpLayer(UdpReceiver *udpr, 
+			struct sockaddr_in &local)
+	:UdpLayer(udpr, local)
+{
+        mStartTime = time(NULL) + STARTUP_PERIOD;
+        mActive = false;
+	return;
+}
+
+TimedUdpLayer::~TimedUdpLayer() { return; }
+
+int TimedUdpLayer::receiveUdpPacket(void *data, int *size, struct sockaddr_in &from)
+{
+	if (0 < UdpLayer::receiveUdpPacket(data, size, from))
+	{
+		if (!mActive)
+		{
+			if (time(NULL) < mStartTime)
+			{
+#ifdef DEBUG_UDP_LAYER 	
+#endif
+				std::cerr << "TimedUdpLayer::receiveUdpPacket() Dropping packet (Too Early)";
+				std::cerr << std::endl;
+				//std::cerr << printPkt(data, *size);
+				//std::cerr << std::endl;
+
+				*size = 0;
+				return -1;
+	
+			}
+
+			mActive = true;
+	
+		}
+
+		/* acceptable port */
+		return *size;
+	}
+	return -1;
+}
+	
+int TimedUdpLayer::sendUdpPacket(const void *data, int size, const struct sockaddr_in &to)
+{
+	if (!mActive)
+	{
+		if (time(NULL) < mStartTime)
+		{
+			/* drop */
+#ifdef DEBUG_UDP_LAYER 	
+#endif
+			std::cerr << "TimedUdpLayer::sendUdpPacket() Dropping packet (Too Early)";
+			std::cerr << std::endl;
+			return size;
+		}
+		
+		/* else activate */
+		mActive = true;
+	}
+
+	// otherwise read normally;
+	return UdpLayer::sendUdpPacket(data, size, to);
+}
+
+
+
+

libbitdht/src/udp/udplayer.h

@@ -165,4 +165,22 @@ virtual	int sendUdpPacket(const void *data, int size, const struct sockaddr_in &
 };
 
 
+/* For Testing - drops packets all packets for initial minute (simulates TTL) */
+class TimedUdpLayer: public UdpLayer
+{
+	public:
+  TimedUdpLayer(UdpReceiver *udpr, struct sockaddr_in &local);
+virtual ~TimedUdpLayer();
+
+        protected:
+
+virtual int receiveUdpPacket(void *data, int *size, struct sockaddr_in &from);
+virtual	int sendUdpPacket(const void *data, int size, const struct sockaddr_in &to);
+
+	time_t mStartTime;
+	bool mActive;
+
+};
+
+
 #endif

libbitdht/src/udp/udpstack.cc

@@ -61,6 +61,11 @@ UdpStack::UdpStack(int testmode, struct sockaddr_in &local)
 		std::cerr << "UdpStack::UdpStack() Installing RestrictedUdpLayer" << std::endl;
 		udpLayer = new RestrictedUdpLayer(this, laddr);
 	}
+	else if (testmode == UDP_TEST_TIMED_LAYER)
+	{
+		std::cerr << "UdpStack::UdpStack() Installing TimedUdpLayer" << std::endl;
+		udpLayer = new TimedUdpLayer(this, laddr);
+	}
 	else
 	{
 		std::cerr << "UdpStack::UdpStack() Installing Standard UdpLayer" << std::endl;

libbitdht/src/udp/udpstack.h

@@ -65,6 +65,7 @@ virtual int sendPkt(const void *data, int size, const struct sockaddr_in &to, in
 
 #define UDP_TEST_LOSSY_LAYER		1
 #define UDP_TEST_RESTRICTED_LAYER	2
+#define UDP_TEST_TIMED_LAYER		3
 
 #define UDP_TEST_LOSSY_FRAC		(0.10)