ns3::PointToPointNetDevice Class Reference

A Device for a Point to Point Network Link. More...

#include <point-to-point-net-device.h>

Inheritance diagram for ns3::PointToPointNetDevice:

Inheritance graph
[legend]
Collaboration diagram for ns3::PointToPointNetDevice:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 PointToPointNetDevice ()
virtual ~PointToPointNetDevice ()
void SetDataRate (DataRate bps)
void SetInterframeGap (Time t)
bool Attach (Ptr< PointToPointChannel > ch)
void SetQueue (Ptr< Queue > queue)
void SetReceiveErrorModel (Ptr< ErrorModel > em)
void Receive (Ptr< Packet > p)
void SetFrameSize (uint16_t frameSize)
uint16_t GetFrameSize (void) const
virtual void SetIfIndex (const uint32_t index)
virtual uint32_t GetIfIndex (void) const
virtual Ptr< ChannelGetChannel (void) const
virtual void SetAddress (Address address)
virtual Address GetAddress (void) const
virtual bool SetMtu (const uint16_t mtu)
virtual uint16_t GetMtu (void) const
virtual bool IsLinkUp (void) const
virtual void SetLinkChangeCallback (Callback< void > callback)
virtual bool IsBroadcast (void) const
virtual Address GetBroadcast (void) const
virtual bool IsMulticast (void) const
virtual Address GetMulticast (Ipv4Address multicastGroup) const
 Make and return a MAC multicast address using the provided multicast group.
virtual bool IsPointToPoint (void) const
 Return true if the net device is on a point-to-point link.
virtual bool IsBridge (void) const
 Return true if the net device is acting as a bridge.
