Changeset 65579 in vbox for trunk/src/VBox/Runtime

Timestamp:

Feb 1, 2017 9:32:38 PM (8 years ago)

Author:

vboxsync

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

113233

Message:

IPRT: RTNetMaskToPrefixIPv4 and RTNetPrefixToMaskIPv4.

Location:

trunk/src/VBox/Runtime

Files:

• common/net/netaddrstr2.cpp (modified) (1 diff)
• testcase/tstRTNetIPv4.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/common/net/netaddrstr2.cpp

@@ -153 +153 @@
 
 
+RTDECL(int) RTNetMaskToPrefixIPv4(PCRTNETADDRIPV4 pMask, int *piPrefix)
+{
+    AssertReturn(pMask != NULL, VERR_INVALID_PARAMETER);
+
+    if (pMask->u == 0)
+    {
+        if (piPrefix != NULL)
+            *piPrefix = 0;
+        return VINF_SUCCESS;
+    }
+
+    const uint32_t uMask = RT_N2H_U32(pMask->u);
+
+    uint32_t uPrefixMask = UINT32_C(0xffffffff);
+    int iPrefixLen = 32;
+
+    while (iPrefixLen > 0) { 
+        if (uMask == uPrefixMask)
+        {
+            if (piPrefix != NULL)
+                *piPrefix = iPrefixLen;
+            return VINF_SUCCESS;
+        }
+
+        --iPrefixLen;
+        uPrefixMask <<= 1;
+    }
+
+    return VERR_INVALID_PARAMETER;
+}
+RT_EXPORT_SYMBOL(RTNetMaskToPrefixIPv4);
+
+
+RTDECL(int) RTNetPrefixToMaskIPv4(int iPrefix, PRTNETADDRIPV4 pMask)
+{
+    AssertReturn(pMask != NULL, VERR_INVALID_PARAMETER);
+
+    if (RT_UNLIKELY(iPrefix < 0 || 32 < iPrefix))
+        return VERR_INVALID_PARAMETER;
+
+    if (RT_LIKELY(iPrefix != 0))
+        pMask->u = RT_H2N_U32(UINT32_C(0xffffffff) << (32 - iPrefix));
+    else /* avoid UB in the shift */
+        pMask->u = 0;
+
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTNetPrefixToMaskIPv4);
+
+
 static int rtNetStrToHexGroup(const char *pcszValue, char **ppszNext,
                               uint16_t *pu16)

trunk/src/VBox/Runtime/testcase/tstRTNetIPv4.cpp

