A Discrete-Event Network Simulator
API
mesh-point-device.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2008,2009 IITP RAS
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: Kirill Andreev <andreev@iitp.ru>
19  * Pavel Boyko <boyko@iitp.ru>
20  */
21 
22 #include "ns3/node.h"
23 #include "ns3/packet.h"
24 #include "ns3/log.h"
25 #include "ns3/pointer.h"
26 #include "ns3/mesh-point-device.h"
27 #include "ns3/wifi-net-device.h"
28 #include "ns3/mesh-wifi-interface-mac.h"
29 
30 namespace ns3 {
31 
32 NS_LOG_COMPONENT_DEFINE ("MeshPointDevice");
33 
34 NS_OBJECT_ENSURE_REGISTERED (MeshPointDevice);
35 
36 TypeId
38 {
39  static TypeId tid = TypeId ("ns3::MeshPointDevice")
40  .SetParent<NetDevice> ()
41  .SetGroupName ("Mesh")
42  .AddConstructor<MeshPointDevice> ()
43  .AddAttribute ("Mtu", "The MAC-level Maximum Transmission Unit",
44  UintegerValue (0xffff),
47  MakeUintegerChecker<uint16_t> ())
48  .AddAttribute ( "RoutingProtocol",
49  "The mesh routing protocol used by this mesh point.",
50  PointerValue (),
55  return tid;
56 }
57 
59  m_ifIndex (0)
60 {
61  NS_LOG_FUNCTION (this);
62  m_channel = CreateObject<BridgeChannel> ();
63 }
64 
66 {
67  NS_LOG_FUNCTION (this);
68  m_node = 0;
69  m_channel = 0;
71 }
72 
73 void
75 {
76  NS_LOG_FUNCTION (this);
77  for (std::vector<Ptr<NetDevice> >::iterator iter = m_ifaces.begin (); iter != m_ifaces.end (); iter++)
78  {
79  *iter = 0;
80  }
81  m_ifaces.clear ();
82  m_node = 0;
83  m_channel = 0;
86 
87 }
88 
89 //-----------------------------------------------------------------------------
90 // NetDevice interface implementation
91 //-----------------------------------------------------------------------------
92 
93 void
94 MeshPointDevice::ReceiveFromDevice (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet, uint16_t protocol,
95  Address const &src, Address const &dst, PacketType packetType)
96 {
97  NS_LOG_FUNCTION (this << incomingPort << packet);
98  NS_LOG_DEBUG ("UID is " << packet->GetUid ());
99  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
100  const Mac48Address dst48 = Mac48Address::ConvertFrom (dst);
101  uint16_t& realProtocol = protocol;
102  NS_LOG_DEBUG ("SRC=" << src48 << ", DST = " << dst48 << ", I am: " << m_address);
103  if (!m_promiscRxCallback.IsNull ())
104  {
105  m_promiscRxCallback (this, packet, protocol, src, dst, packetType);
106  }
107  if (dst48.IsGroup ())
108  {
109  Ptr<Packet> packet_copy = packet->Copy ();
110  if (m_routingProtocol->RemoveRoutingStuff (incomingPort->GetIfIndex (), src48, dst48, packet_copy, realProtocol))
111  {
112  m_rxCallback (this, packet_copy, realProtocol, src);
113  Forward (incomingPort, packet, protocol, src48, dst48);
114 
116  m_rxStats.broadcastDataBytes += packet->GetSize ();
117  }
118  return;
119  }
120  if (dst48 == m_address)
121  {
122  Ptr<Packet> packet_copy = packet->Copy ();
123  if (m_routingProtocol->RemoveRoutingStuff (incomingPort->GetIfIndex (), src48, dst48, packet_copy, realProtocol))
124  {
125  m_rxCallback (this, packet_copy, realProtocol, src);
127  m_rxStats.unicastDataBytes += packet->GetSize ();
128  }
129  return;
130  }
131  else
132  Forward (incomingPort, packet->Copy (), protocol, src48, dst48);
133 }
134 
135 void
136 MeshPointDevice::Forward (Ptr<NetDevice> inport, Ptr<const Packet> packet, uint16_t protocol,
137  const Mac48Address src, const Mac48Address dst)
138 {
139  // pass through routing protocol
140  m_routingProtocol->RequestRoute (inport->GetIfIndex (), src, dst, packet, protocol, MakeCallback (
141  &MeshPointDevice::DoSend, this));
142 }
143 
144 void
145 MeshPointDevice::SetIfIndex (const uint32_t index)
146 {
147  NS_LOG_FUNCTION (this);
148  m_ifIndex = index;
149 }
150 
151 uint32_t
153 {
154  NS_LOG_FUNCTION (this);
155  return m_ifIndex;
156 }
157 
160 {
161  NS_LOG_FUNCTION (this);
162  return m_channel;
163 }
164 
165 Address
167 {
168  NS_LOG_FUNCTION (this);
169  return m_address;
170 }
171 
172 void
174 {
175  NS_LOG_FUNCTION (this);
176  NS_LOG_WARN ("Manual changing mesh point address can cause routing errors.");
178 }
179 
180 bool
181 MeshPointDevice::SetMtu (const uint16_t mtu)
182 {
183  NS_LOG_FUNCTION (this);
184  m_mtu = mtu;
185  return true;
186 }
187 
188 uint16_t
190 {
191  NS_LOG_FUNCTION (this);
192  return m_mtu;
193 }
194 
195 bool
197 {
198  NS_LOG_FUNCTION (this);
199  return true;
200 }
201 
202 void
204 {
205  NS_LOG_FUNCTION (this);
206  // do nothing
207  NS_LOG_WARN ("AddLinkChangeCallback does nothing");
208 }
209 
210 bool
212 {
213  NS_LOG_FUNCTION (this);
214  return true;
215 }
216 
217 Address
219 {
220  NS_LOG_FUNCTION (this);
221  return Mac48Address ("ff:ff:ff:ff:ff:ff");
222 }
223 
224 bool
226 {
227  NS_LOG_FUNCTION (this);
228  return true;
229 }
230 
231 Address
233 {
234  NS_LOG_FUNCTION (this << multicastGroup);
235  Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);
236  return multicast;
237 }
238 
239 bool
241 {
242  NS_LOG_FUNCTION (this);
243  return false;
244 }
245 
246 bool
248 {
249  NS_LOG_FUNCTION (this);
250  return false;
251 }
252 
253 bool
254 MeshPointDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
255 {
256  NS_LOG_FUNCTION (this);
257  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
258  return m_routingProtocol->RequestRoute (m_ifIndex, m_address, dst48, packet, protocolNumber, MakeCallback (
259  &MeshPointDevice::DoSend, this));
260 }
261 
262 bool
263 MeshPointDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest,
264  uint16_t protocolNumber)
265 {
266  NS_LOG_FUNCTION (this);
267  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
268  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
269  return m_routingProtocol->RequestRoute (m_ifIndex, src48, dst48, packet, protocolNumber, MakeCallback (
270  &MeshPointDevice::DoSend, this));
271 }
272 
273 Ptr<Node>
275 {
276  NS_LOG_FUNCTION (this);
277  return m_node;
278 }
279 
280 void
282 {
283  NS_LOG_FUNCTION (this);
284  m_node = node;
285 }
286 
287 bool
289 {
290  NS_LOG_FUNCTION (this);
291  return true;
292 }
293 
294 void
296 {
297  NS_LOG_FUNCTION (this);
298  m_rxCallback = cb;
299 }
300 
301 void
303 {
304  NS_LOG_FUNCTION (this);
305  m_promiscRxCallback = cb;
306 }
307 
308 bool
310 {
311  NS_LOG_FUNCTION (this);
312  return false; // don't allow to bridge mesh network with something else.
313 }
314 
315 Address
317 {
318  NS_LOG_FUNCTION (this << addr);
319  return Mac48Address::GetMulticast (addr);
320 }
321 
322 //-----------------------------------------------------------------------------
323 // Interfaces
324 //-----------------------------------------------------------------------------
325 uint32_t
327 {
328  NS_LOG_FUNCTION (this);
329  return m_ifaces.size ();
330 }
331 
334 {
335  NS_LOG_FUNCTION (this << n);
336  for (std::vector<Ptr<NetDevice> >::const_iterator i = m_ifaces.begin (); i != m_ifaces.end (); i++)
337  {
338  if ((*i)->GetIfIndex () == n)
339  {
340  return (*i);
341  }
342  }
343  NS_FATAL_ERROR ("Mesh point interface is not found by index");
344  return 0;
345 }
346 std::vector<Ptr<NetDevice> >
348 {
349  return m_ifaces;
350 }
351 void
353 {
354  NS_LOG_FUNCTION (this << iface);
355 
356  NS_ASSERT (iface != this);
357  if (!Mac48Address::IsMatchingType (iface->GetAddress ()))
358  {
359  NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be used as a mesh point interface.");
360  }
361  if (!iface->SupportsSendFrom ())
362  {
363  NS_FATAL_ERROR ("Device does not support SendFrom: cannot be used as a mesh point interface.");
364  }
365 
366  // Mesh point has MAC address of it's first interface
367  if (m_ifaces.empty ())
368  {
369  m_address = Mac48Address::ConvertFrom (iface->GetAddress ());
370  }
371  Ptr<WifiNetDevice> wifiNetDev = iface->GetObject<WifiNetDevice> ();
372  if (wifiNetDev == 0)
373  {
374  NS_FATAL_ERROR ("Device is not a WiFi NIC: cannot be used as a mesh point interface.");
375  }
376  Ptr<MeshWifiInterfaceMac> ifaceMac = wifiNetDev->GetMac ()->GetObject<MeshWifiInterfaceMac> ();
377  if (ifaceMac == 0)
378  {
380  "WiFi device doesn't have correct MAC installed: cannot be used as a mesh point interface.");
381  }
382  ifaceMac->SetMeshPointAddress (m_address);
383 
384  // Receive frames from this interface
385  m_node->RegisterProtocolHandler (MakeCallback (&MeshPointDevice::ReceiveFromDevice, this), 0, iface, /*promiscuous = */
386  true);
387  m_ifaces.push_back (iface);
388  m_channel->AddChannel (iface->GetChannel ());
389 }
390 
391 //-----------------------------------------------------------------------------
392 // Protocols
393 //-----------------------------------------------------------------------------
394 
395 void
397 {
398  NS_LOG_FUNCTION (this << protocol);
399  NS_ASSERT_MSG (PeekPointer (protocol->GetMeshPoint ()) == this,
400  "Routing protocol must be installed on mesh point to be useful.");
401  m_routingProtocol = protocol;
402 }
403 
406 {
407  NS_LOG_FUNCTION (this);
408  return m_routingProtocol;
409 }
410 
411 void
413  uint16_t protocol, uint32_t outIface)
414 {
415  NS_LOG_FUNCTION (this << success << packet << src << dst << protocol << outIface);
416  if (!success)
417  {
418  NS_LOG_DEBUG ("Resolve failed");
419  return;
420  }
421 
422  // Count statistics
423  Statistics * stats = ((src == m_address) ? &m_txStats : &m_fwdStats);
424 
425  if (dst.IsBroadcast ())
426  {
427  stats->broadcastData++;
428  stats->broadcastDataBytes += packet->GetSize ();
429  }
430  else
431  {
432  stats->unicastData++;
433  stats->unicastDataBytes += packet->GetSize ();
434  }
435 
436  // Send
437  if (outIface != 0xffffffff)
438  {
439  GetInterface (outIface)->SendFrom (packet, src, dst, protocol);
440  }
441  else
442  {
443  for (std::vector<Ptr<NetDevice> >::iterator i = m_ifaces.begin (); i != m_ifaces.end (); i++)
444  {
445  (*i)->SendFrom (packet->Copy (), src, dst, protocol);
446  }
447  }
448 }
450  unicastData (0), unicastDataBytes (0), broadcastData (0), broadcastDataBytes (0)
451 {
452  NS_LOG_FUNCTION (this);
453 }
454 
455 void
456 MeshPointDevice::Report (std::ostream & os) const
457 {
458  NS_LOG_FUNCTION (this);
459  os << "<Statistics" << std::endl <<
460  "txUnicastData=\"" << m_txStats.unicastData << "\"" << std::endl <<
461  "txUnicastDataBytes=\"" << m_txStats.unicastDataBytes << "\"" << std::endl <<
462  "txBroadcastData=\"" << m_txStats.broadcastData << "\"" << std::endl <<
463  "txBroadcastDataBytes=\"" << m_txStats.broadcastDataBytes << "\"" << std::endl <<
464  "rxUnicastData=\"" << m_rxStats.unicastData << "\"" << std::endl <<
465  "rxUnicastDataBytes=\"" << m_rxStats.unicastDataBytes << "\"" << std::endl <<
466  "rxBroadcastData=\"" << m_rxStats.broadcastData << "\"" << std::endl <<
467  "rxBroadcastDataBytes=\"" << m_rxStats.broadcastDataBytes << "\"" << std::endl <<
468  "fwdUnicastData=\"" << m_fwdStats.unicastData << "\"" << std::endl <<
469  "fwdUnicastDataBytes=\"" << m_fwdStats.unicastDataBytes << "\"" << std::endl <<
470  "fwdBroadcastData=\"" << m_fwdStats.broadcastData << "\"" << std::endl <<
471  "fwdBroadcastDataBytes=\"" << m_fwdStats.broadcastDataBytes << "\"" << std::endl <<
472  "/>" << std::endl;
473 }
474 
475 void
477 {
478  NS_LOG_FUNCTION (this);
479  m_rxStats = Statistics ();
480  m_txStats = Statistics ();
481  m_fwdStats = Statistics ();
482 }
483 
484 } // namespace ns3
uint32_t GetNInterfaces() const
static bool IsMatchingType(const Address &address)
Mac48Address m_address
Mesh point MAC address, supposed to be the address of the first added interface.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
virtual bool IsBridge() const
Return true if the net device is acting as a bridge.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:44
NetDevice::ReceiveCallback m_rxCallback
Receive action.
Ptr< AttributeChecker > MakePointerChecker(void)
Create a PointerChecker for a type.
Definition: pointer.h:224
void ResetStats()
Reset statistics counters.
virtual bool IsBroadcast() const
uint64_t GetUid(void) const
Returns the packet's Uid.
Definition: packet.cc:368
virtual bool SetMtu(const uint16_t mtu)
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:1270
virtual ~MeshPointDevice()
D-tor.
#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
PacketType
Packet types are used as they are in Linux.
Definition: net-device.h:606
U * PeekPointer(const Ptr< U > &p)
Definition: ptr.h:562
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:792
bool IsBroadcast(void) const
virtual void AddLinkChangeCallback(Callback< void > callback)
Statistics m_txStats
Counters.
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
virtual bool IsLinkUp() const
virtual bool IsMulticast() const
Ptr< MeshL2RoutingProtocol > m_routingProtocol
Current routing protocol, used mainly by GetRoutingProtocol.
virtual void DoDispose()
Destructor implementation.
Ptr< BridgeChannel > m_channel
Virtual channel for upper layers.
virtual void SetReceiveCallback(NetDevice::ReceiveCallback cb)
a polymophic address class
Definition: address.h:90
virtual Address GetAddress() const
std::vector< Ptr< NetDevice > > GetInterfaces() const
virtual void SetAddress(Address a)
Set the address of this interface.
Ptr< NetDevice > GetInterface(uint32_t id) const
void SetRoutingProtocol(Ptr< MeshL2RoutingProtocol > protocol)
Register routing protocol to be used. Protocol must be already installed on this mesh point...
Statistics m_rxStats
Counters.
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: pointer.h:220
static Mac48Address GetMulticast(Ipv4Address address)
void Forward(Ptr< NetDevice > incomingPort, Ptr< const Packet > packet, uint16_t protocol, const Mac48Address src, const Mac48Address dst)
Forward packet down to interfaces.
Hold an unsigned integer type.
Definition: uinteger.h:44
Hold together all Wifi-related objects.
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
virtual uint32_t GetIfIndex() const
virtual Address GetMulticast(Ipv4Address multicastGroup) const
Make and return a MAC multicast address using the provided multicast group.
virtual Ptr< Node > GetNode() const
virtual uint16_t GetMtu() const
void AddInterface(Ptr< NetDevice > port)
Attach new interface to the station.
virtual void SetNode(Ptr< Node > node)
static Mac48Address ConvertFrom(const Address &address)
void Report(std::ostream &os) const
Print statistics counters.
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:122
uint16_t m_mtu
MTU in bytes.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Hold objects of type Ptr.
Definition: pointer.h:36
virtual bool SendFrom(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
virtual void SetPromiscReceiveCallback(NetDevice::PromiscReceiveCallback cb)
bool IsGroup(void) const
an EUI-48 address
Definition: mac48-address.h:43
Statistics m_fwdStats
Counters.
Ptr< Node > m_node
Parent node.
void DoSend(bool success, Ptr< Packet > packet, Mac48Address src, Mac48Address dst, uint16_t protocol, uint32_t iface)
Response callback for L2 routing protocol.
virtual Address GetBroadcast() const
static TypeId GetTypeId()
Object type ID for NS3 object system.
virtual Ptr< Channel > GetChannel() const
Virtual net device modeling mesh point.
uint32_t m_ifIndex
If index.
Interface for L2 mesh routing protocol and mesh point communication.
void RegisterProtocolHandler(ProtocolHandler handler, uint16_t protocolType, Ptr< NetDevice > device, bool promiscuous=false)
Definition: node.cc:227
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:90
MeshPointDevice()
C-tor create empty (without interfaces and protocols) mesh point.
Describes an IPv6 address.
Definition: ipv6-address.h:48
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
Network layer to device interface.
Definition: net-device.h:405
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:228
virtual bool NeedsArp() const
virtual bool IsPointToPoint() const
Return true if the net device is on a point-to-point link.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:236
std::vector< Ptr< NetDevice > > m_ifaces
List of interfaces.
virtual void SetIfIndex(const uint32_t index)
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
void ReceiveFromDevice(Ptr< NetDevice > device, Ptr< const Packet > packet, uint16_t protocol, Address const &source, Address const &destination, PacketType packetType)
Receive packet from interface.
NetDevice::PromiscReceiveCallback m_promiscRxCallback
Promisc receive action.
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: uinteger.h:45
a unique identifier for an interface.
Definition: type-id.h:58
virtual bool SupportsSendFrom() const
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:904
Basic MAC of mesh point Wi-Fi interface.
Ptr< MeshL2RoutingProtocol > GetRoutingProtocol() const
Access current routing protocol.