A Discrete-Event Network Simulator
API
fd-net-device.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2012 INRIA, 2012 University of Washington
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: Alina Quereilhac <alina.quereilhac@inria.fr>
19  * Claudio Freire <klaussfreire@sourceforge.net>
20  */
21 
22 #include "fd-net-device.h"
23 
24 #include "ns3/abort.h"
25 #include "ns3/boolean.h"
26 #include "ns3/channel.h"
27 #include "ns3/enum.h"
28 #include "ns3/ethernet-header.h"
29 #include "ns3/ethernet-trailer.h"
30 #include "ns3/log.h"
31 #include "ns3/llc-snap-header.h"
32 #include "ns3/mac48-address.h"
33 #include "ns3/pointer.h"
34 #include "ns3/simulator.h"
35 #include "ns3/string.h"
36 #include "ns3/trace-source-accessor.h"
37 #include "ns3/uinteger.h"
38 
39 #include <unistd.h>
40 #include <arpa/inet.h>
41 #include <net/ethernet.h>
42 
43 namespace ns3 {
44 
45 NS_LOG_COMPONENT_DEFINE ("FdNetDevice");
46 
48  : m_bufferSize (65536) // Defaults to maximum TCP window size
49 {
50 }
51 
52 void
54 {
55  NS_LOG_FUNCTION (this << bufferSize);
56  m_bufferSize = bufferSize;
57 }
58 
60 {
61  NS_LOG_FUNCTION (this);
62 
63  uint8_t *buf = (uint8_t *)malloc (m_bufferSize);
64  NS_ABORT_MSG_IF (buf == 0, "malloc() failed");
65 
66  NS_LOG_LOGIC ("Calling read on fd " << m_fd);
67  ssize_t len = read (m_fd, buf, m_bufferSize);
68  if (len <= 0)
69  {
70  free (buf);
71  buf = 0;
72  len = 0;
73  }
74  NS_LOG_LOGIC ("Read " << len << " bytes on fd " << m_fd);
75  return FdReader::Data (buf, len);
76 }
77 
79 
80 TypeId
82 {
83  static TypeId tid = TypeId ("ns3::FdNetDevice")
84  .SetParent<NetDevice> ()
85  .SetGroupName ("FdNetDevice")
86  .AddConstructor<FdNetDevice> ()
87  .AddAttribute ("Address",
88  "The MAC address of this device.",
89  Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
92  .AddAttribute ("Start",
93  "The simulation time at which to spin up "
94  "the device thread.",
95  TimeValue (Seconds (0.)),
97  MakeTimeChecker ())
98  .AddAttribute ("Stop",
99  "The simulation time at which to tear down "
100  "the device thread.",
101  TimeValue (Seconds (0.)),
103  MakeTimeChecker ())
104  .AddAttribute ("EncapsulationMode",
105  "The link-layer encapsulation type to use.",
106  EnumValue (DIX),
108  MakeEnumChecker (DIX, "Dix",
109  LLC, "Llc",
110  DIXPI, "DixPi"))
111  .AddAttribute ("RxQueueSize", "Maximum size of the read queue. "
112  "This value limits number of packets that have been read "
113  "from the network into a memory buffer but have not yet "
114  "been processed by the simulator.",
115  UintegerValue (1000),
117  MakeUintegerChecker<uint32_t> ())
118  //
119  // Trace sources at the "top" of the net device, where packets transition
120  // to/from higher layers. These points do not really correspond to the
121  // MAC layer of the underlying operating system, but exist to provide
122  // a consistent tracing environment. These trace hooks should really be
123  // interpreted as the points at which a packet leaves the ns-3 environment
124  // destined for the underlying operating system or vice-versa.
125  //
126  .AddTraceSource ("MacTx",
127  "Trace source indicating a packet has "
128  "arrived for transmission by this device",
130  "ns3::Packet::TracedCallback")
131  .AddTraceSource ("MacTxDrop",
132  "Trace source indicating a packet has "
133  "been dropped by the device before transmission",
135  "ns3::Packet::TracedCallback")
136  .AddTraceSource ("MacPromiscRx",
137  "A packet has been received by this device, "
138  "has been passed up from the physical layer "
139  "and is being forwarded up the local protocol stack. "
140  "This is a promiscuous trace,",
142  "ns3::Packet::TracedCallback")
143  .AddTraceSource ("MacRx",
144  "A packet has been received by this device, "
145  "has been passed up from the physical layer "
146  "and is being forwarded up the local protocol stack. "
147  "This is a non-promiscuous trace,",
149  "ns3::Packet::TracedCallback")
150 
151  //
152  // Trace sources designed to simulate a packet sniffer facility (tcpdump).
153  //
154  .AddTraceSource ("Sniffer",
155  "Trace source simulating a non-promiscuous "
156  "packet sniffer attached to the device",
158  "ns3::Packet::TracedCallback")
159  .AddTraceSource ("PromiscSniffer",
160  "Trace source simulating a promiscuous "
161  "packet sniffer attached to the device",
163  "ns3::Packet::TracedCallback")
164  ;
165  return tid;
166 }
167 
169  : m_node (0),
170  m_ifIndex (0),
171  // Defaults to Ethernet v2 MTU
172  m_mtu (1500),
173  m_fd (-1),
174  m_fdReader (0),
175  m_isBroadcast (true),
176  m_isMulticast (false),
177  m_startEvent (),
178  m_stopEvent ()
179 {
180  NS_LOG_FUNCTION (this);
181  Start (m_tStart);
182 }
183 
185 {
186 }
187 
189 {
190  NS_LOG_FUNCTION (this);
191 
192  {
194 
195  while (!m_pendingQueue.empty ())
196  {
197  std::pair<uint8_t *, ssize_t> next = m_pendingQueue.front ();
198  m_pendingQueue.pop ();
199 
200  free (next.first);
201  }
202  }
203 }
204 
205 void
207 {
208  NS_LOG_FUNCTION (this);
209  StopDevice ();
211 }
212 
213 void
215 {
216  NS_LOG_FUNCTION (mode);
217  m_encapMode = mode;
218  NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
219 }
220 
223 {
224  NS_LOG_FUNCTION (this);
225  return m_encapMode;
226 }
227 
228 void
230 {
231  NS_LOG_FUNCTION (tStart);
234 }
235 
236 void
238 {
239  NS_LOG_FUNCTION (tStop);
242 }
243 
244 void
246 {
247  NS_LOG_FUNCTION (this);
248 
249  if (m_fd == -1)
250  {
251  NS_LOG_DEBUG ("FdNetDevice::Start(): Failure, invalid file descriptor.");
252  return;
253  }
254  //
255  // A similar story exists for the node ID. We can't just naively do a
256  // GetNode ()->GetId () since GetNode is going to give us a Ptr<Node> which
257  // is reference counted. We need to stash away the node ID for use in the
258  // read thread.
259  //
260  m_nodeId = GetNode ()->GetId ();
261 
262  m_fdReader = Create<FdNetDeviceFdReader> ();
263  // 22 bytes covers 14 bytes Ethernet header with possible 8 bytes LLC/SNAP
264  m_fdReader->SetBufferSize (m_mtu + 22);
266 
267  NotifyLinkUp ();
268 }
269 
270 void
272 {
273  NS_LOG_FUNCTION (this);
274 
275  if (m_fdReader != 0)
276  {
277  m_fdReader->Stop ();
278  m_fdReader = 0;
279  }
280 
281  if (m_fd != -1)
282  {
283  close (m_fd);
284  m_fd = -1;
285  }
286 }
287 
288 void
289 FdNetDevice::ReceiveCallback (uint8_t *buf, ssize_t len)
290 {
291  NS_LOG_FUNCTION (this << buf << len);
292  bool skip = false;
293 
294  {
296  if (m_pendingQueue.size () >= m_maxPendingReads)
297  {
298  NS_LOG_WARN ("Packet dropped");
299  skip = true;
300  }
301  else
302  {
303  m_pendingQueue.push (std::make_pair (buf, len));
304  }
305  }
306 
307  if (skip)
308  {
309  struct timespec time = {
310  0, 100000000L
311  }; // 100 ms
312  nanosleep (&time, NULL);
313  }
314  else
315  {
317  }
318 }
319 
330 static void
331 AddPIHeader (uint8_t *&buf, size_t &len)
332 {
333  // Synthesize PI header for our friend the kernel
334  uint8_t *buf2 = (uint8_t*)malloc (len + 4);
335  memcpy (buf2 + 4, buf, len);
336  len += 4;
337 
338  // PI = 16 bits flags (0) + 16 bits proto
339  // NOTE: be careful to interpret buffer data explicitly as
340  // little-endian to be insensible to native byte ordering.
341  uint16_t flags = 0;
342  uint16_t proto = 0x0008; // default to IPv4
343  if (len > 14)
344  {
345  if (buf[12] == 0x81 && buf[13] == 0x00 && len > 18)
346  {
347  // tagged ethernet packet
348  proto = buf[16] | (buf[17] << 8);
349  }
350  else
351  {
352  // untagged ethernet packet
353  proto = buf[12] | (buf[13] << 8);
354  }
355  }
356  buf2[0] = (uint8_t)flags;
357  buf2[1] = (uint8_t)(flags >> 8);
358  buf2[2] = (uint8_t)proto;
359  buf2[3] = (uint8_t)(proto >> 8);
360 
361  // swap buffer
362  free (buf);
363  buf = buf2;
364 }
365 
372 static void
373 RemovePIHeader (uint8_t *&buf, ssize_t &len)
374 {
375  // strip PI header if present, shrink buffer
376  if (len >= 4)
377  {
378  len -= 4;
379  memmove (buf, buf + 4, len);
380  buf = (uint8_t*)realloc (buf, len);
381  }
382 }
383 
384 void
386 {
387 
388  uint8_t *buf = 0;
389  ssize_t len = 0;
390 
391  {
393  std::pair<uint8_t *, ssize_t> next = m_pendingQueue.front ();
394  m_pendingQueue.pop ();
395 
396  buf = next.first;
397  len = next.second;
398  }
399 
400  NS_LOG_FUNCTION (this << buf << len);
401 
402  // We need to remove the PI header and ignore it
403  if (m_encapMode == DIXPI)
404  {
405  RemovePIHeader (buf, len);
406  }
407 
408  //
409  // Create a packet out of the buffer we received and free that buffer.
410  //
411  Ptr<Packet> packet = Create<Packet> (reinterpret_cast<const uint8_t *> (buf), len);
412  free (buf);
413  buf = 0;
414 
415  //
416  // Trace sinks will expect complete packets, not packets without some of the
417  // headers
418  //
419  Ptr<Packet> originalPacket = packet->Copy ();
420 
421  Mac48Address destination;
422  Mac48Address source;
423  uint16_t protocol;
424  bool isBroadcast = false;
425  bool isMulticast = false;
426 
427  EthernetHeader header (false);
428 
429  //
430  // This device could be running in an environment where completely unexpected
431  // kinds of packets are flying around, so we need to harden things a bit and
432  // filter out packets we think are completely bogus, so we always check to see
433  // that the packet is long enough to contain the header we want to remove.
434  //
435  if (packet->GetSize () < header.GetSerializedSize ())
436  {
437  m_phyRxDropTrace (originalPacket);
438  return;
439  }
440 
441  packet->RemoveHeader (header);
442  destination = header.GetDestination ();
443  source = header.GetSource ();
444  isBroadcast = header.GetDestination ().IsBroadcast ();
445  isMulticast = header.GetDestination ().IsGroup ();
446  protocol = header.GetLengthType ();
447 
448  //
449  // If the length/type is less than 1500, it corresponds to a length
450  // interpretation packet. In this case, it is an 802.3 packet and
451  // will also have an 802.2 LLC header. If greater than 1500, we
452  // find the protocol number (Ethernet type) directly.
453  //
454  if (m_encapMode == LLC and header.GetLengthType () <= 1500)
455  {
456  LlcSnapHeader llc;
457  //
458  // Check to see that the packet is long enough to possibly contain the
459  // header we want to remove before just naively calling.
460  //
461  if (packet->GetSize () < llc.GetSerializedSize ())
462  {
463  m_phyRxDropTrace (originalPacket);
464  return;
465  }
466 
467  packet->RemoveHeader (llc);
468  protocol = llc.GetType ();
469  }
470 
471  NS_LOG_LOGIC ("Pkt source is " << source);
472  NS_LOG_LOGIC ("Pkt destination is " << destination);
473 
474  PacketType packetType;
475 
476  if (isBroadcast)
477  {
478  packetType = NS3_PACKET_BROADCAST;
479  }
480  else if (isMulticast)
481  {
482  packetType = NS3_PACKET_MULTICAST;
483  }
484  else if (destination == m_address)
485  {
486  packetType = NS3_PACKET_HOST;
487  }
488  else
489  {
490  packetType = NS3_PACKET_OTHERHOST;
491  }
492 
493  //
494  // For all kinds of packetType we receive, we hit the promiscuous sniffer
495  // hook and pass a copy up to the promiscuous callback. Pass a copy to
496  // make sure that nobody messes with our packet.
497  //
498  m_promiscSnifferTrace (originalPacket);
499 
500  if (!m_promiscRxCallback.IsNull ())
501  {
502  m_macPromiscRxTrace (originalPacket);
503  m_promiscRxCallback (this, packet, protocol, source, destination,
504  packetType);
505  }
506 
507  //
508  // If this packet is not destined for some other host, it must be for us
509  // as either a broadcast, multicast or unicast. We need to hit the mac
510  // packet received trace hook and forward the packet up the stack.
511  //
512  if (packetType != NS3_PACKET_OTHERHOST)
513  {
514  m_snifferTrace (originalPacket);
515  m_macRxTrace (originalPacket);
516  m_rxCallback (this, packet, protocol, source);
517  }
518 }
519 
520 bool
521 FdNetDevice::Send (Ptr<Packet> packet, const Address& destination, uint16_t protocolNumber)
522 {
523  NS_LOG_FUNCTION (this << packet << destination << protocolNumber);
524  return SendFrom (packet, m_address, destination, protocolNumber);
525 }
526 
527 bool
528 FdNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
529 {
530  NS_LOG_FUNCTION (this << packet << src << dest << protocolNumber);
531  NS_LOG_LOGIC ("packet: " << packet << " UID: " << packet->GetUid ());
532 
533  if (IsLinkUp () == false)
534  {
535  m_macTxDropTrace (packet);
536  return false;
537  }
538 
539  Mac48Address destination = Mac48Address::ConvertFrom (dest);
541 
542  NS_LOG_LOGIC ("Transmit packet with UID " << packet->GetUid ());
543  NS_LOG_LOGIC ("Transmit packet from " << source);
544  NS_LOG_LOGIC ("Transmit packet to " << destination);
545 
546  EthernetHeader header (false);
547  header.SetSource (source);
548  header.SetDestination (destination);
549 
550  NS_ASSERT_MSG (packet->GetSize () <= m_mtu, "FdNetDevice::SendFrom(): Packet too big " << packet->GetSize ());
551 
552  if (m_encapMode == LLC)
553  {
554  LlcSnapHeader llc;
555  llc.SetType (protocolNumber);
556  packet->AddHeader (llc);
557 
558  header.SetLengthType (packet->GetSize ());
559  }
560  else
561  {
562  header.SetLengthType (protocolNumber);
563  }
564 
565  packet->AddHeader (header);
566 
567  //
568  // there's not much meaning associated with the different layers in this
569  // device, so don't be surprised when they're all stacked together in
570  // essentially one place. We do this for trace consistency across devices.
571  //
572  m_macTxTrace (packet);
573 
574  m_promiscSnifferTrace (packet);
575  m_snifferTrace (packet);
576 
577  NS_LOG_LOGIC ("calling write");
578 
579 
580  size_t len = (size_t) packet->GetSize ();
581  uint8_t *buffer = (uint8_t*)malloc (len);
582  packet->CopyData (buffer, len);
583 
584  // We need to add the PI header
585  if (m_encapMode == DIXPI)
586  {
587  AddPIHeader (buffer, len);
588  }
589 
590  ssize_t written = write (m_fd, buffer, len);
591  free (buffer);
592 
593  if (written == -1 || (size_t) written != len)
594  {
595  m_macTxDropTrace (packet);
596  return false;
597  }
598 
599  return true;
600 }
601 
602 void
604 {
605  if (m_fd == -1 and fd > 0)
606  {
607  m_fd = fd;
608  }
609 }
610 
611 void
613 {
615 }
616 
617 Address
619 {
620  return m_address;
621 }
622 
623 void
625 {
626  m_linkUp = true;
628 }
629 
630 void
631 FdNetDevice::SetIfIndex (const uint32_t index)
632 {
633  m_ifIndex = index;
634 }
635 
636 uint32_t
638 {
639  return m_ifIndex;
640 }
641 
644 {
645  return NULL;
646 }
647 
648 bool
649 FdNetDevice::SetMtu (const uint16_t mtu)
650 {
651  // The MTU depends on the technology associated to
652  // the file descriptor. The user is responsible of
653  // setting the correct value of the MTU.
654  // If the file descriptor is created using a helper,
655  // then is the responsibility of the helper to set
656  // the correct MTU value.
657  m_mtu = mtu;
658  return true;
659 }
660 
661 uint16_t
663 {
664  return m_mtu;
665 }
666 
667 bool
669 {
670  return m_linkUp;
671 }
672 
673 void
675 {
677 }
678 
679 bool
681 {
682  return m_isBroadcast;
683 }
684 
685 void
687 {
688  m_isBroadcast = broadcast;
689 }
690 
691 Address
693 {
694  return Mac48Address ("ff:ff:ff:ff:ff:ff");
695 }
696 
697 bool
699 {
700  return m_isMulticast;
701 }
702 
703 void
705 {
706  m_isMulticast = multicast;
707 }
708 
709 Address
711 {
712  return Mac48Address::GetMulticast (multicastGroup);
713 }
714 
715 Address
717 {
718  return Mac48Address::GetMulticast (addr);
719 }
720 
721 bool
723 {
724  return false;
725 }
726 
727 bool
729 {
730  return false;
731 }
732 
733 Ptr<Node>
735 {
736  return m_node;
737 }
738 
739 void
741 {
742  m_node = node;
743 }
744 
745 bool
747 {
748  return true;
749 }
750 
751 void
753 {
754  m_rxCallback = cb;
755 }
756 
757 void
759 {
760  m_promiscRxCallback = cb;
761 }
762 
763 bool
765 {
766  return true;
767 }
768 
769 } // namespace ns3
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
virtual uint32_t GetIfIndex(void) const
virtual Ptr< Node > GetNode(void) const
bool IsBroadcast(void) const
uint64_t GetUid(void) const
Returns the packet&#39;s Uid.
Definition: packet.cc:390
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
void StopDevice(void)
Tear down the device.
A structure representing data read.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
uint32_t m_nodeId
a copy of the node id so the read thread doesn&#39;t have to GetNode() in in order to find the node ID...
virtual bool IsLinkUp(void) const
Callback template class.
Definition: callback.h:1176
uint16_t m_mtu
The MTU associated to the file descriptor technology.
uint32_t GetId(void) const
Definition: node.cc:107
DIX II / Ethernet II packet.
Definition: fd-net-device.h:98
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
void SetFileDescriptor(int fd)
Set the associated file descriptor.
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
FdNetDevice::EncapsulationMode GetEncapsulationMode(void) const
Get the link layer encapsulation mode of this device.
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
virtual void AddLinkChangeCallback(Callback< void > callback)
EncapsulationMode m_encapMode
The type of encapsulation of the received/transmitted frames.
When using TAP devices, if flag IFF_NO_PI is not set on the device, IP packets will have an extra hea...
Ptr< const AttributeAccessor > MakeEnumAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: enum.h:209
TracedCallback< Ptr< const Packet > > m_macRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
virtual bool SendFrom(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
virtual uint32_t GetSerializedSize(void) const
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
std::queue< std::pair< uint8_t *, ssize_t > > m_pendingQueue
Number of packets that were received and scheduled for read but not yet read.
NetDevice::ReceiveCallback m_rxCallback
The callback used to notify higher layers that a packet has been received.
TracedCallback< Ptr< const Packet > > m_macTxDropTrace
The trace source fired when packets coming into the "top" of the device at the L3/L2 transition are d...
Ptr< const AttributeChecker > MakeMac48AddressChecker(void)
static void Cancel(const EventId &id)
Set the cancel bit on this event: the event&#39;s associated function will not be invoked when it expires...
Definition: simulator.cc:290
Time m_tStart
Time to start spinning up the device.
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
virtual bool SupportsSendFrom() const
void SetType(uint16_t type)
Set the Ethertype.
Ptr< FdNetDeviceFdReader > m_fdReader
Reader for the file descriptor.
void Stop(Time tStop)
Set a stop time for the device.
virtual void SetIsBroadcast(bool broadcast)
Set if the NetDevice is able to send Broadcast messages.
void SetSource(Mac48Address source)
Ptr< const AttributeAccessor > MakeMac48AddressAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
virtual void SetIfIndex(const uint32_t index)
Mac48Address GetSource(void) const
a polymophic address class
Definition: address.h:90
void NotifyLinkUp(void)
Notify that the link is up and ready.
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:446
virtual bool IsPointToPoint(void) const
Return true if the net device is on a point-to-point link.
static void AddPIHeader(uint8_t *&buf, size_t &len)
Synthesize PI header for the kernel.
virtual uint32_t GetSerializedSize(void) const
virtual Ptr< Channel > GetChannel(void) const
TracedCallback< Ptr< const Packet > > m_macTxTrace
The trace source fired when packets come into the "top" of the device at the L3/L2 transition...
Hold variables of type enum.
Definition: enum.h:54
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1389
uint16_t GetLengthType(void) const
static Mac48Address GetMulticast(Ipv4Address address)
AttributeValue implementation for Time.
Definition: nstime.h:1124
uint16_t GetType(void)
Return the Ethertype.
virtual bool IsBridge(void) const
Return true if the net device is acting as a bridge.
virtual bool IsBroadcast(void) const
int m_fd
The file descriptor to read from.
virtual void SetIsMulticast(bool multicast)
Set if the NetDevice is able to send Multicast messages.
A class which provides a simple way to implement a Critical Section.
Definition: system-mutex.h:118
virtual Address GetAddress(void) const
Hold an unsigned integer type.
Definition: uinteger.h:44
void ForwardUp(void)
Forward the frame to the appropriate callback for processing.
uint32_t m_maxPendingReads
Maximum number of packets that can be received and scheduled for read but not yet read...
Mac48Address GetDestination(void) const
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
void StartDevice(void)
Spin up the device.
void ReceiveCallback(uint8_t *buf, ssize_t len)
Callback to invoke when a new frame is received.
Ptr< Node > m_node
The ns-3 node associated to the net device.
static Mac48Address ConvertFrom(const Address &address)
void SetEncapsulationMode(FdNetDevice::EncapsulationMode mode)
Set the link layer encapsulation mode of this device.
EventId m_stopEvent
NetDevice stop event.
virtual void SetPromiscReceiveCallback(NetDevice::PromiscReceiveCallback cb)
int m_fd
The file descriptor used for receive/send network traffic.
TracedCallback m_linkChangeCallbacks
Callbacks to fire if the link changes state (up or down).
Every class exported by the ns3 library is enclosed in the ns3 namespace.
TracedCallback< Ptr< const Packet > > m_promiscSnifferTrace
A trace source that emulates a promiscuous mode protocol sniffer connected to the device...
address
Definition: first.py:44
virtual uint16_t GetMtu(void) const
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
virtual void SetNode(Ptr< Node > node)
an EUI-48 address
Definition: mac48-address.h:43
virtual Address GetBroadcast(void) const
Packet header for Ethernet.
TracedCallback< Ptr< const Packet > > m_snifferTrace
A trace source that emulates a non-promiscuous protocol sniffer connected to the device.
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: nstime.h:1125
virtual bool NeedsArp(void) const
bool IsGroup(void) const
FdReader::Data DoRead(void)
The read implementation.
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
TracedCallback< Ptr< const Packet > > m_phyRxDropTrace
The trace source fired when the phy layer drops a packet it has received.
virtual bool SetMtu(const uint16_t mtu)
Ptr< const AttributeChecker > MakeEnumChecker(int v1, std::string n1, int v2, std::string n2, int v3, std::string n3, int v4, std::string n4, int v5, std::string n5, int v6, std::string n6, int v7, std::string n7, int v8, std::string n8, int v9, std::string n9, int v10, std::string n10, int v11, std::string n11, int v12, std::string n12, int v13, std::string n13, int v14, std::string n14, int v15, std::string n15, int v16, std::string n16, int v17, std::string n17, int v18, std::string n18, int v19, std::string n19, int v20, std::string n20, int v21, std::string n21, int v22, std::string n22)
Make an EnumChecker pre-configured with a set of allowed values by name.
Definition: enum.cc:184
Describes an IPv6 address.
Definition: ipv6-address.h:49
uint32_t m_ifIndex
The ns-3 interface index (in the sense of net device index) that has been assigned to this network de...
static void ScheduleWithContext(uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event with the given context.
Definition: simulator.h:1483
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
802.2 LLC/SNAP Packet
Definition: fd-net-device.h:99
static TypeId GetTypeId(void)
Get the type ID.
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
Network layer to device interface.
Definition: net-device.h:95
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:264
AttributeValue implementation for Mac48Address.
virtual void SetAddress(Address address)
Set the address of this interface.
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:378
void Start(Time tStart)
Set a start time for the device.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:272
virtual void SetReceiveCallback(NetDevice::ReceiveCallback cb)
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
EventId m_startEvent
NetDevice start event.
NetDevice::PromiscReceiveCallback m_promiscRxCallback
The callback used to notify higher layers that a packet has been received in promiscuous mode...
void SetLengthType(uint16_t size)
TracedCallback< Ptr< const Packet > > m_macPromiscRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
EncapsulationMode
Enumeration of the types of frames supported in the class.
Definition: fd-net-device.h:96
uint32_t m_bufferSize
size of the read buffer
Definition: fd-net-device.h:68
void SetBufferSize(uint32_t bufferSize)
Set size of the read buffer.
virtual Address GetMulticast(Ipv4Address multicastGroup) const
Make and return a MAC multicast address using the provided multicast group.
a NetDevice to read/write network traffic from/into a file descriptor.
Definition: fd-net-device.h:84
Mac48Address m_address
The net device mac address.
PacketType
Packet types are used as they are in Linux.
Definition: net-device.h:296
bool m_isBroadcast
Flag indicating whether or not the underlying net device supports broadcast.
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:1270
void SetDestination(Mac48Address destination)
virtual void DoDispose(void)
Destructor implementation.
bool m_linkUp
Flag indicating whether or not the link is up.
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
FdNetDevice()
Constructor for the FdNetDevice.
virtual ~FdNetDevice()
Destructor for the FdNetDevice.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:915
bool m_isMulticast
Flag indicating whether or not the underlying net device supports multicast.
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
Time m_tStop
Time to start tearing down the device.
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
virtual bool IsMulticast(void) const
Header for the LLC/SNAP encapsulation.
SystemMutex m_pendingReadMutex
Mutex to increase pending read counter.
EventImpl * MakeEvent(void(*f)(void))
Make an EventImpl from a function pointer taking varying numbers of arguments.
Definition: make-event.cc:34
static void RemovePIHeader(uint8_t *&buf, ssize_t &len)
Removes PI header.