ns3::PointToPointNetDevice Class Reference
A Device for a Point to Point Network Link. More...
#include <point-to-point-net-device.h>
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< Channel > | GetChannel (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< Node > | GetNode (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< Queue > | GetQueue (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 ¶m) |
| bool | TransmitStart (Ptr< Packet > p) |
| void | TransmitComplete (void) |
Private Attributes | |
| TxMachineState | m_txMachineState |
| DataRate | m_bps |
| Time | m_tInterframeGap |
| Ptr< PointToPointChannel > | m_channel |
| Ptr< Queue > | m_queue |
| Ptr< ErrorModel > | m_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
enum ns3::PointToPointNetDevice::TxMachineState [private] |
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
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] |
| virtual Address ns3::PointToPointNetDevice::GetBroadcast | ( | void | ) | const [virtual] |
- Returns:
- the broadcast address supported by this netdevice.
Implements ns3::NetDevice.
- 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] |
| virtual uint16_t ns3::PointToPointNetDevice::GetMtu | ( | void | ) | const [virtual] |
- Returns:
- the link-level MTU in bytes for this interface.
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
Implements ns3::NetDevice.
- Returns:
- the node base class which contains this network interface.
Implements ns3::NetDevice.
| 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
-
Address: The MAC address of this device.
- Set with class: Mac48AddressValue
- Underlying type: Mac48Address
- Initial value: ff:ff:ff:ff:ff:ff
- Flags: construct write read
-
FrameSize: The maximum size of a packet sent over this device.
- Set with class: ns3::UintegerValue
- Underlying type: uint16_t 0:65535
- Initial value: 1502
- Flags: construct write read
-
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
- Set with class: ns3::PointerValue
- Underlying type: ns3::Ptr< ns3::ErrorModel >
- Initial value: 0
- Flags: construct write read
- InterframeGap: The time to wait between packet (frame) transmissions
-
TxQueue: A queue to use as the transmit queue in the device.
- Set with class: ns3::PointerValue
- Underlying type: ns3::Ptr< ns3::Queue >
- Initial value: 0
- Flags: construct write read
-
Mtu: The MAC-level Maximum Transmission Unit
- Set with class: ns3::UintegerValue
- Underlying type: uint16_t 0:65535
- Flags: write read
- 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] |
| virtual bool ns3::PointToPointNetDevice::IsMulticast | ( | void | ) | const [virtual] |
| 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.
Implements ns3::NetDevice.
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.
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.
- 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.
- 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] |
| 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
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
Implements ns3::NetDevice.
- Parameters:
-
node the node associated to this netdevice.
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.
Implements ns3::NetDevice.
Attach a queue to the PointToPointNetDevice.
The PointToPointNetDevice "owns" a queue that implements a queueing method such as DropTail or RED.
- See also:
- Queue
- 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.
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
DataRate ns3::PointToPointNetDevice::m_bps [private] |
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
uint32_t ns3::PointToPointNetDevice::m_frameSize [private] |
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.
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_macPromiscRxTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_macRxDropTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_macRxTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_macTxDropTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_macTxTrace [private] |
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
uint32_t ns3::PointToPointNetDevice::m_mtu [private] |
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.
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyRxBeginTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyRxDropTrace [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyRxEndTrace [private] |
The trace source fired when a packet ends the reception process from the medium.
- See also:
- class CallBackTraceSource
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyTxBeginTrace [private] |
The trace source fired when a packet begins the transmission process on the medium.
- See also:
- class CallBackTraceSource
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyTxDropTrace [private] |
The trace source fired when the phy layer drops a packet before it tries to transmit it.
- See also:
- class CallBackTraceSource
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_phyTxEndTrace [private] |
The trace source fired when a packet ends the transmission process on the medium.
- See also:
- class CallBackTraceSource
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_promiscSnifferTrace [private] |
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
Ptr<Queue> ns3::PointToPointNetDevice::m_queue [private] |
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
TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_snifferTrace [private] |
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:
- src/devices/point-to-point/point-to-point-net-device.h
- doc/introspected-doxygen.h
