inet::DhcpClient Class Reference

Implements a DHCP client. More...

#include <DhcpClient.h>

Inheritance diagram for inet::DhcpClient:

Public Member Functions
	DhcpClient ()
virtual	~DhcpClient ()
Public Member Functions inherited from inet::ApplicationBase
	ApplicationBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::UdpSocket::ICallback
virtual	~ICallback ()

Protected Types
enum	ClientState {   IDLE, INIT, INIT_REBOOT, REBOOTING,   SELECTING, REQUESTING, BOUND, RENEWING,   REBINDING }
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	scheduleTimerTO (DhcpTimerType type)
virtual void	scheduleTimerT1 ()
virtual void	scheduleTimerT2 ()
const char *	getAndCheckMessageTypeName (DhcpMessageType type)
virtual void	refreshDisplay () const override
virtual void	openSocket ()
virtual void	handleDhcpMessage (Packet *packet)
virtual void	handleTimer (cMessage *msg)
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual void	sendToUdp (Packet *msg, int srcPort, const L3Address &destAddr, int destPort)
virtual void	sendDiscover ()
virtual void	sendRequest ()
virtual void	sendDecline (Ipv4Address declinedIp)
virtual void	recordLease (const Ptr< const DhcpMessage > &dhcpACK)
virtual void	recordOffer (const Ptr< const DhcpMessage > &dhcpOffer)
virtual void	bindLease ()
virtual void	unbindLease ()
virtual void	initClient ()
virtual void	initRebootedClient ()
virtual void	handleDhcpAck (const Ptr< const DhcpMessage > &msg)
virtual NetworkInterface *	chooseInterface ()
virtual void	socketDataArrived (UdpSocket *socket, Packet *packet) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
virtual void	socketErrorArrived (UdpSocket *socket, Indication *indication) override
	Notifies about error indication arrival, indication ownership is transferred to the callee. More...
virtual void	socketClosed (UdpSocket *socket) override
	Notifies about socket closed, indication ownership is transferred to the callee. More...
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Protected Member Functions inherited from inet::ApplicationBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Static Protected Member Functions
static const char *	getStateName (ClientState state)

Protected Attributes
int	serverPort = -1
int	clientPort = -1
UdpSocket	socket
simtime_t	startTime
MacAddress	macAddress
cModule *	host = nullptr
NetworkInterface *	ie = nullptr
ModuleRefByPar< IIpv4RoutingTable >	irt
cMessage *	timerT1 = nullptr
cMessage *	timerT2 = nullptr
cMessage *	timerTo = nullptr
cMessage *	leaseTimer = nullptr
cMessage *	startTimer = nullptr
ClientState	clientState = INIT
unsigned int	xid = 0
DhcpLease *	lease = nullptr
Ipv4Route *	route = nullptr
int	numSent = 0
int	numReceived = 0
int	responseTimeout = 0
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Detailed Description

Implements a DHCP client.

See NED file for more details.

Member Enumeration Documentation

ClientState

enum inet::DhcpClient::ClientState

protected

Enumerator
IDLE
INIT
INIT_REBOOT
REBOOTING
SELECTING
REQUESTING
BOUND
RENEWING
REBINDING

                     {
        IDLE, INIT, INIT_REBOOT, REBOOTING, SELECTING, REQUESTING, BOUND, RENEWING, REBINDING
    };

Constructor & Destructor Documentation

DhcpClient()

inet::DhcpClient::DhcpClient ( )

inline

{}

~DhcpClient()

inet::DhcpClient::~DhcpClient ( )

virtual

{
    cancelAndDelete(timerT1);
    cancelAndDelete(timerTo);
    cancelAndDelete(timerT2);
    cancelAndDelete(leaseTimer);
    cancelAndDelete(startTimer);
    delete lease;
}

Member Function Documentation

bindLease()

void inet::DhcpClient::bindLease ( )

protectedvirtual

