Changeset 11049

Timestamp:

07/31/08 23:19:52 (4 months ago)

Author:

vboxsync

Message:

IPRT/RTNetIPv4: Rewrote the RTNETDHCP header as RTNETBOOTP and associated structures and defines. Added RTNetIPv4IsDHCPValid for validating a DHCP packet and dig out the message type option

Files:

• trunk/include/iprt/net.h (modified) (1 diff)
• trunk/src/VBox/Runtime/common/checksum/ipv4.cpp (modified) (1 diff)

trunk/include/iprt/net.h

@@ -245 +245 @@
-RTDECL(bool)     RTNetIPv4IsUDPValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData, size_t cbPktMax);
-
+/**
+ * IPv4 BOOTP / DHCP packet.
+ */
+#pragma pack(1)
+typedef struct RTNETBOOTP
+{
+    /** 00 - The packet opcode. */
+    uint8_t         bp_op;
+    /** 01 - Hardware address type. Same as RTNETARPHDR::ar_htype.  */
+    uint8_t         bp_htype;
+    /** 02 - Hardware address length. */
+    uint8_t         bp_hlen;
+    /** 03 - Gateway hops. */
+    uint8_t         bp_hops;
+    /** 04 - Transaction ID. */
+    uint32_t        bp_xid;
+    /** 08 - Seconds since boot started. */
+    uint16_t        bp_secs;
+    /** 0a - Unused (BOOTP) / Flags (DHCP). */
+    uint16_t        bp_flags;
+    /** 0c - Client IPv4 address. */
+    RTNETADDRIPV4   bp_ciaddr;
+    /** 10 - Your IPv4 address. */
+    RTNETADDRIPV4   bp_yiaddr;
+    /** 14 - Server IPv4 address. */
+    RTNETADDRIPV4   bp_siaddr;
+    /** 18 - Gateway IPv4 address. */
+    RTNETADDRIPV4   bp_giaddr;
+    /** 1c - Client hardware address. */
+    union
+    {
+        uint8_t     au8[16];
+        RTMAC       Mac;
+    }               bp_chaddr;
+    /** 2c - Server name. */
+    uint8_t         bp_sname[64];
+    /** 6c - File name / more DHCP options. */
+    uint8_t         bp_file[128];
+    /** ec - Vendor specific area (BOOTP) / Options (DHCP).
+     * @remark This is really 312 bytes in the DHCP version. */
+    union
+    {
+        uint8_t         au8[128];
+        struct DHCP
+        {
+            /** ec - The DHCP cookie (RTNET_DHCP_COOKIE). */
+            uint32_t    dhcp_cookie;
+            /** f0 - The DHCP options. */
+            uint8_t     dhcp_opts[124];
+        }           Dhcp;
+    }               bp_vend;
+
+} RTNETBOOTP;
+#pragma pack(0)
+AssertCompileSize(RTNETBOOTP, 0xec + 128);
+/** Pointer to a BOOTP / DHCP packet. */
+typedef RTNETBOOTP *PRTNETBOOTP;
+/** Pointer to a const BOOTP / DHCP packet. */
+typedef RTNETBOOTP const *PCRTNETBOOTP;
+
+/** @name BOOTP packet opcode values
+ * @{ */
+#define RTNETBOOTP_OP_REQUEST       1
+#define RTNETBOOTP_OP_REPLY         2
+/** @} */
+
+/** @name DHCP flags (RTNETBOOTP::bp_flags)
+ * @{ */
+#define RTNET_DHCP_FLAGS_NO_BROADCAST   UINT16_C(0x8000) /** @todo check test!!! */
+/** @} */
+
+/** The DHCP cookie (network endian). */
+#define RTNET_DHCP_COOKIE           UINT32_C(0x63825363)
+
+/**
+ * An IPv4 DHCP option header.
+ */
+typedef struct RTNETDHCPOPT
+{
+    /** 00 - The DHCP option. */
+    uint8_t     dhcp_opt;
+    /** 01 - The data length (excluding this header). */
+    uint8_t     dhcp_len;
+    /*  02 - The option data follows here, optional and of variable length. */
+} RTNETDHCPOPT;
+AssertCompileSize(RTNETDHCPOPT, 2);
+/** Pointer to a DHCP option header. */
+typedef RTNETDHCPOPT *PRTNETDHCPOPT;
+/** Pointer to a const DHCP option header. */
+typedef RTNETDHCPOPT const *PCRTNETDHCPOPT;
+
+/** @name DHCP options
+ * @{ */
+/** 1 byte padding, this has no dhcp_len field. */
+#define RTNET_DHCP_OPT_PAD          0
+/** Have a 8-bit message type value as data, see RTNET_DHCP_MT_*. */
+#define RTNET_DHCP_OPT_MSG_TYPE     53
+/** Marks the end of the DHCP options, this has no dhcp_len field. */
+#define RTNET_DHCP_OPT_END          255
+/** @} */
+
+/** @name DHCP Message Types (option 53)
+ * @{ */
+#define RTNET_DHCP_MT_DISCOVER      1
+#define RTNET_DHCP_MT_OFFER         2
+#define RTNET_DHCP_MT_REQUEST       3
+#define RTNET_DHCP_MT_DECLINE       4
+#define RTNET_DHCP_MT_ACK           5
+#define RTNET_DHCP_MT_NAC           6
+#define RTNET_DHCP_MT_RELEASE       7
+#define RTNET_DHCP_MT_INFORM        8
+/** @} */
+
+RTDECL(bool) RTNetIPv4IsDHCPValid(PCRTNETUDP pUdpHdr, PCRTNETBOOTP pDhcp, size_t cbDhcp, uint8_t *pMsgType);
+
-
-/**
- * IPv4 DHCP packet.
+ * @obsolete Use RTNETBOOTP.
- */
-#pragma pack(1)
-typedef struct RTNETDHCP
-{
+    /** 00 - The packet opcode. */
-    uint8_t         Op;
-    /** Hardware address type. */

trunk/src/VBox/Runtime/common/checksum/ipv4.cpp

@@ -549 +549 @@
-}
-
+
+/**
+ * Minimal validation of a DHCP packet.
+ *
+ * This will fail on BOOTP packets (if sufficient data is supplied).
+ * It will not verify the source and destination ports, that's the
+ * caller's responsibility.
+ *
+ * This function will ASSUME that the hardware type is ethernet
+ * and use that for htype/hlen validation.
+ *
+ * @returns true if valid, false if invalid.
+ * @param   pUdpHdr         Pointer to the UDP header, in network endian (big).
+ *                          This is assumed to be valid and fully mapped.
+ * @param   pDhcp           Pointer to the DHCP packet.
+ *                          This might not be the entire thing, see cbDhcp.
+ * @param   cbDhcp          The number of valid bytes that pDhcp points to.
+ * @param   pMsgType        Where to store the message type (if found).
+ *                          This will be set to 0 if not found and on failure.
+ */
+RTDECL(bool) RTNetIPv4IsDHCPValid(PCRTNETUDP pUdpHdr, PCRTNETBOOTP pDhcp, size_t cbDhcp, uint8_t *pMsgType)
+{
+    AssertPtrNull(pMsgType);
+    if (pMsgType)
+        *pMsgType = 0;
+
+    /*
+     * Validate all the header fields we're able to...
+     */
+    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_op) + sizeof(pDhcp->bp_op))
+        return true;
+    if (RT_UNLIKELY(    pDhcp->bp_op != RTNETBOOTP_OP_REQUEST
+                    &&  pDhcp->bp_op != RTNETBOOTP_OP_REPLY))
+        return false;
+
+    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_htype) + sizeof(pDhcp->bp_htype))
+        return true;
+    if (RT_UNLIKELY(pDhcp->bp_htype != RTNET_ARP_ETHER))
+        return false;
+
+    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_hlen) + sizeof(pDhcp->bp_hlen))
+        return true;
+    if (RT_UNLIKELY(pDhcp->bp_hlen != sizeof(RTMAC)))
+        return false;
+
+    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_flags) + sizeof(pDhcp->bp_flags))
+        return true;
+    if (RT_UNLIKELY(RT_BE2H_U16(pDhcp->bp_flags) & ~(RTNET_DHCP_FLAGS_NO_BROADCAST)))
+        return false;
+
+    /*
+     * Check the DHCP cookie and make sure it isn't followed by an END option
+     * (because that seems to be indicating that it's BOOTP and not DHCP).
+     */
+    ssize_t cbLeft = (ssize_t)cbDhcp - RT_OFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_cookie) + sizeof(pDhcp->bp_vend.Dhcp.dhcp_cookie);
+    if (cbLeft < 0)
+        return true;
+    if (RT_UNLIKELY(RT_BE2H_U32(pDhcp->bp_vend.Dhcp.dhcp_cookie) != RTNET_DHCP_COOKIE))
+        return false;
+    if (cbLeft < 1)
+        return true;
+    PCRTNETDHCPOPT pOpt = (PCRTNETDHCPOPT)&pDhcp->bp_vend.Dhcp.dhcp_opts[0];
+    if (pOpt->dhcp_opt == RTNET_DHCP_OPT_END)
+        return false;
+
+    /*
+     * Scan the options until we find the message type or run out of message.
+     *
+     * We're not strict about termination (END) for many reasons, however,
+     * we don't accept END without MSG_TYPE.
+     */
+    uint8_t MsgType = 0;
+    while (cbLeft > 0)
+    {
+        if (pOpt->dhcp_opt == RTNET_DHCP_OPT_END)
+        {
+            /* Fail if no MSG_TYPE. */
+            if (!MsgType)
+                return false;
+            break;
+        }
+        if (pOpt->dhcp_opt == RTNET_DHCP_OPT_PAD)
+        {
+            pOpt = (PCRTNETDHCPOPT)((uint8_t const *)pOpt + 1);
+            cbLeft--;
+        }
+        else
+        {
+            switch (pOpt->dhcp_opt)
+            {
+                case RTNET_DHCP_OPT_MSG_TYPE:
+                {
+                    if (cbLeft < 3)
+                        return true;
+                    MsgType = *(const uint8_t *)(pOpt + 1);
+                    switch (MsgType)
+                    {
+                        case RTNET_DHCP_MT_DISCOVER:
+                        case RTNET_DHCP_MT_OFFER:
+                        case RTNET_DHCP_MT_REQUEST:
+                        case RTNET_DHCP_MT_DECLINE:
+                        case RTNET_DHCP_MT_ACK:
+                        case RTNET_DHCP_MT_NAC:
+                        case RTNET_DHCP_MT_RELEASE:
+                        case RTNET_DHCP_MT_INFORM:
+                            break;
+
+                        default:
+                            /* we don't know this message type, fail. */
+                            return false;
+                    }
+
+                    /* Found a known message type, consider the job done. */
+                    if (pMsgType)
+                        *pMsgType = MsgType;
+                    return true;
+                }
+            }
+
+            /* Skip the option. */
+            cbLeft -= pOpt->dhcp_len + sizeof(*pOpt);
+            pOpt = (PCRTNETDHCPOPT)((uint8_t const *)pOpt + pOpt->dhcp_len + sizeof(*pOpt));
+        }
+    }
+
+    return true;
+}
+