Attachment #2500 for bug #2123

View | Details | Raw Unified | Return to bug 2123
Collapse All | Expand All

(-)model/aodv-routing-protocol.cc (-15 / +126 lines)

Lines 35-40	Link Here

#include "ns3/inet-socket-address.h"

#include "ns3/inet-socket-address.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/udp-socket-factory.h"

#include "ns3/udp-socket-factory.h"

#include "ns3/udp-l4-protocol.h"

#include "ns3/udp-header.h"

#include "ns3/wifi-net-device.h"

#include "ns3/wifi-net-device.h"

#include "ns3/adhoc-wifi-mac.h"

#include "ns3/adhoc-wifi-mac.h"

#include "ns3/string.h"

#include "ns3/string.h"

Lines 119-124 NS_OBJECT_ENSURE_REGISTERED (DeferredRou	Link Here

119

//-----------------------------------------------------------------------------

121

//-----------------------------------------------------------------------------

120

RoutingProtocol::RoutingProtocol () :

122

RoutingProtocol::RoutingProtocol () :

121

  RreqRetries (2),

123

  RreqRetries (2),

124

  TtlStart (1),

125

  TtlIncrement (2),

126

  TtlThreshold (7),

127

  TimeoutBuffer (2),

122

  RreqRateLimit (10),

128

  RreqRateLimit (10),

123

  RerrRateLimit (10),

129

  RerrRateLimit (10),

124

  ActiveRouteTimeout (Seconds (3)),

130

  ActiveRouteTimeout (Seconds (3)),

Lines 165-170 RoutingProtocol::GetTypeId (void)	Link Here

165

                   TimeValue (Seconds (1)),

171

                   TimeValue (Seconds (1)),

166

                   MakeTimeAccessor (&RoutingProtocol::HelloInterval),

172

                   MakeTimeAccessor (&RoutingProtocol::HelloInterval),

167

                   MakeTimeChecker ())

173

                   MakeTimeChecker ())

174

    .AddAttribute ("TtlStart", "Initial TTL value for RREQ.",

175

	           UintegerValue (1),

176

	           MakeUintegerAccessor (&RoutingProtocol::TtlStart),

177

	           MakeUintegerChecker<uint16_t> ())

178

    .AddAttribute ("TtlIncrement", "TTL increment for each attempt using the expanding ring search for RREQ dissemination.",

179

	           UintegerValue (2),

180

	           MakeUintegerAccessor (&RoutingProtocol::TtlIncrement),

181

	           MakeUintegerChecker<uint16_t> ())

182

    .AddAttribute ("TtlThreshold", "Maximum TTL value for expanding ring search, TTL = NetDiameter is used beyond this value.",

183

	           UintegerValue (7),

184

	           MakeUintegerAccessor (&RoutingProtocol::TtlThreshold),

185

	           MakeUintegerChecker<uint16_t> ())

186

    .AddAttribute ("TimeoutBuffer", "Provide a buffer for the timeout.",

187

	           UintegerValue (2),

188

	           MakeUintegerAccessor (&RoutingProtocol::TimeoutBuffer),

189

	           MakeUintegerChecker<uint16_t> ())

168

    .AddAttribute ("RreqRetries", "Maximum number of retransmissions of RREQ to discover a route",

190

    .AddAttribute ("RreqRetries", "Maximum number of retransmissions of RREQ to discover a route",

169

                   UintegerValue (2),

191

                   UintegerValue (2),

170

                   MakeUintegerAccessor (&RoutingProtocol::RreqRetries),

192

                   MakeUintegerAccessor (&RoutingProtocol::RreqRetries),

Lines 476-481 RoutingProtocol::RouteInput (Ptr<const P	Link Here

476

498

477

                return true;

499

                return true;

478

500

501

            if (header.GetProtocol () == UdpL4Protocol::PROT_NUMBER)

502

503

                UdpHeader udpHeader;

504

                p->PeekHeader (udpHeader);

505

                if (udpHeader.GetDestinationPort () == AODV_PORT)

506

507

                    // AODV packets sent in broadcast are already managed

508

                    return true;

509

510

479

            if (header.GetTtl () > 1)

511

            if (header.GetTtl () > 1)

480

512

481

                NS_LOG_LOGIC ("Forward broadcast. TTL " << (uint16_t) header.GetTtl ());

513

                NS_LOG_LOGIC ("Forward broadcast. TTL " << (uint16_t) header.GetTtl ());

Lines 632-638 RoutingProtocol::NotifyInterfaceUp (uint	Link Here

632

  socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT));

664

  socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT));

