A Discrete-Event Network Simulator
API
point-to-point-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) 2007, 2008 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 
19 #include "ns3/log.h"
20 #include "ns3/queue.h"
21 #include "ns3/simulator.h"
22 #include "ns3/mac48-address.h"
23 #include "ns3/llc-snap-header.h"
24 #include "ns3/error-model.h"
25 #include "ns3/trace-source-accessor.h"
26 #include "ns3/uinteger.h"
27 #include "ns3/pointer.h"
29 #include "point-to-point-channel.h"
30 #include "ppp-header.h"
31 
32 namespace ns3 {
33 
34 NS_LOG_COMPONENT_DEFINE ("PointToPointNetDevice");
35 
36 NS_OBJECT_ENSURE_REGISTERED (PointToPointNetDevice);
37 
38 TypeId
40 {
41  static TypeId tid = TypeId ("ns3::PointToPointNetDevice")
42  .SetParent<NetDevice> ()
43  .SetGroupName ("PointToPoint")
44  .AddConstructor<PointToPointNetDevice> ()
45  .AddAttribute ("Mtu", "The MAC-level Maximum Transmission Unit",
49  MakeUintegerChecker<uint16_t> ())
50  .AddAttribute ("Address",
51  "The MAC address of this device.",
52  Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
55  .AddAttribute ("DataRate",
56  "The default data rate for point to point links",
57  DataRateValue (DataRate ("32768b/s")),
60  .AddAttribute ("ReceiveErrorModel",
61  "The receiver error model used to simulate packet loss",
62  PointerValue (),
64  MakePointerChecker<ErrorModel> ())
65  .AddAttribute ("InterframeGap",
66  "The time to wait between packet (frame) transmissions",
67  TimeValue (Seconds (0.0)),
69  MakeTimeChecker ())
70 
71  //
72  // Transmit queueing discipline for the device which includes its own set
73  // of trace hooks.
74  //
75  .AddAttribute ("TxQueue",
76  "A queue to use as the transmit queue in the device.",
77  PointerValue (),
80 
81  //
82  // Trace sources at the "top" of the net device, where packets transition
83  // to/from higher layers.
84  //
85  .AddTraceSource ("MacTx",
86  "Trace source indicating a packet has arrived "
87  "for transmission by this device",
89  "ns3::Packet::TracedCallback")
90  .AddTraceSource ("MacTxDrop",
91  "Trace source indicating a packet has been dropped "
92  "by the device before transmission",
94  "ns3::Packet::TracedCallback")
95  .AddTraceSource ("MacPromiscRx",
96  "A packet has been received by this device, "
97  "has been passed up from the physical layer "
98  "and is being forwarded up the local protocol stack. "
99  "This is a promiscuous trace,",
101  "ns3::Packet::TracedCallback")
102  .AddTraceSource ("MacRx",
103  "A packet has been received by this device, "
104  "has been passed up from the physical layer "
105  "and is being forwarded up the local protocol stack. "
106  "This is a non-promiscuous trace,",
108  "ns3::Packet::TracedCallback")
109 #if 0
110  // Not currently implemented for this device
111  .AddTraceSource ("MacRxDrop",
112  "Trace source indicating a packet was dropped "
113  "before being forwarded up the stack",
115  "ns3::Packet::TracedCallback")
116 #endif
117  //
118  // Trace sources at the "bottom" of the net device, where packets transition
119  // to/from the channel.
120  //
121  .AddTraceSource ("PhyTxBegin",
122  "Trace source indicating a packet has begun "
123  "transmitting over the channel",
125  "ns3::Packet::TracedCallback")
126  .AddTraceSource ("PhyTxEnd",
127  "Trace source indicating a packet has been "
128  "completely transmitted over the channel",
130  "ns3::Packet::TracedCallback")
131  .AddTraceSource ("PhyTxDrop",
132  "Trace source indicating a packet has been "
133  "dropped by the device during transmission",
135  "ns3::Packet::TracedCallback")
136 #if 0
137  // Not currently implemented for this device
138  .AddTraceSource ("PhyRxBegin",
139  "Trace source indicating a packet has begun "
140  "being received by the device",
142  "ns3::Packet::TracedCallback")
143 #endif
144  .AddTraceSource ("PhyRxEnd",
145  "Trace source indicating a packet has been "
146  "completely received by the device",
148  "ns3::Packet::TracedCallback")
149  .AddTraceSource ("PhyRxDrop",
150  "Trace source indicating a packet has been "
151  "dropped by the device during reception",
153  "ns3::Packet::TracedCallback")
154 
155  //
156  // Trace sources designed to simulate a packet sniffer facility (tcpdump).
157  // Note that there is really no difference between promiscuous and
158  // non-promiscuous traces in a point-to-point link.
159  //
160  .AddTraceSource ("Sniffer",
161  "Trace source simulating a non-promiscuous packet sniffer "
162  "attached to the device",
164  "ns3::Packet::TracedCallback")
165  .AddTraceSource ("PromiscSniffer",
166  "Trace source simulating a promiscuous packet sniffer "
167  "attached to the device",
169  "ns3::Packet::TracedCallback")
170  ;
171  return tid;
172 }
173 
174 
176  :
177  m_txMachineState (READY),
178  m_channel (0),
179  m_linkUp (false),
180  m_currentPkt (0)
181 {
182  NS_LOG_FUNCTION (this);
183 }
184 
186 {
187  NS_LOG_FUNCTION (this);
188 }
189 
190 void
191 PointToPointNetDevice::AddHeader (Ptr<Packet> p, uint16_t protocolNumber)
192 {
193  NS_LOG_FUNCTION (this << p << protocolNumber);
194  PppHeader ppp;
195  ppp.SetProtocol (EtherToPpp (protocolNumber));
196  p->AddHeader (ppp);
197 }
198 
199 bool
201 {
202  NS_LOG_FUNCTION (this << p << param);
203  PppHeader ppp;
204  p->RemoveHeader (ppp);
205  param = PppToEther (ppp.GetProtocol ());
206  return true;
207 }
208 
209 void
211 {
212  NS_LOG_FUNCTION (this);
213  m_node = 0;
214  m_channel = 0;
216  m_currentPkt = 0;
217  m_queue = 0;
219 }
220 
221 void
223 {
224  NS_LOG_FUNCTION (this);
225  m_bps = bps;
226 }
227 
228 void
230 {
231  NS_LOG_FUNCTION (this << t.GetSeconds ());
232  m_tInterframeGap = t;
233 }
234 
235 bool
237 {
238  NS_LOG_FUNCTION (this << p);
239  NS_LOG_LOGIC ("UID is " << p->GetUid () << ")");
240 
241  //
242  // This function is called to start the process of transmitting a packet.
243  // We need to tell the channel that we've started wiggling the wire and
244  // schedule an event that will be executed when the transmission is complete.
245  //
246  NS_ASSERT_MSG (m_txMachineState == READY, "Must be READY to transmit");
248  m_currentPkt = p;
250 
251  Time txTime = m_bps.CalculateBytesTxTime (p->GetSize ());
252  Time txCompleteTime = txTime + m_tInterframeGap;
253 
254  NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << txCompleteTime.GetSeconds () << "sec");
256 
257  bool result = m_channel->TransmitStart (p, this, txTime);
258  if (result == false)
259  {
260  m_phyTxDropTrace (p);
261  }
262  return result;
263 }
264 
265 void
267 {
268  NS_LOG_FUNCTION (this);
269 
270  //
271  // This function is called to when we're all done transmitting a packet.
272  // We try and pull another packet off of the transmit queue. If the queue
273  // is empty, we are done, otherwise we need to start transmitting the
274  // next packet.
275  //
276  NS_ASSERT_MSG (m_txMachineState == BUSY, "Must be BUSY if transmitting");
278 
279  NS_ASSERT_MSG (m_currentPkt != 0, "PointToPointNetDevice::TransmitComplete(): m_currentPkt zero");
280 
282  m_currentPkt = 0;
283 
284  Ptr<Packet> p = m_queue->Dequeue ();
285  if (p == 0)
286  {
287  NS_LOG_LOGIC ("No pending packets in device queue after tx complete");
288  return;
289  }
290 
291  //
292  // Got another packet off of the queue, so start the transmit process again.
293  //
294  m_snifferTrace (p);
296  TransmitStart (p);
297 }
298 
299 bool
301 {
302  NS_LOG_FUNCTION (this << &ch);
303 
304  m_channel = ch;
305 
306  m_channel->Attach (this);
307 
308  //
309  // This device is up whenever it is attached to a channel. A better plan
310  // would be to have the link come up when both devices are attached, but this
311  // is not done for now.
312  //
313  NotifyLinkUp ();
314  return true;
315 }
316 
317 void
319 {
320  NS_LOG_FUNCTION (this << q);
321  m_queue = q;
322 }
323 
324 void
326 {
327  NS_LOG_FUNCTION (this << em);
328  m_receiveErrorModel = em;
329 }
330 
331 void
333 {
334  NS_LOG_FUNCTION (this << packet);
335  uint16_t protocol = 0;
336 
337  if (m_receiveErrorModel && m_receiveErrorModel->IsCorrupt (packet) )
338  {
339  //
340  // If we have an error model and it indicates that it is time to lose a
341  // corrupted packet, don't forward this packet up, let it go.
342  //
343  m_phyRxDropTrace (packet);
344  }
345  else
346  {
347  //
348  // Hit the trace hooks. All of these hooks are in the same place in this
349  // device because it is so simple, but this is not usually the case in
350  // more complicated devices.
351  //
352  m_snifferTrace (packet);
353  m_promiscSnifferTrace (packet);
354  m_phyRxEndTrace (packet);
355 
356  //
357  // Trace sinks will expect complete packets, not packets without some of the
358  // headers.
359  //
360  Ptr<Packet> originalPacket = packet->Copy ();
361 
362  //
363  // Strip off the point-to-point protocol header and forward this packet
364  // up the protocol stack. Since this is a simple point-to-point link,
365  // there is no difference in what the promisc callback sees and what the
366  // normal receive callback sees.
367  //
368  ProcessHeader (packet, protocol);
369 
370  if (!m_promiscCallback.IsNull ())
371  {
372  m_macPromiscRxTrace (originalPacket);
373  m_promiscCallback (this, packet, protocol, GetRemote (), GetAddress (), NetDevice::PACKET_HOST);
374  }
375 
376  m_macRxTrace (originalPacket);
377  m_rxCallback (this, packet, protocol, GetRemote ());
378  }
379 }
380 
383 {
384  NS_LOG_FUNCTION (this);
385  return m_queue;
386 }
387 
388 void
390 {
391  NS_LOG_FUNCTION (this);
392  m_linkUp = true;
394 }
395 
396 void
397 PointToPointNetDevice::SetIfIndex (const uint32_t index)
398 {
399  NS_LOG_FUNCTION (this);
400  m_ifIndex = index;
401 }
402 
403 uint32_t
405 {
406  return m_ifIndex;
407 }
408 
411 {
412  return m_channel;
413 }
414 
415 //
416 // This is a point-to-point device, so we really don't need any kind of address
417 // information. However, the base class NetDevice wants us to define the
418 // methods to get and set the address. Rather than be rude and assert, we let
419 // clients get and set the address, but simply ignore them.
420 
421 void
423 {
424  NS_LOG_FUNCTION (this << address);
426 }
427 
428 Address
430 {
431  return m_address;
432 }
433 
434 bool
436 {
437  NS_LOG_FUNCTION (this);
438  return m_linkUp;
439 }
440 
441 void
443 {
444  NS_LOG_FUNCTION (this);
446 }
447 
448 //
449 // This is a point-to-point device, so every transmission is a broadcast to
450 // all of the devices on the network.
451 //
452 bool
454 {
455  NS_LOG_FUNCTION (this);
456  return true;
457 }
458 
459 //
460 // We don't really need any addressing information since this is a
461 // point-to-point device. The base class NetDevice wants us to return a
462 // broadcast address, so we make up something reasonable.
463 //
464 Address
466 {
467  NS_LOG_FUNCTION (this);
468  return Mac48Address ("ff:ff:ff:ff:ff:ff");
469 }
470 
471 bool
473 {
474  NS_LOG_FUNCTION (this);
475  return true;
476 }
477 
478 Address
480 {
481  NS_LOG_FUNCTION (this);
482  return Mac48Address ("01:00:5e:00:00:00");
483 }
484 
485 Address
487 {
488  NS_LOG_FUNCTION (this << addr);
489  return Mac48Address ("33:33:00:00:00:00");
490 }
491 
492 bool
494 {
495  NS_LOG_FUNCTION (this);
496  return true;
497 }
498 
499 bool
501 {
502  NS_LOG_FUNCTION (this);
503  return false;
504 }
505 
506 bool
508  Ptr<Packet> packet,
509  const Address &dest,
510  uint16_t protocolNumber)
511 {
512  NS_LOG_FUNCTION (this << packet << dest << protocolNumber);
513  NS_LOG_LOGIC ("p=" << packet << ", dest=" << &dest);
514  NS_LOG_LOGIC ("UID is " << packet->GetUid ());
515 
516  //
517  // If IsLinkUp() is false it means there is no channel to send any packet
518  // over so we just hit the drop trace on the packet and return an error.
519  //
520  if (IsLinkUp () == false)
521  {
522  m_macTxDropTrace (packet);
523  return false;
524  }
525 
526  //
527  // Stick a point to point protocol header on the packet in preparation for
528  // shoving it out the door.
529  //
530  AddHeader (packet, protocolNumber);
531 
532  m_macTxTrace (packet);
533 
534  //
535  // We should enqueue and dequeue the packet to hit the tracing hooks.
536  //
537  if (m_queue->Enqueue (packet))
538  {
539  //
540  // If the channel is ready for transition we send the packet right now
541  //
542  if (m_txMachineState == READY)
543  {
544  packet = m_queue->Dequeue ();
545  m_snifferTrace (packet);
546  m_promiscSnifferTrace (packet);
547  bool ret = TransmitStart (packet);
548  return ret;
549  }
550  return true;
551  }
552 
553  // Enqueue may fail (overflow)
554 
555  m_macTxDropTrace (packet);
556  return false;
557 }
558 
559 bool
561  const Address &source,
562  const Address &dest,
563  uint16_t protocolNumber)
564 {
565  NS_LOG_FUNCTION (this << packet << source << dest << protocolNumber);
566  return false;
567 }
568 
569 Ptr<Node>
571 {
572  return m_node;
573 }
574 
575 void
577 {
578  NS_LOG_FUNCTION (this);
579  m_node = node;
580 }
581 
582 bool
584 {
585  NS_LOG_FUNCTION (this);
586  return false;
587 }
588 
589 void
591 {
592  m_rxCallback = cb;
593 }
594 
595 void
597 {
598  m_promiscCallback = cb;
599 }
600 
601 bool
603 {
604  NS_LOG_FUNCTION (this);
605  return false;
606 }
607 
608 void
610 {
611  NS_LOG_FUNCTION (this << p);
612  Receive (p);
613 }
614 
615 Address
617 {
618  NS_LOG_FUNCTION (this);
619  NS_ASSERT (m_channel->GetNDevices () == 2);
620  for (std::size_t i = 0; i < m_channel->GetNDevices (); ++i)
621  {
622  Ptr<NetDevice> tmp = m_channel->GetDevice (i);
623  if (tmp != this)
624  {
625  return tmp->GetAddress ();
626  }
627  }
628  NS_ASSERT (false);
629  // quiet compiler.
630  return Address ();
631 }
632 
633 bool
635 {
636  NS_LOG_FUNCTION (this << mtu);
637  m_mtu = mtu;
638  return true;
639 }
640 
641 uint16_t
643 {
644  NS_LOG_FUNCTION (this);
645  return m_mtu;
646 }
647 
648 uint16_t
650 {
652  switch(proto)
653  {
654  case 0x0021: return 0x0800; //IPv4
655  case 0x0057: return 0x86DD; //IPv6
656  default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
657  }
658  return 0;
659 }
660 
661 uint16_t
663 {
665  switch(proto)
666  {
667  case 0x0800: return 0x0021; //IPv4
668  case 0x86DD: return 0x0057; //IPv6
669  default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
670  }
671  return 0;
672 }
673 
674 
675 } // namespace ns3
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
virtual uint16_t GetMtu(void) const
void SetReceiveErrorModel(Ptr< ErrorModel > em)
Attach a receive ErrorModel to the PointToPointNetDevice.
PointToPointNetDevice()
Construct a PointToPointNetDevice.
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
NetDevice::ReceiveCallback m_rxCallback
Receive callback.
void NotifyLinkUp(void)
Make the link up and running.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
static TypeId GetTypeId(void)
Get the TypeId.
The transmitter is busy transmitting a packet.
virtual uint32_t GetIfIndex(void) const
TracedCallback< Ptr< const Packet > > m_phyTxDropTrace
The trace source fired when the phy layer drops a packet before it tries to transmit it...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
uint32_t m_mtu
The Maximum Transmission Unit.
Ptr< AttributeChecker > MakePointerChecker(void)
Create a PointerChecker for a type.
Definition: pointer.h:231
virtual ~PointToPointNetDevice()
Destroy a PointToPointNetDevice.
static const uint16_t DEFAULT_MTU
Default MTU.
TracedCallback< Ptr< const Packet > > m_phyRxEndTrace
The trace source fired when a packet ends the reception process from the medium.
Ptr< Node > m_node
Node owning this NetDevice.
TracedCallback< Ptr< const Packet > > m_phyRxDropTrace
The trace source fired when the phy layer drops a packet it has received.
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:355
virtual Ptr< Channel > GetChannel(void) const
#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
TracedCallback< Ptr< const Packet > > m_phyTxBeginTrace
The trace source fired when a packet begins the transmission process on the medium.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Ptr< Packet > m_currentPkt
Current packet processed.
virtual Ptr< Node > GetNode(void) const
static uint16_t EtherToPpp(uint16_t protocol)
Ethernet to PPP protocol number mapping.
Ptr< const AttributeChecker > MakeMac48AddressChecker(void)
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
virtual Address GetBroadcast(void) const
Ptr< Queue< Packet > > m_queue
The Queue which this PointToPointNetDevice uses as a packet source.
TracedCallback< Ptr< const Packet > > m_macRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
Ptr< const AttributeAccessor > MakeMac48AddressAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
The transmitter is ready to begin transmission of a packet.
bool ProcessHeader(Ptr< Packet > p, uint16_t &param)
Removes, from a packet of data, all headers and trailers that relate to the protocol implemented by t...
a polymophic address class
Definition: address.h:90
Packet header for PPP.
Definition: ppp-header.h:48
Ptr< const AttributeChecker > MakeDataRateChecker(void)
Definition: data-rate.cc:30
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:449
static uint16_t PppToEther(uint16_t protocol)
PPP to Ethernet protocol number mapping.
Class for representing data rates.
Definition: data-rate.h:88
virtual bool IsPointToPoint(void) const
Return true if the net device is on a point-to-point link.
virtual void SetPromiscReceiveCallback(PromiscReceiveCallback cb)
void SetProtocol(uint16_t protocol)
Set the protocol type carried by this PPP packet.
Definition: ppp-header.cc:96
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:227
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1390
virtual void SetAddress(Address address)
Set the address of this interface.
AttributeValue implementation for Time.
Definition: nstime.h:1126
Hold an unsigned integer type.
Definition: uinteger.h:44
void TransmitComplete(void)
Stop Sending a Packet Down the Wire and Begin the Interframe Gap.
TracedCallback m_linkChangeCallbacks
Callback for the link change event.
TracedCallback< Ptr< const Packet > > m_snifferTrace
A trace source that emulates a non-promiscuous protocol sniffer connected to the device.
bool TransmitStart(Ptr< Packet > p)
Start Sending a Packet Down the Wire.
void SetInterframeGap(Time t)
Set the interframe gap used to separate packets.
NetDevice::PromiscReceiveCallback m_promiscCallback
Receive callback.
Mac48Address m_address
Mac48Address of this NetDevice.
uint16_t GetProtocol(void)
Get the protocol type carried by this PPP packet.
Definition: ppp-header.cc:102
Ptr< const AttributeAccessor > MakeDataRateAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: data-rate.h:242
Time m_tInterframeGap
The interframe gap that the Net Device uses to throttle packet transmission.
virtual void AddLinkChangeCallback(Callback< void > callback)
static Mac48Address ConvertFrom(const Address &address)
virtual void SetReceiveCallback(NetDevice::ReceiveCallback cb)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< Queue< Packet > > GetQueue(void) const
Get a copy of the attached Queue.
virtual Address GetMulticast(Ipv4Address multicastGroup) const
Make and return a MAC multicast address using the provided multicast group.
Hold objects of type Ptr<T>.
Definition: pointer.h:36
address
Definition: first.py:44
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
an EUI-48 address
Definition: mac48-address.h:43
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:1127
void DoMpiReceive(Ptr< Packet > p)
Handler for MPI receive event.
DataRate m_bps
The data rate that the Net Device uses to simulate packet transmission timing.
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
virtual bool IsBridge(void) const
Return true if the net device is acting as a bridge.
Ptr< PointToPointChannel > m_channel
The PointToPointChannel to which this PointToPointNetDevice has been attached.
TracedCallback< Ptr< const Packet > > m_promiscSnifferTrace
A trace source that emulates a promiscuous mode protocol sniffer connected to the device...
Ptr< ErrorModel > m_receiveErrorModel
Error model for receive packet events.
virtual bool SendFrom(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
Describes an IPv6 address.
Definition: ipv6-address.h:49
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
uint32_t m_ifIndex
Index of the interface.
TracedCallback< Ptr< const Packet > > m_macPromiscRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
virtual bool IsBroadcast(void) const
TracedCallback< Ptr< const Packet > > m_phyRxBeginTrace
The trace source fired when a packet begins the reception process from the medium – when the simulat...
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
TxMachineState m_txMachineState
The state of the Net Device transmit state machine.
Packet addressed oo us.
Definition: net-device.h:298
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...
Network layer to device interface.
Definition: net-device.h:95
virtual bool SetMtu(const uint16_t mtu)
virtual void SetIfIndex(const uint32_t index)
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
AttributeValue implementation for Mac48Address.
virtual Address GetAddress(void) const
void SetDataRate(DataRate bps)
Set the Data Rate used for transmission of packets.
TracedCallback< Ptr< const Packet > > m_macRxDropTrace
The trace source fired for packets successfully received by the device but are dropped before being f...
void Receive(Ptr< Packet > p)
Receive a packet from a connected PointToPointChannel.
virtual bool IsMulticast(void) const
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1064
bool Attach(Ptr< PointToPointChannel > ch)
Attach the device to a channel.
virtual void DoDispose(void)
Dispose of the object.
virtual void SetNode(Ptr< Node > node)
bool m_linkUp
Identify if the link is up or not.
virtual bool SupportsSendFrom(void) const
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:1372
void AddHeader(Ptr< Packet > p, uint16_t protocolNumber)
Adds the necessary headers and trailers to a packet of data in order to respect the protocol implemen...
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
Time CalculateBytesTxTime(uint32_t bytes) const
Calculate transmission time.
Definition: data-rate.cc:235
TracedCallback< Ptr< const Packet > > m_macTxTrace
The trace source fired when packets come into the "top" of the device at the L3/L2 transition...
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
void SetQueue(Ptr< Queue< Packet > > queue)
Attach a queue to the PointToPointNetDevice.
TracedCallback< Ptr< const Packet > > m_phyTxEndTrace
The trace source fired when a packet ends the transmission process on the medium. ...