PPP implementation. More...

#include <PPP.h>

Inheritance diagram for inet::PPP:

Public Member Functions
virtual	~PPP ()

Public Member Functions inherited from inet::MACBase
	MACBase ()

virtual	~MACBase ()

Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual void	startTransmitting (cPacket *msg)

virtual PPPFrame *	encapsulate (cPacket *msg)

virtual cPacket *	decapsulate (PPPFrame *pppFrame)

virtual void	refreshDisplay () const override

virtual void	refreshOutGateConnection (bool connected)

virtual void	receiveSignal (cComponent source, simsignal_t signalID, cObject obj, cObject *details) override

virtual InterfaceEntry *	createInterfaceEntry () override
	should create InterfaceEntry More...

virtual bool	isUpperMsg (cMessage *msg) override
	should return true if the msg arrived from upper layer, else return false More...

virtual void	flushQueue () override
	should clear queue and emit signal "dropPkFromHLIfaceDown" with entire packets More...

virtual void	clearQueue () override
	should clear queue silently More...

virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

Protected Member Functions inherited from inet::MACBase
void	registerInterface ()

virtual bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

virtual void	updateOperationalFlag (bool isNodeUp)

virtual bool	isNodeUp ()

virtual void	handleMessageWhenDown (cMessage *msg)

Protected Attributes
long	txQueueLimit = -1

cGate *	physOutGate = nullptr

cChannel *	datarateChannel = nullptr

cQueue	txQueue

cMessage *	endTransmissionEvent = nullptr

IPassiveQueue *	queueModule = nullptr

TxNotifDetails	notifDetails

std::string	oldConnColor

long	numSent = 0

long	numRcvdOK = 0

long	numBitErr = 0

long	numDroppedIfaceDown = 0

Protected Attributes inherited from inet::MACBase
cModule *	hostModule = nullptr

bool	isOperational = false

InterfaceEntry *	interfaceEntry = nullptr

Static Protected Attributes
static simsignal_t	txStateSignal = registerSignal("txState")

static simsignal_t	rxPkOkSignal = registerSignal("rxPkOk")

static simsignal_t	dropPkIfaceDownSignal = registerSignal("dropPkIfaceDown")

static simsignal_t	dropPkBitErrorSignal = registerSignal("dropPkBitError")

static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")

static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")

static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")

static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")

Detailed Description

PPP implementation.

Constructor & Destructor Documentation

inet::PPP::~PPP ( )

virtual

 {
     cancelAndDelete(endTransmissionEvent);
 }

Member Function Documentation

void inet::PPP::clearQueue ( )

overrideprotectedvirtual

should clear queue silently

Implements inet::MACBase.

 {
     // code would look slightly nicer with a pop() function that returns nullptr if empty
     if (queueModule) {
         queueModule->clear();    // clear request count
         queueModule->requestPacket();
     }
     else {
         txQueue.clear();
     }
 }

InterfaceEntry * inet::PPP::createInterfaceEntry ( )

overrideprotectedvirtual

should create InterfaceEntry

Implements inet::MACBase.

 {
     InterfaceEntry *e = new InterfaceEntry(this);
 
     // data rate
     bool connected = datarateChannel != nullptr;
     double datarate = connected ? datarateChannel->getNominalDatarate() : 0;
     e->setDatarate(datarate);
     e->setCarrier(connected);
 
     // generate a link-layer address to be used as interface token for IPv6
     InterfaceToken token(0, getSimulation()->getUniqueNumber(), 64);
     e->setInterfaceToken(token);
 
     // MTU: typical values are 576 (Internet de facto), 1500 (Ethernet-friendly),
     // 4000 (on some point-to-point links), 4470 (Cisco routers default, FDDI compatible)
     e->setMtu(par("mtu").longValue());
 
     // capabilities
     e->setMulticast(true);
     e->setPointToPoint(true);
 
     return e;
 }

cPacket * inet::PPP::decapsulate ( PPPFrame * pppFrame )

protectedvirtual

