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::ILifecycle
virtual	~ILifecycle ()

Protected Types
enum	TimerType { WAIT_OFFER, WAIT_ACK, T1, T2, LEASE_TIMEOUT, START_DHCP }

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

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	finish () override

virtual void	handleMessage (cMessage *msg) override

virtual void	scheduleTimerTO (TimerType type)

virtual void	scheduleTimerT1 ()

virtual void	scheduleTimerT2 ()

const char *	getAndCheckMessageTypeName (DHCPMessageType type)

virtual void	refreshDisplay () const override

virtual void	openSocket ()

virtual void	handleDHCPMessage (DHCPMessage *msg)

virtual void	handleTimer (cMessage *msg)

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

virtual void	sendToUDP (cPacket *msg, int srcPort, const L3Address &destAddr, int destPort)

virtual void	sendDiscover ()

virtual void	sendRequest ()

virtual void	sendDecline (IPv4Address declinedIp)

virtual void	recordLease (DHCPMessage *dhcpACK)

virtual void	recordOffer (DHCPMessage *dhcpOffer)

virtual void	bindLease ()

virtual void	unbindLease ()

virtual void	initClient ()

virtual void	initRebootedClient ()

virtual void	handleDHCPACK (DHCPMessage *msg)

virtual InterfaceEntry *	chooseInterface ()

virtual void	startApp ()

virtual void	stopApp ()

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

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

InterfaceEntry *	ie = nullptr

IIPv4RoutingTable *	irt = nullptr

cMessage *	timerT1 = nullptr

cMessage *	timerT2 = nullptr

cMessage *	timerTo = nullptr

cMessage *	leaseTimer = nullptr

cMessage *	startTimer = nullptr

bool	isOperational = false

ClientState	clientState = INIT

unsigned int	xid = 0

DHCPLease *	lease = nullptr

IPv4Route *	route = nullptr

int	numSent = 0

int	numReceived = 0

int	responseTimeout = 0

Detailed Description

Implements a DHCP client.

See NED file for more details.

Member Enumeration Documentation

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
     };

enum inet::DHCPClient::TimerType

protected

Enumerator
WAIT_OFFER
WAIT_ACK
T1
T2
LEASE_TIMEOUT
START_DHCP

                    {
         WAIT_OFFER, WAIT_ACK, T1, T2, LEASE_TIMEOUT, START_DHCP
     };

Constructor & Destructor Documentation

inet::DHCPClient::DHCPClient ( )

inline

184 {}

inet::DHCPClient::~DHCPClient ( )

virtual

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

Member Function Documentation

void inet::DHCPClient::bindLease ( )

protectedvirtual

Referenced by handleDHCPACK().

 {
     ie->ipv4Data()->setIPAddress(lease->ip);
     ie->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->getName())) {
             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
     cancelEvent(leaseTimer);
     scheduleAt(simTime() + lease->leaseTime, leaseTimer);
 }

InterfaceEntry * inet::DHCPClient::chooseInterface ( )

protectedvirtual

Referenced by initialize(), and startApp().

 {
     IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
     const char *interfaceName = par("interface");
     InterfaceEntry *ie = nullptr;
 
     if (strlen(interfaceName) > 0) {
         ie = ift->getInterfaceByName(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++) {
             InterfaceEntry *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->ipv4Data()->getIPAddress().isUnspecified())
         throw cRuntimeError("Refusing to start DHCP on interface \"%s\" that already has an IP address", ie->getName());
     return ie;
 }

void inet::DHCPClient::finish ( )

overrideprotectedvirtual

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

const char * inet::DHCPClient::getAndCheckMessageTypeName ( DHCPMessageType type )

protected

Referenced by handleDHCPMessage().

 {
     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
     }
 }

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

staticprotected

Referenced by refreshDisplay().

 {
     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
     }
 }

void inet::DHCPClient::handleDHCPACK ( DHCPMessage * msg )

protectedvirtual

Referenced by handleDHCPMessage().

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

void inet::DHCPClient::handleDHCPMessage ( DHCPMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     ASSERT(isOperational && ie != nullptr);
 
     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 = (DHCPMessageType)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);
     }
 }

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

overrideprotectedvirtual

 {
     if (!isOperational) {
         EV_ERROR << "Message '" << msg << "' arrived when module status is down, dropping." << endl;
         delete msg;
         return;
     }
     if (msg->isSelfMessage()) {
         handleTimer(msg);
     }
     else if (msg->arrivedOn("udpIn")) {
         DHCPMessage *dhcpPacket = dynamic_cast<DHCPMessage *>(msg);
         if (!dhcpPacket)
             throw cRuntimeError(dhcpPacket, "Unexpected packet received (not a DHCPMessage)");
 
         handleDHCPMessage(dhcpPacket);
         delete msg;
     }
     else
         throw cRuntimeError("Unknown incoming gate: '%s'", msg->getArrivalGate()->getFullName());
 }

