Fix memory leaks in PendingData class by returning Ptr<Packet> instead of PendingData* where appropriate

src/internet-node/pending-data.cc

@@ -186,37 +186,27 @@ uint32_t PendingData::OffsetFromSeq (const SequenceNumber& f, const SequenceNumb
   return o - f;
 }
 
-PendingData* PendingData::CopyFromOffset (uint32_t s, uint32_t o)
+Ptr<Packet> PendingData::CopyFromOffset (uint32_t s, uint32_t o)
 { // Make a copy of data from starting position "o" for "s" bytes
   // Return NULL if results in zero length data
   uint32_t s1 = std::min (s, SizeFromOffset (o)); // Insure not beyond end of data
   if (s1 == 0)
     {
-      return NULL;   // No data requested
+      return 0;   // No data requested
     }
   if (data)
     { // Actual data exists, make copy and return it
-      uint8_t* d1 = new uint8_t[s1];  // Allocate memory for the copy
-      memcpy (d1, &data[o], s1); // Copy the data
-      PendingData* d = new PendingData (s1, d1, msgSize, responseSize);  // Return copy
-      return d;
+      return Create<Packet> (data+o, s1);
     }
   else
     { // No actual data, just return non-data pdu of correct size
-      return new PendingData (s1, 0, msgSize, responseSize);
+      return Create<Packet> (s1);
     }
 }
 
-PendingData* PendingData::CopyFromSeq (uint32_t s, const SequenceNumber& f, const SequenceNumber& o)
+Ptr<Packet> PendingData::CopyFromSeq (uint32_t s, const SequenceNumber& f, const SequenceNumber& o)
 {
-  PendingData* d = CopyFromOffset (s, OffsetFromSeq(f,o));
-  return d;
+  return CopyFromOffset (s, OffsetFromSeq(f,o));
 }
 
-}//namepsace ns3      
-  
-  
-
-
-
-
+}//namepsace ns3

src/internet-node/pending-data.h

@@ -27,6 +27,8 @@
 
 #include "pending-data.h"
 #include "sequence-number.h"
+
+#include "ns3/ptr.h"
 namespace ns3
 {
 class Packet;
@@ -53,9 +55,9 @@ public:
   virtual uint32_t SizeFromOffset (uint32_t);
   // Available size from sequence difference 
   virtual uint32_t OffsetFromSeq (const SequenceNumber&, const SequenceNumber&);
-  virtual PendingData* CopyFromOffset (uint32_t, uint32_t);  // Size, offset, ret pointer
+  virtual Ptr<Packet> CopyFromOffset (uint32_t, uint32_t);  // Size, offset, ret packet
   // Copy data, size, offset specified by sequence difference
-  virtual PendingData* CopyFromSeq (uint32_t, const SequenceNumber&, const SequenceNumber&);
+  virtual Ptr<Packet> CopyFromSeq (uint32_t, const SequenceNumber&, const SequenceNumber&);
   PendingData*   Copy () const;          // Create a copy of this header
   PendingData*   CopyS (uint32_t);         // Copy with new size
   PendingData*   CopySD (uint32_t, uint8_t*); // Copy with new size, new data

src/internet-node/tcp-socket.cc

@@ -706,18 +706,18 @@ bool TcpSocket::SendPendingData (bool withAck)
           break; // No more
         }
       uint32_t s = std::min (w, m_segmentSize);  // Send no more than window
-      PendingData* d = m_pendingData->CopyFromSeq (s, m_firstPendingSequence, 
+      Ptr<Packet> p = m_pendingData->CopyFromSeq (s, m_firstPendingSequence, 
         m_nextTxSequence);
       NS_LOG_LOGIC("TcpSocket " << this << " sendPendingData"
                    << " txseq " << m_nextTxSequence
                    << " s " << s 
-                   << " datasize " << d->Size() );
+                   << " datasize " << p->GetSize() );
       uint8_t flags = 0;
       if (withAck)
         {
           flags |= TcpHeader::ACK;
         }
-      uint32_t sz = d->Size (); // Size of packet
+      uint32_t sz = p->GetSize (); // Size of packet
       uint32_t remainingData = m_pendingData->SizeFromSeq(
           m_firstPendingSequence,
           m_nextTxSequence + SequenceNumber (sz));
@@ -726,9 +726,6 @@ bool TcpSocket::SendPendingData (bool withAck)
           flags = TcpHeader::FIN;
           m_state = FIN_WAIT_1;
         }
-      // Create and send the packet
-
-      Ptr<Packet> p = Create<Packet> (d->data, sz);
 
       TcpHeader header;
       header.SetFlags (flags);
@@ -1060,18 +1057,18 @@ void TcpSocket::Retransmit ()
         }
       return;
     }
-  PendingData* d = m_pendingData->CopyFromSeq (m_segmentSize,
+  Ptr<Packet> p = m_pendingData->CopyFromSeq (m_segmentSize,
                                             m_firstPendingSequence,
                                             m_highestRxAck);
   // Calculate remaining data for COE check
-  uint32_t remainingData =
-      m_pendingData->SizeFromSeq (m_firstPendingSequence,
-                                m_nextTxSequence + SequenceNumber(d->Size ()));
+  uint32_t remainingData = m_pendingData->SizeFromSeq (
+      m_firstPendingSequence,
+      m_nextTxSequence + SequenceNumber(p->GetSize ()));
   if (m_closeOnEmpty && remainingData == 0)
     { // Add the FIN flag
       flags = flags | TcpHeader::FIN;
     }
-  Ptr<Packet> p = Create<Packet> (d->data, d->Size());
+
   NS_LOG_LOGIC ("TcpSocket " << this << " retxing seq " << m_highestRxAck);
   if (m_retxEvent.IsExpired () )
     {
@@ -1081,7 +1078,7 @@ void TcpSocket::Retransmit ()
           << (Simulator::Now () + rto).GetSeconds ());
       m_retxEvent = Simulator::Schedule (rto,&TcpSocket::ReTxTimeout,this);
     }
-  m_rtt->SentSeq (m_highestRxAck,d->Size ());
+  m_rtt->SentSeq (m_highestRxAck,p->GetSize ());
   // And send the packet
   TcpHeader tcpHeader;
   tcpHeader.SetSequenceNumber (m_nextTxSequence);