Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 747 insertions, 0 deletions

diff --git a/src/VBox/NetworkServices/Dhcpd/Db.cpp b/src/VBox/NetworkServices/Dhcpd/Db.cpp
new file mode 100644
index 00000000..dfafc784
--- /dev/null
+++ b/src/VBox/NetworkServices/Dhcpd/Db.cpp
@@ -0,0 +1,747 @@
+/* $Id: Db.cpp $ */
+/** @file
+ * DHCP server - address database
+ */
+
+/*
+ * Copyright (C) 2017-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#include <iprt/errcore.h>
+#include <iprt/stream.h>
+
+#include "Db.h"
+
+
+Db::Db()
+  : m_pConfig(NULL)
+{
+    return;
+}
+
+
+Db::~Db()
+{
+    /** @todo free bindings */
+}
+
+
+int Db::init(const Config *pConfig)
+{
+    Binding::registerFormat();
+
+    m_pConfig = pConfig;
+
+    m_pool.init(pConfig->getIPv4PoolFirst(),
+                pConfig->getIPv4PoolLast());
+
+    return VINF_SUCCESS;
+}
+
+
+bool Binding::g_fFormatRegistered = false;
+
+
+void Binding::registerFormat()
+{
+    if (g_fFormatRegistered)
+        return;
+
+    int rc = RTStrFormatTypeRegister("binding", rtStrFormat, NULL);
+    AssertRC(rc);
+
+    g_fFormatRegistered = true;
+}
+
+
+DECLCALLBACK(size_t)
+Binding::rtStrFormat(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+                     const char *pszType, void const *pvValue,
+                     int cchWidth, int cchPrecision, unsigned fFlags,
+                     void *pvUser)
+{
+    const Binding *b = static_cast<const Binding *>(pvValue);
+    size_t cb = 0;
+
+    AssertReturn(strcmp(pszType, "binding") == 0, 0);
+    RT_NOREF(pszType);
+
+    RT_NOREF(cchWidth, cchPrecision, fFlags);
+    RT_NOREF(pvUser);
+
+    if (b == NULL)
+    {
+        return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+                           "<NULL>");
+    }
+
+    cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+                      "%RTnaipv4", b->m_addr.u);
+
+    if (b->m_state == Binding::FREE)
+    {
+        cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+                          " free");
+    }
+    else
+    {
+        cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+                          " to %R[id], %s, valid from ",
+                          &b->m_id, b->stateName());
+
+        TimeStamp tsIssued = b->issued();
+        cb += tsIssued.absStrFormat(pfnOutput, pvArgOutput);
+
+        cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+                          " for %ds until ",
+                          b->leaseTime());
+
+        TimeStamp tsValid = b->issued();
+        tsValid.addSeconds(b->leaseTime());
+        cb += tsValid.absStrFormat(pfnOutput, pvArgOutput);
+    }
+
+    return cb;
+}
+
+const char *Binding::stateName() const
+{
+    switch (m_state) {
+    case FREE:
+        return "free";
+    case RELEASED:
+        return "released";
+    case EXPIRED:
+        return "expired";
+    case OFFERED:
+        return "offered";
+    case ACKED:
+        return "acked";
+    default:
+        return "released";
+    }
+}
+
+
+Binding &Binding::setState(const char *pszStateName)
+{
+    if (strcmp(pszStateName, "free") == 0)
+        m_state = Binding::FREE;
+    else if (strcmp(pszStateName, "released") == 0)
+        m_state = Binding::RELEASED;
+    else if (strcmp(pszStateName, "expired") == 0)
+        m_state = Binding::EXPIRED;
+    else if (strcmp(pszStateName, "offered") == 0)
+        m_state = Binding::OFFERED;
+    else if (strcmp(pszStateName, "acked") == 0)
+        m_state = Binding::ACKED;
+    else
+        m_state = Binding::RELEASED;
+
+    return *this;
+}
+
+
+bool Binding::expire(TimeStamp deadline)
+{
+    if (m_state <= Binding::EXPIRED)
+        return false;
+
+    TimeStamp t = m_issued;
+    t.addSeconds(m_secLease);
+
+    if (t < deadline)
+    {
+        if (m_state == Binding::OFFERED)
+            setState(Binding::FREE);
+        else
+            setState(Binding::EXPIRED);
+    }
+    return true;
+}
+
+
+int Binding::toXML(xml::ElementNode *ndParent) const
+{
+    int rc;
+
+    /*
+     * Lease
+     */
+    xml::ElementNode *ndLease = ndParent->createChild("Lease");
+    if (ndLease == NULL)
+        return VERR_GENERAL_FAILURE;
+
+    /* XXX: arrange for lease to get deleted if anything below fails */
+
+
+    ndLease->setAttribute("mac", RTCStringFmt("%RTmac", &m_id.mac()));
+    if (m_id.id().present())
+    {
+        /* I'd prefer RTSTRPRINTHEXBYTES_F_SEP_COLON but there's no decoder */
+        size_t cbStrId = m_id.id().value().size() * 2 + 1;
+        char *pszId = new char[cbStrId];
+        rc = RTStrPrintHexBytes(pszId, cbStrId,
+                                &m_id.id().value().front(), m_id.id().value().size(),
+                                0);
+        ndLease->setAttribute("id", pszId);
+        delete[] pszId;
+    }
+
+    /* unused but we need it to keep the old code happy */
+    ndLease->setAttribute("network", "0.0.0.0");
+
+    ndLease->setAttribute("state", stateName());
+
+
+    /*
+     * Lease/Address
+     */
+    xml::ElementNode *ndAddr = ndLease->createChild("Address");
+    ndAddr->setAttribute("value", RTCStringFmt("%RTnaipv4", m_addr.u));
+
+
+    /*
+     * Lease/Time
+     */
+    xml::ElementNode *ndTime = ndLease->createChild("Time");
+    ndTime->setAttribute("issued", m_issued.getAbsSeconds());
+    ndTime->setAttribute("expiration", m_secLease);
+
+    return VINF_SUCCESS;
+}
+
+
+Binding *Binding::fromXML(const xml::ElementNode *ndLease)
+{
+    int rc;
+
+    /* Lease/@network seems to always have bogus value, ignore it. */
+
+    /*
+     * Lease/@mac
+     */
+    RTCString strMac;
+    bool fHasMac = ndLease->getAttributeValue("mac", &strMac);
+    if (!fHasMac)
+        return NULL;
+
+    RTMAC mac;
+    rc = RTNetStrToMacAddr(strMac.c_str(), &mac);
+    if (RT_FAILURE(rc))
+        return NULL;
+
+    OptClientId id;
+    RTCString strId;
+    bool fHasId = ndLease->getAttributeValue("id", &strId);
+    if (fHasId)
+    {
+        /*
+         * Decode from "de:ad:be:ef".
+         * XXX: RTStrConvertHexBytes() doesn't grok colons
+         */
+        size_t cbBytes = strId.length() / 2;
+        uint8_t *pBytes = new uint8_t[cbBytes];
+        rc = RTStrConvertHexBytes(strId.c_str(), pBytes, cbBytes, 0);
+        if (RT_SUCCESS(rc))
+        {
+            std::vector<uint8_t> rawopt(pBytes, pBytes + cbBytes);
+            id = OptClientId(rawopt);
+        }
+        delete[] pBytes;
+    }
+
+    /*
+     * Lease/@state - not present in old leases file.  We will try to
+     * infer from lease time below.
+     */
+    RTCString strState;
+    bool fHasState = ndLease->getAttributeValue("state", &strState);
+
+    /*
+     * Lease/Address
+     */
+    const xml::ElementNode *ndAddress = ndLease->findChildElement("Address");
+    if (ndAddress == NULL)
+        return NULL;
+
+    /*
+     * Lease/Address/@value
+     */
+    RTCString strAddress;
+    bool fHasValue = ndAddress->getAttributeValue("value", &strAddress);
+    if (!fHasValue)
+        return NULL;
+
+    RTNETADDRIPV4 addr;
+    rc = RTNetStrToIPv4Addr(strAddress.c_str(), &addr);
+    if (RT_FAILURE(rc))
+        return NULL;
+
+    /*
+     * Lease/Time
+     */
+    const xml::ElementNode *ndTime = ndLease->findChildElement("Time");
+    if (ndTime == NULL)
+        return NULL;
+
+    /*
+     * Lease/Time/@issued
+     */
+    int64_t issued;
+    bool fHasIssued = ndTime->getAttributeValue("issued", &issued);
+    if (!fHasIssued)
+        return NULL;
+
+    /*
+     * Lease/Time/@expiration
+     */
+    uint32_t duration;
+    bool fHasExpiration = ndTime->getAttributeValue("expiration", &duration);
+    if (!fHasExpiration)
+        return NULL;
+
+    std::unique_ptr<Binding> b(new Binding(addr));
+    b->m_id = ClientId(mac, id);
+
+    if (fHasState)
+    {
+        b->m_issued = TimeStamp::absSeconds(issued);
+        b->m_secLease = duration;
+        b->setState(strState.c_str());
+    }
+    else
+    {   /* XXX: old code wrote timestamps instead of absolute time. */
+        /* pretend that lease has just ended */
+        TimeStamp fakeIssued = TimeStamp::now();
+        fakeIssued.subSeconds(duration);
+        b->m_issued = fakeIssued;
+        b->m_secLease = duration;
+        b->m_state = Binding::EXPIRED;
+    }
+
+    return b.release();
+}
+
+
+void Db::expire()
+{
+    const TimeStamp now = TimeStamp::now();
+
+    for (bindings_t::iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        Binding *b = *it;
+        b->expire(now);
+    }
+}
+
+
+Binding *Db::createBinding(const ClientId &id)
+{
+    RTNETADDRIPV4 addr = m_pool.allocate();
+    if (addr.u == 0)
+        return NULL;
+
+    Binding *b = new Binding(addr, id);
+    m_bindings.push_front(b);
+    return b;
+}
+
+
+Binding *Db::createBinding(RTNETADDRIPV4 addr, const ClientId &id)
+{
+    bool fAvailable = m_pool.allocate(addr);
+    if (!fAvailable)
+    {
+        /*
+         * XXX: this should not happen.  If the address is from the
+         * pool, which we have verified before, then either it's in
+         * the free pool or there's an binding (possibly free) for it.
+         */
+        return NULL;
+    }
+
+    Binding *b = new Binding(addr, id);
+    m_bindings.push_front(b);
+    return b;
+}
+
+
+Binding *Db::allocateAddress(const ClientId &id, RTNETADDRIPV4 addr)
+{
+    Assert(addr.u == 0 || addressBelongs(addr));
+
+    Binding *addrBinding = NULL;
+    Binding *freeBinding = NULL;
+    Binding *reuseBinding = NULL;
+
+    if (addr.u != 0)
+        LogDHCP(("> allocateAddress %RTnaipv4 to client %R[id]\n", addr.u, &id));
+    else
+        LogDHCP(("> allocateAddress to client %R[id]\n", &id));
+
+    /*
+     * Allocate existing address if client has one.  Ignore requested
+     * address in that case.  While here, look for free addresses and
+     * addresses that can be reused.
+     */
+    const TimeStamp now = TimeStamp::now();
+    for (bindings_t::iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        Binding *b = *it;
+        b->expire(now);
+
+        /*
+         * We've already seen this client, give it its old binding.
+         */
+        if (b->m_id == id)
+        {
+            LogDHCP(("> ... found existing binding %R[binding]\n", b));
+            return b;
+        }
+
+        if (addr.u != 0 && b->m_addr.u == addr.u)
+        {
+            Assert(addrBinding == NULL);
+            addrBinding = b;
+            LogDHCP(("> .... noted existing binding %R[binding]\n", addrBinding));
+        }
+
+        /* if we haven't found a free binding yet, keep looking */
+        if (freeBinding == NULL)
+        {
+            if (b->m_state == Binding::FREE)
+            {
+                freeBinding = b;
+                LogDHCP(("> .... noted free binding %R[binding]\n", freeBinding));
+                continue;
+            }
+
+            /* still no free binding, can this one be reused? */
+            if (b->m_state == Binding::RELEASED)
+            {
+                if (   reuseBinding == NULL
+                    /* released binding is better than an expired one */
+                    || reuseBinding->m_state == Binding::EXPIRED)
+                {
+                    reuseBinding = b;
+                    LogDHCP(("> .... noted released binding %R[binding]\n", reuseBinding));
+                }
+            }
+            else if (b->m_state == Binding::EXPIRED)
+            {
+                if (   reuseBinding == NULL
+                    /* long expired binding is bettern than a recent one */
+                    /* || (reuseBinding->m_state == Binding::EXPIRED && b->olderThan(reuseBinding)) */)
+                {
+                    reuseBinding = b;
+                    LogDHCP(("> .... noted expired binding %R[binding]\n", reuseBinding));
+                }
+            }
+        }
+    }
+
+    /*
+     * Allocate requested address if we can.
+     */
+    if (addr.u != 0)
+    {
+        if (addrBinding == NULL)
+        {
+            addrBinding = createBinding(addr, id);
+            Assert(addrBinding != NULL);
+            LogDHCP(("> .... creating new binding for this address %R[binding]\n",
+                     addrBinding));
+            return addrBinding;
+        }
+
+        if (addrBinding->m_state <= Binding::EXPIRED) /* not in use */
+        {
+            LogDHCP(("> .... reusing %s binding for this address\n",
+                     addrBinding->stateName()));
+            addrBinding->giveTo(id);
+            return addrBinding;
+        }
+        else
+        {
+            LogDHCP(("> .... cannot reuse %s binding for this address\n",
+                     addrBinding->stateName()));
+        }
+    }
+
+    /*
+     * Allocate new (or reuse).
+     */
+    Binding *idBinding = NULL;
+    if (freeBinding != NULL)
+    {
+        idBinding = freeBinding;
+        LogDHCP(("> .... reusing free binding\n"));
+    }
+    else
+    {
+        idBinding = createBinding();
+        if (idBinding != NULL)
+        {
+            LogDHCP(("> .... creating new binding\n"));
+        }
+        else
+        {
+            idBinding = reuseBinding;
+            LogDHCP(("> .... reusing %s binding %R[binding]\n",
+                     reuseBinding->stateName(), reuseBinding));
+        }
+    }
+
+    if (idBinding == NULL)
+    {
+        LogDHCP(("> .... failed to allocate binding\n"));
+        return NULL;
+    }
+
+    idBinding->giveTo(id);
+    LogDHCP(("> .... allocated %R[binding]\n", idBinding));
+
+    return idBinding;
+}
+
+
+
+Binding *Db::allocateBinding(const DhcpClientMessage &req)
+{
+    /** @todo XXX: handle fixed address assignments */
+    OptRequestedAddress reqAddr(req);
+    if (reqAddr.present() && !addressBelongs(reqAddr.value()))
+    {
+        if (req.messageType() == RTNET_DHCP_MT_DISCOVER)
+        {
+            LogDHCP(("DISCOVER: ignoring invalid requested address\n"));
+            reqAddr = OptRequestedAddress();
+        }
+        else
+        {
+            LogDHCP(("rejecting invalid requested address\n"));
+            return NULL;
+        }
+    }
+
+    const ClientId &id(req.clientId());
+
+    Binding *b = allocateAddress(id, reqAddr.value());
+    if (b == NULL)
+        return NULL;
+
+    Assert(b->id() == id);
+
+    /*
+     * XXX: handle requests for specific lease time!
+     * XXX: old lease might not have expired yet?
+     */
+    // OptLeaseTime reqLeaseTime(req);
+    b->setLeaseTime(1200);
+    return b;
+}
+
+
+int Db::addBinding(Binding *newb)
+{
+    if (!addressBelongs(newb->m_addr))
+    {
+        LogDHCP(("Binding for out of range address %RTnaipv4 ignored\n",
+                 newb->m_addr.u));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    for (bindings_t::iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        Binding *b = *it;
+
+        if (newb->m_addr.u == b->m_addr.u)
+        {
+            LogDHCP(("> ADD: %R[binding]\n", newb));
+            LogDHCP(("> .... duplicate ip: %R[binding]\n", b));
+            return VERR_INVALID_PARAMETER;
+        }
+
+        if (newb->m_id == b->m_id)
+        {
+            LogDHCP(("> ADD: %R[binding]\n", newb));
+            LogDHCP(("> .... duplicate id: %R[binding]\n", b));
+            return VERR_INVALID_PARAMETER;
+        }
+    }
+
+    bool ok = m_pool.allocate(newb->m_addr);
+    if (!ok)
+    {
+        LogDHCP(("> ADD: failed to claim IP %R[binding]\n", newb));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    m_bindings.push_back(newb);
+    return VINF_SUCCESS;
+}
+
+
+void Db::cancelOffer(const DhcpClientMessage &req)
+{
+    const OptRequestedAddress reqAddr(req);
+    if (!reqAddr.present())
+        return;
+
+    const RTNETADDRIPV4 addr = reqAddr.value();
+    const ClientId &id(req.clientId());
+
+    for (bindings_t::iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        Binding *b = *it;
+
+        if (b->addr().u == addr.u && b->id() == id)
+        {
+            if (b->state() == Binding::OFFERED)
+            {
+                b->setLeaseTime(0);
+                b->setState(Binding::RELEASED);
+            }
+            return;
+        }
+    }
+}
+
+
+bool Db::releaseBinding(const DhcpClientMessage &req)
+{
+    const RTNETADDRIPV4 addr = req.ciaddr();
+    const ClientId &id(req.clientId());
+
+    for (bindings_t::iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        Binding *b = *it;
+
+        if (b->addr().u == addr.u && b->id() == id)
+        {
+            b->setState(Binding::RELEASED);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+int Db::writeLeases(const std::string &strFileName) const
+{
+    LogDHCP(("writing leases to %s\n", strFileName.c_str()));
+
+    xml::Document doc;
+
+    xml::ElementNode *root = doc.createRootElement("Leases");
+    if (root == NULL)
+        return VERR_INTERNAL_ERROR;
+
+    root->setAttribute("version", "1.0");
+
+    for (bindings_t::const_iterator it = m_bindings.begin();
+         it != m_bindings.end(); ++it)
+    {
+        const Binding *b = *it;
+        b->toXML(root);
+    }
+
+    try {
+        xml::XmlFileWriter writer(doc);
+        writer.write(strFileName.c_str(), true);
+    }
+    catch (const xml::EIPRTFailure &e)
+    {
+        LogDHCP(("%s\n", e.what()));
+        return e.rc();
+    }
+    catch (const RTCError &e)
+    {
+        LogDHCP(("%s\n", e.what()));
+        return VERR_GENERAL_FAILURE;
+    }
+    catch (...)
+    {
+        LogDHCP(("Unknown exception while writing '%s'\n",
+                 strFileName.c_str()));
+        return VERR_GENERAL_FAILURE;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+int Db::loadLeases(const std::string &strFileName)
+{
+    LogDHCP(("loading leases from %s\n", strFileName.c_str()));
+
+    xml::Document doc;
+    try
+    {
+        xml::XmlFileParser parser;
+        parser.read(strFileName.c_str(), doc);
+    }
+    catch (const xml::EIPRTFailure &e)
+    {
+        LogDHCP(("%s\n", e.what()));
+        return e.rc();
+    }
+    catch (const RTCError &e)
+    {
+        LogDHCP(("%s\n", e.what()));
+        return VERR_GENERAL_FAILURE;
+    }
+    catch (...)
+    {
+        LogDHCP(("Unknown exception while reading and parsing '%s'\n",
+                 strFileName.c_str()));
+        return VERR_GENERAL_FAILURE;
+    }
+
+    xml::ElementNode *ndRoot = doc.getRootElement();
+    if (ndRoot == NULL || !ndRoot->nameEquals("Leases"))
+    {
+        return VERR_NOT_FOUND;
+    }
+
+    xml::NodesLoop it(*ndRoot);
+    const xml::ElementNode *node;
+    while ((node = it.forAllNodes()) != NULL)
+    {
+        if (!node->nameEquals("Lease"))
+            continue;
+
+        loadLease(node);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+void Db::loadLease(const xml::ElementNode *ndLease)
+{
+    Binding *b = Binding::fromXML(ndLease);
+    bool expired = b->expire();
+
+    if (!expired)
+        LogDHCP(("> LOAD: lease %R[binding]\n", b));
+    else
+        LogDHCP(("> LOAD: EXPIRED lease %R[binding]\n", b));
+
+    addBinding(b);
+}