Referenced by handleMessage().

 {
     cPacket *msg = pppFrame->decapsulate();
     delete pppFrame;
     return msg;
 }

PPPFrame * inet::PPP::encapsulate ( cPacket * msg )

protectedvirtual

Referenced by startTransmitting().

 {
     PPPFrame *pppFrame = new PPPFrame(msg->getName());
     pppFrame->setByteLength(PPP_OVERHEAD_BYTES);
     pppFrame->encapsulate(msg);
     return pppFrame;
 }

void inet::PPP::flushQueue ( )

overrideprotectedvirtual

should clear queue and emit signal "dropPkFromHLIfaceDown" with entire packets

Implements inet::MACBase.

 {
     // code would look slightly nicer with a pop() function that returns nullptr if empty
     if (queueModule) {
         while (!queueModule->isEmpty()) {
             cMessage *msg = queueModule->pop();
             emit(dropPkIfaceDownSignal, msg);    //FIXME this signal lumps together packets from the network and packets from higher layers! separate them
             delete msg;
         }
         queueModule->clear();    // clear request count
         queueModule->requestPacket();
     }
     else {
         while (!txQueue.isEmpty()) {
             cMessage *msg = (cMessage *)txQueue.pop();
             emit(dropPkIfaceDownSignal, msg);    //FIXME this signal lumps together packets from the network and packets from higher layers! separate them
             delete msg;
         }
     }
 }

void inet::PPP::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (!isOperational) {
         handleMessageWhenDown(msg);
         return;
     }
 
     if (msg == endTransmissionEvent) {
         // Transmission finished, we can start next one.
         EV_INFO << "Transmission successfully completed.\n";
         emit(txStateSignal, 0L);
 
         // fire notification
         notifDetails.setPacket(nullptr);
         emit(NF_PP_TX_END, &notifDetails);
 
         if (!txQueue.isEmpty()) {
             cPacket *pk = (cPacket *)txQueue.pop();
             startTransmitting(pk);
         }
         else if (queueModule && 0 == queueModule->getNumPendingRequests()) {
             queueModule->requestPacket();
         }
     }
     else if (msg->arrivedOn("phys$i")) {
         EV_INFO << "Received " << msg << " from network.\n";
         //TODO: if incoming gate is not connected now, then the link has benn deleted
         // during packet transmission --> discard incomplete packet.
 
         // fire notification
         notifDetails.setPacket(PK(msg));
         emit(NF_PP_RX_END, &notifDetails);
 
         emit(packetReceivedFromLowerSignal, msg);
 
         // check for bit errors
         if (PK(msg)->hasBitError()) {
             EV_WARN << "Bit error in " << msg << endl;
             emit(dropPkBitErrorSignal, msg);
             numBitErr++;
             delete msg;
         }
         else {
             // pass up payload
             PPPFrame *pppFrame = check_and_cast<PPPFrame *>(msg);
             emit(rxPkOkSignal, pppFrame);
             cPacket *payload = decapsulate(pppFrame);
             numRcvdOK++;
             emit(packetSentToUpperSignal, payload);
             EV_INFO << "Sending " << payload << " to upper layer.\n";
             send(payload, "netwOut");
         }
     }
     else {    // arrived on gate "netwIn"
         EV_INFO << "Received " << msg << " from upper layer.\n";
         if (datarateChannel == nullptr) {
             EV_WARN << "Interface is not connected, dropping packet " << msg << endl;
             numDroppedIfaceDown++;
             emit(dropPkIfaceDownSignal, msg);
             delete msg;
 
             if (queueModule && 0 == queueModule->getNumPendingRequests())
                 queueModule->requestPacket();
         }
         else {
             emit(packetReceivedFromUpperSignal, msg);
 
             if (endTransmissionEvent->isScheduled()) {
                 // We are currently busy, so just queue up the packet.
                 EV_DETAIL << "Received " << msg << " for transmission but transmitter busy, queueing.\n";
 
                 if (txQueueLimit && txQueue.getLength() > txQueueLimit)
                     throw cRuntimeError("txQueue length exceeds %d -- this is probably due to "
                                         "a bogus app model generating excessive traffic "
                                         "(or if this is normal, increase txQueueLimit!)",
                             txQueueLimit);
 
                 txQueue.insert(msg);
             }
             else {
                 // We are idle, so we can start transmitting right away.
                 startTransmitting(PK(msg));
             }
         }
     }
 }