{
    auto ipv4Data = ie->getProtocolDataForUpdate<Ipv4InterfaceData>();
    ipv4Data->setIPAddress(lease->ip);
    ipv4Data->setNetmask(lease->subnetMask);
 
    std::string banner = "Got IP " + lease->ip.str();
    host->bubble(banner.c_str());
 
    /*
        The client SHOULD perform a final check on the parameters (ping, Arp).
        If the client detects that the address is already in use:
        EV_INFO << "The offered IP " << lease->ip << " is not available." << endl;
        sendDecline(lease->ip);
        initClient();
     */
 
    EV_INFO << "The requested IP " << lease->ip << "/" << lease->subnetMask << " is available. Assigning it to "
            << host->getFullName() << "." << endl;
 
    Ipv4Route *iroute = nullptr;
    for (int i = 0; i < irt->getNumRoutes(); i++) {
        Ipv4Route *e = irt->getRoute(i);
        if (routeMatches(e, Ipv4Address(), Ipv4Address(), lease->gateway, 0, ie->getInterfaceName())) {
            iroute = e;
            break;
        }
    }
    if (iroute == nullptr) {
        // create gateway route
        route = new Ipv4Route();
        route->setDestination(Ipv4Address());
        route->setNetmask(Ipv4Address());
        route->setGateway(lease->gateway);
        route->setInterface(ie);
        route->setSourceType(Ipv4Route::MANUAL);
        irt->addRoute(route);
    }
 
    // update the routing table
    rescheduleAfter(lease->leaseTime, leaseTimer);
}

Referenced by handleDhcpAck().

chooseInterface()

NetworkInterface * inet::DhcpClient::chooseInterface ( )

protectedvirtual

{
    IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
    const char *interfaceName = par("interface");
    NetworkInterface *ie = nullptr;
 
    if (strlen(interfaceName) > 0) {
        ie = ift->findInterfaceByName(interfaceName);
        if (ie == nullptr)
            throw cRuntimeError("Interface \"%s\" does not exist", interfaceName);
    }
    else {
        // there should be exactly one non-loopback interface that we want to configure
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            NetworkInterface *current = ift->getInterface(i);
            if (!current->isLoopback()) {
                if (ie)
                    throw cRuntimeError("Multiple non-loopback interfaces found, please select explicitly which one you want to configure via DHCP");
                ie = current;
            }
        }
        if (!ie)
            throw cRuntimeError("No non-loopback interface found to be configured via DHCP");
    }
 
    if (!ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress().isUnspecified())
        throw cRuntimeError("Refusing to start DHCP on interface \"%s\" that already has an IP address", ie->getInterfaceName());
    return ie;
}

Referenced by handleStartOperation().

finish()

void inet::DhcpClient::finish ( )

overrideprotectedvirtual

{
    cancelEvent(timerT1);
    cancelEvent(timerTo);
    cancelEvent(timerT2);
    cancelEvent(leaseTimer);
    cancelEvent(startTimer);
}

getAndCheckMessageTypeName()

const char * inet::DhcpClient::getAndCheckMessageTypeName ( DhcpMessageType  type )

protected

{
    switch (type) {
#define CASE(X)    case X: \
        return #X;
        CASE(DHCPDISCOVER);
        CASE(DHCPOFFER);
        CASE(DHCPREQUEST);
        CASE(DHCPDECLINE);
        CASE(DHCPACK);
        CASE(DHCPNAK);
        CASE(DHCPRELEASE);
        CASE(DHCPINFORM);
 
        default:
            throw cRuntimeError("Unknown or invalid DHCP message type %d", type);
#undef CASE
    }
}

Referenced by handleDhcpMessage().

getStateName()

const char * inet::DhcpClient::getStateName ( ClientState  state )

staticprotected

{
    switch (state) {
#define CASE(X)    case X: \
        return #X;
        CASE(INIT);
        CASE(INIT_REBOOT);
        CASE(REBOOTING);
        CASE(SELECTING);
        CASE(REQUESTING);
        CASE(BOUND);
        CASE(RENEWING);
        CASE(REBINDING);
 
        default:
            return "???";
#undef CASE
    }
}

Referenced by refreshDisplay().

handleCrashOperation()

void inet::DhcpClient::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    cancelEvent(timerT1);
    cancelEvent(timerT2);
    cancelEvent(timerTo);
    cancelEvent(leaseTimer);
    cancelEvent(startTimer);
    ie = nullptr;
 
    if (operation->getRootModule() != getContainingNode(this)) // closes socket when the application crashed only
        socket.destroy(); // TODO  in real operating systems, program crash detected by OS and OS closes sockets of crashed programs.
}

handleDhcpAck()

void inet::DhcpClient::handleDhcpAck ( const Ptr< const DhcpMessage > &  msg )

protectedvirtual

