From 4ff262c1c8e90e1c5c46a7a9cb07d492a0aa00cb Mon Sep 17 00:00:00 2001
From: Pramod R Sanaga <pramod@flux.utah.edu>
Date: Thu, 11 Jan 2007 01:39:56 +0000
Subject: [PATCH] 1) Removed potential memory leaks & added destructors for all
 classes. 2) Changed the number of redundant ACKs being sent to vary based on
 ACK size. 3) Libpcap loss at the sender is now handled - by sending packet
 sizes and send times in the packets and having them echoed back in ACKs.
 Reordered ACKs are detected as being seperate from libpcap loss and are
 ignored. 4) updated the plot creation python script to give out loss, maximum
 delay graphs.

---
 pelab/magent/UDP/UdpClientDir/UdpClient.cc    | 119 +++-----
 pelab/magent/UDP/UdpClientDir/UdpLibs.h       |  11 +
 .../UDP/UdpClientDir/UdpMaxDelaySensor.cc     |  43 ++-
 .../UDP/UdpClientDir/UdpMaxDelaySensor.h      |   3 +-
 .../UDP/UdpClientDir/UdpMinDelaySensor.cc     |  74 ++---
 .../UDP/UdpClientDir/UdpMinDelaySensor.h      |   3 +-
 .../magent/UDP/UdpClientDir/UdpPacketInfo.cc  |  10 +-
 pelab/magent/UDP/UdpClientDir/UdpPacketInfo.h |  11 +-
 .../UDP/UdpClientDir/UdpPacketSensor.cc       | 130 ++++----
 .../magent/UDP/UdpClientDir/UdpPacketSensor.h |   5 +-
 pelab/magent/UDP/UdpClientDir/UdpState.h      |  32 +-
 .../UDP/UdpClientDir/UdpThroughputSensor.cc   |  60 ++--
 pelab/magent/UDP/UdpClientDir/makeGnuPlot.py  | 100 +++++--
 pelab/magent/UDP/UdpClientDir/plot.gp         |   2 +-
 pelab/magent/UDP/UdpClientDir/runClient.sh    |   2 +-
 .../magent/UDP/UdpClientDir/showTputGraph.sh  |   6 +-
 pelab/magent/UDP/UdpServerDir/UdpServer.cc    | 278 +++++++-----------
 .../magent/UDP/UdpServerDir/makeServerPlot.py |   2 +-
 pelab/magent/UDP/UdpServerDir/runServer.sh    |   2 +-
 19 files changed, 448 insertions(+), 445 deletions(-)

diff --git a/pelab/magent/UDP/UdpClientDir/UdpClient.cc b/pelab/magent/UDP/UdpClientDir/UdpClient.cc
index eeb0015a7d..7c35ba3c2a 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpClient.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpClient.cc
@@ -22,7 +22,7 @@
 
 #define REMOTE_SERVER_PORT 1500
 #define MAX_MSG 1600
-#define SNAPLEN 128
+#define SNAPLEN 1600
 
 #include "UdpThroughputSensor.h"
 #include "UdpMinDelaySensor.h"
@@ -50,71 +50,12 @@ unsigned long long getTimeMicro()
         return (tmpSecVal*1000*1000 + tmpUsecVal);
 }
 
-// This is not being used  - because we are using libpcap.
-// This is useful if SO_TIMESTAMP option is used instead of the timestamps given by libpcap.
-void handleUDPMsg(struct sockaddr_in *clientAddr, char *udpMessage, int messageLen, struct timeval *timeStampVal)
-{
-	/*
-	printf("Destination IP address = %s\n", inet_ntoa(ipPacket->ip_dst));
-	printf("Source port = %d\n", ntohs(udpHdr->source));
-	printf("Dest port = %d\n\n", ntohs(udpHdr->dest));
-	*/
-
-	//printf("Data being received = %c, %u, %lld, %u\n", *(unsigned char *)(dataPtr), *(unsigned int *)(dataPtr + 1), *(unsigned long long*)(dataPtr + 5), udpLen);
-
-
-        unsigned char packetType = udpMessage[0];
-	unsigned long long timeStamp = 0;
-	unsigned long long tmpSecVal = timeStampVal->tv_sec;
-	unsigned long long tmpUsecVal = timeStampVal->tv_usec;
-
-	timeStamp =  (tmpSecVal*1000*1000 + tmpUsecVal);
-
-	int overheadLen = 46;
-
-        if(packetType == '0')// This is a udp data packet arriving here. Send an
-            // application level acknowledgement packet for it.
-
-            // TODO:The packet can also be leaving from this host - our libpcap filter
-           //  ignores those for now - as such, nothing needs to be done for such packets.
-        {
-		/*
-		if(strcmp( inet_ntoa(ipPacket->ip_dst),"10.1.2.2" ) != 0 )
-		{
-		    packetSensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen - 8, overheadLen, timeStamp);
-		}
-		*/
-	}
-	else if(packetType == '1')
-	{
-		// We received an ACK, pass it on to the sensors.
-		// TODO: Ignore the ACKs being sent out from this host.
-
-		// TODO: For now, we are just passing the packet data part.
-		// For this to work correctly when integrated with magent,
-		// we also need to pass the local port, remote port and
-		// remote IP address, so that the connection can be looked up.
-
-		//Pass the received packet to udp sensors:
-		packetSensor->capturePacket(udpMessage, messageLen, overheadLen, timeStamp);
-		minDelaySensor->capturePacket(udpMessage, messageLen, overheadLen, timeStamp);
-		maxDelaySensor->capturePacket(udpMessage, messageLen,overheadLen, timeStamp);
-		throughputSensor->capturePacket(udpMessage, messageLen, overheadLen, timeStamp);
-	}
-	else
-	{
-		printf("ERROR: Unknown UDP packet received from remote agent\n");
-		return;
-	}
-}
-
-
 void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr, u_char *const udpPacketStart, struct ip const *ipPacket)
 {
 
 	// Get a pointer to the data section of the UDP packet.
 	u_char *dataPtr = udpPacketStart + 8;
-	unsigned short udpLen = ntohs(udpHdr->len);
+	unsigned short udpLen = ntohs(udpHdr->len) - 8;
 
 	//printf("Data being received = %c, %u, %lld, %u\n", *(unsigned char *)(dataPtr), *(unsigned int *)(dataPtr + 1), *(unsigned long long*)(dataPtr + 5), udpLen);
 
@@ -143,7 +84,7 @@ void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr,
         {
 		if(strcmp( inet_ntoa(ipPacket->ip_dst),localIP ) != 0 )
 		{
-		    packetSensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen - 8, overheadLen, timeStamp);
+		    packetSensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen, overheadLen, timeStamp);
 		}
 	}
 	else if(packetType == '1')
@@ -160,10 +101,10 @@ void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr,
 		if(strcmp( inet_ntoa(ipPacket->ip_dst),localIP ) == 0 )
 		{
 			// Pass the captured packet to the udp sensors.
-			packetSensor->capturePacket(reinterpret_cast<char *> (dataPtr), udpLen - 8, overheadLen, timeStamp);
-			minDelaySensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen - 8, overheadLen, timeStamp);
-			maxDelaySensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen - 8, overheadLen, timeStamp);
-			throughputSensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen - 8, overheadLen, timeStamp);
+			packetSensor->capturePacket(reinterpret_cast<char *> (dataPtr), udpLen, overheadLen, timeStamp);
+			minDelaySensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen, overheadLen, timeStamp);
+			maxDelaySensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen, overheadLen, timeStamp);
+			throughputSensor->capturePacket(reinterpret_cast<char *>(dataPtr), udpLen, overheadLen, timeStamp);
 		}
 	}
 	else
@@ -356,19 +297,18 @@ int main(int argc, char *argv[])
 	init_pcap(argv[1], htons(cliAddr.sin_port));
 
 	// Open a file and pass the handle to the throughput sensor.
-	std::ofstream throughputStream;
+	std::ofstream logStream;
 
-	throughputStream.open("Throughput.log", std::ios::out);
+	logStream.open("stats.log", std::ios::out);
 
 	// Initialize the sensors.
 	packetSensor = new UdpPacketSensor(globalUdpState);
-	throughputSensor = new UdpThroughputSensor(globalUdpState, throughputStream);
-	maxDelaySensor = new UdpMaxDelaySensor(globalUdpState);
-	minDelaySensor = new UdpMinDelaySensor(globalUdpState);
+	throughputSensor = new UdpThroughputSensor(globalUdpState, logStream);
+	maxDelaySensor = new UdpMaxDelaySensor(globalUdpState, logStream);
+	minDelaySensor = new UdpMinDelaySensor(globalUdpState, logStream);
 
 	char packetData[1600];
-	unsigned int curSeqNum = 0;
-	unsigned long long sendTime;
+	unsigned short int curSeqNum = 0;
 
 	// Timeout for the non-blocking socket reads and writes.
 	struct timeval selectTimeout;
@@ -384,7 +324,8 @@ int main(int argc, char *argv[])
 	// Number of packets, Size of the packets to be sent, and their sending rate.
 	packetCount = atoi(argv[4]);
 	unsigned long long lastSendTime = 0;
-	int packetLen = atoi(argv[5]);
+	unsigned long long curTime;
+	unsigned short int packetLen = atoi(argv[5]);
 	long sendRate = atoi(argv[6]);
 
 	int overheadLen = 20 + 8 + 14 + 4;
