A Discrete-Event Network Simulator
API
ipv6-interface.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007-2009 Strasbourg University
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: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
19  */
20 
21 #include "ns3/log.h"
22 #include "ns3/node.h"
23 #include "ns3/packet.h"
24 #include "ns3/net-device.h"
25 #include "ns3/mac16-address.h"
26 #include "ns3/mac64-address.h"
27 #include "ns3/traffic-control-layer.h"
28 
29 #include "ipv6-interface.h"
30 #include "ipv6-queue-disc-item.h"
31 #include "loopback-net-device.h"
32 #include "ipv6-l3-protocol.h"
33 #include "icmpv6-l4-protocol.h"
34 #include "ipv6-header.h"
35 #include "ndisc-cache.h"
36 
37 namespace ns3
38 {
39 
40 NS_LOG_COMPONENT_DEFINE ("Ipv6Interface");
41 
42 NS_OBJECT_ENSURE_REGISTERED (Ipv6Interface);
43 
45 {
46  static TypeId tid = TypeId ("ns3::Ipv6Interface")
47  .SetParent<Object> ()
48  .SetGroupName ("Internet")
49  ;
50  return tid;
51 }
52 
54  : m_ifup (false),
55  m_forwarding (true),
56  m_metric (1),
57  m_node (0),
58  m_device (0),
59  m_tc (0),
60  m_ndCache (0),
61  m_curHopLimit (0),
62  m_baseReachableTime (0),
63  m_reachableTime (0),
64  m_retransTimer (0)
65 {
66  NS_LOG_FUNCTION (this);
67 }
68 
70 {
72 }
73 
75 {
77  m_node = 0;
78  m_device = 0;
79  m_tc = 0;
80  m_ndCache = 0;
82 }
83 
85 {
87 
88  if (m_node == 0 || m_device == 0)
89  {
90  return;
91  }
92 
93  /* set up link-local address */
94  if (!DynamicCast<LoopbackNetDevice> (m_device)) /* no autoconf for ip6-localhost */
95  {
96  Address addr = GetDevice ()->GetAddress ();
97 
99  {
101  AddAddress (ifaddr);
102  m_linkLocalAddress = ifaddr;
103  }
104  else if (Mac48Address::IsMatchingType (addr))
105  {
107  AddAddress (ifaddr);
108  m_linkLocalAddress = ifaddr;
109  }
110  else if (Mac16Address::IsMatchingType (addr))
111  {
113  AddAddress (ifaddr);
114  m_linkLocalAddress = ifaddr;
115  }
116  else if (Mac8Address::IsMatchingType (addr))
117  {
119  AddAddress (ifaddr);
120  m_linkLocalAddress = ifaddr;
121  }
122  else
123  {
124  NS_FATAL_ERROR ("IPv6 autoconf for this kind of address not implemented.");
125  }
126  }
127  else
128  {
129  return; /* no NDISC cache for ip6-localhost */
130  }
131 
133  Ptr<Icmpv6L4Protocol> icmpv6;
134  if (proto)
135  {
136  icmpv6 = proto->GetObject <Icmpv6L4Protocol> ();
137  }
138  if (icmpv6 && !m_ndCache)
139  {
140  m_ndCache = icmpv6->CreateCache (m_device, this);
141  }
142 }
143 
145 {
146  NS_LOG_FUNCTION (this << node);
147  m_node = node;
148  DoSetup ();
149 }
150 
152 {
153  NS_LOG_FUNCTION (this << device);
154  m_device = device;
155  DoSetup ();
156 }
157 
158 void
160 {
161  NS_LOG_FUNCTION (this << tc);
162  m_tc = tc;
163 }
164 
166 {
168  return m_device;
169 }
170 
171 void Ipv6Interface::SetMetric (uint16_t metric)
172 {
173  NS_LOG_FUNCTION (this << metric);
174  m_metric = metric;
175 }
176 
177 uint16_t Ipv6Interface::GetMetric () const
178 {
180  return m_metric;
181 }
182 
183 bool Ipv6Interface::IsUp () const
184 {
186  return m_ifup;
187 }
188 
190 {
192  return !m_ifup;
193 }
194 
196 {
198 
199  if (m_ifup)
200  {
201  return;
202  }
203  DoSetup ();
204  m_ifup = true;
205 }
206 
208 {
210  m_ifup = false;
211  m_addresses.clear ();
212  m_ndCache->Flush ();
213 }
214 
216 {
218  return m_forwarding;
219 }
220 
221 void Ipv6Interface::SetForwarding (bool forwarding)
222 {
223  NS_LOG_FUNCTION (this << forwarding);
224  m_forwarding = forwarding;
225 }
226 
228 {
230  Ipv6Address addr = iface.GetAddress ();
231 
232  /* DAD handling */
233  if (!addr.IsAny ())
234  {
235  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
236  {
237  if (it->first.GetAddress () == addr)
238  {
239  return false;
240  }
241  }
242 
244  m_addresses.push_back (std::make_pair (iface, solicited));
245 
246  if (!addr.IsAny () || !addr.IsLocalhost ())
247  {
248  /* DAD handling */
250  Ptr<Icmpv6L4Protocol> icmpv6;
251  if (proto)
252  {
253  icmpv6 = proto->GetObject <Icmpv6L4Protocol> ();
254  }
255 
256  if (icmpv6 && icmpv6->IsAlwaysDad ())
257  {
258  Simulator::Schedule (Seconds (0.), &Icmpv6L4Protocol::DoDAD, icmpv6, addr, this);
260  }
261  }
262  return true;
263  }
264 
265  /* bad address */
266  return false;
267 }
268 
270 {
271  /* IPv6 interface has always at least one IPv6 link-local address */
273 
274  return m_linkLocalAddress;
275 }
276 
278 {
279  /* IPv6 interface has always at least one IPv6 Solicited Multicast address */
280  NS_LOG_FUNCTION (this << address);
281 
282  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
283  {
284  if (it->second == address)
285  {
286  return true;
287  }
288  }
289 
290  return false;
291 }
292 
294 {
295  NS_LOG_FUNCTION (this << index);
296  uint32_t i = 0;
297 
298  if (m_addresses.size () > index)
299  {
300  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
301  {
302  if (i == index)
303  {
304  return it->first;
305  }
306  i++;
307  }
308  }
309  else
310  {
311  NS_FATAL_ERROR ("index " << index << " out of bounds");
312  }
314  return addr; /* quiet compiler */
315 }
316 
318 {
320  return m_addresses.size ();
321 }
322 
324 {
325  NS_LOG_FUNCTION (this << index);
326  uint32_t i = 0;
327 
328  if (m_addresses.size () < index)
329  {
330  NS_FATAL_ERROR ("Removing index that does not exist in Ipv6Interface::RemoveAddress");
331  }
332 
333  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
334  {
335  if (i == index)
336  {
337  Ipv6InterfaceAddress iface = it->first;
338  m_addresses.erase (it);
339  return iface;
340  }
341 
342  i++;
343  }
344  NS_FATAL_ERROR ("Address " << index << " not found");
346  return addr; /* quiet compiler */
347 }
348 
351 {
352  NS_LOG_FUNCTION(this << address);
353 
354  if (address == address.GetLoopback())
355  {
356  NS_LOG_WARN ("Cannot remove loopback address.");
357  return Ipv6InterfaceAddress();
358  }
359 
360  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
361  {
362  if(it->first.GetAddress () == address)
363  {
364  Ipv6InterfaceAddress iface = it->first;
365  m_addresses.erase(it);
366  return iface;
367  }
368  }
369  return Ipv6InterfaceAddress();
370 }
371 
373 {
374  NS_LOG_FUNCTION (this << dst);
375 
376  for (Ipv6InterfaceAddressList::const_iterator it = m_addresses.begin (); it != m_addresses.end (); ++it)
377  {
378  Ipv6InterfaceAddress ifaddr = it->first;
379 
380  if (ifaddr.GetPrefix ().IsMatch (ifaddr.GetAddress (), dst))
381  {
382  return ifaddr;
383  }
384  }
385 
386  /* NS_ASSERT_MSG (false, "Not matching address."); */
388  return ret; /* quiet compiler */
389 }
390 
392 {
393  NS_LOG_FUNCTION (this << p << dest);
394 
395  if (!IsUp ())
396  {
397  return;
398  }
399 
401 
402  /* check if destination is localhost (::1), if yes we don't pass through
403  * traffic control layer */
404  if (DynamicCast<LoopbackNetDevice> (m_device))
405  {
409  p->AddHeader (hdr);
410  m_device->Send (p, m_device->GetBroadcast (), Ipv6L3Protocol::PROT_NUMBER);
411  return;
412  }
413 
414  NS_ASSERT (m_tc != 0);
415 
416  /* check if destination is for one of our interface */
417  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
418  {
419  if (dest == it->first.GetAddress ())
420  {
421  p->AddHeader (hdr);
423  m_device->GetBroadcast (),
424  m_device->GetBroadcast (),
426  return;
427  }
428  }
429 
430  /* other address */
431  if (m_device->NeedsArp ())
432  {
433  NS_LOG_LOGIC ("Needs ARP" << " " << dest);
434  Ptr<Icmpv6L4Protocol> icmpv6 = ipv6->GetIcmpv6 ();
435  Address hardwareDestination;
436  bool found = false;
437 
438  NS_ASSERT (icmpv6);
439 
440  if (dest.IsMulticast ())
441  {
442  NS_LOG_LOGIC ("IsMulticast");
443  NS_ASSERT_MSG (m_device->IsMulticast (), "Ipv6Interface::SendTo (): Sending multicast packet over non-multicast device");
444 
445  hardwareDestination = m_device->GetMulticast (dest);
446  found = true;
447  }
448  else
449  {
450  NS_LOG_LOGIC ("NDISC Lookup");
451  found = icmpv6->Lookup (p, hdr, dest, GetDevice (), m_ndCache, &hardwareDestination);
452  }
453 
454  if (found)
455  {
456  NS_LOG_LOGIC ("Address Resolved. Send.");
457  m_tc->Send (m_device, Create<Ipv6QueueDiscItem> (p, hardwareDestination, Ipv6L3Protocol::PROT_NUMBER, hdr));
458  }
459  }
460  else
461  {
462  NS_LOG_LOGIC ("Doesn't need ARP");
463  m_tc->Send (m_device, Create<Ipv6QueueDiscItem> (p, m_device->GetBroadcast (), Ipv6L3Protocol::PROT_NUMBER, hdr));
464  }
465 }
466 
467 void Ipv6Interface::SetCurHopLimit (uint8_t curHopLimit)
468 {
469  NS_LOG_FUNCTION (this << curHopLimit);
470  m_curHopLimit = curHopLimit;
471 }
472 
474 {
476  return m_curHopLimit;
477 }
478 
479 void Ipv6Interface::SetBaseReachableTime (uint16_t baseReachableTime)
480 {
481  NS_LOG_FUNCTION (this << baseReachableTime);
482  m_baseReachableTime = baseReachableTime;
483 }
484 
486 {
488  return m_baseReachableTime;
489 }
490 
491 void Ipv6Interface::SetReachableTime (uint16_t reachableTime)
492 {
493  NS_LOG_FUNCTION (this << reachableTime);
494  m_reachableTime = reachableTime;
495 }
496 
498 {
500  return m_reachableTime;
501 }
502 
503 void Ipv6Interface::SetRetransTimer (uint16_t retransTimer)
504 {
505  NS_LOG_FUNCTION (this << retransTimer);
506  m_retransTimer = retransTimer;
507 }
508 
510 {
512  return m_retransTimer;
513 }
514 
516 {
517  NS_LOG_FUNCTION (this << address << state);
518 
519  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
520  {
521  if (it->first.GetAddress () == address)
522  {
523  it->first.SetState (state);
524  return;
525  }
526  }
527  /* not found, maybe address has expired */
528 }
529 
531 {
532  NS_LOG_FUNCTION (this << address << uid);
533 
534  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
535  {
536  if (it->first.GetAddress () == address)
537  {
538  it->first.SetNsDadUid (uid);
539  return;
540  }
541  }
542  /* not found, maybe address has expired */
543 }
544 
546 {
547  NS_LOG_FUNCTION (this);
548  return m_ndCache;
549 }
550 
551 } /* namespace ns3 */
552 
Ipv6InterfaceAddressList m_addresses
The addresses assigned to this interface.
static bool IsMatchingType(const Address &address)
Ipv6Address GetAddress() const
Get the IPv6 address.
bool IsLocalhost() const
If the IPv6 address is localhost (::1).
bool m_ifup
The state of this interface.
Packet header for IPv6.
Definition: ipv6-header.h:34
bool AddAddress(Ipv6InterfaceAddress iface)
Add an IPv6 address.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
void SetState(Ipv6Address address, Ipv6InterfaceAddress::State_e state)
Update state of an interface address.
void SetUp()
Enable this interface.
Ipv6InterfaceAddress GetLinkLocalAddress() const
Get link-local address from IPv6 interface.
bool m_forwarding
Forwarding state.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:81
static Mac16Address ConvertFrom(const Address &address)
static bool IsMatchingType(const Address &address)
IPv6 layer implementation.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
IPv6 address associated with an interface.
Ptr< NetDevice > m_device
NetDevice associated with this interface.
void SetDevice(Ptr< NetDevice > device)
Set the NetDevice.
bool IsForwarding() const
If the interface allows forwarding packets.
void SetReachableTime(uint16_t reachableTime)
Set the reachable time.
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
virtual Ptr< NetDevice > GetDevice() const
Get the NetDevice.
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
static bool IsMatchingType(const Address &address)
Check that a generic Address is compatible with Mac8Address.
Definition: mac8-address.cc:63
bool IsSolicitedMulticastAddress(Ipv6Address address) const
Checks if the address is a Solicited Multicast address for this interface.
a polymophic address class
Definition: address.h:90
void SetBaseReachableTime(uint16_t baseReachableTime)
Set the base reachable time.
bool IsMatch(Ipv6Address a, Ipv6Address b) const
If the Address match the type.
static void FunctionDadTimeout(Ptr< Icmpv6L4Protocol > icmpv6, Ipv6Interface *interface, Ipv6Address addr)
Function called when DAD timeout.
uint16_t m_baseReachableTime
Base value used for computing the random reachable time value (in millisecond).
void Send(Ptr< Packet > p, const Ipv6Header &hdr, Ipv6Address dest)
Send a packet through this interface.
void SetMetric(uint16_t metric)
Set the metric.
Ptr< Node > m_node
Node associated with this interface.
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1381
virtual ~Ipv6Interface()
Destructor.
void SetRetransTimer(uint16_t retransTimer)
Set the retransmission timer.
void Flush()
Flush the cache.
Definition: ndisc-cache.cc:152
uint16_t m_retransTimer
Retransmission timer (in millisecond).
bool IsUp() const
Is the interface UP ?
An implementation of the ICMPv6 protocol.
static TypeId GetTypeId()
Get the type ID.
Ipv6InterfaceAddress m_linkLocalAddress
The link-local addresses assigned to this interface.
void SetTrafficControl(Ptr< TrafficControlLayer > tc)
Set the TrafficControlLayer.
void SetNsDadUid(Ipv6Address address, uint32_t uid)
Update NS DAD packet UID of an interface address.
static Mac48Address ConvertFrom(const Address &address)
void SetNode(Ptr< Node > node)
Set node associated with interface.
void SetForwarding(bool forward)
Set forwarding enabled or not.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
bool IsMulticast() const
If the IPv6 address is multicast (ff00::/8).
Every class exported by the ns3 library is enclosed in the ns3 namespace.
uint8_t m_curHopLimit
Current hop limit.
uint16_t GetReachableTime() const
Get the reachable time.
address
Definition: first.py:37
static uint16_t GetStaticProtocolNumber()
Get ICMPv6 protocol number.
void SetCurHopLimit(uint8_t curHopLimit)
Set the current hop limit.
uint32_t GetNAddresses(void) const
Get number of addresses on this IPv6 interface.
std::list< std::pair< Ipv6InterfaceAddress, Ipv6Address > >::const_iterator Ipv6InterfaceAddressListCI
Const Container Iterator for the Ipv6InterfaceAddresses.
Ipv6InterfaceAddress GetAddress(uint32_t index) const
Get an address from IPv6 interface.
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
std::list< std::pair< Ipv6InterfaceAddress, Ipv6Address > >::iterator Ipv6InterfaceAddressListI
Container Iterator for the Ipv6InterfaceAddresses.
void DoDAD(Ipv6Address target, Ptr< Ipv6Interface > interface)
Do the Duplication Address Detection (DAD).
static Ipv6Address MakeAutoconfiguredLinkLocalAddress(Mac16Address mac)
Make the autoconfigured link-local IPv6 address with Mac16Address.
Describes an IPv6 address.
Definition: ipv6-address.h:49
uint16_t GetMetric() const
Get the metric.
State_e
State of an address associated with an interface.
static Mac64Address ConvertFrom(const Address &address)
Packet addressed oo us.
Definition: net-device.h:298
void DoSetup()
Initialize interface.
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:262
uint16_t m_reachableTime
Reachable time (in millisecond).
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1014
uint16_t GetBaseReachableTime() const
Get the base reachable time.
uint8_t GetCurHopLimit() const
Get the current hop limit value.
Describes an IPv6 prefix.
Definition: ipv6-address.h:428
Ipv6InterfaceAddress RemoveAddress(uint32_t index)
Remove an address from interface.
Ptr< NdiscCache > GetNdiscCache() const
A base class which provides memory management and object aggregation.
Definition: object.h:87
bool IsDown() const
Is the interface DOWN ?
virtual void DoDispose()
Dispose this object.
static bool IsMatchingType(const Address &address)
uint16_t m_metric
The metric.
Ptr< TrafficControlLayer > m_tc
TrafficControlLayer associated with this interface.
void SetDown()
Disable this interface.
a unique identifier for an interface.
Definition: type-id.h:58
Ipv6InterfaceAddress GetAddressMatchingDestination(Ipv6Address dst)
Get an address which is in the same network prefix as destination.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:915
Ptr< NdiscCache > m_ndCache
Neighbor cache.
static Mac8Address ConvertFrom(const Address &address)
Convert a generic address to a Mac8Address.
Definition: mac8-address.cc:54
static const uint16_t PROT_NUMBER
The protocol number for IPv6 (0x86DD).
Ipv6Prefix GetPrefix() const
Get the IPv6 prefix.
uint16_t GetRetransTimer() const
Get the retransmission timer.
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
bool IsAny() const
If the IPv6 address is the "Any" address.
static Ipv6Address MakeSolicitedAddress(Ipv6Address addr)
Make the solicited IPv6 address.
Ipv6Interface()
Constructs an Ipv6Interface.