{
    recordLease(msg);
    cancelEvent(timerTo);
    scheduleTimerT1();
    scheduleTimerT2();
    bindLease();
}

Referenced by handleDhcpMessage().

handleDhcpMessage()

void inet::DhcpClient::handleDhcpMessage ( Packet *  packet )

protectedvirtual

{
    ASSERT(isUp() && ie != nullptr);
 
    const auto& msg = packet->peekAtFront<DhcpMessage>();
    if (msg->getOp() != BOOTREPLY) {
        EV_WARN << "Client received a non-BOOTREPLY message, dropping." << endl;
        return;
    }
 
    if (msg->getXid() != xid) {
        EV_WARN << "Message transaction ID is not valid, dropping." << endl;
        return;
    }
 
    DhcpMessageType messageType = msg->getOptions().getMessageType();
    switch (clientState) {
        case INIT:
            EV_WARN << getAndCheckMessageTypeName(messageType) << " message arrived in INIT state. In this state, client does not wait for any message at all, dropping." << endl;
            break;
 
        case SELECTING:
            if (messageType == DHCPOFFER) {
                EV_INFO << "DHCPOFFER message arrived in SELECTING state with IP address: " << msg->getYiaddr() << "." << endl;
                scheduleTimerTO(WAIT_ACK);
                clientState = REQUESTING;
                recordOffer(msg);
                sendRequest(); // we accept the first offer
            }
            else
                EV_WARN << "Client is in SELECTING and the arriving packet is not a DHCPOFFER, dropping." << endl;
            break;
 
        case REQUESTING:
            if (messageType == DHCPOFFER) {
                EV_WARN << "We don't accept DHCPOFFERs in REQUESTING state, dropping." << endl; // remains in REQUESTING
            }
            else if (messageType == DHCPACK) {
                EV_INFO << "DHCPACK message arrived in REQUESTING state. The requested IP address is available in the server's pool of addresses." << endl;
                handleDhcpAck(msg);
                clientState = BOUND;
            }
            else if (messageType == DHCPNAK) {
                EV_INFO << "DHCPNAK message arrived in REQUESTING state. Restarting the configuration process." << endl;
                initClient();
            }
            else {
                EV_WARN << getAndCheckMessageTypeName(messageType) << " message arrived in REQUESTING state. In this state, client does not expect messages of this type, dropping." << endl;
            }
            break;
 
        case BOUND:
            EV_DETAIL << "We are in BOUND, discard all DHCP messages." << endl; // remain in BOUND
            break;
 
        case RENEWING:
            if (messageType == DHCPACK) {
                handleDhcpAck(msg);
                EV_INFO << "DHCPACK message arrived in RENEWING state. The renewing process was successful." << endl;
                clientState = BOUND;
            }
            else if (messageType == DHCPNAK) {
                EV_INFO << "DHPCNAK message arrived in RENEWING state. The renewing process was unsuccessful. Restarting the DHCP configuration process." << endl;
                unbindLease();
                initClient();
            }
            else {
                EV_WARN << getAndCheckMessageTypeName(messageType) << " message arrived in RENEWING state. In this state, client does not expect messages of this type, dropping." << endl;
            }
            break;
 
        case REBINDING:
            if (messageType == DHCPNAK) {
                EV_INFO << "DHPCNAK message arrived in REBINDING state. The rebinding process was unsuccessful. Restarting the DHCP configuration process." << endl;
                unbindLease();
                initClient();
            }
            else if (messageType == DHCPACK) {
                handleDhcpAck(msg);
                EV_INFO << "DHCPACK message arrived in REBINDING state. The rebinding process was successful." << endl;
                clientState = BOUND;
            }
            else {
                EV_WARN << getAndCheckMessageTypeName(messageType) << " message arrived in REBINDING state. In this state, client does not expect messages of this type, dropping." << endl;
            }
            break;
 
        case REBOOTING:
            if (messageType == DHCPACK) {
                handleDhcpAck(msg);
                EV_INFO << "DHCPACK message arrived in REBOOTING state. Initialization with known IP address was successful." << endl;
                clientState = BOUND;
            }
            else if (messageType == DHCPNAK) {
                EV_INFO << "DHCPNAK message arrived in REBOOTING. Initialization with known IP address was unsuccessful." << endl;
                unbindLease();
                initClient();
            }
            else {
                EV_WARN << getAndCheckMessageTypeName(messageType) << " message arrived in REBOOTING state. In this state, client does not expect messages of this type, dropping." << endl;
            }
            break;
 
        default:
            throw cRuntimeError("Unknown or invalid client state %d", clientState);
    }
}

