inet::DHCPServer Class Reference

Implements a DHCP server. More...

#include <DHCPServer.h>

Inheritance diagram for inet::DHCPServer:

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

Protected Types
enum	TimerType { START_DHCP }
typedef std::map< IPv4Address, DHCPLease >	DHCPLeased

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	openSocket ()
virtual DHCPLease *	getLeaseByMac (MACAddress mac)
virtual DHCPLease *	getAvailableLease (IPv4Address requestedAddress, MACAddress &clientMAC)
virtual void	processDHCPMessage (DHCPMessage *packet)
virtual void	sendOffer (DHCPLease *lease, DHCPMessage *packet)
virtual void	sendACK (DHCPLease *lease, DHCPMessage *packet)
virtual void	sendNAK (DHCPMessage *msg)
virtual void	handleSelfMessages (cMessage *msg)
virtual InterfaceEntry *	chooseInterface ()
virtual void	sendToUDP (cPacket *msg, int srcPort, const L3Address &destAddr, int destPort)
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual void	startApp ()
virtual void	stopApp ()
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Attributes
DHCPLeased	leased
bool	isOperational = false
int	numSent = 0
int	numReceived = 0
int	serverPort = -1
int	clientPort = -1
unsigned int	maxNumOfClients = 0
unsigned int	leaseTime = 0
IPv4Address	subnetMask
IPv4Address	gateway
IPv4Address	ipAddressStart
InterfaceEntry *	ie = nullptr
UDPSocket	socket
simtime_t	startTime
cMessage *	startTimer = nullptr

Detailed Description

Implements a DHCP server.

See NED file for more details.

Member Typedef Documentation

typedef std::map<IPv4Address, DHCPLease> inet::DHCPServer::DHCPLeased

protected

Member Enumeration Documentation

enum inet::DHCPServer::TimerType

protected

Enumerator
START_DHCP

                   {
        START_DHCP
    };

Constructor & Destructor Documentation

inet::DHCPServer::DHCPServer

(

)

{
    ie = nullptr;
    startTimer = nullptr;
}

inet::DHCPServer::~DHCPServer ( )

virtual

{
    cancelAndDelete(startTimer);
}

Member Function Documentation

InterfaceEntry * inet::DHCPServer::chooseInterface ( )

protectedvirtual

Referenced by 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 serve DHCP requests on
        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 serve DHCP requests on");
                ie = current;
            }
        }
        if (!ie)
            throw cRuntimeError("No non-loopback interface found to be configured via DHCP");
    }

    return ie;
}

DHCPLease * inet::DHCPServer::getAvailableLease ( IPv4Address  requestedAddress, MACAddress &  clientMAC  )

protectedvirtual

Referenced by processDHCPMessage().

{
    int beginAddr = ipAddressStart.getInt();    // the first address that we might use

    // try to allocate the requested address if that address is valid and not already allocated
    if (!requestedAddress.isUnspecified()) {    // valid
        if (leased.find(requestedAddress) != leased.end() && !leased[requestedAddress].leased) // not already leased (allocated)
            return &leased[requestedAddress];

        // lease does not exist, create it
        leased[requestedAddress] = DHCPLease();
        leased[requestedAddress].ip = requestedAddress;
        leased[requestedAddress].gateway = gateway;
        leased[requestedAddress].subnetMask = subnetMask;

        return &leased[requestedAddress];
    }

    // allocate new address from server's pool of available addresses
    for (unsigned int i = 0; i < maxNumOfClients; i++) {
        IPv4Address ip(beginAddr + i);
        if (leased.find(ip) != leased.end()) {
            // lease exists but not allocated (e.g. expired or released)
            if (!leased[ip].leased)
                return &(leased[ip]);
        }
        else {
            // there is no expired lease so we create a new one
            leased[ip] = DHCPLease();
            leased[ip].ip = ip;
            leased[ip].gateway = gateway;
            leased[ip].subnetMask = subnetMask;
            return &(leased[ip]);
        }
    }
    // no lease available
    return nullptr;
}

DHCPLease * inet::DHCPServer::getLeaseByMac ( MACAddress  mac )