void inet::PPP::initialize ( int stage )

overrideprotectedvirtual

Reimplemented from inet::MACBase.

 {
     MACBase::initialize(stage);
 
     // all initialization is done in the first stage
     if (stage == INITSTAGE_LOCAL) {
         txQueue.setName("txQueue");
         endTransmissionEvent = new cMessage("pppEndTxEvent");
 
         txQueueLimit = par("txQueueLimit");
 
         numSent = numRcvdOK = numBitErr = numDroppedIfaceDown = 0;
         WATCH(numSent);
         WATCH(numRcvdOK);
         WATCH(numBitErr);
         WATCH(numDroppedIfaceDown);
 
         subscribe(POST_MODEL_CHANGE, this);
 
         emit(txStateSignal, 0L);
 
         // find queueModule
         queueModule = nullptr;
 
         if (par("queueModule").stringValue()[0]) {
             cModule *mod = getModuleFromPar<cModule>(par("queueModule"), this);
             if (mod->isSimple())
                 queueModule = check_and_cast<IPassiveQueue *>(mod);
             else {
                 cGate *queueOut = mod->gate("out")->getPathStartGate();
                 queueModule = check_and_cast<IPassiveQueue *>(queueOut->getOwnerModule());
             }
         }
 
         // remember the output gate now, to speed up send()
         physOutGate = gate("phys$o");
 
         // we're connected if other end of connection path is an input gate
         bool connected = physOutGate->getPathEndGate()->getType() == cGate::INPUT;
         // if we're connected, get the gate with transmission rate
         datarateChannel = connected ? physOutGate->getTransmissionChannel() : nullptr;
     }
     else if (stage == INITSTAGE_LINK_LAYER) {
         // register our interface entry in IInterfaceTable
         registerInterface();
 
         // prepare to fire notifications
         notifDetails.setInterfaceEntry(interfaceEntry);
 
         // request first frame to send
         if (queueModule && 0 == queueModule->getNumPendingRequests()) {
             EV_DETAIL << "Requesting first frame from queue module\n";
             queueModule->requestPacket();
         }
     }
 }

virtual bool inet::PPP::isUpperMsg ( cMessage * msg )

inlineoverrideprotectedvirtual

should return true if the msg arrived from upper layer, else return false

Implements inet::MACBase.

79 { return msg->arrivedOn("netwIn"); }

virtual int inet::PPP::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::MACBase.

87 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::PPP::receiveSignal	(	cComponent *	source,
		simsignal_t	signalID,
		cObject *	obj,
		cObject *	details
	)

overrideprotectedvirtual

Reimplemented from inet::MACBase.

 {
     MACBase::receiveSignal(source, signalID, obj, details);
 
     if (signalID != POST_MODEL_CHANGE)
         return;
 
     if (dynamic_cast<cPostPathCreateNotification *>(obj)) {
         cPostPathCreateNotification *gcobj = (cPostPathCreateNotification *)obj;
         if (physOutGate == gcobj->pathStartGate)
             refreshOutGateConnection(true);
     }
     else if (dynamic_cast<cPostPathCutNotification *>(obj)) {
         cPostPathCutNotification *gcobj = (cPostPathCutNotification *)obj;
         if (physOutGate == gcobj->pathStartGate)
             refreshOutGateConnection(false);
     }
     else if (datarateChannel && dynamic_cast<cPostParameterChangeNotification *>(obj)) {
         cPostParameterChangeNotification *gcobj = (cPostParameterChangeNotification *)obj;
         if (datarateChannel == gcobj->par->getOwner() && !strcmp("datarate", gcobj->par->getName()))
             refreshOutGateConnection(true);
     }
 }