Referenced by socketDataArrived().

handleMessageWhenUp()

void inet::DhcpClient::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage()) {
        handleTimer(msg);
    }
    else if (msg->arrivedOn("socketIn")) {
        socket.processMessage(msg);
    }
    else
        throw cRuntimeError("Unknown incoming gate: '%s'", msg->getArrivalGate()->getFullName());
}

handleStartOperation()

void inet::DhcpClient::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    simtime_t start = std::max(startTime, simTime());
    ie = chooseInterface();
    macAddress = ie->getMacAddress();
    scheduleAt(start, startTimer);
}

handleStopOperation()

void inet::DhcpClient::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    cancelEvent(timerT1);
    cancelEvent(timerT2);
    cancelEvent(timerTo);
    cancelEvent(leaseTimer);
    cancelEvent(startTimer);
    ie = nullptr;
 
    // TODO Client should send DHCPRELEASE to the server. However, the correct operation
    // of DHCP does not depend on the transmission of DHCPRELEASE messages.
 
    socket.close();
    delayActiveOperationFinish(par("stopOperationTimeout"));
}

handleTimer()

void inet::DhcpClient::handleTimer ( cMessage *  msg )

protectedvirtual

{
    int category = msg->getKind();
 
    if (category == START_DHCP) {
        openSocket();
        if (lease) {
            clientState = INIT_REBOOT;
            initRebootedClient();
        }
        else { // we have no lease from the previous DHCP process
            clientState = INIT;
            initClient();
        }
    }
    else if (category == WAIT_OFFER) {
        EV_DETAIL << "No DHCP offer received within timeout. Restarting. " << endl;
        initClient();
    }
    else if (category == WAIT_ACK) {
        EV_DETAIL << "No DHCP ACK received within timeout. Restarting." << endl;
        initClient();
    }
    else if (category == T1) {
        EV_DETAIL << "T1 expired. Starting RENEWING state." << endl;
        clientState = RENEWING;
        scheduleTimerTO(WAIT_ACK);
        sendRequest();
    }
    else if (category == T2 && clientState == RENEWING) {
        EV_DETAIL << "T2 expired. Starting REBINDING state." << endl;
        clientState = REBINDING;
        cancelEvent(timerT1);
        cancelEvent(timerT2);
        cancelEvent(timerTo);
//        cancelEvent(leaseTimer);
 
        sendRequest();
        scheduleTimerTO(WAIT_ACK);
    }
    else if (category == T2) {
        // T1 < T2 always holds by definition and when T1 expires client will move to RENEWING
        throw cRuntimeError("T2 occurred in wrong state. (T1 must be earlier than T2.)");
    }
    else if (category == LEASE_TIMEOUT) {
        EV_INFO << "Lease has expired. Starting DHCP process in INIT state." << endl;
        unbindLease();
        clientState = INIT;
        initClient();
    }
    else
        throw cRuntimeError("Unknown self message '%s'", msg->getName());
}

Referenced by handleMessageWhenUp().

initClient()

void inet::DhcpClient::initClient ( )

protectedvirtual

{
    EV_INFO << "Starting DHCP configuration process." << endl;
 
    cancelEvent(timerT1);
    cancelEvent(timerT2);
    cancelEvent(timerTo);
    cancelEvent(leaseTimer);
 
    sendDiscover();
    scheduleTimerTO(WAIT_OFFER);
    clientState = SELECTING;
}

Referenced by handleDhcpMessage(), handleTimer(), and receiveSignal().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    ApplicationBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        timerT1 = new cMessage("T1 Timer", T1);
        timerT2 = new cMessage("T2 Timer", T2);
        timerTo = new cMessage("DHCP Timeout");
        leaseTimer = new cMessage("Lease Timeout", LEASE_TIMEOUT);
        startTimer = new cMessage("Starting DHCP", START_DHCP);
        startTime = par("startTime");
        numSent = 0;
        numReceived = 0;
        xid = 0;
        responseTimeout = 60; // response timeout in seconds RFC 2131, 4.4.3
 
        WATCH(numSent);
        WATCH(numReceived);
        WATCH(clientState);
        WATCH(xid);
 
        // DHCP UDP ports
        clientPort = 68; // client
        serverPort = 67; // server
        // get the routing table to update and subscribe it to the blackboard
        irt.reference(this, "routingTableModule", true);
        // set client to idle state
        clientState = IDLE;
        // get the interface to configure
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        // get the hostname
        host = getContainingNode(this);
        // for a wireless interface subscribe the association event to start the DHCP protocol
        host->subscribe(l2AssociatedSignal, this);
        host->subscribe(interfaceDeletedSignal, this);
        socket.setCallback(this);
        socket.setOutputGate(gate("socketOut"));
    }
}

