internet-apps: use a std::array to store DHCP Chaddr

Author: TommyPec

src/internet-apps/model/dhcp-client.cc

@@ -166,12 +166,12 @@ DhcpClient::StartApplication()
     // Moreover, the length is always 16, because chaddr is 16 bytes.
     Address myAddress = m_device->GetAddress();
     NS_LOG_INFO("My address is " << myAddress);
-    uint8_t addr[Address::MAX_SIZE];
-    std::memset(addr, 0, Address::MAX_SIZE);
-    uint32_t len = myAddress.CopyTo(addr);
-    NS_ASSERT_MSG(len <= 16, "DHCP client can not handle a chaddr larger than 16 bytes");
-    m_chaddr.CopyFrom(addr, 16);
-    NS_LOG_INFO("My m_chaddr is " << m_chaddr);
+    NS_ASSERT_MSG(myAddress.GetLength() <= 16,
+                  "DHCP client can not handle a chaddr larger than 16 bytes");
+
+    m_chaddr.fill(0);
+    myAddress.CopyTo(m_chaddr.begin());
+    NS_LOG_INFO("My Chaddr is " << DhcpChaddrToString(m_chaddr));
 
     bool found = false;
     for (uint32_t i = 0; i < ipv4->GetNAddresses(ifIndex); i++)

src/internet-apps/model/dhcp-client.h

@@ -140,7 +140,7 @@ class DhcpClient : public Application
     Ipv4Address m_remoteAddress;  //!< Initially set to 255.255.255.255 to start DHCP
     Ipv4Address m_offeredAddress; //!< Address offered to the client
     Ipv4Address m_myAddress;      //!< Address assigned to the client
-    Address m_chaddr;         //!< chaddr of the interface (stored as an Address for convenience).
+    DhcpChaddr m_chaddr{};    //!< chaddr of the interface (stored as an Address for convenience).
     Ipv4Mask m_myMask;        //!< Mask of the address assigned
     Ipv4Address m_server;     //!< Address of the DHCP server
     Ipv4Address m_gateway;    //!< Address of the gateway

src/internet-apps/model/dhcp-header.cc

@@ -17,12 +17,35 @@
 #include "ns3/log.h"
 #include "ns3/simulator.h"
 
