A Discrete-Event Network Simulator
API
dsr-rcache.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2011 Yufei Cheng
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Yufei Cheng <yfcheng@ittc.ku.edu>
19  * Song Luan <lsuper@mail.ustc.edu.cn> (Implemented Link Cache using Dijsktra algorithm)
20  *
21  * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
22  * ResiliNets Research Group http://wiki.ittc.ku.edu/resilinets
23  * Information and Telecommunication Technology Center (ITTC)
24  * and Department of Electrical Engineering and Computer Science
25  * The University of Kansas Lawrence, KS USA.
26  *
27  * Work supported in part by NSF FIND (Future Internet Design) Program
28  * under grant CNS-0626918 (Postmodern Internet Architecture),
29  * NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
30  * US Department of Defense (DoD), and ITTC at The University of Kansas.
31  */
32 
33 #include <map>
34 #include <cmath>
35 #include <algorithm>
36 #include <iostream>
37 #include <list>
38 #include <vector>
39 #include <functional>
40 #include <iomanip>
41 #include "ns3/simulator.h"
42 #include "ns3/ipv4-route.h"
43 #include "ns3/socket.h"
44 #include "ns3/log.h"
45 #include "ns3/address-utils.h"
46 #include "ns3/packet.h"
47 #include "ns3/wifi-mac-header.h"
48 #include "dsr-rcache.h"
49 
50 namespace ns3 {
51 
52 NS_LOG_COMPONENT_DEFINE ("DsrRouteCache");
53 
54 namespace dsr {
55 
57 {
58  // compare based on both with hop count considered priority
59  return (a.GetVector ().size () < b.GetVector ().size ())
60  || ((a.GetVector ().size () == b.GetVector ().size ()) && (a.GetExpireTime () > b.GetExpireTime ()))
61  ;
62 }
63 
65 {
66  // compare based on hops
67  return a.GetVector ().size () < b.GetVector ().size ();
68 }
69 
71 {
72  // compare based on expire time
73  return a.GetExpireTime () > b.GetExpireTime ();
74 }
75 
76 void Link::Print () const
77 {
78  NS_LOG_DEBUG (m_low << "----" << m_high);
79 }
80 
82  : m_nodeStability (nodeStab + Simulator::Now ())
83 {
84 }
85 
87 {
88 }
89 
91  : m_linkStability (linkStab + Simulator::Now ())
92 {
93 }
94 
96 {
97 }
98 
99 void DsrLinkStab::Print ( ) const
100 {
101  NS_LOG_LOGIC ("LifeTime: " << GetLinkStability ().As (Time::S));
102 }
103 
104 typedef std::list<DsrRouteCacheEntry>::value_type route_pair;
105 
107  : m_ackTimer (Timer::CANCEL_ON_DESTROY),
108  m_dst (dst),
109  m_path (ip),
110  m_expire (exp + Simulator::Now ()),
111  m_reqCount (0),
112  m_blackListState (false),
113  m_blackListTimeout (Simulator::Now ())
114 {
115 }
116 
118 {
119 }
120 
121 void
123 {
124  m_reqCount = 0;
125  m_expire = badLinkLifetime + Simulator::Now ();
126 }
127 
128 void
129 DsrRouteCacheEntry::Print (std::ostream & os) const
130 {
131  os << m_dst << "\t" << (m_expire - Simulator::Now ()).As (Time::S)
132  << "\t";
133 }
134 
136 
138 {
139  static TypeId tid = TypeId ("ns3::dsr::DsrRouteCache")
140  .SetParent<Object> ()
141  .SetGroupName ("Dsr")
142  .AddConstructor<DsrRouteCache> ()
143  ;
144  return tid;
145 }
146 
148  : m_vector (0),
149  m_maxEntriesEachDst (3),
150  m_isLinkCache (false),
151  m_ntimer (Timer::CANCEL_ON_DESTROY),
152  m_delay (MilliSeconds (100))
153 {
154  /*
155  * The timer to set layer 2 notification, not fully supported by ns3 yet
156  */
160 }
161 
163 {
165  // clear the route cache when done
166  m_sortedRoutes.clear ();
167 }
168 
169 void
170 DsrRouteCache::RemoveLastEntry (std::list<DsrRouteCacheEntry> & rtVector)
171 {
172  NS_LOG_FUNCTION (this);
173  // Release the last entry of route list
174  rtVector.pop_back ();
175 }
176 
177 bool
179 {
180  NS_LOG_FUNCTION (this << dst);
181  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i =
182  m_sortedRoutes.find (dst);
183  if (i == m_sortedRoutes.end ())
184  {
185  NS_LOG_LOGIC ("Failed to find the route entry for the destination " << dst);
186  return false;
187  }
188  else
189  {
190  std::list<DsrRouteCacheEntry> rtVector = i->second;
191  DsrRouteCacheEntry successEntry = rtVector.front ();
192  successEntry.SetExpireTime (RouteCacheTimeout);
193  rtVector.pop_front ();
194  rtVector.push_back (successEntry);
195  rtVector.sort (CompareRoutesExpire); // sort the route vector first
196  m_sortedRoutes.erase (dst); // erase the entry first
197  /*
198  * Save the new route cache along with the destination address in map
199  */
200  std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
201  m_sortedRoutes.insert (std::make_pair (dst, rtVector));
202  return result.second;
203  }
204  return false;
205 }
206 
207 bool
209 {
210  NS_LOG_FUNCTION (this << id);
211  if (IsLinkCache ())
212  {
213  return LookupRoute_Link (id, rt);
214  }
215  else
216  {
217  Purge (); // Purge first to remove expired entries
218  if (m_sortedRoutes.empty ())
219  {
220  NS_LOG_LOGIC ("Route to " << id << " not found; m_sortedRoutes is empty");
221  return false;
222  }
223  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i = m_sortedRoutes.find (id);
224  if (i == m_sortedRoutes.end ())
225  {
226  NS_LOG_LOGIC ("No Direct Route to " << id << " found");
227  for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator j =
228  m_sortedRoutes.begin (); j != m_sortedRoutes.end (); ++j)
229  {
230  std::list<DsrRouteCacheEntry> rtVector = j->second; // The route cache vector linked with destination address
231  /*
232  * Loop through the possibly multiple routes within the route vector
233  */
234  for (std::list<DsrRouteCacheEntry>::const_iterator k = rtVector.begin (); k != rtVector.end (); ++k)
235  {
236  // return the first route in the route vector
238  DsrRouteCacheEntry::IP_VECTOR changeVector;
239 
240  for (DsrRouteCacheEntry::IP_VECTOR::iterator l = routeVector.begin (); l != routeVector.end (); ++l)
241  {
242  if (*l != id)
243  {
244  changeVector.push_back (*l);
245  }
246  else
247  {
248  changeVector.push_back (*l);
249  break;
250  }
251  }
252  /*
253  * When the changed vector is smaller in size and larger than 1, which means we have found a route with the destination
254  * address we are looking for
255  */
256  if ((changeVector.size () < routeVector.size ()) && (changeVector.size () > 1))
257  {
258  DsrRouteCacheEntry changeEntry; // Create the route entry
259  changeEntry.SetVector (changeVector);
260  changeEntry.SetDestination (id);
261  // Use the expire time from original route entry
262  changeEntry.SetExpireTime (k->GetExpireTime ());
263  // We need to add new route entry here
264  std::list<DsrRouteCacheEntry> newVector;
265  newVector.push_back (changeEntry);
266  newVector.sort (CompareRoutesExpire); // sort the route vector first
267  m_sortedRoutes[id] = newVector; // Only get the first sub route and add it in route cache
268  NS_LOG_INFO ("We have a sub-route to " << id << " add it in route cache");
269  }
270  }
271  }
272  }
273  NS_LOG_INFO ("Here we check the route cache again after updated the sub routes");
274  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator m = m_sortedRoutes.find (id);
275  if (m == m_sortedRoutes.end ())
276  {
277  NS_LOG_LOGIC ("No updated route till last time");
278  return false;
279  }
280  /*
281  * We have a direct route to the destination address
282  */
283  std::list<DsrRouteCacheEntry> rtVector = m->second;
284  rt = rtVector.front (); // use the first entry in the route vector
285  NS_LOG_LOGIC ("Route to " << id << " with route size " << rtVector.size ());
286  return true;
287  }
288 }
289 
290 void
291 DsrRouteCache::SetCacheType (std::string type)
292 {
293  NS_LOG_FUNCTION (this << type);
294  if (type == std::string ("LinkCache"))
295  {
296  m_isLinkCache = true;
297  }
298  else if (type == std::string ("PathCache"))
299  {
300  m_isLinkCache = false;
301  }
302  else
303  {
304  m_isLinkCache = true; // use link cache as default
305  NS_LOG_INFO ("Error Cache Type");
306  }
307 }
308 
309 bool
311 {
312  NS_LOG_FUNCTION (this);
313  return m_isLinkCache;
314 }
315 
316 void
318 {
319  NS_LOG_FUNCTION (this << source);
323  // @d shortest-path estimate
324  std::map<Ipv4Address, uint32_t> d;
325  // @pre preceding node
326  std::map<Ipv4Address, Ipv4Address> pre;
327  for (std::map<Ipv4Address, std::map<Ipv4Address, uint32_t> >::iterator i = m_netGraph.begin (); i != m_netGraph.end (); ++i)
328  {
329  if (i->second.find (source) != i->second.end ())
330  {
331  d[i->first] = i->second[source];
332  pre[i->first] = source;
333  }
334  else
335  {
336  d[i->first] = MAXWEIGHT;
337  pre[i->first] = Ipv4Address ("255.255.255.255");
338  }
339  }
340  d[source] = 0;
344  // the node set which shortest distance has been calculated, if true calculated
345  std::map<Ipv4Address, bool> s;
346  double temp = MAXWEIGHT;
347  Ipv4Address tempip = Ipv4Address ("255.255.255.255");
348  for (uint32_t i = 0; i < m_netGraph.size (); i++)
349  {
350  temp = MAXWEIGHT;
351  for (std::map<Ipv4Address,uint32_t>::const_iterator j = d.begin (); j != d.end (); ++j)
352  {
353  Ipv4Address ip = j->first;
354  if (s.find (ip) == s.end ())
355  {
356  /*
357  * \brief The followings are for comparison
358  */
359  if (j->second <= temp)
360  {
361  temp = j->second;
362  tempip = ip;
363  }
364  }
365  }
366  if (!tempip.IsBroadcast ())
367  {
368  s[tempip] = true;
369  for (std::map<Ipv4Address, uint32_t>::const_iterator k = m_netGraph[tempip].begin (); k != m_netGraph[tempip].end (); ++k)
370  {
371  if (s.find (k->first) == s.end () && d[k->first] > d[tempip] + k->second)
372  {
373  d[k->first] = d[tempip] + k->second;
374  pre[k->first] = tempip;
375  }
376  /*
377  * Selects the shortest-length route that has the longest expected lifetime
378  * (highest minimum timeout of any link in the route)
379  * For the computation overhead and complexity
380  * Here I just implement kind of greedy strategy to select link with the longest expected lifetime when there is two options
381  */
382  else if (d[k->first] == d[tempip] + k->second)
383  {
384  std::map<Link, DsrLinkStab>::iterator oldlink = m_linkCache.find (Link (k->first, pre[k->first]));
385  std::map<Link, DsrLinkStab>::iterator newlink = m_linkCache.find (Link (k->first, tempip));
386  if (oldlink != m_linkCache.end () && newlink != m_linkCache.end ())
387  {
388  if (oldlink->second.GetLinkStability () < newlink->second.GetLinkStability ())
389  {
390  NS_LOG_INFO ("Select the link with longest expected lifetime");
391  d[k->first] = d[tempip] + k->second;
392  pre[k->first] = tempip;
393  }
394  }
395  else
396  {
397  NS_LOG_INFO ("Link Stability Info Corrupt");
398  }
399  }
400  }
401  }
402  }
403  // clean the best route table
404  m_bestRoutesTable_link.clear ();
405  for (std::map<Ipv4Address, Ipv4Address>::iterator i = pre.begin (); i != pre.end (); ++i)
406  {
407  // loop for all vertices
409  Ipv4Address iptemp = i->first;
410 
411  if (!i->second.IsBroadcast () && iptemp != source)
412  {
413  while (iptemp != source)
414  {
415  route.push_back (iptemp);
416  iptemp = pre[iptemp];
417  }
418  route.push_back (source);
419  // Reverse the route
420  DsrRouteCacheEntry::IP_VECTOR reverseroute;
421  for (DsrRouteCacheEntry::IP_VECTOR::reverse_iterator j = route.rbegin (); j != route.rend (); ++j)
422  {
423  reverseroute.push_back (*j);
424  }
425  NS_LOG_LOGIC ("Add newly calculated best routes");
426  PrintVector (reverseroute);
427  m_bestRoutesTable_link[i->first] = reverseroute;
428  }
429  }
430 }
431 
432 bool
434 {
435  NS_LOG_FUNCTION (this << id);
437  PurgeLinkNode ();
438  std::map<Ipv4Address, DsrRouteCacheEntry::IP_VECTOR>::const_iterator i = m_bestRoutesTable_link.find (id);
439  if (i == m_bestRoutesTable_link.end ())
440  {
441  NS_LOG_INFO ("No route find to " << id);
442  return false;
443  }
444  else
445  {
446  if (i->second.size () < 2)
447  {
448  NS_LOG_LOGIC ("Route to " << id << " error");
449  return false;
450  }
451 
452  DsrRouteCacheEntry newEntry; // Create the route entry
453  newEntry.SetVector (i->second);
454  newEntry.SetDestination (id);
455  newEntry.SetExpireTime (RouteCacheTimeout);
456  NS_LOG_INFO ("Route to " << id << " found with the length " << i->second.size ());
457  rt = newEntry;
458  std::vector<Ipv4Address> path = rt.GetVector ();
459  PrintVector (path);
460  return true;
461  }
462 }
463 
464 void
466 {
467  NS_LOG_FUNCTION (this);
468  for (std::map<Link, DsrLinkStab>::iterator i = m_linkCache.begin (); i != m_linkCache.end (); )
469  {
470  NS_LOG_DEBUG ("The link stability " << i->second.GetLinkStability ().As (Time::S));
471  std::map<Link, DsrLinkStab>::iterator itmp = i;
472  if (i->second.GetLinkStability () <= Seconds (0))
473  {
474  ++i;
475  m_linkCache.erase (itmp);
476  }
477  else
478  {
479  ++i;
480  }
481  }
483  for (std::map<Ipv4Address, DsrNodeStab>::iterator i = m_nodeCache.begin (); i != m_nodeCache.end (); )
484  {
485  NS_LOG_DEBUG ("The node stability " << i->second.GetNodeStability ().As (Time::S));
486  std::map<Ipv4Address, DsrNodeStab>::iterator itmp = i;
487  if (i->second.GetNodeStability () <= Seconds (0))
488  {
489  ++i;
490  m_nodeCache.erase (itmp);
491  }
492  else
493  {
494  ++i;
495  }
496  }
497 }
498 
499 void
501 {
502  NS_LOG_FUNCTION (this);
503  m_netGraph.clear ();
504  for (std::map<Link, DsrLinkStab>::iterator i = m_linkCache.begin (); i != m_linkCache.end (); ++i)
505  {
506  // Here the weight is set as 1
508  uint32_t weight = 1;
509  m_netGraph[i->first.m_low][i->first.m_high] = weight;
510  m_netGraph[i->first.m_high][i->first.m_low] = weight;
511  }
512 }
513 
514 bool
516 {
517  NS_LOG_FUNCTION (this << node);
518  std::map<Ipv4Address, DsrNodeStab>::const_iterator i = m_nodeCache.find (node);
519  if (i == m_nodeCache.end ())
520  {
521  NS_LOG_INFO ("The initial stability " << m_initStability.As (Time::S));
523  m_nodeCache[node] = ns;
524  return false;
525  }
526  else
527  {
529  NS_LOG_INFO ("The node stability " << i->second.GetNodeStability ().As (Time::S));
530  NS_LOG_INFO ("The stability here " << Time (i->second.GetNodeStability () * m_stabilityIncrFactor).As (Time::S));
531  DsrNodeStab ns (Time (i->second.GetNodeStability () * m_stabilityIncrFactor));
532  m_nodeCache[node] = ns;
533  return true;
534  }
535  return false;
536 }
537 
538 bool
540 {
541  NS_LOG_FUNCTION (this << node);
542  std::map<Ipv4Address, DsrNodeStab>::const_iterator i = m_nodeCache.find (node);
543  if (i == m_nodeCache.end ())
544  {
546  m_nodeCache[node] = ns;
547  return false;
548  }
549  else
550  {
552  NS_LOG_INFO ("The stability here " << i->second.GetNodeStability ().As (Time::S));
553  NS_LOG_INFO ("The stability here " << Time (i->second.GetNodeStability () / m_stabilityDecrFactor).As (Time::S));
554  DsrNodeStab ns (Time (i->second.GetNodeStability () / m_stabilityDecrFactor));
555  m_nodeCache[node] = ns;
556  return true;
557  }
558  return false;
559 }
560 
561 bool
563 {
564  NS_LOG_FUNCTION (this << source);
565  NS_LOG_LOGIC ("Use Link Cache");
567  PurgeLinkNode ();
568  for (uint32_t i = 0; i < nodelist.size () - 1; i++)
569  {
570  DsrNodeStab ns;
572 
573  if (m_nodeCache.find (nodelist[i]) == m_nodeCache.end ())
574  {
575  m_nodeCache[nodelist[i]] = ns;
576  }
577  if (m_nodeCache.find (nodelist[i + 1]) == m_nodeCache.end ())
578  {
579  m_nodeCache[nodelist[i + 1]] = ns;
580  }
581  Link link (nodelist[i], nodelist[i + 1]);
582  DsrLinkStab stab;
585  if (m_nodeCache[nodelist[i]].GetNodeStability () < m_nodeCache[nodelist[i + 1]].GetNodeStability ())
586  {
587  stab.SetLinkStability (m_nodeCache[nodelist[i]].GetNodeStability ());
588  }
589  else
590  {
591  stab.SetLinkStability (m_nodeCache[nodelist[i + 1]].GetNodeStability ());
592  }
593  if (stab.GetLinkStability () < m_minLifeTime)
594  {
595  NS_LOG_LOGIC ("Stability: " << stab.GetLinkStability ().As (Time::S));
598  }
599  m_linkCache[link] = stab;
600  NS_LOG_DEBUG ("Add a new link");
601  link.Print ();
602  NS_LOG_DEBUG ("Link Info");
603  stab.Print ();
604  }
605  UpdateNetGraph ();
606  RebuildBestRouteTable (source);
607  return true;
608 }
609 
610 void
612 {
613  NS_LOG_FUNCTION (this);
615  PurgeLinkNode ();
616  if (rt.size () < 2)
617  {
618  NS_LOG_INFO ("The route is too short");
619  return;
620  }
621  for (DsrRouteCacheEntry::IP_VECTOR::iterator i = rt.begin (); i != rt.end () - 1; ++i)
622  {
623  Link link (*i, *(i + 1));
624  if (m_linkCache.find (link) != m_linkCache.end ())
625  {
626  if (m_linkCache[link].GetLinkStability () < m_useExtends)
627  {
628  m_linkCache[link].SetLinkStability (m_useExtends);
630  NS_LOG_INFO ("The time of the link " << m_linkCache[link].GetLinkStability ().As (Time::S));
631  }
632  }
633  else
634  {
635  NS_LOG_INFO ("We cannot find a link in cache");
636  }
637  }
639  for (DsrRouteCacheEntry::IP_VECTOR::iterator i = rt.begin (); i != rt.end (); ++i)
640  {
641  if (m_nodeCache.find (*i) != m_nodeCache.end ())
642  {
643  NS_LOG_LOGIC ("Increase the stability");
644  if (m_nodeCache[*i].GetNodeStability () <= m_initStability)
645  {
646  IncStability (*i);
647  }
648  else
649  {
650  NS_LOG_INFO ("The node stability has already been increased");
651  }
652  }
653  }
654 }
655 
656 bool
658 {
659  NS_LOG_FUNCTION (this);
660  Purge ();
661  std::list<DsrRouteCacheEntry> rtVector; // Declare the route cache entry vector
662  Ipv4Address dst = rt.GetDestination ();
663  std::vector<Ipv4Address> route = rt.GetVector ();
664 
665  NS_LOG_DEBUG ("The route destination we have " << dst);
666  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i =
667  m_sortedRoutes.find (dst);
668 
669  if (i == m_sortedRoutes.end ())
670  {
671  rtVector.push_back (rt);
672  m_sortedRoutes.erase (dst); // Erase the route entries for dst first
676  std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
677  m_sortedRoutes.insert (std::make_pair (dst, rtVector));
678  return result.second;
679  }
680  else
681  {
682  rtVector = i->second;
683  NS_LOG_DEBUG ("The existing route size " << rtVector.size () << " for destination address " << dst);
687  if (rtVector.size () >= m_maxEntriesEachDst)
688  {
689  RemoveLastEntry (rtVector); // Drop the last entry for the sorted route cache, the route has already been sorted
690  }
691 
692  if (FindSameRoute (rt, rtVector))
693  {
694  NS_LOG_DEBUG ("Find same vector, the FindSameRoute function will update the route expire time");
695  return true;
696  }
697  else
698  {
699  // Check if the expire time for the new route has expired or not
700  if (rt.GetExpireTime () > Time (0))
701  {
702  rtVector.push_back (rt);
703  // This sort function will sort the route cache entries based on the size of route in each of the
704  // route entries
705  rtVector.sort (CompareRoutesExpire);
706  NS_LOG_DEBUG ("The first time" << rtVector.front ().GetExpireTime ().As (Time::S) << " The second time "
707  << rtVector.back ().GetExpireTime ().As (Time::S));
708  NS_LOG_DEBUG ("The first hop" << rtVector.front ().GetVector ().size () << " The second hop "
709  << rtVector.back ().GetVector ().size ());
710  m_sortedRoutes.erase (dst); // erase the route entries for dst first
714  std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
715  m_sortedRoutes.insert (std::make_pair (dst, rtVector));
716  return result.second;
717  }
718  else
719  {
720  NS_LOG_INFO ("The newly found route is already expired");
721  }
722  }
723  }
724  return false;
725 }
726 
727 bool DsrRouteCache::FindSameRoute (DsrRouteCacheEntry & rt, std::list<DsrRouteCacheEntry> & rtVector)
728 {
729  NS_LOG_FUNCTION (this);
730  for (std::list<DsrRouteCacheEntry>::iterator i = rtVector.begin (); i != rtVector.end (); ++i)
731  {
732  // return the first route in the route vector
733  DsrRouteCacheEntry::IP_VECTOR routeVector = i->GetVector ();
734  DsrRouteCacheEntry::IP_VECTOR newVector = rt.GetVector ();
735 
736  if (routeVector == newVector)
737  {
738  NS_LOG_DEBUG ("Found same routes in the route cache with the vector size "
739  << rt.GetDestination () << " " << rtVector.size ());
740  NS_LOG_DEBUG ("The new route expire time " << rt.GetExpireTime ().As (Time::S)
741  << " the original expire time " << i->GetExpireTime ().As (Time::S));
742  if (rt.GetExpireTime () > i->GetExpireTime ())
743  {
744  i->SetExpireTime (rt.GetExpireTime ());
745  }
746  m_sortedRoutes.erase (rt.GetDestination ()); // erase the entry first
747  rtVector.sort (CompareRoutesExpire); // sort the route vector first
748  /*
749  * Save the new route cache along with the destination address in map
750  */
751  std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
752  m_sortedRoutes.insert (std::make_pair (rt.GetDestination (), rtVector));
753  return result.second;
754  }
755  }
756  return false;
757 }
758 
759 bool
761 {
762  NS_LOG_FUNCTION (this << dst);
763  Purge (); // purge the route cache first to remove timeout entries
764  if (m_sortedRoutes.erase (dst) != 0)
765  {
766  NS_LOG_LOGIC ("Route deletion to " << dst << " successful");
767  return true;
768  }
769  NS_LOG_LOGIC ("Route deletion to " << dst << " not successful");
770  return false;
771 }
772 
773 void
775 {
776  NS_LOG_FUNCTION (this << errorSrc << unreachNode << node);
777  if (IsLinkCache ())
778  {
779  // Purge the link node cache first
780  PurgeLinkNode ();
781  /*
782  * The followings are for cleaning the broken link in link cache
783  * We basically remove the link between errorSrc and unreachNode
784  */
785  Link link1 (errorSrc, unreachNode);
786  Link link2 (unreachNode, errorSrc);
787  // erase the two kind of links to make sure the link is removed from the link cache
788  NS_LOG_DEBUG ("Erase the route");
789  m_linkCache.erase (link1);
791  NS_LOG_DEBUG ("The link cache size " << m_linkCache.size ());
792  m_linkCache.erase (link2);
793  NS_LOG_DEBUG ("The link cache size " << m_linkCache.size ());
794 
795  std::map<Ipv4Address, DsrNodeStab>::iterator i = m_nodeCache.find (errorSrc);
796  if (i == m_nodeCache.end ())
797  {
798  NS_LOG_LOGIC ("Update the node stability unsuccessfully");
799  }
800  else
801  {
802  DecStability (i->first);
803  }
804  i = m_nodeCache.find (unreachNode);
805  if (i == m_nodeCache.end ())
806  {
807  NS_LOG_LOGIC ("Update the node stability unsuccessfully");
808  }
809  else
810  {
811  DecStability (i->first);
812  }
813  UpdateNetGraph ();
814  RebuildBestRouteTable (node);
815  }
816  else
817  {
818  /*
819  * the followings are for cleaning the broken link in pathcache
820  *
821  */
822  Purge ();
823  if (m_sortedRoutes.empty ())
824  {
825  return;
826  }
827  /*
828  * Loop all the routes saved in the route cache
829  */
830  for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator j =
831  m_sortedRoutes.begin (); j != m_sortedRoutes.end (); )
832  {
833  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator jtmp = j;
834  Ipv4Address address = j->first;
835  std::list<DsrRouteCacheEntry> rtVector = j->second;
836  /*
837  * Loop all the routes for a single destination
838  */
839  for (std::list<DsrRouteCacheEntry>::iterator k = rtVector.begin (); k != rtVector.end (); )
840  {
841  // return the first route in the route vector
843  DsrRouteCacheEntry::IP_VECTOR changeVector;
844  /*
845  * Loop the ip addresses within a single route entry
846  */
847  for (DsrRouteCacheEntry::IP_VECTOR::iterator i = routeVector.begin (); i != routeVector.end (); ++i)
848  {
849  if (*i != errorSrc)
850  {
851  changeVector.push_back (*i);
852  }
853  else
854  {
855  if (*(i + 1) == unreachNode)
856  {
857  changeVector.push_back (*i);
858  break;
859  }
860  else
861  {
862  changeVector.push_back (*i);
863  }
864  }
865  }
866  /*
867  * Verify if need to remove some affected links
868  */
869  if (changeVector.size () == routeVector.size ())
870  {
871  NS_LOG_DEBUG ("The route does not contain the broken link");
872  ++k;
873  }
874  else if ((changeVector.size () < routeVector.size ()) && (changeVector.size () > 1))
875  {
876  NS_LOG_DEBUG ("sub route " << m_subRoute);
877  if (m_subRoute)
878  {
879  Time expire = k->GetExpireTime ();
880  /*
881  * Remove the route first
882  */
883  k = rtVector.erase (k);
884  DsrRouteCacheEntry changeEntry;
885  changeEntry.SetVector (changeVector);
886  Ipv4Address destination = changeVector.back ();
887  NS_LOG_DEBUG ("The destination of the newly formed route " << destination << " and the size of the route " << changeVector.size ());
888  changeEntry.SetDestination (destination);
889  changeEntry.SetExpireTime (expire); // Initialize the timeout value to the one it has
890  rtVector.push_back (changeEntry); // Add the route entry to the route list
891  NS_LOG_DEBUG ("We have a sub-route to " << destination);
892  }
893  else
894  {
895  /*
896  * Remove the route
897  */
898  k = rtVector.erase (k);
899  }
900  }
901  else
902  {
903  NS_LOG_LOGIC ("Cut route unsuccessful and erase the route");
904  /*
905  * Remove the route
906  */
907  k = rtVector.erase (k);
908  }
909  }
910  ++j;
911  if (!IsLinkCache ())
912  {
913  m_sortedRoutes.erase (jtmp);
914  }
915  if (rtVector.size ())
916  {
917  /*
918  * Save the new route cache along with the destination address in map
919  */
920  rtVector.sort (CompareRoutesExpire);
921  m_sortedRoutes[address] = rtVector;
922  }
923  else
924  {
925  NS_LOG_DEBUG ("There is no route left for that destination " << address);
926  }
927  }
928  }
929 }
930 
931 void
932 DsrRouteCache::PrintVector (std::vector<Ipv4Address>& vec)
933 {
934  NS_LOG_FUNCTION (this);
935  /*
936  * Check elements in a route vector, used when one wants to check the IP addresses saved in
937  */
938  if (!vec.size ())
939  {
940  NS_LOG_DEBUG ("The vector is empty");
941  }
942  else
943  {
944  NS_LOG_DEBUG ("Print all the elements in a vector");
945  for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)
946  {
947  NS_LOG_DEBUG ("The ip address " << *i);
948  }
949  }
950 }
951 
952 void
953 DsrRouteCache::PrintRouteVector (std::list<DsrRouteCacheEntry> route)
954 {
955  NS_LOG_FUNCTION (this);
956  for (std::list<DsrRouteCacheEntry>::iterator i = route.begin (); i != route.end (); i++)
957  {
958  std::vector<Ipv4Address> path = i->GetVector ();
959  NS_LOG_INFO ("Route NO. ");
960  PrintVector (path);
961  }
962 }
963 
964 void
966 {
967  NS_LOG_FUNCTION (this);
968  //Trying to purge the route cache
969  if (m_sortedRoutes.empty ())
970  {
971  NS_LOG_DEBUG ("The route cache is empty");
972  return;
973  }
974  for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator i =
975  m_sortedRoutes.begin (); i != m_sortedRoutes.end (); )
976  {
977  // Loop of route cache entry with the route size
978  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator itmp = i;
979  /*
980  * The route cache entry vector
981  */
982  Ipv4Address dst = i->first;
983  std::list<DsrRouteCacheEntry> rtVector = i->second;
984  NS_LOG_DEBUG ("The route vector size of 1 " << dst << " " << rtVector.size ());
985  if (rtVector.size ())
986  {
987  for (std::list<DsrRouteCacheEntry>::iterator j = rtVector.begin (); j != rtVector.end (); )
988  {
989  NS_LOG_DEBUG ("The expire time of every entry with expire time " << j->GetExpireTime ());
990  /*
991  * First verify if the route has expired or not
992  */
993  if (j->GetExpireTime () <= Seconds (0))
994  {
995  /*
996  * When the expire time has passed, erase the certain route
997  */
998  NS_LOG_DEBUG ("Erase the expired route for " << dst << " with expire time " << j->GetExpireTime ());
999  j = rtVector.erase (j);
1000  }
1001  else
1002  {
1003  ++j;
1004  }
1005  }
1006  NS_LOG_DEBUG ("The route vector size of 2 " << dst << " " << rtVector.size ());
1007  if (rtVector.size ())
1008  {
1009  ++i;
1010  m_sortedRoutes.erase (itmp); // erase the entry first
1011  /*
1012  * Save the new route cache along with the destination address in map
1013  */
1014  m_sortedRoutes.insert (std::make_pair (dst, rtVector));
1015  }
1016  else
1017  {
1018  ++i;
1019  m_sortedRoutes.erase (itmp);
1020  }
1021  }
1022  else
1023  {
1024  ++i;
1025  m_sortedRoutes.erase (itmp);
1026  }
1027  }
1028  return;
1029 }
1030 
1031 void
1032 DsrRouteCache::Print (std::ostream &os)
1033 {
1034  NS_LOG_FUNCTION (this);
1035  Purge ();
1036  os << "\nDSR Route Cache\n"
1037  << "Destination\tGateway\t\tInterface\tFlag\tExpire\tHops\n";
1038  for (std::list<DsrRouteCacheEntry>::const_iterator i =
1039  m_routeEntryVector.begin (); i != m_routeEntryVector.end (); ++i)
1040  {
1041  i->Print (os);
1042  }
1043  os << "\n";
1044 }
1045 
1046 // ----------------------------------------------------------------------------------------------------------
1050 uint16_t
1052 {
1053  NS_LOG_FUNCTION (this);
1054  std::map<Ipv4Address, uint16_t>::const_iterator i =
1055  m_ackIdCache.find (nextHop);
1056  if (i == m_ackIdCache.end ())
1057  {
1058  NS_LOG_LOGIC ("No Ack id for " << nextHop << " found and use id 1 for the first network ack id");
1059  m_ackIdCache[nextHop] = 1;
1060  return 1;
1061  }
1062  else
1063  {
1064  uint16_t ackId = m_ackIdCache[nextHop];
1065  NS_LOG_LOGIC ("Ack id for " << nextHop << " found in the cache has value " << ackId);
1066  ackId++;
1067  m_ackIdCache[nextHop] = ackId;
1068  return ackId;
1069  }
1070 }
1071 
1072 uint16_t
1074 {
1075  return m_ackIdCache.size ();
1076 }
1077 
1078 // ----------------------------------------------------------------------------------------------------------
1082 bool
1084 {
1085  NS_LOG_FUNCTION (this);
1086  PurgeMac (); // purge the mac cache
1087  for (std::vector<Neighbor>::const_iterator i = m_nb.begin ();
1088  i != m_nb.end (); ++i)
1089  {
1090  if (i->m_neighborAddress == addr)
1091  {
1092  return true;
1093  }
1094  }
1095  return false;
1096 }
1097 
1098 Time
1100 {
1101  NS_LOG_FUNCTION (this);
1102  PurgeMac ();
1103  for (std::vector<Neighbor>::const_iterator i = m_nb.begin (); i
1104  != m_nb.end (); ++i)
1105  {
1106  if (i->m_neighborAddress == addr)
1107  {
1108  return (i->m_expireTime - Simulator::Now ());
1109  }
1110  }
1111  return Seconds (0);
1112 }
1113 
1114 void
1115 DsrRouteCache::UpdateNeighbor (std::vector<Ipv4Address> nodeList, Time expire)
1116 {
1117  NS_LOG_FUNCTION (this);
1118  for (std::vector<Neighbor>::iterator i = m_nb.begin (); i != m_nb.end (); ++i)
1119  {
1120  for (std::vector<Ipv4Address>::iterator j = nodeList.begin (); j != nodeList.end (); ++j)
1121  {
1122  if (i->m_neighborAddress == (*j))
1123  {
1124  i->m_expireTime
1125  = std::max (expire + Simulator::Now (), i->m_expireTime);
1126  if (i->m_hardwareAddress == Mac48Address ())
1127  {
1128  i->m_hardwareAddress = LookupMacAddress (i->m_neighborAddress);
1129  }
1130  return;
1131  }
1132  }
1133  }
1134 
1135  Ipv4Address addr;
1136  NS_LOG_LOGIC ("Open link to " << addr);
1137  Neighbor neighbor (addr, LookupMacAddress (addr), expire + Simulator::Now ());
1138  m_nb.push_back (neighbor);
1139  PurgeMac ();
1140 }
1141 
1142 void
1143 DsrRouteCache::AddNeighbor (std::vector<Ipv4Address> nodeList, Ipv4Address ownAddress, Time expire)
1144 {
1145  NS_LOG_LOGIC ("Add neighbor number " << nodeList.size ());
1146  for (std::vector<Ipv4Address>::iterator j = nodeList.begin (); j != nodeList.end (); )
1147  {
1148  Ipv4Address addr = *j;
1149  if (addr == ownAddress)
1150  {
1151  j = nodeList.erase (j);
1152  NS_LOG_DEBUG ("The node list size " << nodeList.size ());
1153  }
1154  else
1155  {
1156  ++j;
1157  }
1158  Neighbor neighbor (addr, LookupMacAddress (addr), expire + Simulator::Now ());
1159  m_nb.push_back (neighbor);
1160  PurgeMac ();
1161  }
1162 }
1163 
1166 {
1173  bool operator() (const DsrRouteCache::Neighbor & nb) const
1174  {
1175  return ((nb.m_expireTime < Simulator::Now ()) || nb.close);
1176  }
1177 };
1178 
1179 void
1181 {
1182  if (m_nb.empty ())
1183  {
1184  return;
1185  }
1186 
1187  CloseNeighbor pred;
1188  if (!m_handleLinkFailure.IsNull ())
1189  {
1190  for (std::vector<Neighbor>::iterator j = m_nb.begin (); j != m_nb.end (); ++j)
1191  {
1192  if (pred (*j))
1193  {
1194  NS_LOG_LOGIC ("Close link to " << j->m_neighborAddress);
1196 // m_handleLinkFailure (j->m_neighborAddress);
1197  }
1198  }
1199  }
1200  m_nb.erase (std::remove_if (m_nb.begin (), m_nb.end (), pred), m_nb.end ());
1201  m_ntimer.Cancel ();
1202  m_ntimer.Schedule ();
1203 }
1204 
1205 void
1207 {
1208  m_ntimer.Cancel ();
1209  m_ntimer.Schedule ();
1210 }
1211 
1212 void
1214 {
1215  m_arp.push_back (a);
1216 }
1217 
1218 void
1220 {
1221  m_arp.erase (std::remove (m_arp.begin (), m_arp.end (), a), m_arp.end ());
1222 }
1223 
1226 {
1227  Mac48Address hwaddr;
1228  for (std::vector<Ptr<ArpCache> >::const_iterator i = m_arp.begin ();
1229  i != m_arp.end (); ++i)
1230  {
1231  ArpCache::Entry * entry = (*i)->Lookup (addr);
1232  if (entry != 0 && (entry->IsAlive () || entry->IsPermanent ()) && !entry->IsExpired ())
1233  {
1234  hwaddr = Mac48Address::ConvertFrom (entry->GetMacAddress ());
1235  break;
1236  }
1237  }
1238  return hwaddr;
1239 }
1240 
1241 void
1243 {
1244  Mac48Address addr = hdr.GetAddr1 ();
1245 
1246  for (std::vector<Neighbor>::iterator i = m_nb.begin (); i != m_nb.end (); ++i)
1247  {
1248  if (i->m_hardwareAddress == addr)
1249  {
1250  i->close = true;
1251  }
1252  }
1253  PurgeMac ();
1254 }
1255 } // namespace dsr
1256 } // namespace ns3
ns3::dsr::DsrRouteCache::Neighbor::close
bool close
is route active
Definition: dsr-rcache.h:646
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:59
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::dsr::DsrRouteCacheEntry::SetDestination
void SetDestination(Ipv4Address d)
Set destination address.
Definition: dsr-rcache.h:285
ns3::dsr::DsrRouteCacheEntry::Print
void Print(std::ostream &os) const
Print necessary fields.
Definition: dsr-rcache.cc:129
ns3::dsr::DsrRouteCache::m_subRoute
bool m_subRoute
Check if save the sub route entries or not.
Definition: dsr-rcache.h:777
ns3::dsr::DsrRouteCacheEntry::GetDestination
Ipv4Address GetDestination() const
Get destination address.
Definition: dsr-rcache.h:277
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
ns3::dsr::DsrRouteCache::DelArpCache
void DelArpCache(Ptr< ArpCache >)
Don't use the provided ARP cache any more (interface is down)
Definition: dsr-rcache.cc:1219
ns3::dsr::DsrNodeStab::~DsrNodeStab
virtual ~DsrNodeStab()
Definition: dsr-rcache.cc:86
ns3::dsr::DsrRouteCache::AddRoute
bool AddRoute(DsrRouteCacheEntry &rt)
Add route cache entry if it doesn't yet exist in route cache.
Definition: dsr-rcache.cc:657
ns3::dsr::route_pair
std::list< DsrRouteCacheEntry >::value_type route_pair
Definition: dsr-rcache.cc:104
ns3::dsr::DsrNodeStab::DsrNodeStab
DsrNodeStab(Time nodeStab=Simulator::Now())
Constructor.
Definition: dsr-rcache.cc:81
ns3::dsr::CompareRoutesBoth
bool CompareRoutesBoth(const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
Definition: dsr-rcache.cc:56
ns3::dsr::CompareRoutesHops
bool CompareRoutesHops(const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
Definition: dsr-rcache.cc:64
ns3::dsr::DsrRouteCache::~DsrRouteCache
virtual ~DsrRouteCache()
Definition: dsr-rcache.cc:162
ns3::Simulator::Now
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::dsr::DsrRouteCacheEntry
DsrRouteCacheEntry class for entries in the route cache.
Definition: dsr-rcache.h:221
ns3::ArpCache::Entry
A record that that holds information about an ArpCache entry.
Definition: arp-cache.h:188
ns3::dsr::DsrRouteCache::Neighbor
Structure to manage neighbor state.
Definition: dsr-rcache.h:642
ns3::dsr::DsrRouteCache::m_routeEntryVector
routeEntryVector m_routeEntryVector
Define the route vector.
Definition: dsr-rcache.h:769
ns3::ArpCache::Entry::IsPermanent
bool IsPermanent(void)
Definition: arp-cache.cc:387
ns3::dsr::DsrRouteCache::m_initStability
Time m_initStability
initial stability
Definition: dsr-rcache.h:759
ns3::dsr::DsrRouteCache::m_nb
std::vector< Neighbor > m_nb
vector of entries
Definition: dsr-rcache.h:865
ns3::dsr::DsrRouteCache::DeleteRoute
bool DeleteRoute(Ipv4Address dst)
Delete the route with certain destination address.
Definition: dsr-rcache.cc:760
ns3::dsr::DsrRouteCache::IsLinkCache
bool IsLinkCache()
is link cached
Definition: dsr-rcache.cc:310
ns3::dsr::DsrRouteCache
DSR route request queue Since DSR is an on demand routing we queue requests while looking for route.
Definition: dsr-rcache.h:381
ns3::dsr::DsrRouteCache::m_bestRoutesTable_link
std::map< Ipv4Address, DsrRouteCacheEntry::IP_VECTOR > m_bestRoutesTable_link
for link route cache
Definition: dsr-rcache.h:790
ns3::dsr::DsrRouteCacheEntry::SetVector
void SetVector(IP_VECTOR v)
Sets the IP vector.
Definition: dsr-rcache.h:301
ns3::dsr::DsrRouteCacheEntry::Invalidate
void Invalidate(Time badLinkLifetime)
Mark entry as "down" (i.e.
Definition: dsr-rcache.cc:122
ns3::dsr::DsrRouteCache::Neighbor::m_expireTime
Time m_expireTime
route expire time
Definition: dsr-rcache.h:645
ns3::dsr::DsrRouteCache::UpdateNeighbor
void UpdateNeighbor(std::vector< Ipv4Address > nodeList, Time expire)
Update expire time for entry with address addr, if it exists, else add new entry.
Definition: dsr-rcache.cc:1115
ns3::dsr::DsrRouteCache::PrintRouteVector
void PrintRouteVector(std::list< DsrRouteCacheEntry > route)
Print all the route vector elements from the route list.
Definition: dsr-rcache.cc:953
ns3::dsr::DsrRouteCache::Purge
void Purge()
Delete all outdated entries and invalidate valid entry if Lifetime is expired.
Definition: dsr-rcache.cc:965
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:44
ns3::dsr::DsrRouteCache::FindSameRoute
bool FindSameRoute(DsrRouteCacheEntry &rt, std::list< DsrRouteCacheEntry > &rtVector)
Find the same route in the route cache.
Definition: dsr-rcache.cc:727
ns3::dsr::DsrRouteCache::IsNeighbor
bool IsNeighbor(Ipv4Address addr)
Check that node with address addr is neighbor.
Definition: dsr-rcache.cc:1083
ns3::dsr::DsrRouteCache::m_stabilityDecrFactor
uint32_t m_stabilityDecrFactor
stability decrease factor
Definition: dsr-rcache.h:757
ns3::WifiMacHeader::GetAddr1
Mac48Address GetAddr1(void) const
Return the address in the Address 1 field.
Definition: wifi-mac-header.cc:424
ns3::dsr::DsrRouteCache::DecStability
bool DecStability(Ipv4Address node)
decrease the stability of the node
Definition: dsr-rcache.cc:539
ns3::dsr::DsrRouteCache::UpdateRouteEntry
bool UpdateRouteEntry(Ipv4Address dst)
Update route cache entry if it has been recently used and successfully delivered the data packet.
Definition: dsr-rcache.cc:178
ns3::Time::As
TimeWithUnit As(const enum Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition: time.cc:429
ns3::dsr::DsrRouteCache::m_arp
std::vector< Ptr< ArpCache > > m_arp
list of ARP cached to be used for layer 2 notifications processing
Definition: dsr-rcache.h:867
ns3::dsr::DsrRouteCache::AddNeighbor
void AddNeighbor(std::vector< Ipv4Address > nodeList, Ipv4Address ownAddress, Time expire)
Add to the neighbor list.
Definition: dsr-rcache.cc:1143
ns3::Timer::Cancel
void Cancel(void)
Cancel the currently-running event if there is one.
Definition: timer.cc:109
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:923
ns3::dsr::DsrRouteCache::m_minLifeTime
Time m_minLifeTime
minimum lifetime
Definition: dsr-rcache.h:760
ns3::dsr::DsrRouteCacheEntry::GetVector
IP_VECTOR GetVector() const
Get the IP vector.
Definition: dsr-rcache.h:293
ns3::dsr::DsrRouteCache::CheckUniqueAckId
uint16_t CheckUniqueAckId(Ipv4Address nextHop)
Check for duplicate ids and save new entries if the id is not present in the table.
Definition: dsr-rcache.cc:1051
ns3::dsr::DsrRouteCache::AddArpCache
void AddArpCache(Ptr< ArpCache > a)
Add ARP cache to be used to allow layer 2 notifications processing.
Definition: dsr-rcache.cc:1213
ns3::dsr::DsrRouteCache::Print
void Print(std::ostream &os)
Print route cache.
Definition: dsr-rcache.cc:1032
ns3::Timer
A simple virtual Timer class.
Definition: timer.h:74
ns3::dsr::CloseNeighbor
CloseNeighbor structure.
Definition: dsr-rcache.cc:1166
ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:85
ns3::Ptr< ArpCache >
ns3::dsr::DsrRouteCache::SetCacheType
void SetCacheType(std::string type)
Dijsktra algorithm to get the best route from m_netGraph and update the m_bestRoutesTable_link when c...
Definition: dsr-rcache.cc:291
ns3::dsr::DsrRouteCache::UpdateNetGraph
void UpdateNetGraph()
Update the Net Graph for the link and node cache has changed.
Definition: dsr-rcache.cc:500
ns3::dsr::CompareRoutesExpire
bool CompareRoutesExpire(const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
Definition: dsr-rcache.cc:70
ns3::dsr::DsrRouteCache::PurgeMac
void PurgeMac()
Remove all expired mac entries.
Definition: dsr-rcache.cc:1180
ns3::Now
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
bianchi11ax.k
int k
Definition: bianchi11ax.py:129
max
#define max(a, b)
Definition: 80211b.c:43
ns3::dsr::DsrRouteCache::ScheduleTimer
void ScheduleTimer()
Schedule m_ntimer.
Definition: dsr-rcache.cc:1206
ns3::dsr::DsrRouteCacheEntry::SetExpireTime
void SetExpireTime(Time exp)
Set expire time.
Definition: dsr-rcache.h:309
ns3::dsr::DsrRouteCacheEntry::IP_VECTOR
std::vector< Ipv4Address > IP_VECTOR
Define the vector to hold Ip address.
Definition: dsr-rcache.h:223
ns3::dsr::DsrRouteCache::PrintVector
void PrintVector(std::vector< Ipv4Address > &vec)
Print the route vector elements.
Definition: dsr-rcache.cc:932
ns3::Object
A base class which provides memory management and object aggregation.
Definition: object.h:88
ns3::dsr::DsrRouteCache::PurgeLinkNode
void PurgeLinkNode()
Purge from the cache if the stability time expired.
Definition: dsr-rcache.cc:465
ns3::Mac48Address::ConvertFrom
static Mac48Address ConvertFrom(const Address &address)
Definition: mac48-address.cc:126
ns3::dsr::DsrRouteCache::IncStability
bool IncStability(Ipv4Address node)
increase the stability of the node
Definition: dsr-rcache.cc:515
ns3::dsr::DsrRouteCacheEntry::GetExpireTime
Time GetExpireTime() const
Get expire time.
Definition: dsr-rcache.h:317
ns3::Timer::Schedule
void Schedule(void)
Schedule a new event using the currently-configured delay, function, and arguments.
Definition: timer.cc:158
ns3::dsr::DsrRouteCache::m_maxEntriesEachDst
uint32_t m_maxEntriesEachDst
number of entries for each destination
Definition: dsr-rcache.h:771
ns3::dsr::DsrRouteCache::m_linkCache
std::map< Link, DsrLinkStab > m_linkCache
The data structure to store link info.
Definition: dsr-rcache.h:791
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::ArpCache::Entry::IsAlive
bool IsAlive(void)
Definition: arp-cache.cc:375
ns3::dsr::DsrRouteCache::m_handleLinkFailure
Callback< void, Ipv4Address, uint8_t > m_handleLinkFailure
The following code handles link-layer acks.
Definition: dsr-rcache.h:859
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1297
first.address
address
Definition: first.py:44
ns3::Timer::SetFunction
void SetFunction(FN fn)
Definition: timer.h:278
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
ns3::dsr::DsrRouteCacheEntry::m_dst
Ipv4Address m_dst
The destination Ip address.
Definition: dsr-rcache.h:365
ns3::ArpCache::Entry::GetMacAddress
Address GetMacAddress(void) const
Definition: arp-cache.cc:454
MAXWEIGHT
#define MAXWEIGHT
The link cache to update all the link status, bi-link is two link for link is a struct when the weigh...
Definition: dsr-rcache.h:782
ns3::Ipv4Address::IsBroadcast
bool IsBroadcast(void) const
Definition: ipv4-address.cc:287
ns3::dsr::DsrRouteCache::RebuildBestRouteTable
void RebuildBestRouteTable(Ipv4Address source)
Rebuild the best route table.
Definition: dsr-rcache.cc:317
ns3::dsr::DsrRouteCache::ProcessTxError
void ProcessTxError(WifiMacHeader const &hdr)
Process layer 2 TX error notification.
Definition: dsr-rcache.cc:1242
ns3::MakeCallback
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1642
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
ns3::dsr::DsrRouteCache::m_ackIdCache
std::map< Ipv4Address, uint16_t > m_ackIdCache
The id cache to ensure all the ids are unique.
Definition: dsr-rcache.h:773
ns3::dsr::DsrRouteCache::m_nodeCache
std::map< Ipv4Address, DsrNodeStab > m_nodeCache
The data structure to store node info.
Definition: dsr-rcache.h:792
test-ns3.result
result
Definition: test-ns3.py:576
NS_LOG_FUNCTION_NOARGS
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
Definition: log-macros-enabled.h:209
ns3::dsr::DsrRouteCache::DeleteAllRoutesIncludeLink
void DeleteAllRoutesIncludeLink(Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node)
Delete all the routes which includes the link from next hop address that has just been notified as un...
Definition: dsr-rcache.cc:774
dsr-rcache.h
ns3::dsr::DsrRouteCache::m_ntimer
Timer m_ntimer
Timer for neighbor's list. Schedule Purge().
Definition: dsr-rcache.h:863
ns3::Timer::SetDelay
void SetDelay(const Time &delay)
Definition: timer.cc:75
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
ns3::dsr::DsrRouteCache::GetAckSize
uint16_t GetAckSize()
Get the ack table size.
Definition: dsr-rcache.cc:1073
ns3::dsr::DsrRouteCacheEntry::~DsrRouteCacheEntry
virtual ~DsrRouteCacheEntry()
Definition: dsr-rcache.cc:117
ns3::dsr::DsrRouteCache::GetTypeId
static TypeId GetTypeId()
Get the type ID.
Definition: dsr-rcache.cc:137
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1289
ns3::Simulator
Control the scheduling of simulation events.
Definition: simulator.h:69
ns3::dsr::DsrRouteCache::DsrRouteCache
DsrRouteCache()
Definition: dsr-rcache.cc:147
ns3::Time::S
@ S
second
Definition: nstime.h:115
ns3::dsr::DsrRouteCacheEntry::m_expire
Time m_expire
Expire time for queue entry.
Definition: dsr-rcache.h:367
ns3::dsr::DsrRouteCache::m_sortedRoutes
std::map< Ipv4Address, routeEntryVector > m_sortedRoutes
Map the ipv4Address to route entry vector.
Definition: dsr-rcache.h:767
ns3::dsr::DsrRouteCache::RouteCacheTimeout
Time RouteCacheTimeout
The maximum period of time that dsr is allowed to for an unused route.
Definition: dsr-rcache.h:752
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:244
ns3::dsr::DsrRouteCache::m_stabilityIncrFactor
uint32_t m_stabilityIncrFactor
stability increase factor
Definition: dsr-rcache.h:758
ns3::dsr::DsrRouteCache::m_useExtends
Time m_useExtends
use extend
Definition: dsr-rcache.h:761
ns3::dsr::DsrRouteCacheEntry::DsrRouteCacheEntry
DsrRouteCacheEntry(IP_VECTOR const &ip=IP_VECTOR(), Ipv4Address dst=Ipv4Address(), Time exp=Simulator::Now())
Constructor.
Definition: dsr-rcache.cc:106
ns3::dsr::DsrRouteCache::m_isLinkCache
bool m_isLinkCache
Check if the route is using path cache or link cache.
Definition: dsr-rcache.h:775
ns3::ArpCache::Entry::IsExpired
bool IsExpired(void) const
Definition: arp-cache.cc:497
ns3::dsr::DsrRouteCache::LookupMacAddress
Mac48Address LookupMacAddress(Ipv4Address addr)
Find MAC address by IP using list of ARP caches.
Definition: dsr-rcache.cc:1225
ns3::dsr::DsrRouteCache::AddRoute_Link
bool AddRoute_Link(DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address node)
dd route link to cache
Definition: dsr-rcache.cc:562
ns3::dsr::DsrRouteCache::m_delay
Time m_delay
This timeout deals with the passive ack.
Definition: dsr-rcache.h:869
ns3::dsr::DsrRouteCache::GetExpireTime
Time GetExpireTime(Ipv4Address addr)
Return expire time for neighbor node with address addr, if exists, else return 0.
Definition: dsr-rcache.cc:1099
ns3::dsr::DsrRouteCache::LookupRoute
bool LookupRoute(Ipv4Address id, DsrRouteCacheEntry &rt)
Lookup route cache entry with destination address dst.
Definition: dsr-rcache.cc:208
ns3::dsr::DsrRouteCacheEntry::m_reqCount
uint8_t m_reqCount
Number of route requests.
Definition: dsr-rcache.h:369
ns3::dsr::DsrRouteCache::m_netGraph
std::map< Ipv4Address, std::map< Ipv4Address, uint32_t > > m_netGraph
Current network graph state for this node, double is weight, which is calculated by the node informat...
Definition: dsr-rcache.h:788
ns3::dsr::DsrRouteCache::routeVector
std::list< DsrRouteCacheEntry::IP_VECTOR > routeVector
Define the vector of route entries.
Definition: dsr-rcache.h:400
ns3::dsr::DsrNodeStab
DsrNodeStab class (DSR node stability)
Definition: dsr-rcache.h:186
ns3::dsr::DsrRouteCache::RemoveLastEntry
void RemoveLastEntry(std::list< DsrRouteCacheEntry > &rtVector)
Remove the aged route cache entries when the route cache is full.
Definition: dsr-rcache.cc:170
ns3::dsr::CloseNeighbor::operator()
bool operator()(const DsrRouteCache::Neighbor &nb) const
Check if the entry is expired.
Definition: dsr-rcache.cc:1173
ns3::dsr::DsrRouteCache::LookupRoute_Link
bool LookupRoute_Link(Ipv4Address id, DsrRouteCacheEntry &rt)
used by LookupRoute when LinkCache
Definition: dsr-rcache.cc:433
ns3::dsr::DsrRouteCache::UseExtends
void UseExtends(DsrRouteCacheEntry::IP_VECTOR rt)
When a link from the Route Cache is used in routing a packet originated or salvaged by that node,...
Definition: dsr-rcache.cc:611
ns3::dsr::DsrRouteCache::m_txErrorCallback
Callback< void, WifiMacHeader const & > m_txErrorCallback
TX error callback.
Definition: dsr-rcache.h:861
ns3::dsr::DsrNodeStab::SetNodeStability
void SetNodeStability(Time nodeStab)
Set node stability.
Definition: dsr-rcache.h:200