initRebootedClient()

void inet::DhcpClient::initRebootedClient ( )

protectedvirtual

{
    sendRequest();
    scheduleTimerTO(WAIT_ACK);
    clientState = REBOOTING;
}

Referenced by handleTimer().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

openSocket()

void inet::DhcpClient::openSocket ( )

protectedvirtual

{
    socket.bind(clientPort);
    socket.setBroadcast(true);
    EV_INFO << "DHCP server bound to port " << serverPort << "." << endl;
}

Referenced by handleTimer().

receiveSignal()

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

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
    printSignalBanner(signalID, obj, details);
 
    // host associated. link is up. change the state to init.
    if (signalID == l2AssociatedSignal) {
        NetworkInterface *associatedIE = check_and_cast_nullable<NetworkInterface *>(obj);
        if (associatedIE && ie == associatedIE && clientState != IDLE) {
            EV_INFO << "Interface associated, starting DHCP." << endl;
            unbindLease();
            initClient();
        }
    }
    else if (signalID == interfaceDeletedSignal) {
        if (isUp())
            throw cRuntimeError("Reacting to interface deletions is not implemented in this module");
    }
}

recordLease()

void inet::DhcpClient::recordLease ( const Ptr< const DhcpMessage > &  dhcpACK )

protectedvirtual

{
    if (!dhcpACK->getYiaddr().isUnspecified()) {
        Ipv4Address ip = dhcpACK->getYiaddr();
        EV_DETAIL << "DHCPACK arrived with " << "IP: " << ip << endl;
 
        lease->subnetMask = dhcpACK->getOptions().getSubnetMask();
 
        if (dhcpACK->getOptions().getRouterArraySize() > 0)
            lease->gateway = dhcpACK->getOptions().getRouter(0);
        if (dhcpACK->getOptions().getDnsArraySize() > 0)
            lease->dns = dhcpACK->getOptions().getDns(0);
        if (dhcpACK->getOptions().getNtpArraySize() > 0)
            lease->ntp = dhcpACK->getOptions().getNtp(0);
 
        lease->leaseTime = dhcpACK->getOptions().getLeaseTime();
        lease->renewalTime = dhcpACK->getOptions().getRenewalTime();
        lease->rebindTime = dhcpACK->getOptions().getRebindingTime();
 
//        std::cout << lease->leaseTime << " " << lease->renewalTime << " " << lease->rebindTime << endl;
    }
    else
        EV_ERROR << "DHCPACK arrived, but no IP address confirmed." << endl;
}

Referenced by handleDhcpAck().

recordOffer()

void inet::DhcpClient::recordOffer ( const Ptr< const DhcpMessage > &  dhcpOffer )

protectedvirtual

{
    if (!dhcpOffer->getYiaddr().isUnspecified()) {
        Ipv4Address ip = dhcpOffer->getYiaddr();
 
//        Byte serverIdB = dhcpOffer->getOptions().get(SERVER_ID);
        Ipv4Address serverId = dhcpOffer->getOptions().getServerIdentifier();
 
        // minimal information to configure the interface
        // create the lease to request
        delete lease;
        lease = new DhcpLease();
        lease->ip = ip;
        lease->mac = macAddress;
        lease->serverId = serverId;
    }
    else
        EV_WARN << "DHCPOFFER arrived, but no IP address has been offered. Discarding it and remaining in SELECTING." << endl;
}

Referenced by handleDhcpMessage().

refreshDisplay()

void inet::DhcpClient::refreshDisplay ( ) const

overrideprotectedvirtual

{
    ApplicationBase::refreshDisplay();
 
    getDisplayString().setTagArg("t", 0, getStateName(clientState));
}

scheduleTimerT1()

void inet::DhcpClient::scheduleTimerT1 ( )

