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, 412 insertions, 0 deletions

diff --git a/src/VBox/NetworkServices/Dhcpd/DhcpMessage.cpp b/src/VBox/NetworkServices/Dhcpd/DhcpMessage.cpp
new file mode 100644
index 00000000..2165959f
--- /dev/null
+++ b/src/VBox/NetworkServices/Dhcpd/DhcpMessage.cpp
@@ -0,0 +1,412 @@
+/* $Id: DhcpMessage.cpp $ */
+/** @file
+ * DHCP Message and its de/serialization.
+ */
+
+/*
+ * 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 "DhcpMessage.h"
+#include "DhcpOptions.h"
+
+#include <iprt/string.h>
+#include <iprt/stream.h>
+
+
+
+DhcpMessage::DhcpMessage()
+  : m_xid(0), m_flags(0),
+    m_ciaddr(), m_yiaddr(), m_siaddr(), m_giaddr(),
+    m_sname(), m_file(),
+    m_optMessageType()
+{
+}
+
+
+/* static */
+DhcpClientMessage *DhcpClientMessage::parse(bool broadcasted, const void *buf, size_t buflen)
+{
+    if (buflen < RT_OFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_opts))
+    {
+        RTPrintf("%s: %zu bytes datagram is too short\n", __FUNCTION__, buflen);
+        return NULL;
+    }
+
+    PCRTNETBOOTP bp = (PCRTNETBOOTP)buf;
+
+    if (bp->bp_op != RTNETBOOTP_OP_REQUEST)
+    {
+        RTPrintf("%s: bad opcode: %d\n", __FUNCTION__, bp->bp_op);
+        return NULL;
+    }
+
+    if (bp->bp_htype != RTNET_ARP_ETHER)
+    {
+        RTPrintf("%s: unsupported htype %d\n", __FUNCTION__, bp->bp_htype);
+        return NULL;
+    }
+
+    if (bp->bp_hlen != sizeof(RTMAC))
+    {
+        RTPrintf("%s: unexpected hlen %d\n", __FUNCTION__, bp->bp_hlen);
+        return NULL;
+    }
+
+    if (   (bp->bp_chaddr.Mac.au8[0] & 0x01) != 0
+        && (bp->bp_flags & RTNET_DHCP_FLAG_BROADCAST) == 0)
+    {
+        RTPrintf("%s: multicast chaddr %RTmac without broadcast flag\n",
+                 __FUNCTION__, &bp->bp_chaddr.Mac);
+    }
+
+    /* we don't want to deal with forwarding */
+    if (bp->bp_giaddr.u != 0)
+    {
+        RTPrintf("%s: giaddr %RTnaipv4\n", __FUNCTION__, bp->bp_giaddr.u);
+        return NULL;
+    }
+
+    if (bp->bp_hops != 0)
+    {
+        RTPrintf("%s: non-zero hops %d\n", __FUNCTION__, bp->bp_hops);
+        return NULL;
+    }
+
+    std::unique_ptr<DhcpClientMessage> msg(new DhcpClientMessage());
+
+    msg->m_broadcasted = broadcasted;
+
+    msg->m_xid = bp->bp_xid;
+    msg->m_flags = bp->bp_flags;
+
+    msg->m_mac = bp->bp_chaddr.Mac;
+
+    msg->m_ciaddr = bp->bp_ciaddr;
+    msg->m_yiaddr = bp->bp_yiaddr;
+    msg->m_siaddr = bp->bp_siaddr;
+    msg->m_giaddr = bp->bp_giaddr;
+
+    if (bp->bp_vend.Dhcp.dhcp_cookie != RT_H2N_U32_C(RTNET_DHCP_COOKIE))
+    {
+        RTPrintf("bad cookie\n");
+        return NULL;
+    }
+
+    int overload;
+    overload = msg->parseOptions(&bp->bp_vend.Dhcp.dhcp_opts,
+                                 buflen - RT_OFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_opts));
+    if (overload < 0)
+        return NULL;
+
+    /* "The 'file' field MUST be interpreted next ..." */
+    if (overload & DHCP_OPTION_OVERLOAD_FILE) {
+        int status = msg->parseOptions(bp->bp_file, sizeof(bp->bp_file));
+        if (status != 0)
+            return NULL;
+    }
+    else if (bp->bp_file[0] != '\0')
+    {
+        /* must be zero terminated, ignore if not */
+        const char *pszFile = (const char *)bp->bp_file;
+        size_t len = RTStrNLen(pszFile, sizeof(bp->bp_file));
+        if (len < sizeof(bp->bp_file))
+            msg->m_file.assign(pszFile, len);
+    }
+
+    /* "... followed by the 'sname' field." */
+    if (overload & DHCP_OPTION_OVERLOAD_SNAME) {
+        int status = msg->parseOptions(bp->bp_sname, sizeof(bp->bp_sname));
+        if (status != 0) /* NB: this includes "nested" Option Overload */
+            return NULL;
+    }
+    else if (bp->bp_sname[0] != '\0')
+    {
+        /* must be zero terminated, ignore if not */
+        const char *pszSName = (const char *)bp->bp_sname;
+        size_t len = RTStrNLen(pszSName, sizeof(bp->bp_sname));
+        if (len < sizeof(bp->bp_sname))
+            msg->m_sname.assign(pszSName, len);
+    }
+
+    msg->m_optMessageType = OptMessageType(*msg);
+    if (!msg->m_optMessageType.present())
+        return NULL;
+
+    msg->m_id = ClientId(msg->m_mac, OptClientId(*msg));
+
+    return msg.release();
+}
+
+
+int DhcpClientMessage::parseOptions(const void *buf, size_t buflen)
+{
+    uint8_t opt, optlen;
+    const uint8_t *data;
+    int overload;
+
+    overload = 0;
+
+    data = static_cast<const uint8_t *>(buf);
+    while (buflen > 0) {
+        opt = *data++;
+        --buflen;
+
+        if (opt == RTNET_DHCP_OPT_PAD) {
+            continue;
+        }
+
+        if (opt == RTNET_DHCP_OPT_END) {
+            break;
+        }
+
+        if (buflen == 0) {
+            RTPrintf("option %d has no length field\n", opt);
+            return -1;
+        }
+
+        optlen = *data++;
+        --buflen;
+
+        if (optlen > buflen) {
+            RTPrintf("option %d truncated (length %d, but only %lu bytes left)\n",
+                   opt, optlen, (unsigned long)buflen);
+            return -1;
+        }
+
+#if 0
+        rawopts_t::const_iterator it(m_optmap.find(opt));
+        if (it != m_optmap.cend())
+            return -1;
+#endif
+        if (opt == RTNET_DHCP_OPT_OPTION_OVERLOAD) {
+            if (optlen != 1) {
+                RTPrintf("Overload Option (option %d) has invalid length %d\n",
+                       opt, optlen);
+                return -1;
+            }
+
+            overload = *data;
+
+            if ((overload & ~DHCP_OPTION_OVERLOAD_MASK) != 0) {
+                RTPrintf("Overload Option (option %d) has invalid value 0x%x\n",
+                       opt, overload);
+                return -1;
+            }
+        }
+        else
+        {
+            m_rawopts.insert(std::make_pair(opt, octets_t(data, data + optlen)));
+        }
+
+        data += optlen;
+        buflen -= optlen;
+    }
+
+    return overload;
+}
+
+
+void DhcpClientMessage::dump() const
+{
+    switch (m_optMessageType.value())
+    {
+        case RTNET_DHCP_MT_DISCOVER:
+            LogDHCP(("DISCOVER"));
+            break;
+
+        case RTNET_DHCP_MT_REQUEST:
+            LogDHCP(("REQUEST"));
+            break;
+
+        case RTNET_DHCP_MT_INFORM:
+            LogDHCP(("INFORM"));
+            break;
+
+        case RTNET_DHCP_MT_DECLINE:
+            LogDHCP(("DECLINE"));
+            break;
+
+        case RTNET_DHCP_MT_RELEASE:
+            LogDHCP(("RELEASE"));
+            break;
+
+        default:
+            LogDHCP(("<Unknown Mesage Type %d>", m_optMessageType.value()));
+            break;
+    }
+
+    if (OptRapidCommit(*this).present())
+        LogDHCP((" (rapid commit)"));
+
+
+    const OptServerId sid(*this);
+    if (sid.present())
+        LogDHCP((" for server %RTnaipv4", sid.value().u));
+
+    LogDHCP((" xid 0x%08x", m_xid));
+    LogDHCP((" chaddr %RTmac\n", &m_mac));
+
+    const OptClientId cid(*this);
+    if (cid.present()) {
+        if (cid.value().size() > 0)
+            LogDHCP((" client id: %.*Rhxs\n", cid.value().size(), &cid.value().front()));
+        else
+            LogDHCP((" client id: <empty>\n"));
+    }
+
+    LogDHCP((" ciaddr %RTnaipv4", m_ciaddr.u));
+    if (m_yiaddr.u != 0)
+        LogDHCP((" yiaddr %RTnaipv4", m_yiaddr.u));
+    if (m_siaddr.u != 0)
+        LogDHCP((" siaddr %RTnaipv4", m_siaddr.u));
+    if (m_giaddr.u != 0)
+        LogDHCP((" giaddr %RTnaipv4", m_giaddr.u));
+    LogDHCP(("%s\n", broadcast() ? "broadcast" : ""));
+
+
+    const OptRequestedAddress reqAddr(*this);
+    if (reqAddr.present())
+        LogDHCP((" requested address %RTnaipv4", reqAddr.value().u));
+    const OptLeaseTime reqLeaseTime(*this);
+    if (reqLeaseTime.present())
+        LogDHCP((" requested lease time %d", reqAddr.value()));
+    if (reqAddr.present() || reqLeaseTime.present())
+        LogDHCP(("\n"));
+
+    const OptParameterRequest params(*this);
+    if (params.present())
+    {
+        LogDHCP((" params {"));
+        typedef OptParameterRequest::value_t::const_iterator it_t;
+        for (it_t it = params.value().begin(); it != params.value().end(); ++it)
+            LogDHCP((" %d", *it));
+        LogDHCP((" }\n"));
+    }
+
+    bool fHeader = true;
+    for (rawopts_t::const_iterator it = m_rawopts.begin();
+         it != m_rawopts.end(); ++it)
+    {
+        const uint8_t optcode = (*it).first;
+        switch (optcode) {
+            case OptMessageType::optcode:      /* FALLTHROUGH */
+            case OptClientId::optcode:         /* FALLTHROUGH */
+            case OptRequestedAddress::optcode: /* FALLTHROUGH */
+            case OptLeaseTime::optcode:        /* FALLTHROUGH */
+            case OptParameterRequest::optcode: /* FALLTHROUGH */
+            case OptRapidCommit::optcode:
+                break;
+
+            default:
+                if (fHeader)
+                {
+                    LogDHCP((" other options:"));
+                    fHeader = false;
+                }
+                LogDHCP((" %d", optcode));
+                break;
+        }
+    }
+    if (!fHeader)
+        LogDHCP(("\n"));
+}
+
+
+DhcpServerMessage::DhcpServerMessage(const DhcpClientMessage &req,
+                                     uint8_t messageTypeParam, RTNETADDRIPV4 serverAddr)
+  : DhcpMessage(),
+    m_optServerId(serverAddr)
+{
+    m_dst.u = 0xffffffff;       /* broadcast */
+
+    m_optMessageType = OptMessageType(messageTypeParam);
+
+    /* copy values from the request (cf. RFC2131 Table 3) */
+    m_xid = req.xid();
+    m_flags = req.flags();
+    m_giaddr = req.giaddr();
+    m_mac = req.mac();
+
+    if (req.messageType() == RTNET_DHCP_MT_REQUEST)
+        m_ciaddr = req.ciaddr();
+}
+
+
+void DhcpServerMessage::maybeUnicast(const DhcpClientMessage &req)
+{
+    if (!req.broadcast() && req.ciaddr().u != 0)
+        setDst(req.ciaddr());
+}
+
+
+void DhcpServerMessage::addOption(DhcpOption *opt)
+{
+    m_optmap << opt;
+}
+
+
+void DhcpServerMessage::addOptions(const optmap_t &optmap)
+{
+    for (optmap_t::const_iterator it ( optmap.begin() );
+         it != optmap.end(); ++it)
+    {
+        m_optmap << it->second;
+    }
+}
+
+
+int DhcpServerMessage::encode(octets_t &data)
+{
+    /*
+     * Header, including DHCP cookie.
+     */
+    RTNETBOOTP bp;
+    RT_ZERO(bp);
+
+    bp.bp_op = RTNETBOOTP_OP_REPLY;
+    bp.bp_htype = RTNET_ARP_ETHER;
+    bp.bp_hlen = sizeof(RTMAC);
+
+    bp.bp_xid = m_xid;
+
+    bp.bp_ciaddr = m_ciaddr;
+    bp.bp_yiaddr = m_yiaddr;
+    bp.bp_siaddr = m_siaddr;
+    bp.bp_giaddr = m_giaddr;
+
+    bp.bp_chaddr.Mac = m_mac;
+
+    bp.bp_vend.Dhcp.dhcp_cookie = RT_H2N_U32_C(RTNET_DHCP_COOKIE);
+
+    data.insert(data.end(), (uint8_t *)&bp, (uint8_t *)&bp.bp_vend.Dhcp.dhcp_opts);
+
+    /*
+     * Options
+     */
+    data << m_optServerId
+         << m_optMessageType;
+
+    for (optmap_t::const_iterator it ( m_optmap.begin() );
+         it != m_optmap.end(); ++it)
+    {
+        RTPrintf("encoding option %d\n", it->first);
+        DhcpOption &opt = *it->second;
+        data << opt;
+    }
+
+    data << OptEnd();
+
+    if (data.size() < 548)      /* XXX */
+        data.resize(548);
+
+    return VINF_SUCCESS;
+}