virtual bool Send (Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
virtual bool SendFrom (Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
virtual Ptr< NodeGetNode (void) const
virtual void SetNode (Ptr< Node > node)
virtual bool NeedsArp (void) const
virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb)
virtual Address GetMulticast (Ipv6Address addr) const
 Get the MAC multicast address corresponding to the IPv6 address provided.
virtual void SetPromiscReceiveCallback (PromiscReceiveCallback cb)
virtual bool SupportsSendFrom (void) const

Static Public Member Functions

static TypeId GetTypeId (void)
 This method returns the TypeId associated to ns3::PointToPointNetDevice.

Private Types

enum  TxMachineState { READY, BUSY }

Private Member Functions

virtual void DoDispose (void)
Ptr< QueueGetQueue (void) const
uint32_t MtuFromFrameSize (uint32_t frameSize)
uint32_t FrameSizeFromMtu (uint32_t mtu)
Address GetRemote (void) const
void AddHeader (Ptr< Packet > p, uint16_t protocolNumber)
bool ProcessHeader (Ptr< Packet > p, uint16_t &param)
bool TransmitStart (Ptr< Packet > p)
void TransmitComplete (void)

Private Attributes

TxMachineState m_txMachineState
DataRate m_bps
Time m_tInterframeGap
Ptr< PointToPointChannelm_channel
Ptr< Queuem_queue
Ptr< ErrorModelm_receiveErrorModel
TracedCallback< Ptr< const
Packet > > 
m_macTxTrace
TracedCallback< Ptr< const
Packet > > 
m_macTxDropTrace
TracedCallback< Ptr< const
Packet > > 
m_macPromiscRxTrace
TracedCallback< Ptr< const
Packet > > 
m_macRxTrace
TracedCallback< Ptr< const
Packet > > 
m_macRxDropTrace
TracedCallback< Ptr< const
Packet > > 
m_phyTxBeginTrace
TracedCallback< Ptr< const
Packet > > 
m_phyTxEndTrace
TracedCallback< Ptr< const
Packet > > 
m_phyTxDropTrace
TracedCallback< Ptr< const
Packet > > 
m_phyRxBeginTrace
TracedCallback< Ptr< const
Packet > > 
m_phyRxEndTrace
TracedCallback< Ptr< const
Packet > > 
m_phyRxDropTrace
TracedCallback< Ptr< const
Packet > > 
m_snifferTrace
TracedCallback< Ptr< const
Packet > > 
m_promiscSnifferTrace
uint32_t m_frameSize
uint32_t m_mtu


Detailed Description

A Device for a Point to Point Network Link.

This PointToPointNetDevice class specializes the NetDevice abstract base class. Together with a PointToPointChannel (and a peer PointToPointNetDevice), the class models, with some level of abstraction, a generic point-to-point or serial link. Key parameters or objects that can be specified for this device include a queue, data rate, and interframe transmission gap (the propagation delay is set in the PointToPointChannel).


Member Enumeration Documentation

Enumeration of the states of the transmit machine of the net device.

Enumerator:
READY  The transmitter is ready to begin transmission of a packet
BUSY  The transmitter is busy transmitting a packet


Constructor & Destructor Documentation

ns3::PointToPointNetDevice::PointToPointNetDevice (  ) 

Construct a PointToPointNetDevice

This is the constructor for the PointToPointNetDevice. It takes as a parameter a pointer to the Node to which this device is connected, as well as an optional DataRate object.

virtual ns3::PointToPointNetDevice::~PointToPointNetDevice (  )  [virtual]

Destroy a PointToPointNetDevice

This is the destructor for the PointToPointNetDevice.


Member Function Documentation

void ns3::PointToPointNetDevice::AddHeader ( Ptr< Packet p,
uint16_t  protocolNumber 
) [private]

Adds the necessary headers and trailers to a packet of data in order to respect the protocol implemented by the agent.

bool ns3::PointToPointNetDevice::Attach ( Ptr< PointToPointChannel ch  ) 

Attach the device to a channel.

Parameters:
ch Ptr to the channel to which this object is being attached.

virtual void ns3::PointToPointNetDevice::DoDispose ( void   )  [private, virtual]

This method is called by Object::Dispose or by the object's destructor, whichever comes first.

Subclasses are expected to implement their real destruction code in an overriden version of this method and chain up to their parent's implementation once they are done. i.e., for simplicity, the destructor of every subclass should be empty and its content should be moved to the associated DoDispose method.

Reimplemented from ns3::Object.

uint32_t ns3::PointToPointNetDevice::FrameSizeFromMtu ( uint32_t  mtu  )  [private]

Calculate the value for the frame size that would be required to be able to set the MTU to the given value.

virtual Address ns3::PointToPointNetDevice::GetAddress ( void   )  const [virtual]

Returns:
the current Address of this interface.

Implements ns3::NetDevice.

virtual Address ns3::PointToPointNetDevice::GetBroadcast ( void   )  const [virtual]

Returns:
the broadcast address supported by this netdevice.
Calling this method is invalid if IsBroadcast returns not true.

Implements ns3::NetDevice.

virtual Ptr<Channel> ns3::PointToPointNetDevice::GetChannel ( void   )  const [virtual]

Returns:
the channel this NetDevice is connected to. The value returned can be zero if the NetDevice is not yet connected to any channel or if the underlying NetDevice has no concept of a channel. i.e., callers _must_ check for zero and be ready to handle it.

Implements ns3::NetDevice.

uint16_t ns3::PointToPointNetDevice::GetFrameSize ( void   )  const

Get The max frame size of packets sent over this device.

Returns:
The max frame size of packets sent over this device.

virtual uint32_t ns3::PointToPointNetDevice::GetIfIndex ( void   )  const [virtual]

Returns:
index ifIndex of the device

Implements ns3::NetDevice.

virtual uint16_t ns3::PointToPointNetDevice::GetMtu ( void   )  const [virtual]

Returns:
the link-level MTU in bytes for this interface.
This value is typically used by the IP layer to perform IP fragmentation when needed.

Implements ns3::NetDevice.

virtual Address ns3::PointToPointNetDevice::GetMulticast ( Ipv6Address  addr  )  const [virtual]

Get the MAC multicast address corresponding to the IPv6 address provided.

Parameters:
addr IPv6 address
Returns:
the MAC multicast address
Warning:
Calling this method is invalid if IsMulticast returns not true.

Implements ns3::NetDevice.

virtual Address ns3::PointToPointNetDevice::GetMulticast ( Ipv4Address  multicastGroup  )  const [virtual]

Make and return a MAC multicast address using the provided multicast group.

RFC 1112 says that an Ipv4 host group address is mapped to an Ethernet multicast address by placing the low-order 23-bits of the IP address into the low-order 23 bits of the Ethernet multicast address 01-00-5E-00-00-00 (hex). Similar RFCs exist for Ipv6 and Eui64 mappings. This method performs the multicast address creation function appropriate to the underlying MAC address of the device. This MAC address is encapsulated in an abstract Address to avoid dependencies on the exact MAC address format.

A default imlementation of GetMulticast is provided, but this method simply NS_ASSERTS. In the case of net devices that do not support multicast, clients are expected to test NetDevice::IsMulticast and avoid attempting to map multicast packets. Subclasses of NetDevice that do support multicasting are expected to override this method and provide an implementation appropriate to the particular device.

Parameters:
multicastGroup The IP address for the multicast group destination of the packet.
Returns:
The MAC multicast Address used to send packets to the provided multicast group.
Warning:
Calling this method is invalid if IsMulticast returns not true.
See also:
Ipv4Address

Address

NetDevice::IsMulticast

Implements ns3::NetDevice.

virtual Ptr<Node> ns3::PointToPointNetDevice::GetNode ( void   )  const [virtual]

Returns:
the node base class which contains this network interface.
When a subclass needs to get access to the underlying node base class to print the nodeid for example, it can invoke this method.

Implements ns3::NetDevice.

Ptr<Queue> ns3::PointToPointNetDevice::GetQueue ( void   )  const [private]

Get a copy of the attached Queue.

This method is provided for any derived class that may need to get direct access to the underlying queue.

Returns:
Ptr to the queue.

Address ns3::PointToPointNetDevice::GetRemote ( void   )  const [private]

Returns:
the address of the remote device connected to this device through the point to point channel.

static TypeId ns3::PointToPointNetDevice::GetTypeId ( void   )  [static]

This method returns the TypeId associated to ns3::PointToPointNetDevice.

This object is accessible through the following paths with Config::Set and Config::Connect:

  • /NodeList/[i]/DeviceList/[i]/$ns3::PointToPointNetDevice
Attributes defined for this type:
  • Address: The MAC address of this device.
  • FrameSize: The maximum size of a packet sent over this device.
  • DataRate: The default data rate for point to point links
    • Set with class: DataRateValue
    • Underlying type: DataRate
    • Initial value: 32768bps
    • Flags: construct write read
  • ReceiveErrorModel: The receiver error model used to simulate packet loss
  • InterframeGap: The time to wait between packet (frame) transmissions
    • Set with class: TimeValue
    • Underlying type: Time
    • Initial value: 0ns
    • Flags: construct write read
  • TxQueue: A queue to use as the transmit queue in the device.
Attributes defined in parent class ns3::NetDevice:
  • Mtu: The MAC-level Maximum Transmission Unit
TraceSources defined for this type:
  • MacTx: Trace source indicating a packet has arrived for transmission by this device
  • MacTxDrop: Trace source indicating a packet has been dropped by the device before transmission
  • MacPromiscRx: A packet has been received by this device, has been passed up from the physical layer and is being forwarded up the local protocol stack. This is a promiscuous trace,
  • MacRx: A packet has been received by this device, has been passed up from the physical layer and is being forwarded up the local protocol stack. This is a non-promiscuous trace,
  • PhyTxBegin: Trace source indicating a packet has begun transmitting over the channel
  • PhyTxEnd: Trace source indicating a packet has been completely transmitted over the channel
  • PhyTxDrop: Trace source indicating a packet has been dropped by the device during transmission
  • PhyRxEnd: Trace source indicating a packet has been completely received by the device
  • PhyRxDrop: Trace source indicating a packet has been dropped by the device during reception
  • Sniffer: Trace source simulating a non-promiscuous packet sniffer attached to the device
  • PromiscSniffer: Trace source simulating a promiscuous packet sniffer attached to the device

Reimplemented from ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::IsBridge ( void   )  const [virtual]

Return true if the net device is acting as a bridge.

Returns:
value of m_isBridge flag

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::IsBroadcast ( void   )  const [virtual]

Returns:
true if this interface supports a broadcast address, false otherwise.

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::IsLinkUp ( void   )  const [virtual]

Returns:
true if link is up; false otherwise

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::IsMulticast ( void   )  const [virtual]

Returns:
value of m_isMulticast flag

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::IsPointToPoint ( void   )  const [virtual]

Return true if the net device is on a point-to-point link.

Returns:
value of m_isPointToPoint flag

Implements ns3::NetDevice.

uint32_t ns3::PointToPointNetDevice::MtuFromFrameSize ( uint32_t  frameSize  )  [private]

Calculate the value for the MTU that would result from setting the frame size to the given value.

virtual bool ns3::PointToPointNetDevice::NeedsArp ( void   )  const [virtual]

Returns:
true if ARP is needed, false otherwise.
Called by higher-layers to check if this NetDevice requires ARP to be used.

Implements ns3::NetDevice.

bool ns3::PointToPointNetDevice::ProcessHeader ( Ptr< Packet p,
uint16_t &  param 
) [private]

Removes, from a packet of data, all headers and trailers that relate to the protocol implemented by the agent

Returns:
Returns true if the packet should be forwarded up the protocol stack.

void ns3::PointToPointNetDevice::Receive ( Ptr< Packet p  ) 

Receive a packet from a connected PointToPointChannel.

The PointToPointNetDevice receives packets from its connected channel and forwards them up the protocol stack. This is the public method used by the channel to indicate that the last bit of a packet has arrived at the device.

See also:
PointToPointChannel
Parameters:
p Ptr to the received packet.

virtual bool ns3::PointToPointNetDevice::Send ( Ptr< Packet packet,
const Address dest,
uint16_t  protocolNumber 
) [virtual]

Parameters:
packet packet sent from above down to Network Device
dest mac address of the destination (already resolved)
protocolNumber identifies the type of payload contained in this packet. Used to call the right L3Protocol when the packet is received.
Called from higher layer to send packet into Network Device to the specified destination Address

Returns:
whether the Send operation succeeded

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::SendFrom ( Ptr< Packet packet,
const Address source,
const Address dest,
uint16_t  protocolNumber 
) [virtual]

Parameters:
packet packet sent from above down to Network Device
source source mac address (so called "MAC spoofing")
dest mac address of the destination (already resolved)
protocolNumber identifies the type of payload contained in this packet. Used to call the right L3Protocol when the packet is received.
Called from higher layer to send packet into Network Device with the specified source and destination Addresses.

Returns:
whether the Send operation succeeded

Implements ns3::NetDevice.

virtual void ns3::PointToPointNetDevice::SetAddress ( Address  address  )  [virtual]

Set the address of this interface

Implements ns3::NetDevice.

void ns3::PointToPointNetDevice::SetDataRate ( DataRate  bps  ) 

Set the Data Rate used for transmission of packets. The data rate is set in the Attach () method from the corresponding field in the channel to which the device is attached. It can be overridden using this method.

See also:
Attach ()
Parameters:
bps the data rate at which this object operates

void ns3::PointToPointNetDevice::SetFrameSize ( uint16_t  frameSize  ) 

Set The max frame size of packets sent over this device.

Okay, that was easy to say, but the details are a bit thorny. We have a MAC-level MTU that is the payload that higher level protocols see. We have a PHY-level MTU which is the maximum number of bytes we can send over the link (cf. 1500 bytes for Ethernet). We also have a frame size which is some total number of bytes in a packet which could or could not include any framing and overhead. There can be a lot of inconsistency in definitions of these terms. For example, RFC 1042 asserts that the terms maximum transmission unit and maximum packet size are equivalent. RFC 791, however, defines MTU as the maximum sized IP datagram that can be sent. Packet size and frame size are sometimes used interchangeably.

So, some careful definitions are in order to avoid confusion:

In real serial channel (HDLC, for example), the wire idles (sends all ones) until the channel begins sending a packet. A frame on the wire starts with a flag character (01111110). This is followed by what is usually called the packet: address, control, payload, and a Frame Check Sequence (FCS). This is followed by another flag character. If the flag characters are used, then bit stuffing must be used to prevent flag characters from appearing in the packet and confusing the link. Som to be strictly and pedantically correct the frame size is then necessarily larger than the packet size on a real link. But, this isn't a real link, it's a simulation of a device similar to a point-to-point device, and we have no good reason to add framing bits and therefore to do bit-stuffing. So, in the case of the point-to-point device, the frame size is equal to the packet size. Since these two values are defined to be equal, there is no danger in assuming they are identical. We define packet size to be equal to frame size and this excludes the flag characters. We define a single (MAC-level) MTU that coresponds to the payload size of the packet, which is the IP-centric view of the term as seen in RFC 791.

To make this concrete, consider PPP framing on a synchronous link. In this framing scheme, a real serial frame on the wire starts with a flag character, address and control characters, then a 16-bit PPP protocol ID (0x21 = IP). Then we would see the actual payload we are supposed to send, presumably an IP datagram. At then we see the FCS and finally another flag character to end the frame. We ignore the flag bits on this device since it they are not needed. We aren't really using HDLC to send frames across the link, so we don't need the address and control bits either. In fact, to encapsulate using unframed PPP all we need to do is prepend the two-byte protocol ID.

Typically the limiting factor in frame size is due to hardware limitations in the underlying HDLC controller receive FIFO buffer size. This number can vary widely. For example, the Motorola MC92460 has a 64 KByte maximum frame size; the Intel IXP4XX series has a 16 KByte size. Older USARTs have a maximum frame size around 2KBytes, and typical PPP links on the Internet have their MTU set to 1500 bytes since this is what will typically be used on Ethernet segments and will avoid path MTU issues. We choose to make the default MTU 1500 bytes which then fixes the maximum frame size as described below.

So, there are really two related variables at work here. There is the maximum frame size that can be sent over the link and there is the MTU.

So, what do we do since these values must always be consistent in the driver? We want to actually allow a user to change these variables, but we want the results (even at intermediate stages of her ultimate change) to be consistent. We certainly don't want to require that users must understand the details of PPP encapsulation in order to set these variables.

Consider the following situation: A user wants to set the maximum frame size to 16 KBytes. This user shouldn't have to concern herself that the PPP encapsulation will consume six bytes. She should not have to figure out that the MTU needs to be set to 16K - 2 bytes to make things consistent.

Similarly, a user who is interested in setting the MTU to 1500 bytes should not be forced to understand that the frame size will need to be set to 1502 bytes.

We could play games trying to figure out what the user wants to do, but that is typically a bad plan and programmers have a long and distinguished history of guessing wrong. We'll avoid all of that and just define a flexible behavior that can be worked to get what you want. Here it is:

  • If the user is changing the MTU, she is interested in getting that part of the system set, so the frame size will be changed to make it consistent;

  • If the user is changing the frame size, he is interested in getting that part of the system set, so the MTU will be changed to make it consistent;

  • You cannot define the MTU and frame size separately -- they are always tied together by the overhead of the PPP encapsulation. This is not a restriction. Consider what this means. Perhaps you want to set the frame size to some large number and the MTU to some small number. The largest packet you can send is going to be limited by the MTU, so it is not possible to send a frame larger than the MTU plus overhead. Having the ability to set a larger frame size is not useful.

So, if a user calls SetFrameSize, we assume that the maximum frame size is the interesting thing for that user and we just adjust the MTU to a new "correct value" based on the current encapsulation mode. If a user calls SetMtu, we assume that the MTU is the interesting property for that user, and we adjust the frame size to a new "correct value" for the current encapsulation mode. If a user calls SetEncapsulationMode, then we take the MTU as the free variable and set its value to match the current frame size.

Parameters:
frameSize The max frame size of packets sent over this device.

virtual void ns3::PointToPointNetDevice::SetIfIndex ( const uint32_t  index  )  [virtual]

Parameters:
index ifIndex of the device

Implements ns3::NetDevice.

void ns3::PointToPointNetDevice::SetInterframeGap ( Time  t  ) 

Set the inteframe gap used to separate packets. The interframe gap defines the minimum space required between packets sent by this device.

Parameters:
t the interframe gap time

virtual void ns3::PointToPointNetDevice::SetLinkChangeCallback ( Callback< void >  callback  )  [virtual]

Parameters:
callback the callback to invoke
Register a callback invoked whenever the link status changes to UP. This callback is typically used by the IP/ARP layer to flush the ARP cache whenever the link goes up.

Implements ns3::NetDevice.

virtual bool ns3::PointToPointNetDevice::SetMtu ( const uint16_t  mtu  )  [virtual]

Parameters:
mtu MTU value, in bytes, to set for the device
Returns:
whether the MTU value was within legal bounds
Override for default MTU defined on a per-type basis.

Implements ns3::NetDevice.

virtual void ns3::PointToPointNetDevice::SetNode ( Ptr< Node node  )  [virtual]

Parameters:
node the node associated to this netdevice.
This method is called from ns3::Node::AddDevice.

Implements ns3::NetDevice.

virtual void ns3::PointToPointNetDevice::SetPromiscReceiveCallback ( PromiscReceiveCallback  cb  )  [virtual]

Parameters:
cb callback to invoke whenever a packet has been received in promiscuous mode and must be forwarded to the higher layers.
Enables netdevice promiscuous mode and sets the callback that will handle promiscuous mode packets. Note, promiscuous mode packets means _all_ packets, including those packets that can be sensed by the netdevice but which are intended to be received by other hosts.

Implements ns3::NetDevice.

void ns3::PointToPointNetDevice::SetQueue ( Ptr< Queue queue  ) 

Attach a queue to the PointToPointNetDevice.

The PointToPointNetDevice "owns" a queue that implements a queueing method such as DropTail or RED.

See also:
Queue

DropTailQueue

Parameters:
queue Ptr to the new queue.

virtual void ns3::PointToPointNetDevice::SetReceiveCallback ( NetDevice::ReceiveCallback  cb  )  [virtual]

Parameters:
cb callback to invoke whenever a packet has been received and must be forwarded to the higher layers.

Implements ns3::NetDevice.

void ns3::PointToPointNetDevice::SetReceiveErrorModel ( Ptr< ErrorModel em  ) 

Attach a receive ErrorModel to the PointToPointNetDevice.

The PointToPointNetDevice may optionally include an ErrorModel in the packet receive chain.

See also:
ErrorModel
Parameters:
em Ptr to the ErrorModel.

virtual bool ns3::PointToPointNetDevice::SupportsSendFrom ( void   )  const [virtual]

Returns:
true if this interface supports a bridging mode, false otherwise.

Implements ns3::NetDevice.

void ns3::PointToPointNetDevice::TransmitComplete ( void   )  [private]

Stop Sending a Packet Down the Wire and Begin the Interframe Gap.

The TransmitComplete method is used internally to finish the process of sending a packet out on the channel.

bool ns3::PointToPointNetDevice::TransmitStart ( Ptr< Packet p  )  [private]

Start Sending a Packet Down the Wire.

The TransmitStart method is the method that is used internally in the PointToPointNetDevice to begin the process of sending a packet out on the channel. The corresponding method is called on the channel to let it know that the physical device this class represents has virually started sending signals. An event is scheduled for the time at which the bits have been completely transmitted.

See also:
PointToPointChannel::TransmitStart ()

TransmitCompleteEvent ()

Parameters:
p a reference to the packet to send
Returns:
true if success, false on failure


Member Data Documentation

The data rate that the Net Device uses to simulate packet transmission timing.

See also:
class DataRate

The PointToPointChannel to which this PointToPointNetDevice has been attached.

See also:
class PointToPointChannel

The frame size/packet size. This corresponds to the maximum number of bytes that can be transmitted as a packet without framing. This corresponds to the 1518 byte packet size often seen on Ethernet.

The trace source fired for packets successfully received by the device immediately before being forwarded up to higher layers (at the L2/L3 transition). This is a promiscuous trace (which doesn't mean a lot here in the point-to-point device).

See also:
class CallBackTraceSource

The trace source fired for packets successfully received by the device but are dropped before being forwarded up to higher layers (at the L2/L3 transition).

See also:
class CallBackTraceSource

The trace source fired for packets successfully received by the device immediately before being forwarded up to higher layers (at the L2/L3 transition). This is a non-promiscuous trace (which doesn't mean a lot here in the point-to-point device).

See also:
class CallBackTraceSource

The trace source fired when packets coming into the "top" of the device at the L3/L2 transition are dropped before being queued for transmission.

See also:
class CallBackTraceSource

The trace source fired when packets come into the "top" of the device at the L3/L2 transition, before being queued for transmission.

See also:
class CallBackTraceSource

The Maxmimum Transmission Unit. This corresponds to the maximum number of bytes that can be transmitted as seen from higher layers. This corresponds to the 1500 byte MTU size often seen on IP over Ethernet.

The trace source fired when a packet begins the reception process from the medium -- when the simulated first bit(s) arrive.

See also:
class CallBackTraceSource

The trace source fired when the phy layer drops a packet it has received. This happens if the receiver is not enabled or the error model is active and indicates that the packet is corrupt.

See also:
class CallBackTraceSource

The trace source fired when a packet ends the reception process from the medium.

See also:
class CallBackTraceSource

The trace source fired when a packet begins the transmission process on the medium.

See also:
class CallBackTraceSource

The trace source fired when the phy layer drops a packet before it tries to transmit it.

See also:
class CallBackTraceSource

The trace source fired when a packet ends the transmission process on the medium.

See also:
class CallBackTraceSource

A trace source that emulates a promiscuous mode protocol sniffer connected to the device. This trace source fire on packets destined for any host just like your average everyday packet sniffer.

On the transmit size, this trace hook will fire after a packet is dequeued from the device queue for transmission. In Linux, for example, this would correspond to the point just before a device hard_start_xmit where dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET ETH_P_ALL handlers.

On the receive side, this trace hook will fire when a packet is received, just before the receive callback is executed. In Linux, for example, this would correspond to the point at which the packet is dispatched to packet sniffers in netif_receive_skb.

See also:
class CallBackTraceSource

The Queue which this PointToPointNetDevice uses as a packet source. Management of this Queue has been delegated to the PointToPointNetDevice and it has the responsibility for deletion.

See also:
class Queue

class DropTailQueue

Error model for receive packet events

A trace source that emulates a non-promiscuous protocol sniffer connected to the device. Unlike your average everyday sniffer, this trace source will not fire on PACKET_OTHERHOST events.

On the transmit size, this trace hook will fire after a packet is dequeued from the device queue for transmission. In Linux, for example, this would correspond to the point just before a device hard_start_xmit where dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET ETH_P_ALL handlers.

On the receive side, this trace hook will fire when a packet is received, just before the receive callback is executed. In Linux, for example, this would correspond to the point at which the packet is dispatched to packet sniffers in netif_receive_skb.

See also:
class CallBackTraceSource

The interframe gap that the Net Device uses to throttle packet transmission

See also:
class Time

The state of the Net Device transmit state machine.

See also:
TxMachineState


The documentation for this class was generated from the following files:

Generated on Fri Apr 9 15:01:09 2010 for NS-3 by  doxygen 1.5.8