Coverage Report

Created: 2026-10-31 06:45

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/h3/src/apps/fuzzers/fuzzerPolygonToCellsExperimental.c
Line
Count
Source
1
/*
2
 * Copyright 2023-2024 Uber Technologies, Inc.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *         http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
/** @file
17
 * @brief Fuzzer program for polygonToCells2 and related functions
18
 */
19
20
#include "aflHarness.h"
21
#include "h3api.h"
22
#include "polyfill.h"
23
#include "polygon.h"
24
#include "utility.h"
25
26
typedef struct {
27
    int res;
28
    int numHoles;
29
    // repeating: num verts, verts
30
    // We add a large fixed buffer so our test case generator for AFL
31
    // knows how large to make the file.
32
    uint8_t buffer[1024];
33
} inputArgs;
34
35
const int MAX_RES = 15;
36
const int MAX_SZ = 4000000;
37
const int MAX_HOLES = 100;
38
39
int populateGeoLoop(GeoLoop *g, const uint8_t *data, size_t *offset,
40
12.4k
                    size_t size) {
41
12.4k
    if (size < *offset + sizeof(int)) {
42
5
        return 1;
43
5
    }
44
12.4k
    int numVerts = *(const int *)(data + *offset);
45
12.4k
    *offset = *offset + sizeof(int);
46
12.4k
    g->numVerts = numVerts;
47
12.4k
    if (size < *offset + sizeof(LatLng) * numVerts) {
48
147
        return 1;
49
147
    }
50
12.2k
    g->verts = (LatLng *)(data + *offset);
51
12.2k
    *offset = *offset + sizeof(LatLng) * numVerts;
52
12.2k
    return 0;
53
12.4k
}
54
55
9.47k
void run(GeoPolygon *geoPolygon, uint32_t flags, int res) {
56
9.47k
    int64_t sz;
57
9.47k
    H3Error err = H3_EXPORT(maxPolygonToCellsSizeExperimental)(geoPolygon, res,
58
9.47k
                                                               flags, &sz);
59
9.47k
    if (!err && sz < MAX_SZ) {
60
8.20k
        H3Index *out = calloc(sz, sizeof(H3Index));
61
8.20k
        H3_EXPORT(polygonToCellsExperimental)(geoPolygon, res, flags, sz, out);
62
8.20k
        free(out);
63
8.20k
    }
64
9.47k
}
65
66
632
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
67
    // TODO: It is difficult for the fuzzer to generate inputs that are
68
    // considered valid by this fuzzer. fuzzerPolygonToCellsNoHoles.c
69
    // is a workaround for that.
70
632
    if (size < sizeof(inputArgs)) {
71
20
        return 0;
72
20
    }
73
612
    const inputArgs *args = (const inputArgs *)data;
74
612
    int res = args->res % (MAX_RES + 1);
75
76
612
    GeoPolygon geoPolygon;
77
612
    int originalNumHoles = args->numHoles % MAX_HOLES;
78
612
    geoPolygon.numHoles = originalNumHoles;
79
612
    if (geoPolygon.numHoles < 0) {
80
7
        return 0;
81
7
    }
82
605
    geoPolygon.holes = calloc(geoPolygon.numHoles, sizeof(GeoLoop));
83
605
    size_t offset = sizeof(inputArgs) - sizeof(args->buffer);
84
605
    if (populateGeoLoop(&geoPolygon.geoloop, data, &offset, size)) {
85
70
        free(geoPolygon.holes);
86
70
        return 0;
87
70
    }
88
12.2k
    for (int i = 0; i < geoPolygon.numHoles; i++) {
89
11.8k
        if (populateGeoLoop(&geoPolygon.holes[i], data, &offset, size)) {
90
82
            free(geoPolygon.holes);
91
82
            return 0;
92
82
        }
93
11.8k
    }
94
95
2.26k
    for (uint32_t flags = 0; flags < CONTAINMENT_INVALID; flags++) {
96
1.81k
        geoPolygon.numHoles = originalNumHoles;
97
1.81k
        run(&geoPolygon, flags, res);
98
1.81k
        geoPolygon.numHoles = 0;
99
1.81k
        run(&geoPolygon, flags, res);
100
1.81k
    }
101
453
    free(geoPolygon.holes);
102
103
453
    return 0;
104
535
}
105
106
AFL_HARNESS_MAIN(sizeof(inputArgs));