+#include <iomanip>
+#include <sstream>
+
+/**
+ * @file
+ * @ingroup internet-apps
+ * DhcpHeader classes implementation.
+ */
+
 namespace ns3
 {
 
 NS_LOG_COMPONENT_DEFINE("DhcpHeader");
 NS_OBJECT_ENSURE_REGISTERED(DhcpHeader);
 
+std::string
+DhcpChaddrToString(const DhcpChaddr& chaddr)
+{
+    std::ostringstream outStream;
+    outStream.fill('0');
+    outStream.setf(std::ios::hex, std::ios::basefield);
+
+    for (std::size_t i = 0; i < chaddr.size(); ++i)
+    {
+        outStream << std::setw(2) << (uint32_t)chaddr[i] << (i < chaddr.size() - 1 ? ":" : "");
+    }
+    return outStream.str();
+}
+
 DhcpHeader::DhcpHeader()
 {
     m_hType = 1;
@@ -105,27 +128,15 @@ DhcpHeader::SetTime()
 }
 
 void
-DhcpHeader::SetChaddr(Address addr)
-{
-    std::memset(m_chaddr, 0, 16);
-    NS_ASSERT_MSG(addr.GetLength() <= 16, "Address length too big");
-    addr.CopyTo(m_chaddr);
-}
-
-void
-DhcpHeader::SetChaddr(uint8_t* addr, uint8_t len)
+DhcpHeader::SetChaddr(DhcpChaddr addr)
 {
-    std::memset(m_chaddr, 0, 16);
-    NS_ASSERT_MSG(len <= 16, "Address length too big");
-    std::memcpy(m_chaddr, addr, len);
+    m_chaddr = addr;
 }
 
-Address
+DhcpChaddr
 DhcpHeader::GetChaddr()
 {
-    Address addr;
-    addr.CopyFrom(m_chaddr, 16);
-    return addr;
+    return m_chaddr;
 }
 
 void
@@ -313,7 +324,7 @@ DhcpHeader::Serialize(Buffer::Iterator start) const
     WriteTo(i, m_yiAddr);
     WriteTo(i, m_siAddr);
     WriteTo(i, m_giAddr);
-    i.Write(m_chaddr, 16);
+    i.Write(m_chaddr.data(), 16);
     i.Write(m_sname, 64);
     i.Write(m_file, 128);
     i.Write(m_magic_cookie, 4);
@@ -390,7 +401,7 @@ DhcpHeader::Deserialize(Buffer::Iterator start)
     ReadFrom(i, m_yiAddr);
     ReadFrom(i, m_siAddr);
     ReadFrom(i, m_giAddr);
-    i.Read(m_chaddr, 16);
+    i.Read(m_chaddr.data(), 16);
     i.Read(m_sname, 64);
     i.Read(m_file, 128);
     i.Read(m_magic_cookie, 4);

src/internet-apps/model/dhcp-header.h

@@ -18,6 +18,12 @@
 #include "ns3/header.h"
 #include "ns3/ipv4-address.h"
 
+/**
+ * @file
+ * @ingroup internet-apps
+ * DhcpHeader classes declaration
+ */
+
 namespace ns3
 {
 
@@ -26,6 +32,24 @@ namespace ns3
  * @defgroup dhcp DHCPv4 Client and Server
  */
 
+/**
+ * @ingroup dhcp
+ *
+ * This is the Chaddr field, which is 16 bytes long. Originally it was
+ * meant to hold the Client Hardware Address (hence the name), but later RFCs
+ * refers to it just as the Client Identifier.
+ */
+using DhcpChaddr = std::array<uint8_t, 16>;
+
+/**
+ * @ingroup dhcp
+ * Function to pretty-print a Chaddr.
+ *
+ * @param chaddr the Chaddr
+ * @return A formatted string
+ */
+std::string DhcpChaddrToString(const DhcpChaddr& chaddr);
+
 /**
  * @ingroup dhcp
  *
@@ -149,20 +173,11 @@ class DhcpHeader : public Header
     void SetTime();
 
     /**
-     * @brief Set the Address of the device.
-     *
-     * Only the relevant bits are considered (i.e., not the type and length)
+     * @brief Set the Chaddress of the device.
      *
      * @param addr Address of the device
      */
-    void SetChaddr(Address addr);
-
-    /**
-     * @brief Set the Address of the device
-     * @param addr Address of the device
-     * @param len Address length
-     */
-    void SetChaddr(uint8_t* addr, uint8_t len);
+    void SetChaddr(DhcpChaddr addr);
 
     /**
      * @brief Get the Address of the client.
@@ -171,7 +186,7 @@ class DhcpHeader : public Header
      *
      * @return Address of the client
      */
-    Address GetChaddr();
+    DhcpChaddr GetChaddr();
 
     /**
      * @brief Set the IPv4Address of the client
@@ -291,7 +306,7 @@ class DhcpHeader : public Header
     uint32_t m_len;            //!< The length of the header
     uint16_t m_secs;           //!< Seconds elapsed
     uint16_t m_flags;          //!< BOOTP flags
-    uint8_t m_chaddr[16];      //!< The address identifier
+    DhcpChaddr m_chaddr;       //!< The client identifier
     Ipv4Address m_yiAddr;      //!< Your (client) IP address
     Ipv4Address m_ciAddr;      //!< The IP address of the client
     Ipv4Address m_siAddr;      //!< Next Server IP address

src/internet-apps/model/dhcp-server.cc

@@ -24,6 +24,7 @@
 #include "ns3/socket.h"
 
 #include <algorithm>
+#include <limits>
 
 namespace ns3
 {
@@ -133,7 +134,8 @@ DhcpServer::StartApplication()
             // set infinite GRANTED_LEASED_TIME for my address
 
             myOwnAddress = ipv4->GetAddress(ifIndex, addrIndex).GetLocal();
-            m_leasedAddresses[Address()] = std::make_pair(myOwnAddress, 0xffffffff);
+            DhcpChaddr null = {};
+            m_leasedAddresses[null] = std::make_pair(myOwnAddress, PERMANENT_LEASE);
             break;
         }
     }
@@ -181,19 +183,18 @@ DhcpServer::TimerHandler()
     NS_LOG_FUNCTION(this);
 
     // Set up timeout events and release of unsolicited addresses from the list
-    LeasedAddressIter i;
-    for (i = m_leasedAddresses.begin(); i != m_leasedAddresses.end(); i++)
+    for (auto [k, v] : m_leasedAddresses)
     {
         // update the address state
-        if (i->second.second != 0xffffffff && i->second.second != 0)
+        if (v.second != PERMANENT_LEASE && v.second != 0)
         {
-            i->second.second--;
-            if (i->second.second == 0)
+            v.second--;
+            if (v.second == 0)
             {
                 NS_LOG_INFO("Address leased state expired, address removed - "
-                            << "chaddr: " << i->first << " IP address " << i->second.first);
-                i->second.second = 0;
-                m_expiredAddresses.push_front(i->first);
+                            << "chaddr: " << DhcpChaddrToString(k) << " IP address " << v.first);
+                v.second = 0;
+                m_expiredAddresses.push_front(k);
             }
         }
     }
@@ -241,7 +242,7 @@ DhcpServer::SendOffer(Ptr<NetDevice> iDev, DhcpHeader header, InetSocketAddress
     NS_LOG_FUNCTION(this << iDev << header << from);
 
     DhcpHeader newDhcpHeader;
-    Address sourceChaddr = header.GetChaddr();
+    DhcpChaddr sourceChaddr = header.GetChaddr();
     uint32_t tran = header.GetTran();
     Ptr<Packet> packet = nullptr;
     Ipv4Address offeredAddress;
@@ -253,11 +254,11 @@ DhcpServer::SendOffer(Ptr<NetDevice> iDev, DhcpHeader header, InetSocketAddress
     {
         // We know this client from some time ago
         if (m_leasedAddresses[sourceChaddr].second != 0 &&
-            m_leasedAddresses[sourceChaddr].second != 0xffffffff)
+            m_leasedAddresses[sourceChaddr].second != PERMANENT_LEASE)
         {
             NS_LOG_LOGIC("This client is sending a DISCOVER but it has still a lease active - "
                          "perhaps it didn't shut down gracefully: "
-                         << sourceChaddr);
+                         << DhcpChaddrToString(sourceChaddr));
         }
 
         m_expiredAddresses.remove(sourceChaddr);
@@ -277,7 +278,7 @@ DhcpServer::SendOffer(Ptr<NetDevice> iDev, DhcpHeader header, InetSocketAddress
             // there's still hope: reuse the old ones.
             if (!m_expiredAddresses.empty())
             {
-                Address oldestChaddr = m_expiredAddresses.back();
+                DhcpChaddr oldestChaddr = m_expiredAddresses.back();
                 m_expiredAddresses.pop_back();
                 offeredAddress = m_leasedAddresses[oldestChaddr].first;
                 m_leasedAddresses.erase(oldestChaddr);
@@ -334,16 +335,15 @@ DhcpServer::SendAck(Ptr<NetDevice> iDev, DhcpHeader header, InetSocketAddress fr
     NS_LOG_FUNCTION(this << iDev << header << from);
 
     DhcpHeader newDhcpHeader;
-    Address sourceChaddr = header.GetChaddr();
+    DhcpChaddr sourceChaddr = header.GetChaddr();
     uint32_t tran = header.GetTran();
     Ptr<Packet> packet = nullptr;
     Ipv4Address address = header.GetReq();
 
     NS_LOG_INFO("DHCP REQUEST from: " << from.GetIpv4() << " source port: " << from.GetPort()
                                       << " - refreshed addr: " << address);
 
-    LeasedAddressIter iter;
-    iter = m_leasedAddresses.find(sourceChaddr);
+    auto iter = m_leasedAddresses.find(sourceChaddr);
     if (iter != m_leasedAddresses.end())
     {
         // update the lease time of this address - send ACK
@@ -393,33 +393,29 @@ DhcpServer::SendAck(Ptr<NetDevice> iDev, DhcpHeader header, InetSocketAddress fr
 }
 
 void
-DhcpServer::AddStaticDhcpEntry(Address chaddr, Ipv4Address addr)
+DhcpServer::AddStaticDhcpEntry(Address macAddr, Ipv4Address addr)
 {
-    NS_LOG_FUNCTION(this << chaddr << addr);
-    Address cleanedCaddr;
+    NS_LOG_FUNCTION(this << macAddr << addr);
+    DhcpChaddr chAddr{};
 
     NS_ASSERT_MSG(addr.Get() >= m_minAddress.Get() && addr.Get() <= m_maxAddress.Get(),
                   "Required address is not in the pool " << addr << " is not in [" << m_minAddress
                                                          << ", " << m_maxAddress << "]");
+    NS_ASSERT_MSG(macAddr.GetLength() <= 16,
+                  "DHCP server can not handle a chaddr larger than 16 bytes");
+    macAddr.CopyTo(chAddr.begin());
 
-    // We need to cleanup the type from the stored chaddr, or later we'll fail to compare it.
-    // Moreover, the length is always 16, because chaddr is 16 bytes.
-    uint8_t buffer[Address::MAX_SIZE];
-    std::memset(buffer, 0, Address::MAX_SIZE);
-    uint32_t len = chaddr.CopyTo(buffer);
-    NS_ASSERT_MSG(len <= 16, "DHCP server can not handle a chaddr larger than 16 bytes");
-    cleanedCaddr.CopyFrom(buffer, 16);
-
-    NS_ASSERT_MSG(m_leasedAddresses.find(cleanedCaddr) == m_leasedAddresses.end(),
-                  "Client has already an active lease: " << m_leasedAddresses[cleanedCaddr].first);
+    NS_ASSERT_MSG(m_leasedAddresses.find(chAddr) == m_leasedAddresses.end(),
+                  "Client has already an active lease: " << m_leasedAddresses[chAddr].first);
 
     auto it = find(m_availableAddresses.begin(), m_availableAddresses.end(), addr);
     NS_ASSERT_MSG(
         it == m_availableAddresses.end(),
         "Required address is not available (perhaps it has been already assigned): " << addr);
 
     m_availableAddresses.remove(addr);
-    m_leasedAddresses[cleanedCaddr] = std::make_pair(addr, 0xffffffff);
+    NS_LOG_INFO("Added a static lease for " << DhcpChaddrToString(chAddr) << " -> " << addr);
+    m_leasedAddresses[chAddr] = std::make_pair(addr, PERMANENT_LEASE);
 }
 
 } // Namespace ns3

src/internet-apps/model/dhcp-server.h

@@ -18,6 +18,7 @@
 #include "ns3/application.h"
 #include "ns3/ipv4-address.h"
 
+#include <limits>
 #include <map>
 
 namespace ns3
@@ -48,10 +49,10 @@ class DhcpServer : public Application
     /**
      * @brief Add a static entry to the pool.
      *
-     * @param chaddr The client chaddr.
-     * @param addr The address to handle to the client.
+     * @param macAddr The client MAC address.
+     * @param addr The IP address to handle to the client.
      */
-    void AddStaticDhcpEntry(Address chaddr, Ipv4Address addr);
+    void AddStaticDhcpEntry(Address macAddr, Ipv4Address addr);
 
   protected:
     void DoDispose() override;
@@ -97,21 +98,16 @@ class DhcpServer : public Application
     Ipv4Address m_gateway;     //!< The gateway address
 
     /// Leased address container - chaddr + IP addr / lease time
-    typedef std::map<Address, std::pair<Ipv4Address, uint32_t>> LeasedAddress;
-    /// Leased address iterator - chaddr + IP addr / lease time
-    typedef std::map<Address, std::pair<Ipv4Address, uint32_t>>::iterator LeasedAddressIter;
-    /// Leased address const iterator - chaddr + IP addr / lease time
-    typedef std::map<Address, std::pair<Ipv4Address, uint32_t>>::const_iterator LeasedAddressCIter;
+    using LeasedAddress = std::map<DhcpChaddr, std::pair<Ipv4Address, uint32_t>>;
 
     /// Expired address container - chaddr
-    typedef std::list<Address> ExpiredAddress;
-    /// Expired address iterator - chaddr
-    typedef std::list<Address>::iterator ExpiredAddressIter;
-    /// Expired address const iterator - chaddr
-    typedef std::list<Address>::const_iterator ExpiredAddressCIter;
+    using ExpiredAddress = std::list<DhcpChaddr>;
 
     /// Available address container - IP addr
-    typedef std::list<Ipv4Address> AvailableAddress;
+    using AvailableAddress = std::list<Ipv4Address>;
+
+    /// The maximum representable lease time means permanent lease.
+    static constexpr uint32_t PERMANENT_LEASE = std::numeric_limits<uint32_t>::max();
 
     LeasedAddress m_leasedAddresses;   //!< Leased address and their status (cache memory)
     ExpiredAddress m_expiredAddresses; //!< Expired addresses to be reused (chaddr of the clients)