AODV model for review

src/applications/v4ping/v4ping.cc

 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "v4ping.h"
 #include "ns3/icmpv4.h"
 #include "ns3/assert.h"
 #include "ns3/log.h"
 #include "ns3/ipv4-address.h"
 #include "ns3/socket.h"
 #include "ns3/uinteger.h"
+#include "ns3/boolean.h"
 #include "ns3/inet-socket-address.h"
 #include "ns3/packet.h"
 #include "ns3/trace-source-accessor.h"
-#include "ns3/simulator.h"
 
 namespace ns3 {
 
 NS_LOG_COMPONENT_DEFINE ("V4Ping");
 NS_OBJECT_ENSURE_REGISTERED (V4Ping);
 
 TypeId·
 V4Ping::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::V4Ping")
     .SetParent<Application> ()
     .AddConstructor<V4Ping> ()
     .AddAttribute ("Remote",·
                    "The address of the machine we want to ping.",
                    Ipv4AddressValue (),
                    MakeIpv4AddressAccessor (&V4Ping::m_remote),
                    MakeIpv4AddressChecker ())
+    .AddAttribute ("Verbose",
+                   "Produce usual output.",
+                   BooleanValue (false),
+                   MakeBooleanAccessor (&V4Ping::m_verbose),
+                   MakeBooleanChecker ())
+    .AddAttribute ("Interval", "Wait  interval  seconds between sending each packet.",
+                   TimeValue (Seconds (1)),
+                   MakeTimeAccessor (&V4Ping::m_interval),
+                   MakeTimeChecker ())
+    .AddAttribute ("Size", "The number of data bytes to be sent, real packet will be 8 (ICMP) + 20 (IP) bytes longer.",
+                   UintegerValue (56),
+                   MakeUintegerAccessor (&V4Ping::m_size),
+                   MakeUintegerChecker<uint32_t> (16))
     .AddTraceSource ("Rtt",
                      "The rtt calculated by the ping.",
                      MakeTraceSourceAccessor (&V4Ping::m_traceRtt));
     ;
   return tid;
 }
 
 V4Ping::V4Ping ()
-  : m_socket (0),
-    m_seq (0)
-{}
+  : m_interval (Seconds (1)),
+    m_size (56),
+    m_socket (0),
+    m_seq (0),
+    m_verbose (false),
+    m_recv (0)
+{
+}
 V4Ping::~V4Ping ()
 {}
 
 void
 V4Ping::DoDispose (void)
 {
   NS_LOG_FUNCTION (this);
   m_socket = 0;
   Application::DoDispose ();
 }
@@ skipping 20 matching lines @@
   while (m_socket->GetRxAvailable () > 0)
     {
       Address from;
       Ptr<Packet> p = m_socket->RecvFrom (0xffffffff, 0, from);
       NS_LOG_DEBUG ("recv " << p->GetSize () << " bytes");
       NS_ASSERT (InetSocketAddress::IsMatchingType (from));
       InetSocketAddress realFrom = InetSocketAddress::ConvertFrom (from);
       NS_ASSERT (realFrom.GetPort () == 1); // protocol should be icmp.
       Ipv4Header ipv4;
       p->RemoveHeader (ipv4);
+      uint32_t recvSize = p->GetSize ();
       NS_ASSERT (ipv4.GetProtocol () == 1); // protocol should be icmp.
       Icmpv4Header icmp;
       p->RemoveHeader (icmp);
       if (icmp.GetType () == Icmpv4Header::ECHO_REPLY)
         {
           Icmpv4Echo echo;
           p->RemoveHeader (echo);
-          if (echo.GetSequenceNumber () == (m_seq - 1) &&
-              echo.GetIdentifier () == 0)
+          std::map<uint16_t, Time>::iterator i = m_sent.find(echo.GetSequenceNumber());
+ ·········
+          if (i != m_sent.end () && echo.GetIdentifier () == 0)
             {
-              uint32_t buf[4];
+              uint32_t buf[m_size / 4];
               uint32_t dataSize = echo.GetDataSize ();
               if (dataSize == sizeof(buf))
                 {
                   echo.GetData ((uint8_t *)buf);
 
                   if (buf[0] == GetNode ()->GetId () &&
                       buf[1] == GetApplicationId ())
                     {
-                      int64_t ts = buf[3];
-                      ts <<= 32;
-                      ts |= buf[2];
-                      Time sendTime = TimeStep (ts);
+                      Time sendTime = i->second;
                       NS_ASSERT (Simulator::Now () > sendTime);
                       Time delta = Simulator::Now () - sendTime;
+······················
+                      m_sent.erase (i);
+                      m_avgRtt.Update (delta.GetMilliSeconds());
+                      m_recv++;
                       m_traceRtt (delta);
+······················
+                      if (m_verbose)
+                        {
+                          std::cout << recvSize << " bytes from " << realFrom.GetIpv4() << ":"
+                                    << " icmp_seq=" << echo.GetSequenceNumber ()
+                                    << " ttl=" << (unsigned)ipv4.GetTtl ()
+                                    << " time=" << delta.GetMilliSeconds() << " ms\n";
+                        }
                     }
                 }
             }
         }
     }
 }
 
 void
 V4Ping::Write32 (uint8_t *buffer, uint32_t data)
 {
   buffer[0] = (data >> 0) & 0xff;
   buffer[1] = (data >> 8) & 0xff;
   buffer[2] = (data >> 16) & 0xff;
   buffer[3] = (data >> 24) & 0xff;
 }
 
 void·