633

  socket->BindToNetDevice (l3->GetNetDevice (i));

665

  socket->BindToNetDevice (l3->GetNetDevice (i));

634

  socket->SetAllowBroadcast (true);

666

  socket->SetAllowBroadcast (true);

635

  socket->SetAttribute ("IpTtl", UintegerValue (1));

667

  socket->SetIpRecvTtl (true);

636

  m_socketAddresses.insert (std::make_pair (socket, iface));

668

  m_socketAddresses.insert (std::make_pair (socket, iface));

637

669

638

  // create also a subnet broadcast socket

670

  // create also a subnet broadcast socket

Lines 643-649 RoutingProtocol::NotifyInterfaceUp (uint	Link Here

643

  socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

675

  socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

644

  socket->BindToNetDevice (l3->GetNetDevice (i));

676

  socket->BindToNetDevice (l3->GetNetDevice (i));

645

  socket->SetAllowBroadcast (true);

677

  socket->SetAllowBroadcast (true);

646

  socket->SetAttribute ("IpTtl", UintegerValue (1));

678

  socket->SetIpRecvTtl (true);

647

  m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

679

  m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

648

680

649

  // Add local broadcast record to the routing table

681

  // Add local broadcast record to the routing table

Lines 744-750 RoutingProtocol::NotifyAddAddress (uint3	Link Here

744

          socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

776

          socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

745

          socket->BindToNetDevice (l3->GetNetDevice (i));

777

          socket->BindToNetDevice (l3->GetNetDevice (i));

746

          socket->SetAllowBroadcast (true);

778

          socket->SetAllowBroadcast (true);

747

          socket->SetAttribute ("IpTtl", UintegerValue (1));

779

          socket->SetIpRecvTtl (true);

748

          m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

780

          m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

749

781

750

          // Add local broadcast record to the routing table

782

          // Add local broadcast record to the routing table

Lines 793-799 RoutingProtocol::NotifyRemoveAddress (ui	Link Here

793

          socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT));

825

          socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT));

794

          socket->BindToNetDevice (l3->GetNetDevice (i));

826

          socket->BindToNetDevice (l3->GetNetDevice (i));

795

          socket->SetAllowBroadcast (true);

827

          socket->SetAllowBroadcast (true);

796

          socket->SetAttribute ("IpTtl", UintegerValue (1));

828

          socket->SetIpRecvTtl (true);

797

          m_socketAddresses.insert (std::make_pair (socket, iface));

829

          m_socketAddresses.insert (std::make_pair (socket, iface));

798

830

799

          // create also a unicast socket

831

          // create also a unicast socket

Lines 804-810 RoutingProtocol::NotifyRemoveAddress (ui	Link Here

804

          socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

836

          socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT));

805

          socket->BindToNetDevice (l3->GetNetDevice (i));

837

          socket->BindToNetDevice (l3->GetNetDevice (i));

806

          socket->SetAllowBroadcast (true);

838

          socket->SetAllowBroadcast (true);

807

          socket->SetAttribute ("IpTtl", UintegerValue (1));

839

          socket->SetIpRecvTtl (true);

808

          m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

840

          m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface));

809

841

810

          // Add local broadcast record to the routing table

842

          // Add local broadcast record to the routing table