@@ -112 +112 @@
 
 
+#define CHECKMASK(_mask, _rcExpected, _iExpectedPrefix)                 \
+    do {                                                                \
+        /* const */ RTNETADDRIPV4 Mask;                                 \
+        int iExpectedPrefix = (_iExpectedPrefix);                       \
+        int iPrefix;                                                    \
+        const int rcExpected = (_rcExpected);                           \
+        int rc2;                                                        \
+                                                                        \
+        Mask.u = RT_H2N_U32_C(UINT32_C(_mask));                         \
+        rc2 = RTNetMaskToPrefixIPv4(&Mask, &iPrefix);                   \
+                                                                        \
+        if (rcExpected == VINF_SUCCESS)                                 \
+        {                                                               \
+            if (rc2 != rcExpected)                                      \
+            {                                                           \
+                /* unexpected failure */                                \
+                RTTestIFailed("at line %d: mask %RTnaipv4:"             \
+                              " expected prefix length %d got %Rrc\n",  \
+                              __LINE__, Mask.u,                         \
+                              iExpectedPrefix, rc2);                    \
+            }                                                           \
+            else if (iPrefix != iExpectedPrefix)                        \
+            {                                                           \
+                /* unexpected result */                                 \
+                RTTestIFailed("at line %d: mask %RTnaipv4:"             \
+                              " expected prefix length %d got %d\n",    \
+                              __LINE__, Mask.u,                         \
+                              iExpectedPrefix, iPrefix);                \
+            }                                                           \
+        }                                                               \
+        else /* expect failure */                                       \
+        {                                                               \
+            if (rc2 == VINF_SUCCESS)                                    \
+            {                                                           \
+                /* unexpected success */                                \
+                RTTestIFailed("at line %d: mask %RTnaipv4:"             \
+                              " expected %Rrc got prefix length %d\n",  \
+                              __LINE__, Mask.u,                         \
+                              rcExpected, iPrefix);                     \
+            }                                                           \
+            else if (rc2 != rcExpected)                                 \
+            {                                                           \
+                /* unexpected error */                                  \
+                RTTestIFailed("at line %d: mask %RTnaipv4:"             \
+                              " expected %Rrc got %Rrc\n",              \
+                              __LINE__, Mask.u,                         \
+                              rcExpected, rc2);                         \
+            }                                                           \
+        }                                                               \
+    } while (0)
+
+#define CHECKPREFIX(_prefix, _rcExpected, _mask)                        \
+    do {                                                                \
+        const int iPrefix = (_prefix);                                  \
+        RTNETADDRIPV4 ExpectedMask, Mask;                               \
+        const int rcExpected = (_rcExpected);                           \
+        int rc2;                                                        \
+                                                                        \
+        ExpectedMask.u = RT_H2N_U32_C(UINT32_C(_mask));                 \
+        rc2 = RTNetPrefixToMaskIPv4(iPrefix, &Mask);                    \
+                                                                        \
+        if (rcExpected == VINF_SUCCESS)                                 \
+        {                                                               \
+            if (rc2 != rcExpected)                                      \
+            {                                                           \
+                /* unexpected failure */                                \
+                RTTestIFailed("at line %d: prefix %d:"                  \
+                              " expected mask %RTnaipv4 got %Rrc\n",    \
+                              __LINE__, iPrefix,                        \
+                              ExpectedMask.u, rc2);                     \
+            }                                                           \
+            else if (Mask.u != ExpectedMask.u)                          \
+            {                                                           \
+                /* unexpected result */                                 \
+                RTTestIFailed("at line %d: prefix %d:"                  \
+                              " expected mask %RTnaipv4 got %RTnaipv4\n", \
+                              __LINE__, iPrefix,                        \
+                              ExpectedMask.u, Mask.u);                  \
+            }                                                           \
+        }                                                               \
+        else /* expect failure */                                       \
+        {                                                               \
+            if (rc2 == VINF_SUCCESS)                                    \
+            {                                                           \
+                /* unexpected success */                                \
+                RTTestIFailed("at line %d: prefix %d:"                  \
+                              " expected %Rrc got mask %RTnaipv4\n",    \
+                              __LINE__, iPrefix,                        \
+                              rcExpected, Mask.u);                      \
+            }                                                           \
+            else if (rc2 != rcExpected)                                 \
+            {                                                           \
+                /* unexpected error */                                  \
+                RTTestIFailed("at line %d: prefix %d:"                  \
+                              " expected %Rrc got %Rrc\n",              \
+                              __LINE__, iPrefix,                        \
+                              rcExpected, rc2);                         \
+            }                                                           \
+        }                                                               \
+    } while (0)
+
+#define GOODMASK(_mask, _prefix)                                        \
+    do {                                                                \
+        CHECKMASK(_mask, VINF_SUCCESS, _prefix);                        \
+        CHECKPREFIX(_prefix, VINF_SUCCESS, _mask);                      \
+    } while (0)
+
+#define BADMASK(_mask) \
+    CHECKMASK(_mask, VERR_INVALID_PARAMETER, -1)
+
+#define BADPREFIX(_prefix) \
+    CHECKPREFIX(_prefix, VERR_INVALID_PARAMETER, 0)
+
+
 int main()
 {
@@ -153 +267 @@
     NOT_ANY("0.0.0.0x");        /* bad address */
 
+
+    /*
+     * The mask <-> prefix table is small so we can test it all.
+     */
+    GOODMASK(0x00000000,  0); /* 0.0.0.0         */
+    GOODMASK(0x80000000,  1); /* 128.0.0.0       */
+    GOODMASK(0xc0000000,  2); /* 192.0.0.0       */
+    GOODMASK(0xe0000000,  3); /* 224.0.0.0       */
+    GOODMASK(0xf0000000,  4); /* 240.0.0.0       */
+    GOODMASK(0xf8000000,  5); /* 248.0.0.0       */
+    GOODMASK(0xfc000000,  6); /* 252.0.0.0       */
+    GOODMASK(0xfe000000,  7); /* 254.0.0.0       */
+    GOODMASK(0xff000000,  8); /* 255.0.0.0       */
+    GOODMASK(0xff800000,  9); /* 255.128.0.0     */
+    GOODMASK(0xffc00000, 10); /* 255.192.0.0     */
+    GOODMASK(0xffe00000, 11); /* 255.224.0.0     */
+    GOODMASK(0xfff00000, 12); /* 255.240.0.0     */
+    GOODMASK(0xfff80000, 13); /* 255.248.0.0     */
+    GOODMASK(0xfffc0000, 14); /* 255.252.0.0     */
+    GOODMASK(0xfffe0000, 15); /* 255.254.0.0     */
+    GOODMASK(0xffff0000, 16); /* 255.255.0.0     */
+    GOODMASK(0xffff8000, 17); /* 255.255.128.0   */
+    GOODMASK(0xffffc000, 18); /* 255.255.192.0   */
+    GOODMASK(0xffffe000, 19); /* 255.255.224.0   */
+    GOODMASK(0xfffff000, 20); /* 255.255.240.0   */
+    GOODMASK(0xfffff800, 21); /* 255.255.248.0   */
+    GOODMASK(0xfffffc00, 22); /* 255.255.252.0   */
+    GOODMASK(0xfffffe00, 23); /* 255.255.254.0   */
+    GOODMASK(0xffffff00, 24); /* 255.255.255.0   */
+    GOODMASK(0xffffff80, 25); /* 255.255.255.128 */
+    GOODMASK(0xffffffc0, 26); /* 255.255.255.192 */
+    GOODMASK(0xffffffe0, 27); /* 255.255.255.224 */
+    GOODMASK(0xfffffff0, 28); /* 255.255.255.240 */
+    GOODMASK(0xfffffff8, 29); /* 255.255.255.248 */
+    GOODMASK(0xfffffffc, 30); /* 255.255.255.252 */
+    GOODMASK(0xfffffffe, 31); /* 255.255.255.254 */
+    GOODMASK(0xffffffff, 32); /* 255.255.255.255 */
+
+    BADMASK(0x01020304);
+
+    BADPREFIX(-1);
+    BADPREFIX(33);
+
     return RTTestSummaryAndDestroy(hTest);
 }