Changeset 79818 in vbox for trunk/src/VBox/NetworkServices/Dhcpd/Db.cpp

Timestamp:

Jul 16, 2019 7:00:06 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

132192

Message:

Dhcpd: Fixed address assignments. bugref:9288

File:

• trunk/src/VBox/NetworkServices/Dhcpd/Db.cpp (modified) (11 diffs)

trunk/src/VBox/NetworkServices/Dhcpd/Db.cpp

@@ -70 +70 @@
     if (b->m_state == Binding::FREE)
         cb += pfnOutput(pvArgOutput, RT_STR_TUPLE(" free"));
+    else if (b->m_fFixed)
+        cb += pfnOutput(pvArgOutput, RT_STR_TUPLE(" fixed"));
     else
     {
@@ -87 +89 @@
 }
 
+
+/**
+ * Used to update the client ID of a fixed address assignment.
+ *
+ * We only have the MAC address when prepraring the binding, so the full client
+ * ID must be supplied when the client requests it.
+ *
+ * @param   a_ridClient         The client ID.
+ * @throws  std::bad_alloc
+ */
+void Binding::idUpdate(const ClientId &a_ridClient)
+{
+    AssertReturnVoid(isFixed());
+    m_id = a_ridClient;
+}
+
+
+/**
+ * Get the state as a string for the XML lease database.
+ */
 const char *Binding::stateName() const RT_NOEXCEPT
 {
@@ -108 +130 @@
 
 
+/**
+ * Sets the state by name (reverse of Binding::stateName()).
+ */
 Binding &Binding::setState(const char *pszStateName) RT_NOEXCEPT
 {
@@ -139 +164 @@
 bool Binding::expire(Timestamp tsDeadline) RT_NOEXCEPT
 {
-    if (m_state <= Binding::EXPIRED)
+    if (m_state <= Binding::EXPIRED || m_fFixed)
         return false;
 
@@ -338 +363 @@
     m_pConfig = pConfig;
 
-    return m_pool.init(pConfig->getIPv4PoolFirst(), pConfig->getIPv4PoolLast());
+    int rc = m_pool.init(pConfig->getIPv4PoolFirst(), pConfig->getIPv4PoolLast());
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * If the server IP is in the dynamic range, preallocate it like a fixed assignment.
+         */
+        rc = i_enterFixedAddressAssignment(pConfig->getIPv4Address(), pConfig->getMacAddress());
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Preallocate any fixed address assignments:
+             */
+            Config::HostConfigVec vecHostConfigs;
+            rc = pConfig->getFixedAddressConfigs(vecHostConfigs);
+            for (Config::HostConfigVec::const_iterator it = vecHostConfigs.begin();
+                 it != vecHostConfigs.end() && RT_SUCCESS(rc); ++it)
+                rc = i_enterFixedAddressAssignment((*it)->getFixedAddress(), (*it)->getMACAddress());
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * Used by Db::init() to register a fixed address assignment.
+ *
+ * @returns IPRT status code.
+ * @param   a_rAddress      The IPv4 address assignment.
+ * @param   a_rMACAddress   The MAC address.
+ */
+int Db::i_enterFixedAddressAssignment(RTNETADDRIPV4 const &a_rAddress, RTMAC const &a_rMACAddress) RT_NOEXCEPT
+{
+    LogRelFunc(("%RTmac: %RTnaipv4\n", &a_rMACAddress, a_rAddress));
+    Assert(m_pConfig->isInIPv4Network(a_rAddress)); /* should've been checked elsewhere already */
+
+    /*
+     * If the address is part of the pool, we have to allocate it to
+     * prevent it from being used again.
+     */
+    if (m_pool.contains(a_rAddress))
+    {
+        if (!m_pool.allocate(a_rAddress))
+        {
+            LogRelFunc(("%RTnaipv4 already allocated?\n", a_rAddress));
+            return VERR_ADDRESS_CONFLICT;
+        }
+    }
+
+    /*
+     * Create the binding.
+     */
+    Binding *pBinding = NULL;
+    try
+    {
+        pBinding = new Binding(a_rAddress, a_rMACAddress, true /*fFixed*/);
+        m_bindings.push_front(pBinding);
+    }
+    catch (std::bad_alloc &)
+    {
+        if (pBinding)
+            delete pBinding;
+        return VERR_NO_MEMORY;
+    }
+    return VINF_SUCCESS;
 }
 
@@ -442 +531 @@
         /*
          * We've already seen this client, give it its old binding.
+         *
+         * If the client's MAC address is configured with a fixed
+         * address, give its preconfigured binding.  Fixed bindings
+         * are always at the head of the m_bindings list, so we
+         * won't be confused by any old leases of the client.
          */
         if (b->m_id == id)
         {
             LogRel(("> ... found existing binding %R[binding]\n", b));
+            return b;
+        }
+        if (b->isFixed() && b->id().mac() == id.mac())
+        {
+            b->idUpdate(id);
+            LogRel(("> ... found fixed binding %R[binding]\n", b));
             return b;
         }
@@ -552 +652 @@
 Binding *Db::allocateBinding(const DhcpClientMessage &req)
 {
-    /** @todo XXX: handle fixed address assignments */
+    const ClientId &id(req.clientId());
 
     /*
      * Get and validate the requested address (if present).
+     *
+     * Fixed assignments are often outside the dynamic range, so we much detect
+     * those to make sure they aren't rejected based on IP range.  ASSUMES fixed
+     * assignments are at the head of the binding list.
      */
     OptRequestedAddress reqAddr(req);
     if (reqAddr.present() && !addressBelongs(reqAddr.value()))
     {
-        if (req.messageType() == RTNET_DHCP_MT_DISCOVER)
+        bool fIsFixed = false;
+        for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end() && (*it)->isFixed(); ++it)
+            if (reqAddr.value().u == (*it)->addr().u)
+            {
+                if (   (*it)->id() == id
+                    || (*it)->id().mac() == id.mac())
+                {
+                    fIsFixed = true;
+                    break;
+                }
+            }
+        if (fIsFixed)
+            reqAddr = OptRequestedAddress();
+        else if (req.messageType() == RTNET_DHCP_MT_DISCOVER)
         {
             LogRel(("DISCOVER: ignoring invalid requested address\n"));
@@ -572 +689 @@
      * Allocate the address.
      */
-    const ClientId &id(req.clientId());
-
     Binding *b = i_allocateAddress(id, reqAddr.value());
     if (b != NULL)
@@ -668 +783 @@
             {
                 LogRel2(("Db::cancelOffer: cancelling %R[binding]\n", b));
-                b->setLeaseTime(0);
-                b->setState(Binding::RELEASED);
+                if (!b->isFixed())
+                {
+                    b->setLeaseTime(0);
+                    b->setState(Binding::RELEASED);
+                }
+                else
+                    b->setState(Binding::ACKED);
             }
             else
@@ -699 +819 @@
         {
             LogRel2(("Db::releaseBinding: releasing %R[binding]\n", b));
-            b->setState(Binding::RELEASED);
-            return true;
+            if (!b->isFixed())
+            {
+                b->setState(Binding::RELEASED);
+                return true;
+            }
+            b->setState(Binding::ACKED);
+            return false;
         }
     }
@@ -741 +866 @@
         {
             const Binding *b = *it;
-            b->toXML(pElmRoot);
+            if (!b->isFixed())
+                b->toXML(pElmRoot);
         }
     }