Ppp

Package: inet.linklayer.ppp

Ppp

simple module

PPP implementation.

Packets are encapsulated in PppFrame.

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 IOutputQueue) 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 named txQueue to queue up packets waiting for transmission. Conceptually, txQueue is of infinite size, but for better diagnostics one can specify a hard limit in the txQueueLimit 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 also: PppInterface, IOutputQueue, PppFrame

Ppp

Used in compound modules

Name Type Description
PppInterface compound module

PPP interface. Complements the PPP module with an output queue for QoS and RED support.

Parameters

Name Type Default value Description
interfaceTableModule string

The path to the InterfaceTable module

sendRawBytes bool false

when true packets are serialized into a sequence of bytes before sending out

txQueueLimit int 1000

only used if queueModule==""; zero means infinite

queueModule string ""

path of external (QoS,RED,etc) queue module

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
lifecycleSupport
display i=block/rxtx

Gates

Name Direction Size Description
upperLayerIn input
upperLayerOut output
phys inout

Signals

Name Type Unit
rxPkOk inet::Packet
packetReceivedFromLower cPacket
packetReceivedFromUpper cPacket
packetDropped inet::Packet
packetSentToLower inet::Packet
packetSentToUpper cPacket
transmissionStateChanged long

Statistics

Name Title Source Record Unit 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 ~PppFrame.
//
// 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 ~IOutputQueue)
// 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 named txQueue to queue up packets waiting for transmission.
// Conceptually, txQueue is of infinite size, but for better diagnostics
// one can specify a hard limit in the txQueueLimit 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, ~IOutputQueue, ~PppFrame
//
simple Ppp
{
    parameters:
        string interfaceTableModule;   // The path to the InterfaceTable module
        bool sendRawBytes = default(false); // when true packets are serialized into a sequence of bytes before sending out
        int txQueueLimit = default(1000);  // only used if queueModule==""; zero means infinite
        string queueModule = default("");  // path of external (QoS,RED,etc) queue module
        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
        @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);
        @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