Bug fixes for compactCells

src/apps/fuzzers/fuzzerCompact.c

@@ -30,35 +30,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     }
 
     uint8_t res = *data;
-    uint8_t uncompactRes = (*(data + 1)) % (MAX_UNCOMPACT_RES + 1);
     H3Index *input = (H3Index *)(data + sizeof(H3Index));
     size_t inputSize = (size - sizeof(H3Index)) / sizeof(H3Index);
 
     // fuzz compactCells
     H3Index *compacted = calloc(inputSize, sizeof(H3Index));
-    H3Error compactErr = H3_EXPORT(compactCells)(input, compacted, inputSize);
-
-    // fuzz uncompactCells using output of above
-    if (!compactErr) {
-        int compactedCount = 0;
-        for (int i = 0; i < inputSize; i++) {
-            if (compacted[i] != H3_NULL) {
-                compactedCount++;
-            }
-        }
-        if (compactedCount < 2) {
-            int64_t uncompactedSize;
-            H3Error err = H3_EXPORT(uncompactCellsSize)(
-                compacted, inputSize, uncompactRes, &uncompactedSize);
-            if (!err && uncompactedSize < MAX_UNCOMPACT_SIZE) {
-                H3Index *uncompacted = calloc(uncompactedSize, sizeof(H3Index));
-                H3_EXPORT(uncompactCells)
-                (compacted, compactedCount, uncompacted, uncompactedSize,
-                 uncompactRes);
-                free(uncompacted);
-            }
-        }
-    }
+    H3_EXPORT(compactCells)(input, compacted, inputSize);
+    free(compacted);
 
     // fuzz uncompactCells using the original input
     int64_t uncompactedSize;
@@ -71,7 +49,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
         (input, inputSize, uncompacted, uncompactedSize, res);
         free(uncompacted);
     }
-    free(compacted);
 
     return 0;
 }

src/apps/testapps/testCompactCells.c

@@ -262,6 +262,31 @@ SUITE(compactCells) {
         }
     }
 
+    TEST(compactCells_reservedBitsSet) {
+        const int numHex = 7;
+        H3Index bad[] = {
+            0x0010000000010000, 0x0180c6c6c6c61616, 0x1616ffffffffffff,
+            0xffff8affffffffff, 0xffffffffffffc6c6, 0xffffffffffffffc6,
+            0xc6c6c6c6c66fffe0,
+        };
+        H3Index output[] = {0, 0, 0, 0, 0, 0, 0};
+
+        t_assert(H3_EXPORT(compactCells)(bad, output, numHex) == E_CELL_INVALID,
+                 "compactCells returns E_CELL_INVALID on bad input");
+    }
+
+    TEST(compactCells_parentError) {
+        const int numHex = 3;
+        H3Index bad[] = {0, 0, 0};
+        H3Index output[] = {0, 0, 0};
+        H3_SET_RESOLUTION(bad[0], 10);
+        H3_SET_RESOLUTION(bad[1], 5);
+
+        t_assert(
+            H3_EXPORT(compactCells)(bad, output, numHex) == E_RES_MISMATCH,
+            "compactCells returns E_RES_MISMATCH on bad input (parent error)");
+    }
+
     TEST(uncompactCells_wrongRes) {
         int numHex = 3;
         H3Index someHexagons[] = {0, 0, 0};

src/h3lib/lib/h3Index.c

@@ -330,16 +330,27 @@ H3Error H3_EXPORT(compactCells)(const H3Index *h3Set, H3Index *compactedSet,
         for (int i = 0; i < numRemainingHexes; i++) {
             H3Index currIndex = remainingHexes[i];
             if (currIndex != 0) {
+                // If the reserved bits were set by the caller, the
+                // algorithm below may encounter undefined behavior
+                // because it expects to have set the reserved bits
+                // itself.
+                if (H3_GET_RESERVED_BITS(currIndex) != 0) {
+                    H3_MEMORY(free)(remainingHexes);
+                    H3_MEMORY(free)(hashSetArray);
+                    return E_CELL_INVALID;
+                }
+
                 H3Index parent;
                 H3Error parentError =
                     H3_EXPORT(cellToParent)(currIndex, parentRes, &parent);
-                // LCOV_EXCL_START
                 // Should never be reachable as a result of the compact
-                // algorithm.
+                // algorithm. Can happen if cellToParent errors e.g.
+                // because of incompatible resolutions.
                 if (parentError) {
+                    H3_MEMORY(free)(remainingHexes);
+                    H3_MEMORY(free)(hashSetArray);
                     return parentError;
                 }
-                // LCOV_EXCL_STOP
                 // Modulus hash the parent into the temp array
                 int loc = (int)(parent % numRemainingHexes);
                 int loopCount = 0;
@@ -432,6 +443,9 @@ H3Error H3_EXPORT(compactCells)(const H3Index *h3Set, H3Index *compactedSet,
                 // Should never be reachable as a result of the compact
                 // algorithm.
                 if (parentError) {
+                    // TODO: Determine if this is somehow reachable.
+                    H3_MEMORY(free)(remainingHexes);
+                    H3_MEMORY(free)(hashSetArray);
                     return parentError;
                 }
                 // LCOV_EXCL_STOP