protectedvirtual

{
    // cancel the previous T1
    rescheduleAfter(lease->renewalTime, timerT1); // RFC 2131 4.4.5
}

Referenced by handleDhcpAck().

scheduleTimerT2()

void inet::DhcpClient::scheduleTimerT2 ( )

protectedvirtual

{
    // cancel the previous T2
    rescheduleAfter(lease->rebindTime, timerT2); // RFC 2131 4.4.5
}

Referenced by handleDhcpAck().

scheduleTimerTO()

void inet::DhcpClient::scheduleTimerTO ( DhcpTimerType  type )

protectedvirtual

{
    // cancel the previous timeout
    timerTo->setKind(type);
    rescheduleAfter(responseTimeout, timerTo);
}

Referenced by handleDhcpMessage(), handleTimer(), initClient(), and initRebootedClient().

sendDecline()

void inet::DhcpClient::sendDecline ( Ipv4Address  declinedIp )

protectedvirtual

{
    xid = intuniform(0, RAND_MAX);
    Packet *packet = new Packet("DHCPDECLINE");
    const auto& decline = makeShared<DhcpMessage>();
    decline->setOp(BOOTREQUEST);
    uint16_t length = 236; // packet size without the options field
    decline->setHtype(1); // ethernet
    decline->setHlen(6); // hardware Address length (6 octets)
    decline->setHops(0);
    decline->setXid(xid); // transaction id
    decline->setSecs(0); // 0 seconds from transaction started
    decline->setBroadcast(false); // unicast
    decline->setChaddr(macAddress); // my MAC address
    decline->setSname(""); // no server name given
    decline->setFile(""); // no file given
    auto& options = decline->getOptionsForUpdate();
    options.setMessageType(DHCPDECLINE);
    length += 3;
    options.setRequestedIp(declinedIp);
    length += 6;
 
    // magic cookie and the end field
    length += 5;
 
    decline->setChunkLength(B(length));
 
    packet->insertAtBack(decline);
 
    EV_INFO << "Sending DHCPDECLINE." << endl;
    sendToUdp(packet, clientPort, Ipv4Address::ALLONES_ADDRESS, serverPort);
}

sendDiscover()

void inet::DhcpClient::sendDiscover ( )

protectedvirtual

{
    // setting the xid
    xid = intuniform(0, RAND_MAX);
//    std::cout << xid << endl;
    Packet *packet = new Packet("DHCPDISCOVER");
    const auto& discover = makeShared<DhcpMessage>();
    discover->setOp(BOOTREQUEST);
    uint16_t length = 236; // packet size without the options field
    discover->setHtype(1); // ethernet
    discover->setHlen(6); // hardware Address lenght (6 octets)
    discover->setHops(0);
    discover->setXid(xid); // transaction id
    discover->setSecs(0); // 0 seconds from transaction started
    discover->setBroadcast(false); // unicast
    discover->setChaddr(macAddress); // my mac address
    discover->setSname(""); // no server name given
    discover->setFile(""); // no file given
    auto& options = discover->getOptionsForUpdate();
    options.setMessageType(DHCPDISCOVER);
    length += 3;
    options.setClientIdentifier(macAddress);
    length += 9;
    options.setRequestedIp(Ipv4Address());
    //length += 6; not added because unspecified
 
    // set the parameters to request
    options.setParameterRequestListArraySize(4);
    options.setParameterRequestList(0, SUBNET_MASK);
    options.setParameterRequestList(1, ROUTER);
    options.setParameterRequestList(2, DNS);
    options.setParameterRequestList(3, NTP_SRV);
    length += (2 + options.getParameterRequestListArraySize());
 
    // magic cookie and the end field
    length += 5;
 
    discover->setChunkLength(B(length));
 
    packet->insertAtBack(discover);
 
    EV_INFO << "Sending DHCPDISCOVER." << endl;
    sendToUdp(packet, clientPort, Ipv4Address::ALLONES_ADDRESS, serverPort);
}

Referenced by initClient().

sendRequest()

void inet::DhcpClient::sendRequest ( )

protectedvirtual