void inet::PPP::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     std::ostringstream buf;
     const char *color = "";
 
     if (datarateChannel != nullptr) {
         char datarateText[40];
 
         double datarate = datarateChannel->getNominalDatarate();
         if (datarate >= 1e9)
             sprintf(datarateText, "%gGbps", datarate / 1e9);
         else if (datarate >= 1e6)
             sprintf(datarateText, "%gMbps", datarate / 1e6);
         else if (datarate >= 1e3)
             sprintf(datarateText, "%gkbps", datarate / 1e3);
         else
             sprintf(datarateText, "%gbps", datarate);
 
         buf << datarateText << "\nrcv:" << numRcvdOK << " snt:" << numSent;
 
         if (numBitErr > 0)
             buf << "\nerr:" << numBitErr;
 
         if (endTransmissionEvent->isScheduled()) {
             color = txQueue.getLength() >= 3 ? "red" : "yellow";
         }
     }
     else {
         buf << "not connected\ndropped:" << numDroppedIfaceDown;
         color = "#707070";
     }
     getDisplayString().setTagArg("t", 0, buf.str().c_str());
     getDisplayString().setTagArg("i", 1, color);
 }

void inet::PPP::refreshOutGateConnection ( bool connected )

protectedvirtual

Referenced by receiveSignal().

 {
     Enter_Method_Silent();
 
     // we're connected if other end of connection path is an input gate
     if (connected)
         ASSERT(physOutGate->getPathEndGate()->getType() == cGate::INPUT);
 
     if (!connected) {
         if (endTransmissionEvent->isScheduled()) {
             cancelEvent(endTransmissionEvent);
 
             if (datarateChannel)
                 datarateChannel->forceTransmissionFinishTime(SIMTIME_ZERO);
         }
 
         if (queueModule) {
             // Clear external queue: send a request, and received packet will be deleted in handleMessage()
             if (0 == queueModule->getNumPendingRequests())
                 queueModule->requestPacket();
         }
         else {
             //Clear inner queue
             while (!txQueue.isEmpty()) {
                 cMessage *msg = check_and_cast<cMessage *>(txQueue.pop());
                 EV_ERROR << "Interface is not connected, dropping packet " << msg << endl;
                 numDroppedIfaceDown++;
                 emit(dropPkIfaceDownSignal, msg);
                 delete msg;
             }
         }
     }
 
     cChannel *oldChannel = datarateChannel;
     // if we're connected, get the gate with transmission rate
     datarateChannel = connected ? physOutGate->getTransmissionChannel() : nullptr;
     double datarate = connected ? datarateChannel->getNominalDatarate() : 0;
 
     if (datarateChannel && !oldChannel)
         datarateChannel->subscribe(POST_MODEL_CHANGE, this);
 
     // update interface state if it is in use
     if (interfaceEntry) {
         interfaceEntry->setCarrier(connected);
         interfaceEntry->setDatarate(datarate);
     }
 
     if (queueModule && 0 == queueModule->getNumPendingRequests())
         queueModule->requestPacket();
 }

void inet::PPP::startTransmitting ( cPacket * msg )

protectedvirtual

Referenced by handleMessage().

 {
     // if there's any control info, remove it; then encapsulate the packet
     delete msg->removeControlInfo();
     PPPFrame *pppFrame = encapsulate(msg);
 
     // fire notification
     notifDetails.setPacket(pppFrame);
     emit(NF_PP_TX_BEGIN, &notifDetails);
 
     // send
     EV_INFO << "Transmission of " << pppFrame << " started.\n";
     emit(txStateSignal, 1L);
     emit(packetSentToLowerSignal, pppFrame);
     send(pppFrame, physOutGate);
 
     ASSERT(datarateChannel == physOutGate->getTransmissionChannel());    //FIXME reread datarateChannel when changed
 
     // schedule an event for the time when last bit will leave the gate.
     simtime_t endTransmissionTime = datarateChannel->getTransmissionFinishTime();
     scheduleAt(endTransmissionTime, endTransmissionEvent);
     numSent++;
 }