-V4Ping::StartApplication (void)
+V4Ping::Send ()
 {
-  NS_LOG_FUNCTION (this);
-  m_socket = Socket::CreateSocket (GetNode (), TypeId::LookupByName ("ns3::Ipv4RawSocketFactory"));
-  NS_ASSERT (m_socket != 0);
-  m_socket->SetAttribute ("Protocol", UintegerValue (1)); // icmp
-  m_socket->SetRecvCallback (MakeCallback (&V4Ping::Receive, this));
-  InetSocketAddress src = InetSocketAddress (Ipv4Address::GetAny (), 0);
-  int status;
-  status = m_socket->Bind (src);
-  NS_ASSERT (status != -1);
-  InetSocketAddress dst = InetSocketAddress (m_remote, 0);
-  status = m_socket->Connect (dst);
-  NS_ASSERT (status != -1);
   Ptr<Packet> p = Create<Packet> ();
   Icmpv4Echo echo;
   echo.SetSequenceNumber (m_seq);
   m_seq++;
   echo.SetIdentifier (0);
 
   //
   // We must write quantities out in some form of network order.  Since there
   // isn't an htonl to work with we just follow the convention in pcap traces
   // (where any difference would show up anyway) and borrow that code.  Don't
   // be too surprised when you see that this is a little endian convention.
   //
-  uint8_t data[4 * sizeof(uint32_t)];
+  uint8_t data[m_size];
+  for (uint32_t i = 0; i < m_size; ++i) data[i] = 0;
+  NS_ASSERT (m_size >= 16);
+··
   uint32_t tmp = GetNode ()->GetId ();
   Write32 (&data[0 * sizeof(uint32_t)], tmp);
 
   tmp = GetApplicationId ();
   Write32 (&data[1 * sizeof(uint32_t)], tmp);
 
-  int64_t now = Simulator::Now ().GetTimeStep ();
-  tmp = now & 0xffffffff;
-  Write32 (&data[2 * sizeof(uint32_t)], tmp);
-
-  now >>= 32;
-  tmp = now & 0xffffffff;
-  Write32 (&data[3 * sizeof(uint32_t)], tmp);
-
-  Ptr<Packet> dataPacket = Create<Packet> ((uint8_t *) &data, 16);
+  Ptr<Packet> dataPacket = Create<Packet> ((uint8_t *) &data, m_size);
   echo.SetData (dataPacket);
   p->AddHeader (echo);
   Icmpv4Header header;
   header.SetType (Icmpv4Header::ECHO);
   header.SetCode (0);
   p->AddHeader (header);
   m_socket->Send (p, 0);
+  m_sent.insert (std::make_pair (m_seq - 1, Simulator::Now()));··
+  m_next = Simulator::Schedule (m_interval, & V4Ping::Send, this);
+}
+
+void·
+V4Ping::StartApplication (void)
+{
+  NS_LOG_FUNCTION (this);
 ··
+  m_started = Simulator::Now ();
+  if (m_verbose)
+    {
+      std::cout << "PING  " << m_remote << " 56(84) bytes of data.\n";
+    }
+··
+  m_socket = Socket::CreateSocket (GetNode (), TypeId::LookupByName ("ns3::Ipv4RawSocketFactory"));
+  NS_ASSERT (m_socket != 0);
+  m_socket->SetAttribute ("Protocol", UintegerValue (1)); // icmp
+  m_socket->SetRecvCallback (MakeCallback (&V4Ping::Receive, this));
+  InetSocketAddress src = InetSocketAddress (Ipv4Address::GetAny (), 0);
+  int status;
+  status = m_socket->Bind (src);
+  NS_ASSERT (status != -1);
+  InetSocketAddress dst = InetSocketAddress (m_remote, 0);
+  status = m_socket->Connect (dst);
+  NS_ASSERT (status != -1);
+··
+  Send ();
 }
 void·
 V4Ping::StopApplication (void)
 {
   NS_LOG_FUNCTION (this);
+  m_next.Cancel();
   m_socket->Close ();
+··
+  if (m_verbose)
+    {
+      std::ostringstream os;
+      os.precision (4);
+      os << "--- " << m_remote << " ping statistics ---\n"·
+                << m_seq << " packets transmitted, " << m_recv << " received, "·
+                << ((m_seq - m_recv) * 100 / m_seq) << "% packet loss, "
+                << "time " << (Simulator::Now () - m_started).GetMilliSeconds () << "ms\n";
+······
+      if (m_avgRtt.Count () > 0)
+        os << "rtt min/avg/max/mdev = " << m_avgRtt.Min() << "/" << m_avgRtt.Avg() << "/"
+                                               << m_avgRtt.Max() << "/" << m_avgRtt.Err()
+                                               << " ms\n";
+      std::cout << os.str();
+    }
 }
 
 
 } // namespace ns3