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 }
182 
184 {
185  NS_LOG_FUNCTION (this);
186 }
187 
188 void
190 {
191  NS_LOG_FUNCTION (this);
192  Start (m_tStart);
193  if (m_tStop != Seconds (0))
194  {
195  Stop (m_tStop);
196  }
197 
199 }
200 
201 void
203 {
204  NS_LOG_FUNCTION (this);
205  StopDevice ();
207 }
208 
209 void
211 {
212  NS_LOG_FUNCTION (this << mode);
213  m_encapMode = mode;
214  NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
215 }
216 
219 {
220  NS_LOG_FUNCTION (this);
221  return m_encapMode;
222 }
223 
224 void
226 {
227  NS_LOG_FUNCTION (this << tStart);
230 }
231 
232 void
234 {
235  NS_LOG_FUNCTION (this << tStop);
238 }
239 
240 void
242 {
243  NS_LOG_FUNCTION (this);
244 
245  if (m_fd == -1)
246  {
247  NS_LOG_DEBUG ("FdNetDevice::Start(): Failure, invalid file descriptor.");
248  return;
249  }
250 
253 
255 
256  NotifyLinkUp ();
257 }
258 
261 {
262  NS_LOG_FUNCTION (this);
263 
264  Ptr<FdNetDeviceFdReader> fdReader = Create<FdNetDeviceFdReader> ();
265  // 22 bytes covers 14 bytes Ethernet header with possible 8 bytes LLC/SNAP
266  fdReader->SetBufferSize (m_mtu + 22);
267  return fdReader;
268 }
269 
270 void
272 {
273  NS_LOG_FUNCTION (this);
274 }
275 
276 void
278 {
279  NS_LOG_FUNCTION (this);
280 }
281 
282 void
284 {
285  NS_LOG_FUNCTION (this);
286 
287  if (m_fdReader != 0)
288  {
289  m_fdReader->Stop ();
290  m_fdReader = 0;
291  }
292 
293  if (m_fd != -1)
294  {
295  close (m_fd);
296  m_fd = -1;
297  }
298 
299  while (!m_pendingQueue.empty ())
300  {
301  std::pair<uint8_t *, ssize_t> next = m_pendingQueue.front ();
302  m_pendingQueue.pop ();
303  FreeBuffer (next.first);
304  }
305 
307 }
308 
309 void
310 FdNetDevice::ReceiveCallback (uint8_t *buf, ssize_t len)
311 {
312  NS_LOG_FUNCTION (this << static_cast<void *> (buf) << len);
313  bool skip = false;
314 
315  {
316  std::unique_lock lock {m_pendingReadMutex};
317  if (m_pendingQueue.size () >= m_maxPendingReads)
318  {
319  NS_LOG_WARN ("Packet dropped");
320  skip = true;
321  }
322  else
323  {
324  m_pendingQueue.push (std::make_pair (buf, len));
325  }
326  }
327 
328  if (skip)
329  {
330  struct timespec time = {
331  0, 100000000L
332  }; // 100 ms
333  nanosleep (&time, NULL);
334  }
335  else
336  {
338  }
339 }
340 
351 static void
352 AddPIHeader (uint8_t *&buf, size_t &len)
353 {
354  // Synthesize PI header for our friend the kernel
355  uint8_t *buf2 = (uint8_t*)malloc (len + 4);
356  memcpy (buf2 + 4, buf, len);
357  len += 4;
358 
359  // PI = 16 bits flags (0) + 16 bits proto
360  // NOTE: be careful to interpret buffer data explicitly as
361  // little-endian to be insensible to native byte ordering.
362  uint16_t flags = 0;
363  uint16_t proto = 0x0008; // default to IPv4
364  if (len > 14)
365  {
366  if (buf[12] == 0x81 && buf[13] == 0x00 && len > 18)
367  {
368  // tagged ethernet packet
369  proto = buf[16] | (buf[17] << 8);
370  }
371  else
372  {
373  // untagged ethernet packet
374  proto = buf[12] | (buf[13] << 8);
375  }
376  }
377  buf2[0] = (uint8_t)flags;
378  buf2[1] = (uint8_t)(flags >> 8);
379  buf2[2] = (uint8_t)proto;
380  buf2[3] = (uint8_t)(proto >> 8);
381 
382  // swap buffer
383  free (buf);
384  buf = buf2;
385 }
386 
393 static void
394 RemovePIHeader (uint8_t *&buf, ssize_t &len)
395 {
396  // strip PI header if present, shrink buffer
397  if (len >= 4)
398  {
399  len -= 4;
400  memmove (buf, buf + 4, len);
401  buf = (uint8_t*)realloc (buf, len);
402  }
403 }
404 
405 uint8_t *
407 {
408  return (uint8_t*) malloc(len);
409 }
410 
411 void
413 {
414  free (buf);
415 }
416 
417 void
419 {
420  NS_LOG_FUNCTION (this);
421 
422  uint8_t *buf = 0;
423  ssize_t len = 0;
424 
425  if (m_pendingQueue.empty())
426  {
427  NS_LOG_LOGIC ("buffer is empty, probably the device is stopped.");
428  return;
429  }
430 
431  {
432  std::unique_lock lock {m_pendingReadMutex};
433  std::pair<uint8_t *, ssize_t> next = m_pendingQueue.front ();
434  m_pendingQueue.pop ();
435 
436  buf = next.first;
437  len = next.second;
438  }
439 
440  NS_LOG_LOGIC ("buffer: " << static_cast<void *> (buf) << " length: " << len);
441 
442  // We need to remove the PI header and ignore it
443  if (m_encapMode == DIXPI)
444  {
445  RemovePIHeader (buf, len);
446  }
447 
448  //
449  // Create a packet out of the buffer we received and free that buffer.
450  //
451  Ptr<Packet> packet = Create<Packet> (reinterpret_cast<const uint8_t *> (buf), len);
452  FreeBuffer (buf);
453  buf = 0;
454 
455  //
456  // Trace sinks will expect complete packets, not packets without some of the
457  // headers
458  //
459  Ptr<Packet> originalPacket = packet->Copy ();
460 
461  Mac48Address destination;
462  Mac48Address source;
463  uint16_t protocol;
464  bool isBroadcast = false;
465  bool isMulticast = false;
466 
467  EthernetHeader header (false);
468 
469  //
470  // This device could be running in an environment where completely unexpected
471  // kinds of packets are flying around, so we need to harden things a bit and
472  // filter out packets we think are completely bogus, so we always check to see
473  // that the packet is long enough to contain the header we want to remove.
474  //
475  if (packet->GetSize () < header.GetSerializedSize ())
476  {
477  m_phyRxDropTrace (originalPacket);
478  return;
479  }
480 
481  packet->RemoveHeader (header);
482  destination = header.GetDestination ();
483  source = header.GetSource ();
484  isBroadcast = header.GetDestination ().IsBroadcast ();
485  isMulticast = header.GetDestination ().IsGroup ();
486  protocol = header.GetLengthType ();
487 
488  //
489  // If the length/type is less than 1500, it corresponds to a length
490  // interpretation packet. In this case, it is an 802.3 packet and
491  // will also have an 802.2 LLC header. If greater than 1500, we
492  // find the protocol number (Ethernet type) directly.
493  //
494  if (m_encapMode == LLC and header.GetLengthType () <= 1500)
495  {
496  LlcSnapHeader llc;
497  //
498  // Check to see that the packet is long enough to possibly contain the
499  // header we want to remove before just naively calling.
500  //
501  if (packet->GetSize () < llc.GetSerializedSize ())
502  {
503  m_phyRxDropTrace (originalPacket);
504  return;
505  }
506 
507  packet->RemoveHeader (llc);
508  protocol = llc.GetType ();
509  }
510 
511  NS_LOG_LOGIC ("Pkt source is " << source);
512  NS_LOG_LOGIC ("Pkt destination is " << destination);
513 
514  PacketType packetType;
515 
516  if (isBroadcast)
517  {
518  packetType = NS3_PACKET_BROADCAST;
519  }
520  else if (isMulticast)
521  {
522  packetType = NS3_PACKET_MULTICAST;
523  }
524  else if (destination == m_address)
525  {
526  packetType = NS3_PACKET_HOST;
527  }
528  else
529  {
530  packetType = NS3_PACKET_OTHERHOST;
531  }
532 
533  //
534  // For all kinds of packetType we receive, we hit the promiscuous sniffer
535  // hook and pass a copy up to the promiscuous callback. Pass a copy to
536  // make sure that nobody messes with our packet.
537  //
538  m_promiscSnifferTrace (originalPacket);
539 
540  if (!m_promiscRxCallback.IsNull ())
541  {
542  m_macPromiscRxTrace (originalPacket);
543  m_promiscRxCallback (this, packet, protocol, source, destination,
544  packetType);
545  }
546 
547  //
548  // If this packet is not destined for some other host, it must be for us
549  // as either a broadcast, multicast or unicast. We need to hit the mac
550  // packet received trace hook and forward the packet up the stack.
551  //
552  if (packetType != NS3_PACKET_OTHERHOST)
553  {
554  m_snifferTrace (originalPacket);
555  m_macRxTrace (originalPacket);
556  m_rxCallback (this, packet, protocol, source);
557  }
558 }
559 
560 bool
561 FdNetDevice::Send (Ptr<Packet> packet, const Address& destination, uint16_t protocolNumber)
562 {
563  NS_LOG_FUNCTION (this << packet << destination << protocolNumber);
564  return SendFrom (packet, m_address, destination, protocolNumber);
565 }
566 
567 bool
568 FdNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
569 {
570  NS_LOG_FUNCTION (this << packet << src << dest << protocolNumber);
571  NS_LOG_LOGIC ("packet: " << packet << " UID: " << packet->GetUid ());
572 
573  if (IsLinkUp () == false)
574  {
575  m_macTxDropTrace (packet);
576  return false;
577  }
578 
579  Mac48Address destination = Mac48Address::ConvertFrom (dest);
581 
582  NS_LOG_LOGIC ("Transmit packet with UID " << packet->GetUid ());
583  NS_LOG_LOGIC ("Transmit packet from " << source);
584  NS_LOG_LOGIC ("Transmit packet to " << destination);
585 
586  EthernetHeader header (false);
587  header.SetSource (source);
588  header.SetDestination (destination);
589 
590  NS_ASSERT_MSG (packet->GetSize () <= m_mtu, "FdNetDevice::SendFrom(): Packet too big " << packet->GetSize ());
591 
592  if (m_encapMode == LLC)
593  {
594  LlcSnapHeader llc;
595  llc.SetType (protocolNumber);
596  packet->AddHeader (llc);
597 
598  header.SetLengthType (packet->GetSize ());
599  }
600  else
601  {
602  header.SetLengthType (protocolNumber);
603  }
604 
605  packet->AddHeader (header);
606 
607  //
608  // there's not much meaning associated with the different layers in this
609  // device, so don't be surprised when they're all stacked together in
610  // essentially one place. We do this for trace consistency across devices.
611  //
612  m_macTxTrace (packet);
613 
614  m_promiscSnifferTrace (packet);
615  m_snifferTrace (packet);
616 
617  NS_LOG_LOGIC ("calling write");
618 
619 
620  size_t len = (size_t) packet->GetSize ();
621  uint8_t *buffer = AllocateBuffer (len);
622  if(!buffer)
623  {
624  m_macTxDropTrace(packet);
625  return false;
626  }
627 
628  packet->CopyData (buffer, len);
629 
630  // We need to add the PI header
631  if (m_encapMode == DIXPI)
632  {
633  AddPIHeader (buffer, len);
634  }
635 
636  ssize_t written = Write(buffer, len);
637  FreeBuffer (buffer);
638 
639  if (written == -1 || (size_t) written != len)
640  {
641  m_macTxDropTrace (packet);
642  return false;
643  }
644 
645  return true;
646 }
647 
648 ssize_t
649 FdNetDevice::Write (uint8_t *buffer, size_t length)
650 {
651  NS_LOG_FUNCTION (this << static_cast<void *> (buffer) << length);
652 
653  uint32_t ret = write (m_fd, buffer, length);
654  return ret;
655 }
656 
657 void
659 {
660  if (m_fd == -1 and fd > 0)
661  {
662  m_fd = fd;
663  }
664 }
665 
666 int
668 {
669  return m_fd;
670 }
671 
672 void
674 {
676 }
677 
678 Address
680 {
681  return m_address;
682 }
683 
684 void
686 {
687  m_linkUp = true;
689 }
690 
691 void
692 FdNetDevice::SetIfIndex (const uint32_t index)
693 {
694  m_ifIndex = index;
695 }
696 
697 uint32_t
699 {
700  return m_ifIndex;
701 }
702 
705 {
706  return NULL;
707 }
708 
709 bool
710 FdNetDevice::SetMtu (const uint16_t mtu)
711 {
712  // The MTU depends on the technology associated to
713  // the file descriptor. The user is responsible of
714  // setting the correct value of the MTU.
715  // If the file descriptor is created using a helper,
716  // then is the responsibility of the helper to set
717  // the correct MTU value.
718  m_mtu = mtu;
719  return true;
720 }
721 
722 uint16_t
724 {
725  return m_mtu;
726 }
727 
728 bool
730 {
731  return m_linkUp;
732 }
733 
734 void
736 {
738 }
739 
740 bool
742 {
743  return m_isBroadcast;
744 }
745 
746 void
748 {
749  m_isBroadcast = broadcast;
750 }
751 
752 Address
754 {
755  return Mac48Address ("ff:ff:ff:ff:ff:ff");
756 }
757 
758 bool
760 {
761  return m_isMulticast;
762 }
763 
764 void
766 {
767  m_isMulticast = multicast;
768 }
769 
770 Address
772 {
773  return Mac48Address::GetMulticast (multicastGroup);
774 }
775 
776 Address
778 {
779  return Mac48Address::GetMulticast (addr);
780 }
781 
782 bool
784 {
785  return false;
786 }
787 
788 bool
790 {
791  return false;
792 }
793 
794 Ptr<Node>
796 {
797  return m_node;
798 }
799 
800 void
802 {
803  m_node = node;
804 
805  // Save the node ID for use in the read thread, to avoid having
806  // to make a call to GetNode ()->GetId () that increments
807  // Ptr<Node>'s reference count.
808  m_nodeId = node->GetId ();
809 }
810 
811 bool
813 {
814  return true;
815 }
816 
817 void
819 {
820  m_rxCallback = cb;
821 }
822 
823 void
825 {
826  m_promiscRxCallback = cb;
827 }
828 
829 bool
831 {
832  return true;
833 }
834 
835 } // namespace ns3
a polymophic address class
Definition: address.h:91
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:1386
Hold variables of type enum.
Definition: enum.h:55
Packet header for Ethernet.
void SetDestination(Mac48Address destination)
void SetLengthType(uint16_t size)
void SetSource(Mac48Address source)
Mac48Address GetDestination(void) const
virtual uint32_t GetSerializedSize(void) const
Mac48Address GetSource(void) const
uint16_t GetLengthType(void) const
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.
FdReader::Data DoRead(void)
The read implementation.
a NetDevice to read/write network traffic from/into a file descriptor.
Definition: fd-net-device.h:85
EventId m_stopEvent
NetDevice stop event.
virtual uint32_t GetIfIndex(void) const
virtual void FreeBuffer(uint8_t *buf)
Free the given packet buffer.
bool m_isBroadcast
Flag indicating whether or not the underlying net device supports broadcast.
Ptr< FdReader > m_fdReader
Reader for the file descriptor.
virtual void DoInitialize(void)
Method Initialization for start and stop attributes.
uint32_t m_ifIndex
The ns-3 interface index (in the sense of net device index) that has been assigned to this network de...
int m_fd
The file descriptor used for receive/send network traffic.
virtual uint8_t * AllocateBuffer(size_t len)
Allocate packet buffer.
uint16_t m_mtu
The MTU associated to the file descriptor technology.
virtual void SetIsBroadcast(bool broadcast)
Set if the NetDevice is able to send Broadcast messages.
virtual void DoDispose(void)
Destructor implementation.
virtual void SetNode(Ptr< Node > node)
virtual ~FdNetDevice()
Destructor for the FdNetDevice.
FdNetDevice::EncapsulationMode GetEncapsulationMode(void) const
Get the link layer encapsulation mode of this device.
void Start(Time tStart)
Set a start time for the device.
Ptr< Node > m_node
The ns-3 node associated to the net device.
TracedCallback m_linkChangeCallbacks
Callbacks to fire if the link changes state (up or down).
virtual uint16_t GetMtu(void) const
virtual void SetReceiveCallback(NetDevice::ReceiveCallback cb)
uint32_t m_maxPendingReads
Maximum number of packets that can be received and scheduled for read but not yet read.
virtual bool IsMulticast(void) const
std::mutex m_pendingReadMutex
Mutex to increase pending read counter.
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_macRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
void NotifyLinkUp(void)
Notify that the link is up and ready.
virtual bool NeedsArp(void) const
Time m_tStart
Time to start spinning up the device.
void Stop(Time tStop)
Set a stop time for the device.
virtual void DoFinishStoppingDevice(void)
Complete additional actions, if any, to tear down the device.
EventId m_startEvent
NetDevice start event.
bool m_isMulticast
Flag indicating whether or not the underlying net device supports multicast.
virtual Address GetAddress(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,...
virtual void SetIfIndex(const uint32_t index)
virtual bool SetMtu(const uint16_t mtu)
TracedCallback< Ptr< const Packet > > m_promiscSnifferTrace
A trace source that emulates a promiscuous mode protocol sniffer connected to the device.
virtual void SetAddress(Address address)
Set the address of this interface.
void ForwardUp(void)
Forward the frame to the appropriate callback for processing.
FdNetDevice()
Constructor for the FdNetDevice.
TracedCallback< Ptr< const Packet > > m_snifferTrace
A trace source that emulates a non-promiscuous protocol sniffer connected to the device.
virtual bool IsLinkUp(void) const
static TypeId GetTypeId(void)
Get the type ID.
virtual bool IsBridge(void) const
Return true if the net device is acting as a bridge.
void SetEncapsulationMode(FdNetDevice::EncapsulationMode mode)
Set the link layer encapsulation mode of this device.
virtual Ptr< FdReader > DoCreateFdReader(void)
Create the FdReader object.
virtual void AddLinkChangeCallback(Callback< void > callback)
virtual Ptr< Node > GetNode(void) const
EncapsulationMode m_encapMode
The type of encapsulation of the received/transmitted frames.
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
NetDevice::PromiscReceiveCallback m_promiscRxCallback
The callback used to notify higher layers that a packet has been received in promiscuous mode.
TracedCallback< Ptr< const Packet > > m_phyRxDropTrace
The trace source fired when the phy layer drops a packet it has received.
virtual bool IsPointToPoint(void) const
Return true if the net device is on a point-to-point link.
EncapsulationMode
Enumeration of the types of frames supported in the class.
Definition: fd-net-device.h:97
@ DIX
DIX II / Ethernet II packet.
Definition: fd-net-device.h:98
@ DIXPI
When using TAP devices, if flag IFF_NO_PI is not set on the device, IP packets will have an extra hea...
@ LLC
802.2 LLC/SNAP Packet
Definition: fd-net-device.h:99
virtual void SetPromiscReceiveCallback(NetDevice::PromiscReceiveCallback cb)
bool m_linkUp
Flag indicating whether or not the link is up.
virtual Address GetMulticast(Ipv4Address multicastGroup) const
Make and return a MAC multicast address using the provided multicast group.
TracedCallback< Ptr< const Packet > > m_macPromiscRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
void SetFileDescriptor(int fd)
Set the associated file descriptor.
Time m_tStop
Time to start tearing down the device.
virtual ssize_t Write(uint8_t *buffer, size_t length)
Write packet data to device.
virtual bool SendFrom(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
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...
virtual Ptr< Channel > GetChannel(void) const
virtual void DoFinishStartingDevice(void)
Complete additional actions, if any, to spin up down the device.
Mac48Address m_address
The net device mac address.
virtual void SetIsMulticast(bool multicast)
Set if the NetDevice is able to send Multicast messages.
virtual bool SupportsSendFrom() const
virtual bool IsBroadcast(void) const
virtual Address GetBroadcast(void) const
int GetFileDescriptor(void) const
Get the associated file descriptor.
void StopDevice(void)
Tear down the device.
uint32_t m_nodeId
a copy of the node id so the read thread doesn't have to GetNode() in in order to find the node ID.
void StartDevice(void)
Spin up the device.
int m_fd
The file descriptor to read from.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
Describes an IPv6 address.
Definition: ipv6-address.h:50
Header for the LLC/SNAP encapsulation.
uint16_t GetType(void)
Return the Ethertype.
virtual uint32_t GetSerializedSize(void) const
void SetType(uint16_t type)
Set the Ethertype.
an EUI-48 address
Definition: mac48-address.h:44
static Mac48Address GetMulticast(Ipv4Address address)
bool IsGroup(void) const
bool IsBroadcast(void) const
static Mac48Address ConvertFrom(const Address &address)
AttributeValue implementation for Mac48Address.
Network layer to device interface.
Definition: net-device.h:96
PacketType
Packet types are used as they are in Linux.
Definition: net-device.h:297
Callback< bool, Ptr< NetDevice >, Ptr< const Packet >, uint16_t, const Address & > ReceiveCallback
Definition: net-device.h:318
uint32_t GetId(void) const
Definition: node.cc:109
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
virtual void DoInitialize(void)
Initialize() implementation.
Definition: object.cc:353
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:378
uint64_t GetUid(void) const
Returns the packet's Uid.
Definition: packet.cc:390
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
static void Cancel(const EventId &id)
Set the cancel bit on this event: the event's associated function will not be invoked when it expires...
Definition: simulator.cc:268
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:556
static void ScheduleWithContext(uint32_t context, Time const &delay, FUNC f, Ts &&... args)
Schedule an event with the given context.
Definition: simulator.h:571
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
AttributeValue implementation for Time.
Definition: nstime.h:1308
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
Hold an unsigned integer type.
Definition: uinteger.h:44
#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:88
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:205
Ptr< const AttributeAccessor > MakeMac48AddressAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Ptr< const AttributeChecker > MakeMac48AddressChecker(void)
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:1309
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
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
static void RemovePIHeader(uint8_t *&buf, ssize_t &len)
Removes PI header.
static void AddPIHeader(uint8_t *&buf, size_t &len)
Synthesize PI header for the kernel.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:265
EventImpl * MakeEvent(void(*f)(void))
Make an EventImpl from a function pointer taking varying numbers of arguments.
Definition: make-event.cc:34
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
address
Definition: first.py:44
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeChecker > MakeEnumChecker(int v, std::string n, Ts... args)
Make an EnumChecker pre-configured with a set of allowed values by name.
Definition: enum.h:162
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:522
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:1648
A structure representing data read.