Attachment #1584 for bug #1190

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




  m_rreqRateLimitTimer (Timer::CANCEL_ON_DESTROY),
  m_rerrRateLimitTimer (Timer::CANCEL_ON_DESTROY)
{
  if (EnableHello)
    {
      m_nb.SetCallback (MakeCallback (&RoutingProtocol::SendRerrWhenBreaksLinkToNextHop, this));
    }
}

TypeId

RoutingProtocol::Start ()
{
  NS_LOG_FUNCTION (this);
  m_nb.SetCallback (MakeCallback (&RoutingProtocol::SendRerrWhenBreaksLinkToNextHop, this));    //need not be dependent on whether hellos are enabled
  m_nb.ScheduleTimer ();
      m_nb.ScheduleTimer ();
    }
  m_rreqRateLimitTimer.SetFunction (&RoutingProtocol::RreqRateLimitTimerExpire,
                                    this);
  m_rreqRateLimitTimer.Schedule (Seconds (1));

  m_rerrRateLimitTimer.SetFunction (&RoutingProtocol::RerrRateLimitTimerExpire,
                                    this);
  m_rerrRateLimitTimer.Schedule (Seconds (1));

}

Ptr<Ipv4Route>

          m_routingTable.LookupRoute (origin, toOrigin);
          UpdateRouteLifeTime (toOrigin.GetNextHop (), ActiveRouteTimeout);

          //m_nb.Update (route->GetGateway (), ActiveRouteTimeout);     //updating neighbor timeout only should be done if received from neighbor
          m_nb.Update (toOrigin.GetNextHop (), ActiveRouteTimeout);

          ucb (route, p, header);

    {
      m_htimer.SetFunction (&RoutingProtocol::HelloTimerExpire, this);
      m_htimer.Schedule (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 100)));
      m_lastBcastTime = Time (0);
    }

  m_ipv4 = ipv4;

  ScheduleRreqRetry (dst);
  if (EnableHello)
    {
      m_lastBcastTime = Simulator::Now ();
        {
          m_htimer.Cancel ();
          m_htimer.Schedule (HelloInterval - Time (0.01 * MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))));
        }
    }
}


          m_routingTable.Update (newEntry);
        }
    }
    
  /*     
   *   A node MAY determine connectivity by listening for packets from its
   *   set of neighbors.  If, within the past DELETE_PERIOD, it has received  
   *   Every HELLO_INTERVAL milliseconds, the node checks
   *   whether it has sent a broadcast (e.g., a RREQ or an appropriate layer
   *   2 message) within the last HELLO_INTERVAL.  If it has not...
   *   ...
   *   A node MAY determine connectivity by listening for packets from its
   *   set of neighbors.  If, within the past DELETE_PERIOD, it has received
   *   a Hello message from a neighbor, and then for that neighbor does not
   *   receive any packets (Hello messages or otherwise) for more than
   *   ALLOWED_HELLO_LOSS * HELLO_INTERVAL milliseconds, the node SHOULD
   *   assume that the link to this neighbor is currently lost.
   */
  
  if (EnableHello)
    {
      m_nb.Update (sender, Time (AllowedHelloLoss * HelloInterval));
    }
}

void


  if (EnableHello)
    {
      m_lastBcastTime = Simulator::Now ();
        {
          m_htimer.Cancel ();
          m_htimer.Schedule (HelloInterval - Time (0.1 * MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))));
	}
    }
}


      toNeighbor.SetInterface (m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0));
      m_routingTable.Update (toNeighbor);
    }
  if (EnableHello)
    {
      m_nb.Update (rrepHeader.GetDst (), Time (AllowedHelloLoss * HelloInterval));
    }
}

void

RoutingProtocol::HelloTimerExpire ()
{
  NS_LOG_FUNCTION (this);
  if (Simulator::Now () - m_lastBcastTime > HelloInterval)
    if (m_routingTable.LookupPartOfAnyActiveRoutes ())
      SendHello ();
  m_htimer.Cancel ();
  Time t = Time (0.01 * MilliSeconds (m_uniformRandomVariable->GetInteger (0, 100)));
  m_htimer.Schedule (HelloInterval - t);

            }
          socket->SendTo (packet, 0, InetSocketAddress (destination, AODV_PORT));
        }
    if (EnableHello)
      {
        m_lastBcastTime = Simulator::Now ();
      }
    }
}


      socket->SendTo (packet, 0, InetSocketAddress (destination, AODV_PORT));
      m_rerrCount++;
    }
  if (EnableHello)
    {
      m_lastBcastTime = Simulator::Now ();
    }  
}

Ptr<Socket>

(-)a/src/aodv/model/aodv-routing-protocol.h (+2 lines)

Lines 168-173	Link Here

168

  uint16_t m_rreqCount;

168

  uint16_t m_rreqCount;

169

  /// Number of RERRs used for RERR rate control

169

  /// Number of RERRs used for RERR rate control

170

  uint16_t m_rerrCount;

170

  uint16_t m_rerrCount;

171

  /// Last time a control packet was broadcast

172

  Time m_lastBcastTime;

171

173

172

private:

174

private:

173

  /// Start protocol operation

175

  /// Start protocol operation




}

bool
RoutingTable::LookupPartOfAnyActiveRoutes ()
{
  NS_LOG_FUNCTION (this);
  for (std::map<Ipv4Address, RoutingTableEntry>::const_iterator i =
         m_ipv4AddressEntry.begin (); i != m_ipv4AddressEntry.end (); ++i)
    {
      if (i->first != i->second.GetNextHop ())
        {
          if (i->second.GetFlag () == VALID);
            return true;
        }
    }  
  return false;
}

bool
RoutingTable::DeleteRoute (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);

(-)a/src/aodv/model/aodv-rtable.h (+2 lines)

Lines 216-221	Link Here

216

  bool LookupRoute (Ipv4Address dst, RoutingTableEntry & rt);

216

  bool LookupRoute (Ipv4Address dst, RoutingTableEntry & rt);

217

  /// Lookup route in VALID state

217

  /// Lookup route in VALID state

218

  bool LookupValidRoute (Ipv4Address dst, RoutingTableEntry & rt);

218

  bool LookupValidRoute (Ipv4Address dst, RoutingTableEntry & rt);

219

  /// Lookup if there are any active routes for which the node is part of the path.  Cannot be a neighbor route

220

  bool LookupPartOfAnyActiveRoutes ();

219

  /// Update routing table

221

  /// Update routing table

220

  bool Update (RoutingTableEntry & rt);

222

  bool Update (RoutingTableEntry & rt);

221

  /// Set routing table entry flags

223

  /// Set routing table entry flags

Return to bug 1190