@@ -396,6 +337,8 @@ int main(int argc, char *argv[])
 	lastSendTime = getTimeMicro();
 	echoLen = sizeof(echoServAddr);
 
+	FILE *sendDevFile = fopen("SendDeviation.log", "w");
+
 	/* send data */
 	while(true) 
 	{
@@ -417,18 +360,35 @@ int main(int argc, char *argv[])
 				// For now, take a command line argument giving the rate
 				// at which UDP packets should be sent ( this rate includes
 				// the overhead for UDP, IP & ethernet headers ( &ethernet checksum)
-				if(getTimeMicro() - lastSendTime > timeInterval)
+				curTime = getTimeMicro();
+				if(curTime - lastSendTime > timeInterval)
 				{
+					logStream << "SendDeviation:TIME="<<curTime<<",Deviation="<< curTime - lastSendTime - timeInterval<<std::endl;
+
 					curSeqNum++;
 					// Indicate that this is a data UDP packet - not an ACK.
 					packetData[0] = '0';
 
 					// Put the sequence number of the packet.
-					memcpy(&packetData[1],&curSeqNum, sizeof(unsigned int));
+					memcpy(&packetData[1],&curSeqNum, globalConsts::USHORT_INT_SIZE);
+
+					// Copy the size of the packet.. This can be 
+					// by the sensors in case they miss this packet
+					// because of libpcap buffer overflow.
+					// The size of the packet & its timestamp at the 
+					// sender are echoed in the ACKs.
+
+					memcpy(&packetData[1 + globalConsts::USHORT_INT_SIZE],&packetLen, globalConsts::USHORT_INT_SIZE);
+
+					// Copy the timestamp of when this packet is being sent.
+
+					// This timestamp will not be as accurate as 
+					// the one captured by libpcap, but can be
+					// used as a fallback option in case we miss
+					// this packet because of a libpcap buffer overflow.
+					memcpy(&packetData[1 + 2*globalConsts::USHORT_INT_SIZE], &curTime, globalConsts::ULONG_LONG_SIZE);
 
-					memcpy(&packetData[1 + sizeof(unsigned int)],&packetLen, sizeof(unsigned int));
-					sendTime = getTimeMicro();
-					lastSendTime = sendTime;
+					lastSendTime = curTime;
 
 					rc = sendto(sd, packetData, packetLen, flags, 
 					(struct sockaddr *) &remoteServAddr, 
@@ -464,5 +424,6 @@ int main(int argc, char *argv[])
 
 
 	}
+	fclose(sendDevFile);
 	return 0;
 }
diff --git a/pelab/magent/UDP/UdpClientDir/UdpLibs.h b/pelab/magent/UDP/UdpClientDir/UdpLibs.h
index da37ed8c2b..29fa1da6da 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpLibs.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpLibs.h
@@ -12,4 +12,15 @@
 #include <climits>
 #include <limits.h>
 
+namespace globalConsts {
+
+	const short int USHORT_INT_SIZE = sizeof(unsigned short int);
+	const short int ULONG_LONG_SIZE = sizeof(unsigned long long);
+	const short int UCHAR_SIZE = sizeof(unsigned char);
+
+	const static int redunAckSize = 2*USHORT_INT_SIZE + ULONG_LONG_SIZE;
+	const static int seqNumSize = USHORT_INT_SIZE;
+	const static int minAckPacketSize = 1 + 2*USHORT_INT_SIZE + ULONG_LONG_SIZE;
+}
+
 #endif
diff --git a/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.cc b/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.cc
index 5107e9a48d..1b32a3a941 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.cc
@@ -1,8 +1,9 @@
 #include "UdpMaxDelaySensor.h"
 
-UdpMaxDelaySensor::UdpMaxDelaySensor(UdpState &udpStateVal)
+UdpMaxDelaySensor::UdpMaxDelaySensor(UdpState &udpStateVal, ofstream &outStreamVal)
 	: maxDelay(0),
-	udpStateInfo(udpStateVal)
+	udpStateInfo(udpStateVal),
+	outStream(outStreamVal)
 {
 
 }
@@ -15,36 +16,47 @@ void UdpMaxDelaySensor::localSend(char *packetData, int Len,int overheadLen, uns
 
 void UdpMaxDelaySensor::localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp)
 {
-	int minSize = 1 + sizeof(unsigned int) + sizeof(unsigned long long);
-
-        if(Len < minSize)
+        if(Len < globalConsts::minAckPacketSize)
         {
                 cout << "Error: UDP packet data sent to MaxDelaySensor::localAck was less than the "
-                        " required minimum "<< minSize << " bytes\n";
-		udpStateInfo.ackError = true;
+                        " required minimum "<< globalConsts::minAckPacketSize << " bytes\n";
                 return;
         }
 
-	// Something went wrong with this packet - either the packet was not
-	// the minimum size or it was a re-ordered ACK - don't do anything
+	 // This is a re-ordered ACK - don't do anything
 	// with it - just return.
 	if( udpStateInfo.ackError == true )
 		return;
 
-        int numRedunAcks = static_cast<int>(packetData[0]);
-        vector<UdpPacketInfo * >::iterator vecIterator;
-        unsigned int seqNum = *(unsigned int *)(packetData + 1);
+        unsigned short int seqNum = *(unsigned short int *)(packetData + 1);
+        unsigned short int echoedPacketSize = *(unsigned short int *)(packetData + 1 + globalConsts::USHORT_INT_SIZE);
+	unsigned long long echoedTimestamp = *(unsigned long long *)(packetData + 1 + 2*globalConsts::USHORT_INT_SIZE);
         unsigned long long oneWayQueueDelay;
         bool eventFlag = false;
 
+        vector<UdpPacketInfo>::iterator vecIterator;
         vecIterator = find_if(udpStateInfo.recentSentPackets.begin(), udpStateInfo.recentSentPackets.end(), bind2nd(equalSeqNum(), seqNum));
 
 	// Find the one way RTT for this packet.
-        oneWayQueueDelay = (timeStamp - (*vecIterator)->timeStamp)/2;
+
+	// We lost this packet send time due to loss in libpcap, use the
+	// time echoed in the ACK packet.
+	if(udpStateInfo.isAckFake == true)
+		oneWayQueueDelay = (timeStamp - echoedTimestamp)/2;
+	else
+		oneWayQueueDelay = (timeStamp - (*vecIterator).timeStamp)/2;
 
 	// Scale the value of one way RTT, so that it is correct for a transmission
-	// size of 1500 bytes.
-	oneWayQueueDelay = ( oneWayQueueDelay )*1500 / (overheadLen + Len + 1);
+	// size of 1518 bytes.
+
+	// We lost this packet size details due to loss in libpcap, use the
+	// size echoed in the ACK packet - this does not included the header
+	// overhead for the packet - we assume that the packet on the reverse path
+	// has the same overhead length as the original packet.
+	if(udpStateInfo.isAckFake == true)
+		oneWayQueueDelay = ( oneWayQueueDelay )*1518 / (overheadLen + echoedPacketSize);
+	else
+		oneWayQueueDelay = ( oneWayQueueDelay )*1518 / ((*vecIterator).packetSize);
 
 	// Find the queuing delay for this packet, by subtracting the
 	// one way minimum delay from the above value.
@@ -63,6 +75,7 @@ void UdpMaxDelaySensor::localAck(char *packetData, int Len,int overheadLen, unsi
 		// Report the maximum delay
 		cout << "New Max Delay = " << maxDelay << "\n";
         }
+	outStream << "MAXD:TIME="<<timeStamp<<",MAXD="<<maxDelay<<endl;
 
 	udpStateInfo.maxDelay = maxDelay;
 }
diff --git a/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.h b/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.h
index 10118999ff..3ca966671a 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpMaxDelaySensor.h
@@ -10,13 +10,14 @@ class UdpSensor;
 class UdpMaxDelaySensor:public UdpSensor{
 	public:
 
-		explicit UdpMaxDelaySensor(UdpState &udpStateVal);
+		explicit UdpMaxDelaySensor(UdpState &udpStateVal, ofstream &outStreamVal);
 		void localSend(char *packetData, int Len,int overheadLen, unsigned long long timeStamp);
 		void localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp);
 
 	private:
 		unsigned long long maxDelay;
 		UdpState &udpStateInfo;
+		ofstream &outStream;
 };
 
 #endif
diff --git a/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.cc b/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.cc
index 26dd73e381..c9764fd359 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.cc
@@ -1,8 +1,9 @@
 #include "UdpMinDelaySensor.h"
 
-UdpMinDelaySensor::UdpMinDelaySensor(UdpState &udpStateVal)
+UdpMinDelaySensor::UdpMinDelaySensor(UdpState &udpStateVal, ofstream &outStreamVal)
 	: minDelay(ULONG_LONG_MAX),
-	udpStateInfo(udpStateVal)
+	udpStateInfo(udpStateVal),
+	outStream(outStreamVal)
 {
 
 }
