Ppp

simple module

PPP implementation.

Packets are encapsulated in ~PppHeader and ~PppTrailer.

PPP is a complex protocol with strong support for link configuration and maintenance. This model ignores those details, and only performs simple encapsulation/decapsulation and queuing.

In routers, PPP relies on an external queue module (see ~IPacketQueue) to model finite buffer, implement QoS and/or RED, and requests packets from this external queue one-by-one.

In hosts, no such queue is used, so PPP contains an internal queue to store packets waiting for transmission. Conceptually, the queue is of infinite size, but for better diagnostics one can specify a hard limit in the packetCapacity parameter -- if this is exceeded, the simulation stops with an error.

There is no buffering done on received packets -- they are just decapsulated and sent up immediately.

<b>See also:</b> ~PppInterface

Inheritance diagram

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram.

Used in compound modules

Name	Type	Description
PppInterface	compound module	Implements a PPP network interface.

Extends

Name	Type	Description
SimpleModule	simple module	Base module for all INET simple modules.

Parameters

Name	Type	Default value	Description
displayStringTextFormat	string	"rate: %b\nsent: %s, rcvd: %r\nqueue: %q, drop: %d"	Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
interfaceTableModule	string		The path to the InterfaceTable module
sendRawBytes	bool	false	When true packets are serialized into a sequence of bytes before sending out
mtu	int	4470B
stopOperationExtraTime	double	-1s	Extra time after lifecycle stop operation finished
stopOperationTimeout	double	2s	Timeout value for lifecycle stop operation

Properties

Name	Value	Description
class	Ppp
lifecycleSupport
display	i=block/rxtx

Gates

Name	Direction	Size	Description
upperLayerIn	input
upperLayerOut	output
phys	inout

Signals

Name	Type	Description
receptionEnded	inet::Packet
rxPkOk	inet::Packet
packetReceivedFromLower	cPacket
packetReceivedFromUpper	cPacket
packetDropped	inet::Packet
packetSentToLower	inet::Packet
packetSentToUpper	cPacket
transmissionStateChanged	long	1:transmit, 0:idle
transmissionEnded	inet::Packet

Statistics

Name	Title	Source	Record	Interpolation Mode
rcvdPkFromHl	packets received from higher layer	packetReceivedFromUpper	count, sum(packetBytes), vector(packetBytes)	none
passedUpPk	packets passed to higher layer	packetSentToUpper	count, sum(packetBytes), vector(packetBytes)	none
packetDropInterfaceDown	packet drop: interface down	packetDropReasonIsInterfaceDown(packetDropped)	count, sum(packetBytes), vector(packetBytes)	none
rxPkOk	packets received OK	rxPkOk	count, sum(packetBytes), vector(packetBytes)	none
txPk	packets transmitted	packetSentToLower	count, sum(packetBytes), vector(packetBytes)	none
transmissionState	tx state	transmissionStateChanged	timeavg, vector	sample-hold
packetDropIncorrectlyReceived	packet drop: incorrectly received	packetDropReasonIsIncorrectlyReceived(packetDropped)	count, sum(packetBytes), vector(packetBytes)	none

Source code

//
// PPP implementation.
//
// Packets are encapsulated in ~PppHeader and ~PppTrailer.
//
// PPP is a complex protocol with strong support for link configuration
// and maintenance. This model ignores those details, and only performs
// simple encapsulation/decapsulation and queuing.
//
// In routers, PPP relies on an external queue module (see ~IPacketQueue)
// to model finite buffer, implement QoS and/or RED, and requests packets
// from this external queue one-by-one.
//
// In hosts, no such queue is used, so PPP contains an internal
// queue to store packets waiting for transmission.
// Conceptually, the queue is of infinite size, but for better diagnostics
// one can specify a hard limit in the `packetCapacity` parameter -- if this is
// exceeded, the simulation stops with an error.
//
// There is no buffering done on received packets -- they are just decapsulated
// and sent up immediately.
//
// @see ~PppInterface
//
simple Ppp extends SimpleModule
{
    parameters:
        @class(Ppp);
        string interfaceTableModule;   // The path to the InterfaceTable module
        displayStringTextFormat = default("rate: %b\nsent: %s, rcvd: %r\nqueue: %q, drop: %d");
        bool sendRawBytes = default(false); // When true packets are serialized into a sequence of bytes before sending out
        int mtu @unit(B) = default(4470B);
        @lifecycleSupport;
        double stopOperationExtraTime @unit(s) = default(-1s);    // Extra time after lifecycle stop operation finished
        double stopOperationTimeout @unit(s) = default(2s);    // Timeout value for lifecycle stop operation
        @class(Ppp);
        @display("i=block/rxtx");

        @signal[transmissionStateChanged](type=long);    // 1:transmit, 0:idle
        @signal[rxPkOk](type=inet::Packet);
        @signal[packetDropped](type=inet::Packet);
        @signal[packetSentToLower](type=inet::Packet);
        @signal[packetReceivedFromLower](type=cPacket);
        @signal[packetSentToUpper](type=cPacket);
        @signal[packetReceivedFromUpper](type=cPacket);
        @signal[transmissionEnded](type=inet::Packet);
        @signal[receptionEnded](type=inet::Packet);
        @statistic[transmissionState](title="tx state"; source=transmissionStateChanged; record=timeavg,vector; interpolationmode=sample-hold);
        @statistic[txPk](title="packets transmitted"; source=packetSentToLower; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @statistic[rxPkOk](title="packets received OK"; source=rxPkOk; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @statistic[packetDropIncorrectlyReceived](title="packet drop: incorrectly received"; source=packetDropReasonIsIncorrectlyReceived(packetDropped); record=count,sum(packetBytes),vector(packetBytes); interpolationmode=none);
        @statistic[packetDropInterfaceDown](title="packet drop: interface down"; source=packetDropReasonIsInterfaceDown(packetDropped); record=count,sum(packetBytes),vector(packetBytes); interpolationmode=none);
        @statistic[rcvdPkFromHl](title="packets received from higher layer"; source=packetReceivedFromUpper; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @statistic[passedUpPk](title="packets passed to higher layer"; source=packetSentToUpper; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
    gates:
        input upperLayerIn;
        output upperLayerOut;
        inout phys @labels(PppFrame);
}

File: src/inet/linklayer/ppp/Ppp.ned