{
    // setting the xid
    xid = intuniform(0, RAND_MAX); // generating a new xid for each transmission
 
    const auto& request = makeShared<DhcpMessage>();
    request->setOp(BOOTREQUEST);
    uint16_t length = 236; // packet size without the options field
    request->setHtype(1); // ethernet
    request->setHlen(6); // hardware Address length (6 octets)
    request->setHops(0);
    request->setXid(xid); // transaction id
    request->setSecs(0); // 0 seconds from transaction started
    request->setBroadcast(false); // unicast
    request->setYiaddr(Ipv4Address()); // no 'your IP' addr
    request->setGiaddr(Ipv4Address()); // no DHCP Gateway Agents
    request->setChaddr(macAddress); // my mac address;
    request->setSname(""); // no server name given
    request->setFile(""); // no file given
    auto& options = request->getOptionsForUpdate();
    options.setMessageType(DHCPREQUEST);
    length += 3;
    options.setClientIdentifier(macAddress);
    length += 9;
 
    // set the parameters to request
    options.setParameterRequestListArraySize(4);
    options.setParameterRequestList(0, SUBNET_MASK);
    options.setParameterRequestList(1, ROUTER);
    options.setParameterRequestList(2, DNS);
    options.setParameterRequestList(3, NTP_SRV);
    length += (2 + options.getParameterRequestListArraySize());
 
    L3Address destAddr;
 
    // RFC 4.3.6 Table 4
    if (clientState == INIT_REBOOT) {
        options.setRequestedIp(lease->ip);
        length += 6;
        request->setCiaddr(Ipv4Address()); // zero
        destAddr = Ipv4Address::ALLONES_ADDRESS;
        EV_INFO << "Sending DHCPREQUEST asking for IP " << lease->ip << " via broadcast." << endl;
    }
    else if (clientState == REQUESTING) {
        options.setServerIdentifier(lease->serverId);
        length += 6;
        options.setRequestedIp(lease->ip);
        length += 6;
        request->setCiaddr(Ipv4Address()); // zero
        destAddr = Ipv4Address::ALLONES_ADDRESS;
        EV_INFO << "Sending DHCPREQUEST asking for IP " << lease->ip << " via broadcast." << endl;
    }
    else if (clientState == RENEWING) {
        request->setCiaddr(lease->ip); // the client IP
        destAddr = lease->serverId;
        EV_INFO << "Sending DHCPREQUEST extending lease for IP " << lease->ip << " via unicast to " << lease->serverId << "." << endl;
    }
    else if (clientState == REBINDING) {
        request->setCiaddr(lease->ip); // the client IP
        destAddr = Ipv4Address::ALLONES_ADDRESS;
        EV_INFO << "Sending DHCPREQUEST renewing the IP " << lease->ip << " via broadcast." << endl;
    }
    else
        throw cRuntimeError("Invalid state");
 
    // magic cookie and the end field
    length += 5;
 
    request->setChunkLength(B(length));
 
    Packet *packet = new Packet("DHCPREQUEST");
    packet->insertAtBack(request);
    sendToUdp(packet, clientPort, destAddr, serverPort);
}

Referenced by handleDhcpMessage(), handleTimer(), and initRebootedClient().

sendToUdp()

void inet::DhcpClient::sendToUdp ( Packet *  msg, int  srcPort, const L3Address &  destAddr, int  destPort  )

protectedvirtual

{
    EV_INFO << "Sending packet " << msg << endl;
    msg->addTagIfAbsent<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
    socket.sendTo(msg, destAddr, destPort);
}

Referenced by sendDecline(), sendDiscover(), and sendRequest().

socketClosed()

void inet::DhcpClient::socketClosed ( UdpSocket *  socket )

overrideprotectedvirtual

Notifies about socket closed, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    if (operationalState == State::STOPPING_OPERATION && !socket.isOpen())
        startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
}

socketDataArrived()

void inet::DhcpClient::socketDataArrived ( UdpSocket *  socket, Packet *  packet  )

overrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    // process incoming packet
    handleDhcpMessage(packet);
    delete packet;
}

socketErrorArrived()

void inet::DhcpClient::socketErrorArrived ( UdpSocket *  socket, Indication *  indication  )

overrideprotectedvirtual

Notifies about error indication arrival, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    EV_WARN << "Ignoring UDP error report " << indication->getName() << endl;
    delete indication;
}

unbindLease()

void inet::DhcpClient::unbindLease ( )

protectedvirtual