protectedvirtual

Referenced by processDHCPMessage().

{
    for (auto & elem : leased) {
        // lease exist
        if (elem.second.mac == mac) {
            EV_DETAIL << "Found lease for MAC " << mac << "." << endl;
            return &(elem.second);
        }
    }
    EV_DETAIL << "Lease not found for MAC " << mac << "." << endl;

    // lease does not exist
    return nullptr;
}

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

overrideprotectedvirtual

{
    DHCPMessage *dhcpPacket = dynamic_cast<DHCPMessage *>(msg);
    if (msg->isSelfMessage()) {
        handleSelfMessages(msg);
    }
    else if (dhcpPacket)
        processDHCPMessage(dhcpPacket);
    else {
        // note: unknown packets are likely ICMP errors in response to DHCP messages we sent out; just ignore them
        EV_WARN << "Unknown packet '" << msg->getName() << "', discarding it." << endl;
        delete msg;
    }
}

bool inet::DHCPServer::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;
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
            stopApp();
            isOperational = false;
        }
    }
    else
        throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
    return true;
}

void inet::DHCPServer::handleSelfMessages ( cMessage *  msg )

protectedvirtual

Referenced by handleMessage().

{
    if (msg->getKind() == START_DHCP) {
        openSocket();
    }
    else
        throw cRuntimeError("Unknown selfmessage type!");
}

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        startTimer = new cMessage("Start DHCP server", START_DHCP);
        startTime = par("startTime");
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        numSent = 0;
        numReceived = 0;
        WATCH(numSent);
        WATCH(numReceived);
        WATCH_MAP(leased);

        // DHCP UDP ports
        clientPort = 68;    // client
        serverPort = 67;    // server

        cModule *host = getContainingNode(this);
        host->subscribe(NF_INTERFACE_DELETED, this);

        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(host->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;

        if (isOperational)
            startApp();
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::DHCPServer::openSocket ( )

protectedvirtual

Referenced by handleSelfMessages().

{
    if (!ie)
        throw cRuntimeError("Interface to listen does not exist. aborting");
    socket.setOutputGate(gate("udpOut"));
    socket.bind(serverPort);
    socket.setBroadcast(true);
    EV_INFO << "DHCP server bound to port " << serverPort << endl;
}

void inet::DHCPServer::processDHCPMessage ( DHCPMessage *  packet )

protectedvirtual

Referenced by handleMessage().

{
    ASSERT(isOperational && ie != nullptr);

    // check that the packet arrived on the interface we are supposed to serve
    UDPDataIndication *ctrl = check_and_cast<UDPDataIndication *>(packet->removeControlInfo());
    int inputInterfaceId = ctrl->getInterfaceId();
    delete ctrl;
    if (inputInterfaceId != ie->getInterfaceId()) {
        EV_WARN << "DHCP message arrived on a different interface, dropping\n";
        delete packet;
        return;
    }

    // check the OP code
    if (packet->getOp() == BOOTREQUEST) {
        int messageType = packet->getOptions().getMessageType();

        if (messageType == DHCPDISCOVER) {    // RFC 2131, 4.3.1
            EV_INFO << "DHCPDISCOVER arrived. Handling it." << endl;

            DHCPLease *lease = getLeaseByMac(packet->getChaddr());
            if (!lease) {
                // MAC not registered, create offering a new lease to the client
                lease = getAvailableLease(packet->getOptions().getRequestedIp(), packet->getChaddr());
                if (lease != nullptr) {
                    // std::cout << "MAC: " << packet->getChaddr() << " ----> IP: " << lease->ip << endl;
                    lease->mac = packet->getChaddr();
                    lease->xid = packet->getXid();
                    //lease->parameterRequestList = packet->getOptions().get(PARAM_LIST); TODO: !!
                    lease->leased = true;    // TODO
                    sendOffer(lease, packet);
                }
                else
                    EV_ERROR << "No lease available. Ignoring discover." << endl;
            }
            else {
                // MAC already exist, offering the same lease
                lease->xid = packet->getXid();
                //lease->parameterRequestList = packet->getOptions().get(PARAM_LIST); // TODO: !!
                sendOffer(lease, packet);
            }
        }
        else if (messageType == DHCPREQUEST) {    // RFC 2131, 4.3.2
            EV_INFO << "DHCPREQUEST arrived. Handling it." << endl;

            // check if the request was in response of an offering
            if (packet->getOptions().getServerIdentifier() == ie->ipv4Data()->getIPAddress()) {
                // the REQUEST is in response to an offering (because SERVER_ID is filled)
                // otherwise the msg is a request to extend an existing lease (e. g. INIT-REBOOT)

                DHCPLease *lease = getLeaseByMac(packet->getChaddr());
                if (lease != nullptr) {
                    if (lease->ip != packet->getOptions().getRequestedIp()) {
                        EV_ERROR << "The 'requested IP address' must be filled in with the 'yiaddr' value from the chosen DHCPOFFER." << endl;
                        sendNAK(packet);
                    }
                    else {
                        EV_INFO << "From now " << lease->ip << " is leased to " << lease->mac << "." << endl;
                        lease->xid = packet->getXid();
                        lease->leaseTime = leaseTime;
                        lease->leased = true;

                        // TODO: final check before ACK (it is not necessary but recommended)
                        sendACK(lease, packet);

                        // TODO: update the display string to inform how many clients are assigned
                    }
                }
                else {
                    EV_ERROR << "There is no available lease for " << packet->getChaddr() << ". Probably, the client missed to send DHCPDISCOVER before DHCPREQUEST." << endl;
                    sendNAK(packet);
                }
            }
            else {
                if (packet->getCiaddr().isUnspecified()) {    // init-reboot
                    // std::cout << "init-reboot" << endl;
                    IPv4Address requestedAddress = packet->getOptions().getRequestedIp();
                    auto it = leased.find(requestedAddress);
                    if (it == leased.end()) {
                        // if DHCP server has no record of the requested IP, then it must remain silent
                        // and may output a warning to the network admin
                        EV_WARN << "DHCP server has no record of IP " << requestedAddress << "." << endl;
                    }
                    else if (IPv4Address::maskedAddrAreEqual(requestedAddress, it->second.ip, subnetMask)) {    // on the same network
                        DHCPLease *lease = &it->second;
                        EV_INFO << "Initialization with known IP address (INIT-REBOOT) " << lease->ip << " on " << lease->mac << " was successful." << endl;
                        lease->xid = packet->getXid();
                        lease->leaseTime = leaseTime;
                        lease->leased = true;

                        // TODO: final check before ACK (it is not necessary but recommended)
                        sendACK(lease, packet);
                    }
                    else {
                        EV_ERROR << "The requested IP address is incorrect, or is on the wrong network." << endl;
                        sendNAK(packet);
                    }
                }
                else {    // renewing or rebinding: in this case ciaddr must be filled in with client's IP address
                    auto it = leased.find(packet->getCiaddr());
                    DHCPLease *lease = &it->second;
                    if (it != leased.end()) {
                        EV_INFO << "Request for renewal/rebinding IP " << lease->ip << " to " << lease->mac << "." << endl;
                        lease->xid = packet->getXid();
                        lease->leaseTime = leaseTime;
                        lease->leased = true;

                        // unicast ACK to ciaddr
                        sendACK(lease, packet);
                    }
                    else {
                        EV_ERROR << "Renewal/rebinding process failed: requested IP address " << packet->getCiaddr() << " not found in the server's database!" << endl;
                        sendNAK(packet);
                    }
                }
            }
        }
        else
            EV_WARN << "BOOTREQUEST arrived, but DHCP message type is unknown. Dropping it." << endl;
    }
    else {
        EV_WARN << "Message opcode is unknown. This DHCP server only handles BOOTREQUEST messages. Dropping it." << endl;
    }

    EV_DEBUG << "Deleting " << packet << "." << endl;
    delete packet;

    numReceived++;
}

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

overrideprotectedvirtual

{
    Enter_Method_Silent();

    if (signalID == NF_INTERFACE_DELETED) {
        if (isOperational) {
            InterfaceEntry *nie = check_and_cast<InterfaceEntry *>(obj);
            if (ie == nie)
                throw cRuntimeError("Reacting to interface deletions is not implemented in this module");
        }
    }
    else
        throw cRuntimeError("Unexpected signal: %s", getSignalName(signalID));
}

void inet::DHCPServer::sendACK ( DHCPLease *  lease, DHCPMessage *  packet  )

protectedvirtual

Referenced by processDHCPMessage().

{
    EV_INFO << "Sending the ACK to " << lease->mac << "." << endl;

    DHCPMessage *ack = new DHCPMessage("DHCPACK");
    ack->setOp(BOOTREPLY);
    ack->setByteLength(308);    // DHCP ACK packet size
    ack->setHtype(1);    // ethernet
    ack->setHlen(6);    // hardware address length (6 octets)
    ack->setHops(0);
    ack->setXid(lease->xid);    // transaction id;
    ack->setSecs(0);    // 0 seconds from transaction started
    ack->setBroadcast(false);
    ack->setCiaddr(lease->ip);    // client IP addr.
    ack->setYiaddr(lease->ip);    // client IP addr.

    ack->setChaddr(lease->mac);    // client MAC address
    ack->setSname("");    // no server name given
    ack->setFile("");    // no file given
    ack->getOptions().setMessageType(DHCPACK);

    // add the lease options
    ack->getOptions().setSubnetMask(lease->subnetMask);
    ack->getOptions().setRenewalTime(leaseTime * 0.5);    // RFC 4.4.5
    ack->getOptions().setRebindingTime(leaseTime * 0.875);
    ack->getOptions().setLeaseTime(leaseTime);
    ack->getOptions().setRouterArraySize(1);
    ack->getOptions().setRouter(0, lease->gateway);
    ack->getOptions().setDnsArraySize(1);
    ack->getOptions().setDns(0, lease->dns);

    // add the server ID as the RFC says
    ack->getOptions().setServerIdentifier(ie->ipv4Data()->getIPAddress());

    // register the lease time
    lease->leaseTime = simTime();

    /* RFC 2131, 4.1
     * If the 'giaddr' field in a DHCP message from a client is non-zero,
     * the server sends any return messages to the 'DHCP server' port on the
     * BOOTP relay agent whose address appears in 'giaddr'. If the 'giaddr'
     * field is zero and the 'ciaddr' field is nonzero, then the server
     * unicasts DHCPOFFER and DHCPACK messages to the address in 'ciaddr'.
     * If 'giaddr' is zero and 'ciaddr' is zero, and the broadcast bit is
     * set, then the server broadcasts DHCPOFFER and DHCPACK messages to
     * 0xffffffff. If the broadcast bit is not set and 'giaddr' is zero and
     * 'ciaddr' is zero, then the server unicasts DHCPOFFER and DHCPACK
     * messages to the client's hardware address and 'yiaddr' address.
     */
    IPv4Address destAddr;
    if (!packet->getGiaddr().isUnspecified())
        destAddr = packet->getGiaddr();
    else if (!packet->getCiaddr().isUnspecified())
        destAddr = packet->getCiaddr();
    else if (packet->getBroadcast())
        destAddr = IPv4Address::ALLONES_ADDRESS;
    else {
        // TODO should send it to client's hardware address and yiaddr address, but the application can not set the destination MACAddress.
        // destAddr = lease->ip;
        destAddr = IPv4Address::ALLONES_ADDRESS;
    }

    sendToUDP(ack, serverPort, destAddr, clientPort);
}

void inet::DHCPServer::sendNAK ( DHCPMessage *  msg )

protectedvirtual

Referenced by processDHCPMessage().

{
    // EV_INFO << "Sending NAK to " << lease->mac << "." << endl;
    DHCPMessage *nak = new DHCPMessage("DHCPNAK");
    nak->setOp(BOOTREPLY);
    nak->setByteLength(308);    // DHCPNAK packet size
    nak->setHtype(1);    // ethernet
    nak->setHlen(6);    // hardware address length (6 octets)
    nak->setHops(0);
    nak->setXid(msg->getXid());    // transaction id from client
    nak->setSecs(0);    // 0 seconds from transaction started.
    nak->setBroadcast(msg->getBroadcast());
    nak->setGiaddr(msg->getGiaddr());    // next server IP
    nak->setChaddr(msg->getChaddr());
    nak->getOptions().setServerIdentifier(ie->ipv4Data()->getIPAddress());
    nak->getOptions().setMessageType(DHCPNAK);

    /* RFC 2131, 4.1
     *
     * In all cases, when 'giaddr' is zero, the server broadcasts any DHCPNAK
     * messages to 0xffffffff.
     */
    IPv4Address destAddr = IPv4Address::ALLONES_ADDRESS;
    if (!msg->getGiaddr().isUnspecified())
        destAddr = msg->getGiaddr();
    sendToUDP(nak, serverPort, destAddr, clientPort);
}

void inet::DHCPServer::sendOffer ( DHCPLease *  lease, DHCPMessage *  packet  )

protectedvirtual

Referenced by processDHCPMessage().

{
    EV_INFO << "Offering " << *lease << endl;

    DHCPMessage *offer = new DHCPMessage("DHCPOFFER");
    offer->setOp(BOOTREPLY);
    offer->setByteLength(308);    // DHCP OFFER packet size
    offer->setHtype(1);    // ethernet
    offer->setHlen(6);    // hardware address lenght (6 octets)
    offer->setHops(0);
    offer->setXid(lease->xid);    // transaction id
    offer->setSecs(0);    // 0 seconds from transaction started
    offer->setBroadcast(false);    // unicast

    offer->setYiaddr(lease->ip);    // ip offered.
    offer->setGiaddr(lease->gateway);    // next server ip

    offer->setChaddr(lease->mac);    // client mac address
    offer->setSname("");    // no server name given
    offer->setFile("");    // no file given
    offer->getOptions().setMessageType(DHCPOFFER);

    // add the offer options
    offer->getOptions().setSubnetMask(lease->subnetMask);
    offer->getOptions().setRenewalTime(leaseTime * 0.5);    // RFC 4.4.5
    offer->getOptions().setRebindingTime(leaseTime * 0.875);
    offer->getOptions().setLeaseTime(leaseTime);
    offer->getOptions().setRouterArraySize(1);
    offer->getOptions().setRouter(0, lease->gateway);
    offer->getOptions().setDnsArraySize(1);
    offer->getOptions().setDns(0, lease->dns);

    // add the server_id as the RFC says
    offer->getOptions().setServerIdentifier(ie->ipv4Data()->getIPAddress());

    // register the offering time // todo: ?
    lease->leaseTime = simTime();

    /* RFC 2131, 4.1
     * If the 'giaddr' field in a DHCP message from a client is non-zero,
     * the server sends any return messages to the 'DHCP server' port on the
     * BOOTP relay agent whose address appears in 'giaddr'. If the 'giaddr'
     * field is zero and the 'ciaddr' field is nonzero, then the server
     * unicasts DHCPOFFER and DHCPACK messages to the address in 'ciaddr'.
     * If 'giaddr' is zero and 'ciaddr' is zero, and the broadcast bit is
     * set, then the server broadcasts DHCPOFFER and DHCPACK messages to
     * 0xffffffff. If the broadcast bit is not set and 'giaddr' is zero and
     * 'ciaddr' is zero, then the server unicasts DHCPOFFER and DHCPACK
     * messages to the client's hardware address and 'yiaddr' address.
     */
    IPv4Address destAddr;
    if (!packet->getGiaddr().isUnspecified())
        destAddr = packet->getGiaddr();
    else if (!packet->getCiaddr().isUnspecified())
        destAddr = packet->getCiaddr();
    else if (packet->getBroadcast())
        destAddr = IPv4Address::ALLONES_ADDRESS;
    else {
        // TODO should send it to client's hardware address and yiaddr address, but the application can not set the destination MACAddress.
        // destAddr = lease->ip;
        destAddr = IPv4Address::ALLONES_ADDRESS;
    }

    sendToUDP(offer, serverPort, destAddr, clientPort);
}

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

protectedvirtual

Referenced by sendACK(), sendNAK(), and sendOffer().

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

void inet::DHCPServer::startApp ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

{
    maxNumOfClients = par("maxNumClients");
    leaseTime = par("leaseTime");

    simtime_t start = std::max(startTime, simTime());
    ie = chooseInterface();
    IPv4InterfaceData *ipv4data = ie->ipv4Data();
    if (ipv4data == nullptr)
        throw cRuntimeError("interface %s is not configured for IPv4", ie->getFullName());
    const char *gatewayStr = par("gateway").stringValue();
    gateway = *gatewayStr ? L3AddressResolver().resolve(gatewayStr, L3AddressResolver::ADDR_IPv4).toIPv4() : ipv4data->getIPAddress();
    subnetMask = ipv4data->getNetmask();
    long numReservedAddresses = par("numReservedAddresses").longValue();
    uint32_t networkStartAddress = ipv4data->getIPAddress().getInt() & ipv4data->getNetmask().getInt();
    ipAddressStart = IPv4Address(networkStartAddress + numReservedAddresses);
    if (!IPv4Address::maskedAddrAreEqual(ipv4data->getIPAddress(), ipAddressStart, subnetMask))
        throw cRuntimeError("The numReservedAddresses parameter larger than address range");
    if (!IPv4Address::maskedAddrAreEqual(ipv4data->getIPAddress(), IPv4Address(ipAddressStart.getInt() + maxNumOfClients - 1), subnetMask))
        throw cRuntimeError("Not enough IP addresses in subnet for %d clients", maxNumOfClients);
    scheduleAt(start, startTimer);
}

void inet::DHCPServer::stopApp ( )

protectedvirtual

Referenced by handleOperationStage().

{
    leased.clear();
    ie = nullptr;
    cancelEvent(startTimer);
    // socket.close(); TODO:
}

Member Data Documentation

int inet::DHCPServer::clientPort = -1

protected

Referenced by initialize(), sendACK(), sendNAK(), and sendOffer().

IPv4Address inet::DHCPServer::gateway

protected

Referenced by getAvailableLease(), and startApp().

InterfaceEntry* inet::DHCPServer::ie = nullptr

protected

Referenced by chooseInterface(), DHCPServer(), openSocket(), processDHCPMessage(), receiveSignal(), sendACK(), sendNAK(), sendOffer(), sendToUDP(), startApp(), and stopApp().

IPv4Address inet::DHCPServer::ipAddressStart

protected

Referenced by getAvailableLease(), and startApp().

bool inet::DHCPServer::isOperational = false

protected

Referenced by handleOperationStage(), initialize(), processDHCPMessage(), and receiveSignal().

DHCPLeased inet::DHCPServer::leased

protected

Referenced by getAvailableLease(), getLeaseByMac(), initialize(), processDHCPMessage(), and stopApp().

unsigned int inet::DHCPServer::leaseTime = 0

protected

Referenced by processDHCPMessage(), sendACK(), sendOffer(), and startApp().

unsigned int inet::DHCPServer::maxNumOfClients = 0

protected

Referenced by getAvailableLease(), and startApp().

int inet::DHCPServer::numReceived = 0

protected

Referenced by initialize(), and processDHCPMessage().

int inet::DHCPServer::numSent = 0

protected

Referenced by initialize(), and sendToUDP().

int inet::DHCPServer::serverPort = -1

protected

Referenced by initialize(), openSocket(), sendACK(), sendNAK(), and sendOffer().

UDPSocket inet::DHCPServer::socket

protected

Referenced by openSocket(), and sendToUDP().

simtime_t inet::DHCPServer::startTime

protected

Referenced by initialize(), and startApp().

cMessage* inet::DHCPServer::startTimer = nullptr

protected

Referenced by DHCPServer(), initialize(), startApp(), stopApp(), and ~DHCPServer().

IPv4Address inet::DHCPServer::subnetMask

protected

Referenced by getAvailableLease(), processDHCPMessage(), and startApp().

---

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

• DHCPServer.h
• DHCPServer.cc