bool inet::DHCPClient::handleOperationStage	(	LifecycleOperation *	operation,
		int	stage,
		IDoneCallback *	doneCallback
	)

overrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

 {
     Enter_Method_Silent();
     if (dynamic_cast<NodeStartOperation *>(operation)) {
         if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER) {
             startApp();
             isOperational = true;
         }
     }
     else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
         if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
             stopApp();
             isOperational = false;
             ie = nullptr;
         }
     }
     else if (dynamic_cast<NodeCrashOperation *>(operation)) {
         if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
             stopApp();
             isOperational = false;
             ie = nullptr;
         }
     }
     else
         throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
     return true;
 }

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

protectedvirtual

Referenced by handleMessage().

 {
     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());
 }

void inet::DHCPClient::initClient ( )

protectedvirtual

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

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

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

overrideprotectedvirtual

 {
     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");
     }
     else if (stage == INITSTAGE_APPLICATION_LAYER) {
         NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
         isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
 
         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 hostname
         host = getContainingNode(this);
 
         // for a wireless interface subscribe the association event to start the DHCP protocol
         host->subscribe(NF_L2_ASSOCIATED, this);
         host->subscribe(NF_INTERFACE_DELETED, this);
 
         // get the routing table to update and subscribe it to the blackboard
         irt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
         // set client to idle state
         clientState = IDLE;
         // get the interface to configure
 
         if (isOperational) {
             ie = chooseInterface();
             // grab the interface MAC address
             macAddress = ie->getMacAddress();
             startApp();
         }
     }
 }

void inet::DHCPClient::initRebootedClient ( )

protectedvirtual

Referenced by handleTimer().

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

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

inlineoverrideprotectedvirtual

78 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::DHCPClient::openSocket ( )

protectedvirtual

Referenced by handleTimer().

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

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

overrideprotectedvirtual

 {
     Enter_Method_Silent();
     printNotificationBanner(signalID, obj);
 
     // host associated. link is up. change the state to init.
     if (signalID == NF_L2_ASSOCIATED) {
         InterfaceEntry *associatedIE = check_and_cast_nullable<InterfaceEntry *>(obj);
         if (associatedIE && ie == associatedIE) {
             EV_INFO << "Interface associated, starting DHCP." << endl;
             unbindLease();
             initClient();
         }
     }
     else if (signalID == NF_INTERFACE_DELETED) {
         if (isOperational)
             throw cRuntimeError("Reacting to interface deletions is not implemented in this module");
     }
 }

void inet::DHCPClient::recordLease ( DHCPMessage * dhcpACK )

protectedvirtual

Referenced by handleDHCPACK().

 {
     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;
 }

void inet::DHCPClient::recordOffer ( DHCPMessage * dhcpOffer )

protectedvirtual

Referenced by handleDHCPMessage().

 {
     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;
 }

void inet::DHCPClient::refreshDisplay ( ) const

overrideprotectedvirtual

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

void inet::DHCPClient::scheduleTimerT1 ( )

protectedvirtual

Referenced by handleDHCPACK().

 {
     // cancel the previous T1
     cancelEvent(timerT1);
     scheduleAt(simTime() + (lease->renewalTime), timerT1);    // RFC 2131 4.4.5
 }

void inet::DHCPClient::scheduleTimerT2 ( )

protectedvirtual

Referenced by handleDHCPACK().

 {
     // cancel the previous T2
     cancelEvent(timerT2);
     scheduleAt(simTime() + (lease->rebindTime), timerT2);    // RFC 2131 4.4.5
 }

void inet::DHCPClient::scheduleTimerTO ( TimerType type )

protectedvirtual

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

 {
     // cancel the previous timeout
     cancelEvent(timerTo);
     timerTo->setKind(type);
     scheduleAt(simTime() + responseTimeout, timerTo);
 }

void inet::DHCPClient::sendDecline ( IPv4Address declinedIp )

protectedvirtual

 {
     xid = intuniform(0, RAND_MAX);
     DHCPMessage *decline = new DHCPMessage("DHCPDECLINE");
     decline->setOp(BOOTREQUEST);
     decline->setByteLength(280);    // DHCPDECLINE packet size
     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
     decline->getOptions().setMessageType(DHCPDECLINE);
     decline->getOptions().setRequestedIp(declinedIp);
     EV_INFO << "Sending DHCPDECLINE." << endl;
     sendToUDP(decline, clientPort, IPv4Address::ALLONES_ADDRESS, serverPort);
 }