{
    EV_INFO << "Unbinding lease on " << ie->getInterfaceName() << "." << endl;
 
    cancelEvent(timerT1);
    cancelEvent(timerT2);
    cancelEvent(timerTo);
    cancelEvent(leaseTimer);
 
    irt->deleteRoute(route);
    ie->getProtocolDataForUpdate<Ipv4InterfaceData>()->setIPAddress(Ipv4Address());
    ie->getProtocolDataForUpdate<Ipv4InterfaceData>()->setNetmask(Ipv4Address::ALLONES_ADDRESS);
}

Referenced by handleDhcpMessage(), handleTimer(), and receiveSignal().

Member Data Documentation

clientPort

int inet::DhcpClient::clientPort = -1

protected

Referenced by initialize(), openSocket(), sendDecline(), sendDiscover(), and sendRequest().

clientState

ClientState inet::DhcpClient::clientState = INIT

protected

Referenced by handleDhcpMessage(), handleTimer(), initClient(), initialize(), initRebootedClient(), receiveSignal(), refreshDisplay(), and sendRequest().

host

cModule* inet::DhcpClient::host = nullptr

protected

Referenced by bindLease(), and initialize().

ie

NetworkInterface* inet::DhcpClient::ie = nullptr

protected

Referenced by bindLease(), chooseInterface(), handleCrashOperation(), handleDhcpMessage(), handleStartOperation(), handleStopOperation(), receiveSignal(), sendToUdp(), and unbindLease().

irt

ModuleRefByPar<IIpv4RoutingTable> inet::DhcpClient::irt

protected

Referenced by bindLease(), initialize(), and unbindLease().

lease

DhcpLease* inet::DhcpClient::lease = nullptr

protected

Referenced by bindLease(), handleTimer(), recordLease(), recordOffer(), scheduleTimerT1(), scheduleTimerT2(), sendRequest(), and ~DhcpClient().

leaseTimer

cMessage* inet::DhcpClient::leaseTimer = nullptr

protected

Referenced by bindLease(), finish(), handleCrashOperation(), handleStopOperation(), initClient(), initialize(), unbindLease(), and ~DhcpClient().

macAddress

MacAddress inet::DhcpClient::macAddress

protected

Referenced by handleStartOperation(), recordOffer(), sendDecline(), sendDiscover(), and sendRequest().

numReceived

int inet::DhcpClient::numReceived = 0

protected

Referenced by initialize().

numSent

int inet::DhcpClient::numSent = 0

protected

Referenced by initialize().

responseTimeout

int inet::DhcpClient::responseTimeout = 0

protected

Referenced by initialize(), and scheduleTimerTO().

route

Ipv4Route* inet::DhcpClient::route = nullptr

protected

Referenced by bindLease(), and unbindLease().

serverPort

int inet::DhcpClient::serverPort = -1

protected

Referenced by initialize(), openSocket(), sendDecline(), sendDiscover(), and sendRequest().

socket

UdpSocket inet::DhcpClient::socket

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), initialize(), openSocket(), sendToUdp(), and socketClosed().

startTime

simtime_t inet::DhcpClient::startTime

protected

Referenced by handleStartOperation(), and initialize().

startTimer

cMessage* inet::DhcpClient::startTimer = nullptr

protected

Referenced by finish(), handleCrashOperation(), handleStartOperation(), handleStopOperation(), initialize(), and ~DhcpClient().

timerT1

cMessage* inet::DhcpClient::timerT1 = nullptr

protected

Referenced by finish(), handleCrashOperation(), handleStopOperation(), handleTimer(), initClient(), initialize(), scheduleTimerT1(), unbindLease(), and ~DhcpClient().

timerT2

cMessage* inet::DhcpClient::timerT2 = nullptr

protected

Referenced by finish(), handleCrashOperation(), handleStopOperation(), handleTimer(), initClient(), initialize(), scheduleTimerT2(), unbindLease(), and ~DhcpClient().

timerTo

cMessage* inet::DhcpClient::timerTo = nullptr

protected

Referenced by finish(), handleCrashOperation(), handleDhcpAck(), handleStopOperation(), handleTimer(), initClient(), initialize(), scheduleTimerTO(), unbindLease(), and ~DhcpClient().

xid

unsigned int inet::DhcpClient::xid = 0

protected

Referenced by handleDhcpMessage(), initialize(), sendDecline(), sendDiscover(), and sendRequest().

---

The documentation for this class was generated from the following files:

• DhcpClient.h
• DhcpClient.cc