Lines 910-923 RoutingProtocol::SendRequest (Ipv4Addres	Link Here

910

  rreqHeader.SetDst (dst);

942

  rreqHeader.SetDst (dst);

911

943

912

  RoutingTableEntry rt;

944

  RoutingTableEntry rt;

945

  // Using the Hop field in Routing Table to manage the expanding ring search

946

  uint16_t ttl = TtlStart;

913

  if (m_routingTable.LookupRoute (dst, rt))

947

  if (m_routingTable.LookupRoute (dst, rt))

914

948

915

      rreqHeader.SetHopCount (rt.GetHop ());

949

      if (rt.GetFlag () != IN_SEARCH)

950

951

	  ttl = std::min<uint16_t> (rt.GetHop () + TtlIncrement, NetDiameter);

952

953

      else

954

955

  	  ttl = rt.GetHop () + TtlIncrement;

956

  	  if (ttl > TtlThreshold)

957

  	    ttl = NetDiameter;

958

959

      if (ttl == NetDiameter)

960

  	rt.IncrementRreqCnt ();

916

      if (rt.GetValidSeqNo ())

961

      if (rt.GetValidSeqNo ())

917

        rreqHeader.SetDstSeqno (rt.GetSeqNo ());

962

        rreqHeader.SetDstSeqno (rt.GetSeqNo ());

918

      else

963

      else

919

        rreqHeader.SetUnknownSeqno (true);

964

        rreqHeader.SetUnknownSeqno (true);

965

      rt.SetHop (ttl);

920

      rt.SetFlag (IN_SEARCH);

966

      rt.SetFlag (IN_SEARCH);

967

      rt.SetLifeTime (PathDiscoveryTime);

921

      m_routingTable.Update (rt);

968

      m_routingTable.Update (rt);

922

969

923

  else

970

  else

Lines 925-932 RoutingProtocol::SendRequest (Ipv4Addres	Link Here

925

      rreqHeader.SetUnknownSeqno (true);

972

      rreqHeader.SetUnknownSeqno (true);

926

      Ptr<NetDevice> dev = 0;

973

      Ptr<NetDevice> dev = 0;

927

      RoutingTableEntry newEntry (/*device=*/ dev, /*dst=*/ dst, /*validSeqNo=*/ false, /*seqno=*/ 0,

974

      RoutingTableEntry newEntry (/*device=*/ dev, /*dst=*/ dst, /*validSeqNo=*/ false, /*seqno=*/ 0,

928

                                              /*iface=*/ Ipv4InterfaceAddress (),/*hop=*/ 0,

975

                                              /*iface=*/ Ipv4InterfaceAddress (),/*hop=*/ ttl,

929

                                              /*nextHop=*/ Ipv4Address (), /*lifeTime=*/ Seconds (0));

976

                                              /*nextHop=*/ Ipv4Address (), /*lifeTime=*/ PathDiscoveryTime);

977

      // Check if TtlStart == NetDiameter

978

      if (ttl == NetDiameter)

979

        newEntry.IncrementRreqCnt ();

930

      newEntry.SetFlag (IN_SEARCH);

980

      newEntry.SetFlag (IN_SEARCH);

931

      m_routingTable.AddRoute (newEntry);

981

      m_routingTable.AddRoute (newEntry);

932

982

Lines 940-946 RoutingProtocol::SendRequest (Ipv4Addres	Link Here

940

  rreqHeader.SetOriginSeqno (m_seqNo);

990

  rreqHeader.SetOriginSeqno (m_seqNo);

941

  m_requestId++;

991

  m_requestId++;

942

  rreqHeader.SetId (m_requestId);

992

  rreqHeader.SetId (m_requestId);

943

  rreqHeader.SetHopCount (0);

944

993

945

  // Send RREQ as subnet directed broadcast from each interface used by aodv

994

  // Send RREQ as subnet directed broadcast from each interface used by aodv

946

  for (std::map<Ptr<Socket>, Ipv4InterfaceAddress>::const_iterator j =

995

  for (std::map<Ptr<Socket>, Ipv4InterfaceAddress>::const_iterator j =

Lines 953-958 RoutingProtocol::SendRequest (Ipv4Addres	Link Here

953

      m_rreqIdCache.IsDuplicate (iface.GetLocal (), m_requestId);

1002

      m_rreqIdCache.IsDuplicate (iface.GetLocal (), m_requestId);

954

1003

955

      Ptr<Packet> packet = Create<Packet> ();

1004

      Ptr<Packet> packet = Create<Packet> ();

1005

      SocketIpTtlTag tag;

1006

      tag.SetTtl (ttl);

1007

      packet->AddPacketTag (tag);

956

      packet->AddHeader (rreqHeader);

1008

      packet->AddHeader (rreqHeader);

957

      TypeHeader tHeader (AODVTYPE_RREQ);

1009

      TypeHeader tHeader (AODVTYPE_RREQ);

958

      packet->AddHeader (tHeader);

1010

      packet->AddHeader (tHeader);

Lines 993-1002 RoutingProtocol::ScheduleRreqRetry (Ipv4	Link Here

993

  m_addressReqTimer[dst].SetArguments (dst);

1045

  m_addressReqTimer[dst].SetArguments (dst);

994

  RoutingTableEntry rt;

1046

  RoutingTableEntry rt;

995

  m_routingTable.LookupRoute (dst, rt);

1047

  m_routingTable.LookupRoute (dst, rt);

996

  rt.IncrementRreqCnt ();

1048

  Time retry;

997

  m_routingTable.Update (rt);

1049

  if (rt.GetHop () < NetDiameter)

998

  m_addressReqTimer[dst].Schedule (Time (rt.GetRreqCnt () * NetTraversalTime));

1050

999

  NS_LOG_LOGIC ("Scheduled RREQ retry in " << Time (rt.GetRreqCnt () * NetTraversalTime).GetSeconds () << " seconds");

1051

      retry = 2 * NodeTraversalTime * (rt.GetHop () + TimeoutBuffer);

1052

1053

  else

1054

1055

      // Binary exponential backoff

1056

      retry = std::pow<uint16_t> (2, rt.GetRreqCnt () - 1) * NetTraversalTime;

1057

1058

  m_addressReqTimer[dst].Schedule (retry);

1059

  NS_LOG_LOGIC ("Scheduled RREQ retry in " << retry.GetSeconds () << " seconds");

1000

1060

1001

1061

1002

void

1062

void

Lines 1254-1265 RoutingProtocol::RecvRequest (Ptr<Packet	Link Here

1254

1314

1255

1315

1256

1316

1317

  SocketIpTtlTag tag;

1318

  p->RemovePacketTag (tag);

1319

  if (tag.GetTtl () < 2)

1320

1321

      NS_LOG_DEBUG ("TTL exceeded. Drop RREQ origin " << src << " destination " << dst );

1322

      return;

1323

1324

1257

  for (std::map<Ptr<Socket>, Ipv4InterfaceAddress>::const_iterator j =

1325

  for (std::map<Ptr<Socket>, Ipv4InterfaceAddress>::const_iterator j =

1258

         m_socketAddresses.begin (); j != m_socketAddresses.end (); ++j)

1326

         m_socketAddresses.begin (); j != m_socketAddresses.end (); ++j)

1259

1327

1260

      Ptr<Socket> socket = j->first;

1328

      Ptr<Socket> socket = j->first;

1261

      Ipv4InterfaceAddress iface = j->second;

1329

      Ipv4InterfaceAddress iface = j->second;

1262

      Ptr<Packet> packet = Create<Packet> ();

1330

      Ptr<Packet> packet = Create<Packet> ();

1331

      SocketIpTtlTag ttl;

1332

      ttl.SetTtl (tag.GetTtl () - 1);

1333

      packet->AddPacketTag (ttl);

1263

      packet->AddHeader (rreqHeader);

1334

      packet->AddHeader (rreqHeader);

1264

      TypeHeader tHeader (AODVTYPE_RREQ);

1335

      TypeHeader tHeader (AODVTYPE_RREQ);

1265

      packet->AddHeader (tHeader);

1336

      packet->AddHeader (tHeader);

Lines 1292-1297 RoutingProtocol::SendReply (RreqHeader c	Link Here

1292

  RrepHeader rrepHeader ( /*prefixSize=*/ 0, /*hops=*/ 0, /*dst=*/ rreqHeader.GetDst (),

1363

  RrepHeader rrepHeader ( /*prefixSize=*/ 0, /*hops=*/ 0, /*dst=*/ rreqHeader.GetDst (),

1293

                                          /*dstSeqNo=*/ m_seqNo, /*origin=*/ toOrigin.GetDestination (), /*lifeTime=*/ MyRouteTimeout);

1364

                                          /*dstSeqNo=*/ m_seqNo, /*origin=*/ toOrigin.GetDestination (), /*lifeTime=*/ MyRouteTimeout);

1294

  Ptr<Packet> packet = Create<Packet> ();

1365

  Ptr<Packet> packet = Create<Packet> ();

1366

  SocketIpTtlTag tag;

1367

  tag.SetTtl (toOrigin.GetHop ());

1368

  packet->AddPacketTag (tag);

1295

  packet->AddHeader (rrepHeader);

1369

  packet->AddHeader (rrepHeader);

1296

  TypeHeader tHeader (AODVTYPE_RREP);

1370

  TypeHeader tHeader (AODVTYPE_RREP);

1297

  packet->AddHeader (tHeader);

1371

  packet->AddHeader (tHeader);

Lines 1324-1329 RoutingProtocol::SendReplyByIntermediate	Link Here

1324

  m_routingTable.Update (toOrigin);

1398

  m_routingTable.Update (toOrigin);

1325

1399

1326

  Ptr<Packet> packet = Create<Packet> ();

1400

  Ptr<Packet> packet = Create<Packet> ();

1401

  SocketIpTtlTag tag;

1402

  tag.SetTtl (toOrigin.GetHop ());

1403

  packet->AddPacketTag (tag);

1327

  packet->AddHeader (rrepHeader);

1404

  packet->AddHeader (rrepHeader);

1328

  TypeHeader tHeader (AODVTYPE_RREP);

1405

  TypeHeader tHeader (AODVTYPE_RREP);

1329

  packet->AddHeader (tHeader);

1406

  packet->AddHeader (tHeader);

Lines 1338-1343 RoutingProtocol::SendReplyByIntermediate	Link Here

1338

                                                 /*dst seqno=*/ toOrigin.GetSeqNo (), /*origin=*/ toDst.GetDestination (),

1415

                                                 /*dst seqno=*/ toOrigin.GetSeqNo (), /*origin=*/ toDst.GetDestination (),

1339

                                                 /*lifetime=*/ toOrigin.GetLifeTime ());

1416

                                                 /*lifetime=*/ toOrigin.GetLifeTime ());

1340

      Ptr<Packet> packetToDst = Create<Packet> ();

1417

      Ptr<Packet> packetToDst = Create<Packet> ();

1418

      SocketIpTtlTag gratTag;

1419

      gratTag.SetTtl (toDst.GetHop ());

1420

      packetToDst->AddPacketTag (gratTag);

1341

      packetToDst->AddHeader (gratRepHeader);

1421

      packetToDst->AddHeader (gratRepHeader);

1342

      TypeHeader type (AODVTYPE_RREP);

1422

      TypeHeader type (AODVTYPE_RREP);

1343

      packetToDst->AddHeader (type);

1423

      packetToDst->AddHeader (type);

Lines 1355-1360 RoutingProtocol::SendReplyAck (Ipv4Addre	Link Here

1355

  RrepAckHeader h;

1435

  RrepAckHeader h;

1356

  TypeHeader typeHeader (AODVTYPE_RREP_ACK);

1436

  TypeHeader typeHeader (AODVTYPE_RREP_ACK);

1357

  Ptr<Packet> packet = Create<Packet> ();

1437

  Ptr<Packet> packet = Create<Packet> ();

1438

  SocketIpTtlTag tag;

1439

  tag.SetTtl (1);

1440

  packet->AddPacketTag (tag);

1358

  packet->AddHeader (h);

1441

  packet->AddHeader (h);

1359

  packet->AddHeader (typeHeader);

1442

  packet->AddHeader (typeHeader);

1360

  RoutingTableEntry toNeighbor;

1443

  RoutingTableEntry toNeighbor;

Lines 1480-1487 RoutingProtocol::RecvReply (Ptr<Packet>	Link Here

1480

      toNextHopToOrigin.InsertPrecursor (toDst.GetNextHop ());

1563

      toNextHopToOrigin.InsertPrecursor (toDst.GetNextHop ());

1481

      m_routingTable.Update (toNextHopToOrigin);

1564

      m_routingTable.Update (toNextHopToOrigin);

1482

1565

1566

  SocketIpTtlTag tag;

1567

  p->RemovePacketTag(tag);

1568

  if (tag.GetTtl () < 2)

1569

1570

      NS_LOG_DEBUG ("TTL exceeded. Drop RREP destination " << dst << " origin " << rrepHeader.GetOrigin ());

1571

      return;

1572

1483

1573

1484

  Ptr<Packet> packet = Create<Packet> ();

1574

  Ptr<Packet> packet = Create<Packet> ();

1575

  SocketIpTtlTag ttl;

1576

  ttl.SetTtl (tag.GetTtl() - 1);

1577

  packet->AddPacketTag (ttl);

1485

  packet->AddHeader (rrepHeader);

1578

  packet->AddHeader (rrepHeader);

1486

  TypeHeader tHeader (AODVTYPE_RREP);

1579

  TypeHeader tHeader (AODVTYPE_RREP);

1487

  packet->AddHeader (tHeader);

1580

  packet->AddHeader (tHeader);

Lines 1569-1574 RoutingProtocol::RecvError (Ptr<Packet>	Link Here

1569

1662

1570

          TypeHeader typeHeader (AODVTYPE_RERR);

1663

          TypeHeader typeHeader (AODVTYPE_RERR);

1571

          Ptr<Packet> packet = Create<Packet> ();

1664

          Ptr<Packet> packet = Create<Packet> ();

1665

          SocketIpTtlTag tag;

1666

          tag.SetTtl (1);

1667

          packet->AddPacketTag (tag);

1572

          packet->AddHeader (rerrHeader);

1668

          packet->AddHeader (rerrHeader);

1573

          packet->AddHeader (typeHeader);

1669

          packet->AddHeader (typeHeader);

1574

          SendRerrMessage (packet, precursors);

1670

          SendRerrMessage (packet, precursors);

Lines 1586-1591 RoutingProtocol::RecvError (Ptr<Packet>	Link Here

1586

1682

1587

      TypeHeader typeHeader (AODVTYPE_RERR);

1683

      TypeHeader typeHeader (AODVTYPE_RERR);

1588

      Ptr<Packet> packet = Create<Packet> ();

1684

      Ptr<Packet> packet = Create<Packet> ();

1685

      SocketIpTtlTag tag;

1686

      tag.SetTtl (1);

1687

      packet->AddPacketTag (tag);

1589

      packet->AddHeader (rerrHeader);

1688

      packet->AddHeader (rerrHeader);

1590

      packet->AddHeader (typeHeader);

1689

      packet->AddHeader (typeHeader);

1591

      SendRerrMessage (packet, precursors);

1690

      SendRerrMessage (packet, precursors);

Lines 1611-1617 RoutingProtocol::RouteRequestTimerExpire	Link Here

1611

*/

1710

*/

1612

  if (toDst.GetRreqCnt () == RreqRetries)

1711

  if (toDst.GetRreqCnt () == RreqRetries)

1613

1712

1614

      NS_LOG_LOGIC ("route discovery to " << dst << " has been attempted RreqRetries (" << RreqRetries << ") times");

1713

      NS_LOG_LOGIC ("route discovery to " << dst << " has been attempted RreqRetries (" << RreqRetries << ") times with ttl " << NetDiameter);

1615

      m_addressReqTimer.erase (dst);

1714

      m_addressReqTimer.erase (dst);

1616

      m_routingTable.DeleteRoute (dst);

1715

      m_routingTable.DeleteRoute (dst);

1617

      NS_LOG_DEBUG ("Route not found. Drop all packets with dst " << dst);

1716

      NS_LOG_DEBUG ("Route not found. Drop all packets with dst " << dst);

Lines 1621-1627 RoutingProtocol::RouteRequestTimerExpire	Link Here

1621

1720

1622

  if (toDst.GetFlag () == IN_SEARCH)

1721

  if (toDst.GetFlag () == IN_SEARCH)

1623

1722

1624

      NS_LOG_LOGIC ("Resend RREQ to " << dst << " ttl " << NetDiameter);

1723

      NS_LOG_LOGIC ("Resend RREQ to " << dst << " previous ttl " << toDst.GetHop ());

1625

      SendRequest (dst);

1724

      SendRequest (dst);

1626

1725

1627

  else

1726

  else

Lines 1693-1698 RoutingProtocol::SendHello ()	Link Here

1693

      RrepHeader helloHeader (/*prefix size=*/ 0, /*hops=*/ 0, /*dst=*/ iface.GetLocal (), /*dst seqno=*/ m_seqNo,

1792

      RrepHeader helloHeader (/*prefix size=*/ 0, /*hops=*/ 0, /*dst=*/ iface.GetLocal (), /*dst seqno=*/ m_seqNo,

1694

                                               /*origin=*/ iface.GetLocal (),/*lifetime=*/ Time (AllowedHelloLoss * HelloInterval));

1793

                                               /*origin=*/ iface.GetLocal (),/*lifetime=*/ Time (AllowedHelloLoss * HelloInterval));

1695

      Ptr<Packet> packet = Create<Packet> ();

1794

      Ptr<Packet> packet = Create<Packet> ();

1795

      SocketIpTtlTag tag;

1796

      tag.SetTtl (1);

1797

      packet->AddPacketTag (tag);

1696

      packet->AddHeader (helloHeader);

1798

      packet->AddHeader (helloHeader);

1697

      TypeHeader tHeader (AODVTYPE_RREP);

1799

      TypeHeader tHeader (AODVTYPE_RREP);

1698

      packet->AddHeader (tHeader);

1800

      packet->AddHeader (tHeader);

Lines 1757-1762 RoutingProtocol::SendRerrWhenBreaksLinkT	Link Here

1757

          NS_LOG_LOGIC ("Send RERR message with maximum size.");

1859

          NS_LOG_LOGIC ("Send RERR message with maximum size.");

1758

          TypeHeader typeHeader (AODVTYPE_RERR);

1860

          TypeHeader typeHeader (AODVTYPE_RERR);

1759

          Ptr<Packet> packet = Create<Packet> ();

1861

          Ptr<Packet> packet = Create<Packet> ();

1862

          SocketIpTtlTag tag;

1863

          tag.SetTtl (1);

1864

          packet->AddPacketTag (tag);

1760

          packet->AddHeader (rerrHeader);

1865

          packet->AddHeader (rerrHeader);

1761

          packet->AddHeader (typeHeader);

1866

          packet->AddHeader (typeHeader);

1762

          SendRerrMessage (packet, precursors);

1867

          SendRerrMessage (packet, precursors);

Lines 1774-1779 RoutingProtocol::SendRerrWhenBreaksLinkT	Link Here

1774

1879

1775

      TypeHeader typeHeader (AODVTYPE_RERR);

1880

      TypeHeader typeHeader (AODVTYPE_RERR);

1776

      Ptr<Packet> packet = Create<Packet> ();

1881

      Ptr<Packet> packet = Create<Packet> ();

1882

      SocketIpTtlTag tag;

1883

      tag.SetTtl (1);

1884

      packet->AddPacketTag (tag);

1777

      packet->AddHeader (rerrHeader);

1885

      packet->AddHeader (rerrHeader);

1778

      packet->AddHeader (typeHeader);

1886

      packet->AddHeader (typeHeader);

1779

      SendRerrMessage (packet, precursors);

1887

      SendRerrMessage (packet, precursors);

Lines 1802-1807 RoutingProtocol::SendRerrWhenNoRouteToFo	Link Here

1802

  rerrHeader.AddUnDestination (dst, dstSeqNo);

1910

  rerrHeader.AddUnDestination (dst, dstSeqNo);

1803

  RoutingTableEntry toOrigin;

1911

  RoutingTableEntry toOrigin;

1804

  Ptr<Packet> packet = Create<Packet> ();

1912

  Ptr<Packet> packet = Create<Packet> ();

1913

  SocketIpTtlTag tag;

1914

  tag.SetTtl (1);

1915

  packet->AddPacketTag (tag);

1805

  packet->AddHeader (rerrHeader);

1916

  packet->AddHeader (rerrHeader);

1806

  packet->AddHeader (TypeHeader (AODVTYPE_RERR));

1917

  packet->AddHeader (TypeHeader (AODVTYPE_RERR));

1807

  if (m_routingTable.LookupValidRoute (origin, toOrigin))

1918

  if (m_routingTable.LookupValidRoute (origin, toOrigin))

(-)model/aodv-routing-protocol.h (-3 / +7 lines)

Lines 103-108 private:	Link Here

103

104

  // Protocol parameters.

104

  // Protocol parameters.

105

  uint32_t RreqRetries;             ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route

105

  uint32_t RreqRetries;             ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route

106

  uint16_t TtlStart;                ///< Initial TTL value for RREQ.

107

  uint16_t TtlIncrement;            ///< TTL increment for each attempt using the expanding ring search for RREQ dissemination.

108

  uint16_t TtlThreshold;            ///< Maximum TTL value for expanding ring search, TTL = NetDiameter is used beyond this value.

109

  uint16_t TimeoutBuffer;           ///< Provide a buffer for the timeout.

106

  uint16_t RreqRateLimit;           ///< Maximum number of RREQ per second.

110

  uint16_t RreqRateLimit;           ///< Maximum number of RREQ per second.

107

  uint16_t RerrRateLimit;           ///< Maximum number of REER per second.

111

  uint16_t RerrRateLimit;           ///< Maximum number of REER per second.

108

  Time ActiveRouteTimeout;          ///< Period of time during which the route is considered to be valid.

112

  Time ActiveRouteTimeout;          ///< Period of time during which the route is considered to be valid.

Lines 172-180 private:	Link Here

172

  /// If route exists and valid, forward packet.

176

  /// If route exists and valid, forward packet.

173

  bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);

177

  bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);

174

/**

178

/**

175

  * To reduce congestion in a network, repeated attempts by a source node at route discovery

179

   * Repeated attempts by a source node at route discovery for a single destination

176

  * for a single destination MUST utilize a binary exponential backoff.

180

   * use the expanding ring search technique.

177

*/

181

*/

178

  void ScheduleRreqRetry (Ipv4Address dst);

182

  void ScheduleRreqRetry (Ipv4Address dst);

179

/**

183

/**

180

   * Set lifetime field in routing table entry to the maximum of existing lifetime and lt, if the entry exists

184

   * Set lifetime field in routing table entry to the maximum of existing lifetime and lt, if the entry exists

Return to bug 2123