void inet::DHCPClient::sendDiscover ( )

protectedvirtual

Referenced by initClient().

 {
     // setting the xid
     xid = intuniform(0, RAND_MAX);
     //std::cout << xid << endl;
     DHCPMessage *discover = new DHCPMessage("DHCPDISCOVER");
     discover->setOp(BOOTREQUEST);
     discover->setByteLength(280);    // DHCP Discover packet size;
     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
     discover->getOptions().setMessageType(DHCPDISCOVER);
     discover->getOptions().setClientIdentifier(macAddress);
     discover->getOptions().setRequestedIp(IPv4Address());
 
     // set the parameters to request
     discover->getOptions().setParameterRequestListArraySize(4);
     discover->getOptions().setParameterRequestList(0, SUBNET_MASK);
     discover->getOptions().setParameterRequestList(1, ROUTER);
     discover->getOptions().setParameterRequestList(2, DNS);
     discover->getOptions().setParameterRequestList(3, NTP_SRV);
 
     EV_INFO << "Sending DHCPDISCOVER." << endl;
     sendToUDP(discover, clientPort, IPv4Address::ALLONES_ADDRESS, serverPort);
 }

void inet::DHCPClient::sendRequest ( )

protectedvirtual

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

 {
     // setting the xid
     xid = intuniform(0, RAND_MAX);    // generating a new xid for each transmission
 
     DHCPMessage *request = new DHCPMessage("DHCPREQUEST");
     request->setOp(BOOTREQUEST);
     request->setByteLength(280);    // DHCP request packet size
     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
     request->getOptions().setMessageType(DHCPREQUEST);
     request->getOptions().setClientIdentifier(macAddress);
 
     // set the parameters to request
     request->getOptions().setParameterRequestListArraySize(4);
     request->getOptions().setParameterRequestList(0, SUBNET_MASK);
     request->getOptions().setParameterRequestList(1, ROUTER);
     request->getOptions().setParameterRequestList(2, DNS);
     request->getOptions().setParameterRequestList(3, NTP_SRV);
 
     // RFC 4.3.6 Table 4
     if (clientState == INIT_REBOOT) {
         request->getOptions().setRequestedIp(lease->ip);
         request->setCiaddr(IPv4Address());    // zero
         EV_INFO << "Sending DHCPREQUEST asking for IP " << lease->ip << " via broadcast." << endl;
         sendToUDP(request, clientPort, IPv4Address::ALLONES_ADDRESS, serverPort);
     }
     else if (clientState == REQUESTING) {
         request->getOptions().setServerIdentifier(lease->serverId);
         request->getOptions().setRequestedIp(lease->ip);
         request->setCiaddr(IPv4Address());    // zero
         EV_INFO << "Sending DHCPREQUEST asking for IP " << lease->ip << " via broadcast." << endl;
         sendToUDP(request, clientPort, IPv4Address::ALLONES_ADDRESS, serverPort);
     }
     else if (clientState == RENEWING) {
         request->setCiaddr(lease->ip);    // the client IP
         EV_INFO << "Sending DHCPREQUEST extending lease for IP " << lease->ip << " via unicast to " << lease->serverId << "." << endl;
         sendToUDP(request, clientPort, lease->serverId, serverPort);
     }
     else if (clientState == REBINDING) {
         request->setCiaddr(lease->ip);    // the client IP
         EV_INFO << "Sending DHCPREQUEST renewing the IP " << lease->ip << " via broadcast." << endl;
         sendToUDP(request, clientPort, IPv4Address::ALLONES_ADDRESS, serverPort);
     }
     else
         throw cRuntimeError("Invalid state");
 }

void inet::DHCPClient::sendToUDP	(	cPacket *	msg,
		int	srcPort,
		const L3Address &	destAddr,
		int	destPort
	)

protectedvirtual

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

 {
     EV_INFO << "Sending packet " << msg << endl;
     UDPSocket::SendOptions options;
     options.outInterfaceId = ie->getInterfaceId();
     socket.sendTo(msg, destAddr, destPort, &options);
 }

void inet::DHCPClient::startApp ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

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

void inet::DHCPClient::stopApp ( )

protectedvirtual

Referenced by handleOperationStage().

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

void inet::DHCPClient::unbindLease ( )

protectedvirtual

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

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