@@ -16,36 +17,47 @@ void UdpMinDelaySensor::localSend(char *packetData, int Len,int overheadLen,unsi
 
 void UdpMinDelaySensor::localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp)
 {
-	int minSize = 1 + sizeof(unsigned int) + sizeof(unsigned long long);
-
-        if(Len < minSize)
+        if(Len < globalConsts::minAckPacketSize)
         {
                 cout << "Error: UDP packet data sent to MinDelaySensor::localAck was less than the "
-                        " required minimum "<< minSize << " bytes\n";
-		udpStateInfo.ackError = true;
+                        " required minimum "<< globalConsts::minAckPacketSize << " bytes\n";
                 return;
         }
 
-	// Something went wrong with this packet - either the packet was not
-	// the minimum size or it was a re-ordered ACK - don't do anything
+	 // This is a re-ordered ACK - don't do anything
 	// with it - just return.
 	if( udpStateInfo.ackError == true )
 		return;
 
+	unsigned short int seqNum = *(unsigned short int *)(packetData + 1);
+	unsigned short int echoedPacketSize = *(unsigned short int *)(packetData + 1 + globalConsts::USHORT_INT_SIZE);
+	unsigned long long echoedTimestamp = *(unsigned long long *)(packetData + 1 + 2*globalConsts::USHORT_INT_SIZE);
 
-	int numRedunAcks = static_cast<int>(packetData[0]);
-	vector<UdpPacketInfo * >::iterator vecIterator;
-	unsigned int seqNum = *(unsigned int *)(packetData + 1);
 	unsigned long long oneWayDelay;
 	bool eventFlag = false;
 
+	vector<UdpPacketInfo >::iterator vecIterator;
 	vecIterator = find_if(udpStateInfo.recentSentPackets.begin(), udpStateInfo.recentSentPackets.end(), bind2nd(equalSeqNum(), seqNum));
 
 	// Calculate the one way delay as half of RTT.
-	oneWayDelay = (timeStamp - (*vecIterator)->timeStamp)/2;
+
+	// We lost this packet send time due to loss in libpcap, use the 
+	// time echoed in the ACK packet.
+	if(udpStateInfo.isAckFake == true)
+		oneWayDelay = (timeStamp - echoedTimestamp)/2;
+	else
+		oneWayDelay = (timeStamp - (*vecIterator).timeStamp)/2;
 
 	// Calculate the delay for the maximum sized packet.
-	oneWayDelay = ( oneWayDelay ) * 1500 / (overheadLen + Len + 1);
+
+	// We lost this packet size details due to loss in libpcap, use the 
+	// size echoed in the ACK packet - this does not included the header
+	// overhead for the packet - we assume that the packet on the reverse path
+	// has the same overhead length as the original packet.
+	if(udpStateInfo.isAckFake == true)
+		oneWayDelay = ( oneWayDelay ) * 1518 / (overheadLen + echoedPacketSize);
+	else
+		oneWayDelay = ( oneWayDelay ) * 1518 / ( (*vecIterator).packetSize);
 
 	// Set this as the new minimum one way delay.
 	if(oneWayDelay < minDelay)
@@ -54,47 +66,15 @@ void UdpMinDelaySensor::localAck(char *packetData, int Len,int overheadLen, unsi
 		minDelay = oneWayDelay;
 	}
 
-	int redunAckSize = sizeof(unsigned int) + sizeof(unsigned long);
-	int seqNumSize = sizeof(unsigned int);
-
 	// We should not be calculating the minimum delay based on the
 	// redundant ACKs - because we cannot exactly calculate their
 	// RTT values, from just the receiver timestamps.
-	/*
-	if(numRedunAcks > 0)
-	{
-		int i;
-		unsigned int redunSeqNum;
-		unsigned long timeDiff;
-
-		for(i = 0;i < numRedunAcks; i++)
-		{
-			redunSeqNum = *(unsigned int *)(packetData + minSize + i*redunAckSize);
-			timeDiff = *(unsigned long *)(packetData + minSize + i*redunAckSize + seqNumSize);
-
-			vecIterator = find_if(udpStateInfo.recentSentPackets.begin(), udpStateInfo.recentSentPackets.end(), bind2nd(equalSeqNum(), redunSeqNum));
-
-			if(vecIterator != udpStateInfo.recentSentPackets.end())
-			{
-				oneWayDelay = (timeStamp - timeDiff - (*vecIterator)->timeStamp ) /2;
-				oneWayDelay = ( oneWayDelay ) * 1500 / ( (*vecIterator)->packetSize + overheadLen );
-
-				if(oneWayDelay > 0 && oneWayDelay < minDelay)
-				{
-					eventFlag = true;
-					minDelay = oneWayDelay;
-					minDelayBytes = (*vecIterator)->packetSize + overheadLen;
-				}
-			}
-		}
-
-	}
-	*/
 
 	// Send an event message to the monitor to change the value of minimum one way delay.
 	if(eventFlag == true)
 	{
 		cout << "New Min delay = " << minDelay << "\n";
 	}
+	outStream << "MIND:TIME="<<timeStamp<<",MIND="<<minDelay<<endl;
 	udpStateInfo.minDelay = minDelay;
 }
diff --git a/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.h b/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.h
index 70df9d9282..5f61f10f83 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpMinDelaySensor.h
@@ -10,13 +10,14 @@ class UdpSensor;
 class UdpMinDelaySensor:public UdpSensor{
 	public:
 
-		explicit UdpMinDelaySensor(UdpState &udpStateVal);
+		explicit UdpMinDelaySensor(UdpState &udpStateVal, ofstream &outStreamVal);
 		void localSend(char *packetData, int Len,int overheadLen, unsigned long long timeStamp);
 		void localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp);
 
 	private:
 		unsigned long long minDelay;
 		UdpState &udpStateInfo;
+		ofstream &outStream;
 };
 
 #endif
diff --git a/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.cc b/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.cc
index ddab272cf1..a6bcb28333 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.cc
@@ -1,11 +1,13 @@
 #include "UdpPacketInfo.h"
 
-UdpPacketInfo::UdpPacketInfo(unsigned int seqVal, unsigned int packetSizeVal, unsigned long long timeStampVal, bool isFastPacketVal)
+UdpPacketInfo::UdpPacketInfo()
+{
+
+}
+UdpPacketInfo::UdpPacketInfo(unsigned short int seqVal,unsigned short int packetSizeVal, unsigned long long timeStampVal)
 	:seqNum(seqVal),
 	packetSize(packetSizeVal),
-	timeStamp(timeStampVal),
-	isFastPacket(isFastPacketVal),
-	lastTimeDiff(0)
+	timeStamp(timeStampVal)
 {
 
 }
diff --git a/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.h b/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.h
index 761bb7b198..d1593fb9d6 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpPacketInfo.h
@@ -3,12 +3,13 @@
 
 class UdpPacketInfo{
         public:
-	explicit UdpPacketInfo::UdpPacketInfo(unsigned int, unsigned int, unsigned long long, bool);
-        unsigned int seqNum;
-        unsigned int packetSize;
+	UdpPacketInfo::UdpPacketInfo();
+	UdpPacketInfo::UdpPacketInfo(unsigned short int, unsigned short int, unsigned long long);
+        unsigned short int seqNum;
+        unsigned short int packetSize;
         unsigned long long timeStamp;
-	bool isFastPacket;
-	unsigned long long lastTimeDiff;
+
+	bool isFake;
 };
 
 #endif
diff --git a/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.cc b/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.cc
index 0b5c83d257..b67e43cd12 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.cc
@@ -1,102 +1,123 @@
 #include "UdpPacketSensor.h"
 
 UdpPacketSensor::UdpPacketSensor(UdpState &udpStateVal)
