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

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

Inheritance diagram for ns3::PointToPointNetDevice:

Collaboration diagram for ns3::PointToPointNetDevice:

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	SetAddress (Mac48Address addr)
void	SetFrameSize (uint16_t frameSize)
uint16_t	GetFrameSize (void) const
virtual void	SetName (const std::string name)
virtual std::string	GetName (void) const
virtual void	SetIfIndex (const uint32_t index)
virtual uint32_t	GetIfIndex (void) const
virtual Ptr< Channel >	GetChannel (void) const
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 (void) const
	Return the MAC multicast base address used when mapping multicast groups to MAC multicast addresses.
virtual Address	MakeMulticastAddress (Ipv4Address multicastGroup) const
	Make and return a MAC multicast address using the provided multicast group.
virtual bool	IsPointToPoint (void) const
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 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 &param)
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
TracedCallback< Ptr< const Packet > >	m_rxTrace
TracedCallback< Ptr< const Packet > >	m_dropTrace
Ptr< ErrorModel >	m_receiveErrorModel
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]

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.

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 ( void ) const [virtual]

Return the MAC multicast base address used when mapping multicast groups to MAC multicast addresses.

Typically when one constructs a multicast MAC addresses, some bits from the IP multicast group are copied into a corresponding MAC multicast group. In EUI-48, for example, the low order 23 bits of the multicast group are copied to the MAC multicast group base address.

This method allows access to the underlying MAC multicast group base address. It is expected that in most cases, a net device client will allow the net device to perform the actual construction of the multicast address. Use of this method is discouraged unless you have a good reason to perform a custom mapping. You should prefer NetDevice::MakeMulticastAddress which will do the RFC-specified mapping for the net device in question.

Returns:: The multicast address supported by this net device.

Warning:: Calling this method is invalid if IsMulticast returns not true. The method NS_ASSERTs if the device is not a multicast device.

See also:: NetDevice::MakeMulticastAddress

Implements ns3::NetDevice.

virtual std::string ns3::PointToPointNetDevice::GetName ( void ) const [virtual]

Returns:: name name of the device (e.g. "eth0")

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]/$ns3PointToPointNetDevice

Attributes defined for this type:

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
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
InterframeGap: The time to wait between packet (frame) transmissions
- Set with class: TimeValue
- Underlying type: Time
- Initial value: 0ns
- Flags: construct write read

Attributes defined in parent class ns3::NetDevice:

Mtu: The MAC-level Maximum Transmission Unit
- Set with class: ns3::UintegerValue
- Underlying type: uint16_t 0:65535
- Flags: write read

TraceSources defined for this type:

Rx: Trace source to fire on reception of a MAC packet.
Drop: Trace source to fire on when a MAC packet is dropped.

Reimplemented from 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]

Returns:: value of m_isPointToPoint flag

Implements ns3::NetDevice.

virtual Address ns3::PointToPointNetDevice::MakeMulticastAddress ( 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 MakeMulticastAddress 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.

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.

void ns3::PointToPointNetDevice::SetAddress ( Mac48Address addr )

Assign a MAC address to this device.

See also:: Mac48Address

Parameters:

addr

The new address.

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::SetName ( const std::string name ) [virtual]

Parameters:

name

name of the device (e.g. "eth0")

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

DataRate ns3::PointToPointNetDevice::m_bps [private]

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

See also:: class DataRate

Ptr<PointToPointChannel> ns3::PointToPointNetDevice::m_channel [private]

The PointToPointChannel to which this PointToPointNetDevice has been attached.

See also:: class PointToPointChannel

TracedCallback<Ptr<const Packet> > ns3::PointToPointNetDevice::m_dropTrace [private]

The trace source for the packet drop events that the device can fire.

See also:: class CallBackTraceSource

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.

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.

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.