-	:udpStateInfo(udpStateVal)
+	:udpStateInfo(udpStateVal),
+	lastSeenSeqNum(-1)
 {
-	lastPacketTime = 0;
 
+}
+
+UdpPacketSensor::~UdpPacketSensor()
+{
+	// Empty the list used to store the packets.
+	sentPacketList.clear();
 
 }
 
 void UdpPacketSensor::localSend(char *packetData, int Len, int overheadLen, unsigned long long timeStamp)
 {
-	int minSize = 2*sizeof(unsigned int);
+	int minSize = 2*globalConsts::USHORT_INT_SIZE;
 
 	if(Len < minSize)
 	{
 		cout << "Error: UDP packet data sent to PacketSensor::localSend was less than the "
 			" required minimum "<< minSize << " bytes\n";
-		udpStateInfo.sendError = true;
 		return;
 	}
-	udpStateInfo.sendError = false;
 
-	unsigned int seqNum = *(unsigned int *)(packetData);
-	unsigned int packetSize = *(unsigned int *)(packetData + sizeof(unsigned int));
-	bool isFastPacket = false;
-	unsigned long long sendTimeDelta = 0;
+	unsigned short int seqNum = *(unsigned short int *)(packetData);
+	unsigned short int packetSize = *(unsigned short int *)(packetData + globalConsts::USHORT_INT_SIZE) + overheadLen;
+	UdpPacketInfo tmpPacketInfo;
 
-	if(lastPacketTime == 0)
-		lastPacketTime = timeStamp;
-	else
+	if(lastSeenSeqNum != -1)
 	{
+		// We missed some packets because of loss in libpcap buffer.
+		// Add fake packets to the sent list, their sizes and time stamps
+		// are unknown - but they can be gathered from the ACK packets.
+		if(seqNum > (lastSeenSeqNum + 1))
+		{
+			for(int i = 1;i < seqNum - lastSeenSeqNum ; i++)
+			{
+				tmpPacketInfo.seqNum = lastSeenSeqNum + i;
+				tmpPacketInfo.isFake = true;
 
-		sendTimeDelta = timeStamp - lastPacketTime;
-		lastPacketTime = timeStamp;
-
+				sentPacketList.push_back(tmpPacketInfo);
+			}
+		}
 	}
-	if(! sentPacketList.empty())
-		sentPacketList.back()->lastTimeDiff = sendTimeDelta;
 
-	sentPacketList.push_back(new UdpPacketInfo(seqNum, packetSize, timeStamp, isFastPacket));
+	lastSeenSeqNum = seqNum;
+
+	tmpPacketInfo.seqNum = seqNum;
+	tmpPacketInfo.packetSize = packetSize;
+	tmpPacketInfo.timeStamp = timeStamp;
+	tmpPacketInfo.isFake = false;
+
+	sentPacketList.push_back(tmpPacketInfo);
 }
 
 void UdpPacketSensor::localAck(char *packetData, int Len, int overheadLen, unsigned long long timeStamp)
 {
-	int minSize = 1 + sizeof(unsigned int) + sizeof(unsigned long long);
-
-	if(Len < minSize)
+	if(Len < globalConsts::minAckPacketSize)
 	{
 		cout << "Error: UDP packet data sent to PacketSensor::localAck was less than the "
-			" minimum "<< minSize << " bytes\n";
-		udpStateInfo.ackError = true;
+			" minimum "<< globalConsts::minAckPacketSize << " bytes\n";
 		return;
 	}
 
-	unsigned int seqNum = *(unsigned int *)(packetData + 1);
+	unsigned short int seqNum = *(unsigned short int *)(packetData + 1);
 
 	// Find the entry for the packet this ACK is acknowledging, and
 	// remove it from the sent(&unacked) packet list.
-	list<UdpPacketInfo * >::iterator listIterator;
+	list<UdpPacketInfo >::iterator listIterator;
 
 	listIterator = find_if(sentPacketList.begin(), sentPacketList.end(), bind2nd(equalSeqNum(), seqNum)); 
 
 	if(listIterator == sentPacketList.end())
 	{
-		cout << "ERROR: Unacked packet list is incorrect Or incorrect"
-			"acknowledgement received for seqNum = "<<seqNum<<" in PacketSensor::localAck\n";
+		cout << "WARNING: Unknown seq number "<<seqNum<<" is being ACKed. "
+			"We might have received "
+			" a reordered ACK, which has already been ACKed using redundant ACKs .\n";
 		udpStateInfo.ackError = true;
-		return;
 	}
-	udpStateInfo.ackError = false;
+	else
+		udpStateInfo.ackError = false;
 
-	int i;
+	// We received an ACK correctly(without reordering), but we dont have any record of ever
+	// sending the original packet(Actually, we have a fake packet inserted into our send list)
+       //	-- this indicates libpcap loss.
+	if( (*listIterator).isFake == true)
+		udpStateInfo.isAckFake = true;
+	else
+		udpStateInfo.isAckFake = false;
 
-	// Remove the old state information.
-	for(i = 0;i < udpStateInfo.recentSentPackets.size(); i++)
-		delete udpStateInfo.recentSentPackets[i];
 
+	// Remove the old state information.
 	udpStateInfo.recentSentPackets.clear();
 	udpStateInfo.packetLoss = 0;
-	udpStateInfo.fastPacketLoss = 0;
-	udpStateInfo.lostPacketDelay = 0;
-	udpStateInfo.lastSentTime = (ULONG_LONG_MAX);
 
-	int redunAckSize = sizeof(unsigned int) + sizeof(unsigned long);
-	int numRedunAcks = static_cast<int>(packetData[0]);
+	int i;
+	unsigned char numRedunAcksChar = 0; 
+	int numRedunAcks = 0; 
+
+	// Read how many redundant ACKs are being sent in this packet.
+	memcpy(&numRedunAcksChar, &packetData[0], globalConsts::UCHAR_SIZE);
+
+	numRedunAcks = static_cast<int>(numRedunAcksChar);
 
 	// Store an iterator to the current seqNum being acknowledge, and delete it at the end.
-	list<UdpPacketInfo * >::iterator curPacketIterator = listIterator;
+	list<UdpPacketInfo >::iterator curPacketIterator = listIterator;
 
 	// Look at the redundant ACKs first.
+	UdpPacketInfo tmpPacketInfo;
 
 	if(numRedunAcks > 0)
 	{
-		unsigned int redunSeqNum;
+		unsigned short int redunSeqNum;
 
 		for(i = 0; i < numRedunAcks; i++)
 		{
-			redunSeqNum = *(unsigned int *)(packetData + minSize + i*redunAckSize);
+			redunSeqNum = *(unsigned short int *)(packetData + globalConsts::minAckPacketSize + i*globalConsts::redunAckSize);
 			listIterator = sentPacketList.end();
 
 			// Check whether the packet that this redundant ACK refers to exists
@@ -108,18 +129,24 @@ void UdpPacketSensor::localAck(char *packetData, int Len, int overheadLen, unsig
 			// from the list and consider it acked.
 			if(listIterator != curPacketIterator && listIterator != sentPacketList.end())
 			{
-				udpStateInfo.recentSentPackets.push_back(new UdpPacketInfo((*listIterator)->seqNum, (*listIterator)->packetSize, (*listIterator)->timeStamp, (*listIterator)->isFastPacket) );
+				tmpPacketInfo.seqNum = (*listIterator).seqNum;
+				tmpPacketInfo.packetSize = (*listIterator).packetSize;
+				tmpPacketInfo.timeStamp = (*listIterator).timeStamp;
+				tmpPacketInfo.isFake = (*listIterator).isFake;
 
-				if( (*listIterator)->timeStamp < udpStateInfo.lastSentTime)
-					udpStateInfo.lastSentTime = (*listIterator)->timeStamp;
+				udpStateInfo.recentSentPackets.push_back(tmpPacketInfo);
 
-				delete (*listIterator);
 				sentPacketList.erase(listIterator);
 			}
 		}
 	}
 
-	udpStateInfo.recentSentPackets.push_back(new UdpPacketInfo((*curPacketIterator)->seqNum, (*curPacketIterator)->packetSize, (*curPacketIterator)->timeStamp, (*curPacketIterator)->isFastPacket));
+	tmpPacketInfo.seqNum = (*curPacketIterator).seqNum;
+	tmpPacketInfo.packetSize = (*curPacketIterator).packetSize;
+	tmpPacketInfo.timeStamp = (*curPacketIterator).timeStamp;
+	tmpPacketInfo.isFake = (*curPacketIterator).isFake;
+
+	udpStateInfo.recentSentPackets.push_back(tmpPacketInfo);
 
 	// Check for packet loss - if we have any unacked packets with sequence
 	// numbers less than the received ACK seq number, then the packets/or their ACKS
@@ -127,18 +154,12 @@ void UdpPacketSensor::localAck(char *packetData, int Len, int overheadLen, unsig
 
 	// Find out how many packets were lost.
 
-	listIterator = find_if(sentPacketList.begin(), curPacketIterator, bind2nd(lessSeqNum(), seqNum  )); 
+	listIterator = find_if(sentPacketList.begin(), curPacketIterator, bind2nd(lessSeqNum(), seqNum)); 
 
 	if( (listIterator != sentPacketList.end()) && (listIterator != curPacketIterator ))
 	{
 
 		do{
-			if( (*listIterator)->timeStamp < udpStateInfo.lastSentTime)
-				udpStateInfo.lastSentTime = (*listIterator)->timeStamp;
-
-			udpStateInfo.lostPacketDelay += (*listIterator)->lastTimeDiff;
-
-			delete (*listIterator);
 			sentPacketList.erase(listIterator);
 			listIterator = sentPacketList.end();
 
@@ -151,8 +172,5 @@ void UdpPacketSensor::localAck(char *packetData, int Len, int overheadLen, unsig
 
 	}
 
-	if( (*curPacketIterator)->timeStamp < udpStateInfo.lastSentTime)
-		udpStateInfo.lastSentTime = (*curPacketIterator)->timeStamp;
-	delete (*curPacketIterator);
 	sentPacketList.erase(curPacketIterator);
 }
diff --git a/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.h b/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.h
index ea702050d6..4d00af2657 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpPacketSensor.h
@@ -17,14 +17,15 @@ class UdpPacketSensor:public UdpSensor{
 	public:
 
 	explicit UdpPacketSensor(UdpState &udpStateVal);
+	~UdpPacketSensor();
 	void localSend(char *packetData, int Len, int overheadLen, unsigned long long timeStamp);
 	void localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp);
 
 	private:
 
-	list<UdpPacketInfo *> sentPacketList;
+	list<UdpPacketInfo> sentPacketList;
 	UdpState & udpStateInfo;
-	unsigned long long lastPacketTime;
+	long lastSeenSeqNum;
 };
 
 
diff --git a/pelab/magent/UDP/UdpClientDir/UdpState.h b/pelab/magent/UDP/UdpClientDir/UdpState.h
index eaefbd36a2..3d4242fc9a 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpState.h
+++ b/pelab/magent/UDP/UdpClientDir/UdpState.h
@@ -8,38 +8,40 @@ using namespace std;
 
 class UdpPacketInfo;
 
-struct UdpState{
+class UdpState{
+	public:
 	// vector of info about packets sent from this host,
         // sequence number, timestamp & size of the packet.
-	vector< UdpPacketInfo * > recentSentPackets;
+	vector< UdpPacketInfo > recentSentPackets;
 
 	// Indicates the number of packets lost ( in a batch of 4 sent packets ) 
 	// updated whenever an ACK is received.
-	int packetLoss, fastPacketLoss;
-	unsigned long long lastSentTime;
+	int packetLoss;
 	unsigned long long minDelay;
 	unsigned long long maxDelay;
-	unsigned long long minAckTimeDiff;
-	unsigned long long queuingDelay;
-	unsigned long long lostPacketDelay;
 
-	long minDelayBytes;
-	bool sendError, ackError;
+	bool ackError, isAckFake;
+
+	~UdpState()
+	{
+		// Remove any packets stored in the vector.
+		recentSentPackets.clear();
+	}
 };
 
-class equalSeqNum:public binary_function<const UdpPacketInfo * , unsigned int, bool> {
+class equalSeqNum:public binary_function<UdpPacketInfo , unsigned short int, bool> {
         public:
-        bool operator()(const UdpPacketInfo *packet, unsigned int seqNum) const
+        bool operator()(const UdpPacketInfo& packet, unsigned short int seqNum) const
         {
-                return (packet->seqNum == seqNum);
+                return (packet.seqNum == seqNum);
         }
 };
 
-class lessSeqNum:public binary_function<const UdpPacketInfo *, int, bool> {
+class lessSeqNum:public binary_function<UdpPacketInfo , unsigned short int, bool> {
         public:
-        bool operator()(const UdpPacketInfo *packet,unsigned int seqNum) const
+        bool operator()(const UdpPacketInfo& packet,unsigned short int seqNum) const
         {
-                return (packet->seqNum < seqNum);
+                return (packet.seqNum < seqNum);
         }
 };
 
diff --git a/pelab/magent/UDP/UdpClientDir/UdpThroughputSensor.cc b/pelab/magent/UDP/UdpClientDir/UdpThroughputSensor.cc
index bec369ac96..6543d55e1a 100644
--- a/pelab/magent/UDP/UdpClientDir/UdpThroughputSensor.cc
+++ b/pelab/magent/UDP/UdpClientDir/UdpThroughputSensor.cc
@@ -17,35 +17,28 @@ void UdpThroughputSensor::localSend(char *packetData, int Len, int overheadLen,
 
 void UdpThroughputSensor::localAck(char *packetData, int Len,int overheadLen, unsigned long long timeStamp)
 {
-	int minSize = 1 + sizeof(unsigned int) + sizeof(unsigned long long);
-
-	if(Len < minSize)
+	if(Len < globalConsts::minAckPacketSize )
         {
                 cout << "Error: UDP packet data sent to ThroughputSensor::localAck was less than the "
-                        " required minimum "<< minSize << " bytes\n";
-		udpStateInfo.ackError = true;
+                        " required minimum "<< globalConsts::minAckPacketSize<< " bytes\n";
                 return;
         }
 
-	// Something went wrong with this packet - either the packet was not
-	// the minimum size or it was a re-ordered ACK - don't do anything
+	// This is a re-ordered ACK - don't do anything
 	// with it - just return.
 	if( udpStateInfo.ackError == true )
 		return;
 
-
-	int redunAckSize = sizeof(unsigned int) + sizeof(unsigned long);
-	int seqNumSize = sizeof(unsigned int);
-
-	// Find out how many redundant ACKs this packet is carrying - 0 to 3.
-	int numRedunAcks = static_cast<int>(packetData[0]);
-	packetData++;
+	// Find out how many redundant ACKs this packet is carrying - 0 to 121.
+	unsigned char numRedunAcksChar = 0;
+	memcpy(&numRedunAcksChar, &packetData[0], globalConsts::UCHAR_SIZE);
+	int numRedunAcks = static_cast<int>(numRedunAcksChar);
 
 	int numThroughputAcks = 1;
 	double avgThroughput = 0;
 
 	// This is the timestamp at the receiver, when the original packet was received.
-	unsigned long long currentAckTimeStamp = *(unsigned long long *)(packetData + sizeof(unsigned int)); 
+	unsigned long long currentAckTimeStamp = *(unsigned long long *)(packetData + 1 + 2*globalConsts::USHORT_INT_SIZE ); 
 
 	// This is the first ACK we have seen, store its receiver timestamp
 	// and return, we cannot calculate throughput from just one ACK - at least 2.
@@ -55,21 +48,24 @@ void UdpThroughputSensor::localAck(char *packetData, int Len,int overheadLen, un
 		return;
 	}
 
-	unsigned int seqNum = *(unsigned int *)(packetData);
+	unsigned short int seqNum = *(unsigned int *)(packetData + 1);
+	unsigned short int echoedPacketSize = *(unsigned short int *)(packetData + 1 + globalConsts::USHORT_INT_SIZE);
 
-	unsigned long ackTimeDiff = currentAckTimeStamp - lastAckTime;
-	unsigned long timeDiff = 0;
-	vector<UdpPacketInfo * >::iterator vecIterator;
+	unsigned long long ackTimeDiff = currentAckTimeStamp - lastAckTime;
+	unsigned long long timeDiff = 0;
+	vector<UdpPacketInfo>::iterator vecIterator;
 
 	// Average the throughput over all the packets being acknowledged.
 	if(numRedunAcks > 0)
 	{
 		int i;
-		unsigned int redunSeqNum;
+		unsigned short int redunSeqNum;
+		unsigned short int redunPacketSize;
 
 		for(i = 0;i < numRedunAcks; i++)
 		{
-			redunSeqNum = *(unsigned int *)(packetData + minSize + i*redunAckSize);
+			redunSeqNum = *(unsigned short int *)(packetData + 1 + globalConsts::minAckPacketSize + i*globalConsts::redunAckSize);
+			redunPacketSize = *(unsigned short int *)(packetData + 1 + globalConsts::minAckPacketSize + i*globalConsts::redunAckSize + globalConsts::USHORT_INT_SIZE);
 
 			// Find if this redundant ACK is useful - or it was acked before.
 			vecIterator = find_if(udpStateInfo.recentSentPackets.begin(), udpStateInfo.recentSentPackets.end(), bind2nd(equalSeqNum(), redunSeqNum));
@@ -80,9 +76,14 @@ void UdpThroughputSensor::localAck(char *packetData, int Len,int overheadLen, un
 				// the redundant ACK.
 				numThroughputAcks++;
 
-				timeDiff = *(unsigned long *)(packetData + minSize + i*redunAckSize + seqNumSize);
+				timeDiff = *(unsigned long long *)(packetData + 1 + globalConsts::minAckPacketSize + i*globalConsts::redunAckSize + globalConsts::seqNumSize);
 
-				avgThroughput += 8000000.0*( static_cast<double> ( (*vecIterator)->packetSize + overheadLen ))  / ( static_cast<double>(ackTimeDiff - timeDiff)*1024.0 );
+				// We lost the record of the size of this packet due to libpcap
+				// loss, use the length echoed back in the ACK.
+				if((*vecIterator).isFake == true)
+					avgThroughput += 8000000.0*( static_cast<double> ( redunPacketSize ))  / ( static_cast<double>(ackTimeDiff - timeDiff)*1024.0 );
+				else
+					avgThroughput += 8000000.0*( static_cast<double> ( (*vecIterator).packetSize ))  / ( static_cast<double>(ackTimeDiff - timeDiff)*1024.0 );
 
 					ackTimeDiff = timeDiff;
 			}
@@ -93,7 +94,12 @@ void UdpThroughputSensor::localAck(char *packetData, int Len,int overheadLen, un
 	// Calculate the throughput for the current packet being ACKed.
 	vecIterator = find_if(udpStateInfo.recentSentPackets.begin(), udpStateInfo.recentSentPackets.end(), bind2nd(equalSeqNum(), seqNum));
 
-	avgThroughput += 8000000.0*( static_cast<double> ((*vecIterator)->packetSize + overheadLen ))  / ( static_cast<double>(ackTimeDiff)*1024.0 );
+	// We lost the record of the size of this packet due to libpcap
+	// loss, use the length echoed back in the ACK.
+	if(udpStateInfo.isAckFake == true)
+		avgThroughput += 8000000.0*( static_cast<double> (echoedPacketSize ))  / ( static_cast<double>(ackTimeDiff)*1024.0 );
+	else
+		avgThroughput += 8000000.0*( static_cast<double> ((*vecIterator).packetSize ))  / ( static_cast<double>(ackTimeDiff)*1024.0 );
 
 	throughputKbps = avgThroughput / (static_cast<double> (numThroughputAcks) );
 
@@ -105,13 +111,15 @@ void UdpThroughputSensor::localAck(char *packetData, int Len,int overheadLen, un
 		// than the last seen value.
 		cout << "Tentative bandwidth for seqNum = "<<seqNum<<", value = "<< throughputKbps <<"acktimeDiff = "<<ackTimeDiff<<"\n";
 
-		outStream << "TIME="<<timeStamp<<",TENTATIVE="<<throughputKbps<<endl;
+		outStream << "TPUT:TIME="<<timeStamp<<",TENTATIVE="<<throughputKbps<<endl;
+		outStream << "LOSS:TIME="<<timeStamp<<",LOSS=0"<<endl;
 	}
 	else
 	{
 		// Send this as the authoritative available bandwidth value.
 		cout << "Authoritative bandwidth for seqNum = "<<seqNum<<", value = "<< throughputKbps <<"ackTimeDiff = "<<ackTimeDiff<<"\n";
-		outStream << "TIME="<<timeStamp<<",AUTHORITATIVE="<<throughputKbps<<endl;
+		outStream << "TPUT:TIME="<<timeStamp<<",AUTHORITATIVE="<<throughputKbps<<endl;
+		outStream << "LOSS:TIME="<<timeStamp<<",LOSS="<<udpStateInfo.packetLoss<<endl;
 	}
 
 	// Save the receiver timestamp of this ACK packet, so that we can
diff --git a/pelab/magent/UDP/UdpClientDir/makeGnuPlot.py b/pelab/magent/UDP/UdpClientDir/makeGnuPlot.py
index 95d2289c0c..d74877643a 100755
--- a/pelab/magent/UDP/UdpClientDir/makeGnuPlot.py
+++ b/pelab/magent/UDP/UdpClientDir/makeGnuPlot.py
@@ -1,36 +1,100 @@
 import sys
 import re
+import math
 
+# Read stats from the log output by UdpClient.
 inFile = open(sys.argv[1], 'r')
 
-outFile = open(sys.argv[2], 'w')
+bandwidthFile = "AvailBandwidth.log"
+throughputFile = "Throughput.log"
+lossFile = "Loss.log"
+minDelayFile = "MinDelay.log"
+maxDelayFile = "MaxDelay.log"
+sendDeviationFile = "SendDeviation.log"
 
-regExp = re.compile('^(\w*?)\=(\d*)\,(\w*?)\=([\d\.]*)')
+# And print out the bandwidth, packet loss, minimum delay and
+# queue size into seperate files, so that they can be plotted
+# with GnuPlot.
+outFileBandwidth = open(bandwidthFile, 'w')
+outFileThroughput = open(throughputFile, 'w')
+outFileLoss = open(lossFile, 'w')
+outFileMinD = open(minDelayFile, 'w')
+outFileMaxD = open(maxDelayFile, 'w')
+outFileSendDeviation = open(sendDeviationFile, 'w')
+
+regExp = re.compile('^(\w*?):(\w*?)\=(\d*)\,(\w*?)\=([\d\.]*)')
 
-count = 0
 availBandwidth = 0
-initTime = 0
-timeDiff = 0;
 bandWidthBps = 0
+throughputBps = 0
+
+# Array indices, 0 - throughput, 1 - loss, 2 - minimum delay, 3 - queue size
+# 4 - deviation in send times
+initTimeArray = [0,0,0,0,0]
+timeDiffArray = [0,0,0,0,0]
+initFlagsArray = [0,0,0,0,0]
 
 for line in inFile:
 	match = regExp.match(line)
 
-	if count == 0:
-		initTime = match.group(2)
-		timeDiff = 0
-		count = count + 1
-	else:
-		timeDiff = int(match.group(2)) - int(initTime)
+	if match.group(1) == 'TPUT':
+		if initFlagsArray[0] == 0:
+			initTimeArray[0] = int(match.group(3))
+			timeDiffArray[0] = 0
+			initFlagsArray[0] = 1
+		else:
+			timeDiffArray[0] = int(match.group(3)) - initTimeArray[0]
 
-	if match.group(3) == 'AUTHORITATIVE':
-		availBandwidth = float(match.group(4))
-	elif match.group(3) == 'TENTATIVE':
-		if float(match.group(4)) > availBandwidth:
-			availBandwidth = float(match.group(4))
+		if match.group(4) == 'AUTHORITATIVE':
+			availBandwidth = float(match.group(5))
+		elif match.group(4) == 'TENTATIVE':
+			if float(match.group(5)) > availBandwidth:
+				availBandwidth = float(match.group(5))
 
-	bandWidthBps = 1024*availBandwidth / ( 8 )
+		bandWidthBps = 1024*availBandwidth / ( 8 )
+		throughputBps = 1024* ( float(match.group(5) ) ) / ( 8 )
 		
-	outFile.write(str(timeDiff) + "  " + str(bandWidthBps) + "\n" )
+		outFileBandwidth.write(str(timeDiffArray[0]) + "  " + str(bandWidthBps) + "\n" )
+		outFileThroughput.write(str(timeDiffArray[0]) + "  " + str(throughputBps) + "\n" )
+
+	elif match.group(1) == 'LOSS':
+		if initFlagsArray[1] == 0:
+			initTimeArray[1] = int(match.group(3))
+			timeDiffArray[1] = 0
+			initFlagsArray[1] = 1
+		else:
+			timeDiffArray[1] = int(match.group(3)) - initTimeArray[1]
+
+		outFileLoss.write(str(timeDiffArray[1]) + "  " + match.group(5) + "\n" )
+
+	elif match.group(1) == 'MIND':
+		if initFlagsArray[2] == 0:
+			initTimeArray[2] = int(match.group(3))
+			timeDiffArray[2] = 0
+			initFlagsArray[2] = 1
+		else:
+			timeDiffArray[2] = int(match.group(3)) - initTimeArray[2]
+
+		outFileMinD.write(str(timeDiffArray[2]) + "  " + match.group(5) + "\n" )
+
+	elif match.group(1) == 'MAXD':
+		if initFlagsArray[3] == 0:
+			initTimeArray[3] = int(match.group(3))
+			timeDiffArray[3] = 0
+			initFlagsArray[3] = 1
+		else:
+			timeDiffArray[3] = int(match.group(3)) - initTimeArray[3]
+
+		outFileMaxD.write(str(timeDiffArray[3]) + "  " + match.group(5) + "\n" )
+	elif match.group(1) == 'SendDeviation':
+		if initFlagsArray[4] == 0:
+			initTimeArray[4] = int(match.group(3))
+			timeDiffArray[4] = 0
+			initFlagsArray[4] = 1
+		else:
+			timeDiffArray[4] = int(match.group(3)) - initTimeArray[4]
+
+		outFileSendDeviation.write(str(timeDiffArray[4]) + "  " + match.group(5) + "\n" )
+
 
 
diff --git a/pelab/magent/UDP/UdpClientDir/plot.gp b/pelab/magent/UDP/UdpClientDir/plot.gp
index 6c05a26970..0acdc89f1f 100644
--- a/pelab/magent/UDP/UdpClientDir/plot.gp
+++ b/pelab/magent/UDP/UdpClientDir/plot.gp
@@ -1,5 +1,5 @@
 set xlabel "Time( micro sec )"
 set ylabel "Bandwidth( Bytes per sec )"
 
-plot 'Output.log' with lines
+plot 'Throughput.log' with lines
 
diff --git a/pelab/magent/UDP/UdpClientDir/runClient.sh b/pelab/magent/UDP/UdpClientDir/runClient.sh
index 404cc6cbbc..cac59eb4bd 100755
--- a/pelab/magent/UDP/UdpClientDir/runClient.sh
+++ b/pelab/magent/UDP/UdpClientDir/runClient.sh
@@ -14,4 +14,4 @@
 
 # NOTE: The UdpServer needs to be restarted before running the client for a second time.
 
-sudo ./UdpClient eth1 10.1.1.2 udpnode2 200000 958 500000
+sudo ./UdpClient eth0 10.1.1.2 node1 600 1470 200000
diff --git a/pelab/magent/UDP/UdpClientDir/showTputGraph.sh b/pelab/magent/UDP/UdpClientDir/showTputGraph.sh
index 8a04ee4b19..3f7c30f86f 100755
--- a/pelab/magent/UDP/UdpClientDir/showTputGraph.sh
+++ b/pelab/magent/UDP/UdpClientDir/showTputGraph.sh
@@ -5,10 +5,10 @@
 # This data is dumped in Throughput.log - it is converted to a data file for GNUplot
 # using a python script makeGnuPlot.py
 
-# The GNUplot file plot.gp displays the graph from data values in Output.log
+# The GNUplot file plot.gp displays the graph from data values in stats.log
 
-# NOTE: If you want to run the client multiple times, save the Output.log with 
+# NOTE: If you want to run the client multiple times, save the stats.log with 
 # another name, because it will be overwritten every time this shell script is run.
 
-python makeGnuPlot.py Throughput.log Output.log
+python makeGnuPlot.py stats.log
 gnuplot -persist plot.gp
diff --git a/pelab/magent/UDP/UdpServerDir/UdpServer.cc b/pelab/magent/UDP/UdpServerDir/UdpServer.cc
index 8aedb0e84b..a2a905019f 100644
--- a/pelab/magent/UDP/UdpServerDir/UdpServer.cc
+++ b/pelab/magent/UDP/UdpServerDir/UdpServer.cc
@@ -24,31 +24,40 @@
 
 #define LOCAL_SERVER_PORT 1500
 #define MAX_MSG 1524
-#define SNAPLEN 128
+#define SNAPLEN 1600
 
 pcap_t *pcapDescriptor = NULL;
 
 struct udpAck{
-	int seqNo;
+	unsigned short int seqNo;
+	unsigned short int packetSize;
+	unsigned long long senderTimestamp;
 	unsigned long long ackTime;
 };
 
 
-char appAck[2000];
+char appAck[1600];
 unsigned int curSeqNum = 0;
 unsigned long long milliSec = 0;
 
 int queueStartPtr = -1;
 int queueEndPtr = -1;
-const int ackQueueSize = 3;
+const int ackQueueSize = 121;
+const int minNoOfAcks = 3;
 struct udpAck ackQueue[ackQueueSize];
 
 int sd, rc, n, flags;
 socklen_t cliLen;
 struct sockaddr_in cliAddr, servAddr;
-unsigned long long lastAckTime = 0;
 std::ofstream outFile;
 
+namespace globalConsts {
+
+	const short int USHORT_INT_SIZE = sizeof(unsigned short int);
+	const short int ULONG_LONG_SIZE = sizeof(unsigned long long);
+	const short int UCHAR_SIZE = sizeof(unsigned char);
+}
+
 unsigned long long getPcapTimeMicro(const struct timeval *tp)
 {
 	unsigned long long tmpSecVal = tp->tv_sec;
@@ -57,145 +66,22 @@ unsigned long long getPcapTimeMicro(const struct timeval *tp)
 	return (tmpSecVal*1000*1000 + tmpUsecVal);
 }
 
-// This is not used right now - only relevant if we are using SO_TIMESTAMP option instead
-// of libpcap.
-void handleUDPMsg(struct sockaddr_in *clientAddr, char *udpMessage, int messageLen, struct timeval *timeStamp, std::ofstream &fileHandle)
-{
-	/*
-        printf("Destination IP address = %s\n", inet_ntoa(ipPacket->ip_dst));
-        printf("Source port = %d\n", ntohs(udpHdr->source));
-        printf("Dest port = %d\n\n", ntohs(udpHdr->dest));
-	*/
-	struct timeval timeVal;
-//	gettimeofday(&timeVal, NULL);
-	//std::cout << "Time before = "<<getPcapTimeMilli(&timeVal)<<std::endl;
-
-	unsigned char packetType = udpMessage[0];
-	unsigned long long milliSec = 0;
-	int ackLength = 0;
-
-	if(packetType == '0')
-	{
-		// This is a udp data packet arriving here. Send an
-		// application level acknowledgement packet for it.
-
-		// TODO:The packet can also be leaving from this host - our libpcap filter
-		//  ignores those for now - as such, nothing needs to be done for such packets.
-
-		unsigned int packetSeqNum = *(unsigned int *)(udpMessage + 1) ;
-		//printf("Data being received = %c, %u\n", *(unsigned char *)(dataPtr), *(unsigned int *)(dataPtr + 1));
-
-		// If this sequence number is greater than the last sequence number
-		// we saw then send an acknowledgement for it. Otherwise, ignore the
-		// packet.
-
-	    // TODO:Take wrap around into account.
-		if(packetSeqNum > curSeqNum)
-		{
-			appAck[0] = '1';
-			memcpy(&appAck[2], &packetSeqNum, sizeof(unsigned int));
-
-			milliSec = getPcapTimeMicro(timeStamp);
-			fileHandle << "Time="<<milliSec<<",Size="<<messageLen+20+8+14+4<<std::endl;
-			if(lastAckTime == 0)
-				lastAckTime = milliSec;
-			else
-			{
-			//	std::cout << "Time of receive = "<<milliSec<<std::endl;
-				lastAckTime = milliSec;
-			}
-
-			memcpy(&appAck[2 + sizeof(unsigned int)], &milliSec, sizeof(unsigned long long));
-
-			// Include the sequence numbers, and ACK times of the last
-			// seen three packets.
-
-			// This condition holds only for the first ACK - means that
-			// there weren't any packets ACKed before this.
-			int numAcks;
-			unsigned long timeDiff = 0;
-			int ackSize = sizeof(unsigned int) + sizeof(unsigned long);
-
-			if(queueStartPtr == -1 && queueEndPtr == -1)
-			{
-			    // Do nothing.
-			    numAcks = 0;
-			}
-			else if(queueStartPtr <= queueEndPtr)
-				numAcks = queueEndPtr - queueStartPtr + 1;
-			else
-				numAcks = 3;
-
-			// Print a single digit number (0,1,2 or 3), indicating the
-			// number of redundant ACKs being sent.
-			appAck[1] = static_cast<char>(numAcks);
-			ackLength = numAcks*ackSize + sizeof(unsigned int) + sizeof(unsigned long long) + 2;
-
-			int redunAckStart = 2 + sizeof(unsigned int) + sizeof(unsigned long long);
-
-			// The ACK packet must be the same size as the original UDP
-			// packet that was received - this is needed so that the 
-			// one way delay can be calculated as RTT/2.
-			if( messageLen > ackLength)
-				ackLength = messageLen;
-
-			for(int i = 0;i < numAcks; i++)
-			{
-			    memcpy(&appAck[redunAckStart + i*ackSize], &ackQueue[(queueStartPtr + i)%ackQueueSize].seqNo, sizeof(unsigned int));
-
-			    
-			    timeDiff = milliSec - ackQueue[(queueStartPtr + i)%ackQueueSize].ackTime;
-		//	    std::cout << "Timediff between redun = "<< ackQueue[ (queueStartPtr + i)%ackQueueSize].seqNo <<", and this = "<<timeDiff<<std::endl;
-			    memcpy(&appAck[redunAckStart + i*ackSize + sizeof(unsigned int)], &timeDiff, sizeof(unsigned long));
-			}
-
-			// Always maintain the sequence numbers and ack send times
-			// of the last three ACK packets.
-			queueEndPtr = (queueEndPtr + 1)%ackQueueSize;
-			if(queueStartPtr != -1)
-			{
-				if(queueStartPtr == queueEndPtr)
-					queueStartPtr = (queueStartPtr + 1)%ackQueueSize;
-			}
-			else
-			    queueStartPtr = 0;
-
-			ackQueue[queueEndPtr].seqNo = packetSeqNum;
-			ackQueue[queueEndPtr].ackTime = milliSec;
-
-			curSeqNum = packetSeqNum;
-
-			sendto(sd,appAck,ackLength,flags,(struct sockaddr *)clientAddr,cliLen);
-		}
-
-	}
-	else if(packetType == '1') 
-	{
-		// TODO:This is an udp ACK packet. If it is being sent
-		// out from this host, do nothing. ( right now, this case does not
-		// occur, because our libpcap filter is only accepting incoming packets).
-
-		// If we are receiving an ACK, pass it on to the sensors.
-	}
-	else
-	{
-		printf("ERROR: Unknown UDP packet received from remote agent\n");
-		return;
-	}
-
-//	gettimeofday(&timeVal, NULL);
-//	std::cout << "Time After = "<<getPcapTimeMicro(&timeVal)<<std::endl;
-}
-
 void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr, u_char *const udpPacketStart, struct ip const *ipPacket)
 {
 
+	// Get a pointer to the start of the data portion of the packet.
         u_char *dataPtr = udpPacketStart + 8;
-        unsigned short udpLen = ntohs(udpHdr->len);
 
+	// Calculate the size of the data portion of this UDP packet.
+	// Subtract eight bytes to account for the UDP header.
+        unsigned short udpLen = ntohs(udpHdr->len) - 8;
+
+	// The first byte of the data portion indicates whether this
+	// is a send packet(0) or an ACK packet(1)
 	unsigned char packetType = *(unsigned char *)(dataPtr);
+
+
 	unsigned long long milliSec = 0;
-	int ackLength = 0;
 
 	if(packetType == '0')// This is a udp data packet arriving here. Send an
 	    // application level acknowledgement packet for it.
@@ -205,38 +91,52 @@ void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr,
 		// are integrated into magent, then the functionality of this procedure
 		// will be a combination of code below and that in UdpClient.
 	{
-	    unsigned int packetSeqNum = *(unsigned int *)(dataPtr + 1) ;
-	    int overhead = ipPacket->ip_hl*4 + 8 + 14 + 2;
+		unsigned short int packetSeqNum = *(unsigned short int *)(dataPtr + 1) ;
+		std::cout<<"Received seq no = "<<packetSeqNum<<std::endl;
+
+		// Calculate the header overhead, IP, 8 bytes for UDP, 14 + 4 for ethernet
+		int overhead = ipPacket->ip_hl*4 + 8 + 14 + 4;
+		unsigned short int recvPacketLen = *(unsigned short int *)(dataPtr + 1 + globalConsts::USHORT_INT_SIZE) + overhead;
+
+		unsigned long long senderTimestamp = *(unsigned long long *)(dataPtr + 1 + 2*globalConsts::USHORT_INT_SIZE );
+
+		// This holds the length of ACK packet we are going to send out.
+		int ackLength = 0;
         //printf("Data being received = %c, %u\n", *(unsigned char *)(dataPtr), *(unsigned int *)(dataPtr + 1));
 
 	    // If this sequence number is greater than the last sequence number
-	    // we saw then send an acknowledgement for it. Otherwise, ignore the
-	    // packet.
+	    // we saw, then send an acknowledgement for it. Otherwise, ignore the
+	    // packet - it arrived out of order.
 
 	    // TODO:Take wrap around into account.
 	    if(packetSeqNum > curSeqNum)
 	    {
+		    // Indicate that this is an ACK packet.
 		appAck[0] = '1';
-		memcpy(&appAck[2], &packetSeqNum, sizeof(unsigned int));
 
+		// Print the sequence number being ACKed.
+		memcpy(&appAck[2], &packetSeqNum, globalConsts::USHORT_INT_SIZE);
+
+		// Print the size of the received packet.
+		memcpy(&appAck[2 + globalConsts::USHORT_INT_SIZE], &recvPacketLen, globalConsts::USHORT_INT_SIZE);
+
+		// Get the timestamp of when this packet was received by libpcap.
 		milliSec = getPcapTimeMicro(&pcap_info->ts);
-		outFile << "TIME="<<milliSec<<",SIZE="<<udpLen - 8 + overhead<<std::endl;
-		if(lastAckTime == 0)
-			lastAckTime = milliSec;
-		else
-		{
-			lastAckTime = milliSec;
-		}
-		memcpy(&appAck[2 + sizeof(unsigned int)], &milliSec, sizeof(unsigned long long));
+		memcpy(&appAck[2 + 2*globalConsts::USHORT_INT_SIZE], &milliSec, globalConsts::ULONG_LONG_SIZE);
+		outFile << "TIME="<<milliSec<<",SIZE="<<udpLen + overhead<<std::endl;
 
-		// Include the sequence numbers, and ACK times of the last
-		// seen three packets.
+		// Include the sequence numbers, and ACK times of at least the last
+		// seen three packets - more than 3 if the packet size allows.
 
 		// This condition holds only for the first ACK - means that
 		// there weren't any packets ACKed before this.
 		int numAcks;
-		unsigned long timeDiff = 0;
-		int ackSize = sizeof(unsigned int) + sizeof(unsigned long);
+		unsigned long long timeDiff = 0;
+
+		// Size of each redundant ACK - 2 bytes for sequence number + 2 bytes
+	       // for the packet size +	8 bytes for timestamp.
+		int ackSize = 2*globalConsts::USHORT_INT_SIZE +  globalConsts::ULONG_LONG_SIZE;
+
 		if(queueStartPtr == -1 && queueEndPtr == -1)
 		{
 		    // Do nothing.
@@ -245,31 +145,66 @@ void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr,
 		else if(queueStartPtr <= queueEndPtr)
 			numAcks = queueEndPtr - queueStartPtr + 1;
 		else
-			numAcks = 3;
-
-		// Print a single digit number (0,1,2 or 3), indicating the
-		// number of redundant ACKs being sent.
-		appAck[1] = static_cast<char>(numAcks);
-		ackLength = numAcks*ackSize + sizeof(unsigned int) + sizeof(unsigned long long) + 2;
-
-		int redunAckStart = 2 + sizeof(unsigned int) + sizeof(unsigned long long);
-
+			numAcks = ackQueueSize;
+
+		int minimumAcks = minNoOfAcks; // Minimum is currently 3.
+
+		// This is the packet size that is needed to hold the minimum
+		// number of redundant ACKs + sequence number being ACKed + other data.
+		ackLength = minimumAcks*ackSize + 2*globalConsts::USHORT_INT_SIZE + globalConsts::ULONG_LONG_SIZE + 2;
+
+		// Check to see if the original packet size can accommodate more
+		// than 3 redundant ACKs.
+		int spaceLeft = udpLen - ackLength;
+
+		// Accommodate as many redundant ACKs as possible.
+		if(spaceLeft > ackSize)
+			minimumAcks = minimumAcks + spaceLeft / ackSize;
+
+		// We have more ACKs in store than we can send,
+		// send only so many ACKs that will fit into the
+		// packet being sent.
+		if(numAcks > minimumAcks)
+			numAcks = minimumAcks;
+
+		// Print in the second byte of the ACK how many redundant
+		// ACKs it is carrying.( minimum 3, maximum 121 )
+		memcpy(&appAck[1], &numAcks, globalConsts::UCHAR_SIZE);
+
+		// Calculate the size of the data portion to accommodate the
+		// ACK + redundant ACKs.
+		// Note: Some bytes ( < 12 ) might not be counted in this number
+		// because our redundant ACK size is 12. These extra bytes
+		// will be accounted for by the step below which makes the
+		// packet being sent the same size as the received packet.
+		ackLength = numAcks*ackSize + 2*globalConsts::USHORT_INT_SIZE + globalConsts::ULONG_LONG_SIZE + 2;
 		// The ACK packet must be the same size as the original UDP
 		// packet that was received - this is needed so that the 
 		// one way delay can be calculated as RTT/2.
-		if( (udpLen - 8) > ackLength)
-			ackLength = udpLen - 8;
+		if( (udpLen) > ackLength)
+			ackLength = udpLen;
+
+		// This indicates where the redundant ACKs start in the packet.
+		int redunAckStart = 2 + 2*globalConsts::USHORT_INT_SIZE + globalConsts::ULONG_LONG_SIZE;
 
+		// Copy the redundant ACKs.
 		for(int i = 0;i < numAcks; i++)
 		{
-		    memcpy(&appAck[redunAckStart + i*ackSize], &ackQueue[(queueStartPtr + i)%ackQueueSize].seqNo, sizeof(unsigned int));
+			// Copy the seq. number this redun ACK is acking.
+		    memcpy(&appAck[redunAckStart + i*ackSize], &ackQueue[(queueStartPtr + i)%ackQueueSize].seqNo, globalConsts::USHORT_INT_SIZE);
+
+		    // Copy the size of the packet being acked.
+		    memcpy(&appAck[redunAckStart + i*ackSize + globalConsts::USHORT_INT_SIZE], &ackQueue[(queueStartPtr + i)%ackQueueSize].packetSize, globalConsts::USHORT_INT_SIZE);
 
 		    timeDiff = milliSec - ackQueue[(queueStartPtr + i)%ackQueueSize].ackTime;
-		    memcpy(&appAck[redunAckStart + i*ackSize + sizeof(unsigned int)], &timeDiff, sizeof(unsigned long));
+
+		    // Copy the time diffrence between when this packet was received
+		    // and when the latest packet being ACKed was received here.
+		    memcpy(&appAck[redunAckStart + i*ackSize + 2*globalConsts::USHORT_INT_SIZE], &timeDiff, globalConsts::ULONG_LONG_SIZE);
 		}
 
 		// Always maintain the sequence numbers and ack send times
-		// of the last three ACK packets.
+		// of the last ackQueueSize(121) ACK packets.
 		queueEndPtr = (queueEndPtr + 1)%ackQueueSize;
 		if(queueStartPtr != -1)
 		{
@@ -281,9 +216,14 @@ void handleUDP(struct pcap_pkthdr const *pcap_info, struct udphdr const *udpHdr,
 
 		ackQueue[queueEndPtr].seqNo = packetSeqNum;
 		ackQueue[queueEndPtr].ackTime = milliSec;
+		ackQueue[queueEndPtr].packetSize = recvPacketLen;
+		ackQueue[queueEndPtr].senderTimestamp = senderTimestamp;
 
+		// Store the last sequence number seen, so that we can discard
+		// UDP packets which have been re-ordered.
 		curSeqNum = packetSeqNum;
 
+		// Send the ACK off to the host we received the data packet from.
 		sendto(sd,appAck,ackLength,flags,(struct sockaddr *)&cliAddr,cliLen);
 	    }
 
@@ -465,7 +405,7 @@ int main(int argc, char *argv[])
 		n = recvfrom(sd, msg, MAX_MSG, flags,
 		 (struct sockaddr *) &cliAddr, &cliLen);
 
-		pcap_dispatch(pcapDescriptor, 1, pcapCallback, NULL);
+		pcap_dispatch(pcapDescriptor, -1, pcapCallback, NULL);
 
 		if(n<0) 
 		{
diff --git a/pelab/magent/UDP/UdpServerDir/makeServerPlot.py b/pelab/magent/UDP/UdpServerDir/makeServerPlot.py
index 8e59b39167..276457de80 100755
--- a/pelab/magent/UDP/UdpServerDir/makeServerPlot.py
+++ b/pelab/magent/UDP/UdpServerDir/makeServerPlot.py
@@ -13,6 +13,7 @@ initTime = 0
 timeDiff = 0;
 lastTime = 0;
 currentTime = 0;
+line = ""
 
 for line in inFile:
 	match = regExp.match(line)
@@ -30,4 +31,3 @@ for line in inFile:
 
 	outFile.write(str(timeDiff) + "  " + str(bandWidth) + "\n" )
 
-
diff --git a/pelab/magent/UDP/UdpServerDir/runServer.sh b/pelab/magent/UDP/UdpServerDir/runServer.sh
index 2f56f1f761..27f4b8dd4a 100755
--- a/pelab/magent/UDP/UdpServerDir/runServer.sh
+++ b/pelab/magent/UDP/UdpServerDir/runServer.sh
@@ -13,4 +13,4 @@
 # The server runs in an infinite while loop - it can be terminated after the session
 # is determined to be done at the client - kill using Ctrl-C.
 
-sudo ./UdpServer eth1
+sudo ./UdpServer eth0
-- 
GitLab