Coverage Report

Created: 2026-10-10 06:20

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/postgis/fuzzers/liblwgeom_fuzzer.hpp
Line
Count
Source
1
/******************************************************************************
2
 *
3
 * Project:  PostGIS
4
 * Purpose:  Shared liblwgeom fuzzer support
5
 *
6
 ******************************************************************************
7
 * Copyright (C) 2026 Darafei Praliaskouski <me@komzpa.net>
8
 *
9
 * This program is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU General Public License
11
 * as published by the Free Software Foundation; either version 2
12
 * of the License, or (at your option) any later version.
13
 *
14
 ****************************************************************************/
15
16
#ifndef POSTGIS_LIBLWGEOM_FUZZER_HPP
17
#define POSTGIS_LIBLWGEOM_FUZZER_HPP
18
19
#include <setjmp.h>
20
#include <stdarg.h>
21
#include <stddef.h>
22
#include <stdlib.h>
23
24
extern "C" {
25
#include "liblwgeom.h"
26
}
27
28
static jmp_buf postgis_lwgeom_fuzzer_jmp_buf;
29
static void **postgis_lwgeom_fuzzer_ptrs = NULL;
30
static size_t postgis_lwgeom_fuzzer_count = 0;
31
static size_t postgis_lwgeom_fuzzer_capacity = 0;
32
33
3.17k
#define POSTGIS_LWGEOM_FUZZER_SETJMP() setjmp(postgis_lwgeom_fuzzer_jmp_buf)
34
35
static int
36
postgis_lwgeom_fuzzer_track_add(void *ptr)
37
19.8M
{
38
19.8M
  void **new_ptrs;
39
19.8M
  size_t new_capacity;
40
41
19.8M
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
63
  {
43
63
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
63
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
63
    if (new_ptrs == NULL)
46
0
      return 0;
47
63
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
63
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
63
  }
50
51
19.8M
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
19.8M
  return 1;
53
19.8M
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
15.5M
{
38
15.5M
  void **new_ptrs;
39
15.5M
  size_t new_capacity;
40
41
15.5M
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
17
  {
43
17
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
17
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
17
    if (new_ptrs == NULL)
46
0
      return 0;
47
17
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
17
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
17
  }
50
51
15.5M
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
15.5M
  return 1;
53
15.5M
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
1.21k
{
38
1.21k
  void **new_ptrs;
39
1.21k
  size_t new_capacity;
40
41
1.21k
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
1
  {
43
1
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
1
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
1
    if (new_ptrs == NULL)
46
0
      return 0;
47
1
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
1
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
1
  }
50
51
1.21k
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
1.21k
  return 1;
53
1.21k
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
1.62M
{
38
1.62M
  void **new_ptrs;
39
1.62M
  size_t new_capacity;
40
41
1.62M
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
12
  {
43
12
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
12
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
12
    if (new_ptrs == NULL)
46
0
      return 0;
47
12
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
12
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
12
  }
50
51
1.62M
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
1.62M
  return 1;
53
1.62M
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
764k
{
38
764k
  void **new_ptrs;
39
764k
  size_t new_capacity;
40
41
764k
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
11
  {
43
11
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
11
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
11
    if (new_ptrs == NULL)
46
0
      return 0;
47
11
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
11
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
11
  }
50
51
764k
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
764k
  return 1;
53
764k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
559k
{
38
559k
  void **new_ptrs;
39
559k
  size_t new_capacity;
40
41
559k
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
10
  {
43
10
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
10
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
10
    if (new_ptrs == NULL)
46
0
      return 0;
47
10
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
10
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
10
  }
50
51
559k
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
559k
  return 1;
53
559k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
Line
Count
Source
37
1.31M
{
38
1.31M
  void **new_ptrs;
39
1.31M
  size_t new_capacity;
40
41
1.31M
  if (postgis_lwgeom_fuzzer_count == postgis_lwgeom_fuzzer_capacity)
42
12
  {
43
12
    new_capacity = postgis_lwgeom_fuzzer_capacity ? postgis_lwgeom_fuzzer_capacity * 2 : 64;
44
12
    new_ptrs = (void **)realloc(postgis_lwgeom_fuzzer_ptrs, new_capacity * sizeof(void *));
45
12
    if (new_ptrs == NULL)
46
0
      return 0;
47
12
    postgis_lwgeom_fuzzer_ptrs = new_ptrs;
48
12
    postgis_lwgeom_fuzzer_capacity = new_capacity;
49
12
  }
50
51
1.31M
  postgis_lwgeom_fuzzer_ptrs[postgis_lwgeom_fuzzer_count++] = ptr;
52
1.31M
  return 1;
53
1.31M
}
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_add(void*)
54
55
static void
56
postgis_lwgeom_fuzzer_track_remove(void *ptr)
57
2.99M
{
58
22.9G
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
22.9G
  {
60
22.9G
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
2.99M
    {
62
2.99M
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
2.99M
      return;
64
2.99M
    }
65
22.9G
  }
66
2.99M
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
19.1k
{
58
120M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
120M
  {
60
120M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
19.1k
    {
62
19.1k
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
19.1k
      return;
64
19.1k
    }
65
120M
  }
66
19.1k
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
711
{
58
1.42k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
1.42k
  {
60
1.42k
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
711
    {
62
711
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
711
      return;
64
711
    }
65
1.42k
  }
66
711
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
1.62M
{
58
10.6G
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
10.6G
  {
60
10.6G
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
1.62M
    {
62
1.62M
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
1.62M
      return;
64
1.62M
    }
65
10.6G
  }
66
1.62M
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
215k
{
58
1.09G
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
1.09G
  {
60
1.09G
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
215k
    {
62
215k
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
215k
      return;
64
215k
    }
65
1.09G
  }
66
215k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
269k
{
58
368M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
368M
  {
60
368M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
269k
    {
62
269k
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
269k
      return;
64
269k
    }
65
368M
  }
66
269k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
Line
Count
Source
57
861k
{
58
10.7G
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
59
10.7G
  {
60
10.7G
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
61
861k
    {
62
861k
      postgis_lwgeom_fuzzer_ptrs[i] = postgis_lwgeom_fuzzer_ptrs[--postgis_lwgeom_fuzzer_count];
63
861k
      return;
64
861k
    }
65
10.7G
  }
66
861k
}
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_track_remove(void*)
67
68
static void
69
postgis_lwgeom_fuzzer_cleanup_allocations(void)
70
26.6k
{
71
16.8M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
16.8M
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
26.6k
  postgis_lwgeom_fuzzer_count = 0;
74
26.6k
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
5.32k
{
71
15.5M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
15.5M
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
5.32k
  postgis_lwgeom_fuzzer_count = 0;
74
5.32k
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
678
{
71
1.17k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
500
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
678
  postgis_lwgeom_fuzzer_count = 0;
74
678
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
4.71k
{
71
4.71k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
0
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
4.71k
  postgis_lwgeom_fuzzer_count = 0;
74
4.71k
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
5.12k
{
71
553k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
548k
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
5.12k
  postgis_lwgeom_fuzzer_count = 0;
74
5.12k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
5.98k
{
71
296k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
290k
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
5.98k
  postgis_lwgeom_fuzzer_count = 0;
74
5.98k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
4.70k
{
71
458k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
453k
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
4.70k
  postgis_lwgeom_fuzzer_count = 0;
74
4.70k
}
geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_cleanup_allocations()
Line
Count
Source
70
94
{
71
94
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
72
0
    free(postgis_lwgeom_fuzzer_ptrs[i]);
73
94
  postgis_lwgeom_fuzzer_count = 0;
74
94
}
75
76
static void *
77
postgis_lwgeom_fuzzer_malloc(size_t size)
78
19.8M
{
79
19.8M
  void *ptr = malloc(size);
80
19.8M
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
19.8M
  return ptr;
86
19.8M
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
15.5M
{
79
15.5M
  void *ptr = malloc(size);
80
15.5M
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
15.5M
  return ptr;
86
15.5M
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
1.21k
{
79
1.21k
  void *ptr = malloc(size);
80
1.21k
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
1.21k
  return ptr;
86
1.21k
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
1.62M
{
79
1.62M
  void *ptr = malloc(size);
80
1.62M
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
1.62M
  return ptr;
86
1.62M
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
764k
{
79
764k
  void *ptr = malloc(size);
80
764k
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
764k
  return ptr;
86
764k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
559k
{
79
559k
  void *ptr = malloc(size);
80
559k
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
559k
  return ptr;
86
559k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
Line
Count
Source
78
1.31M
{
79
1.31M
  void *ptr = malloc(size);
80
1.31M
  if (ptr != NULL && !postgis_lwgeom_fuzzer_track_add(ptr))
81
0
  {
82
0
    free(ptr);
83
0
    return NULL;
84
0
  }
85
1.31M
  return ptr;
86
1.31M
}
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_malloc(unsigned long)
87
88
static void *
89
postgis_lwgeom_fuzzer_realloc(void *ptr, size_t size)
90
79.8k
{
91
79.8k
  void *new_ptr;
92
93
79.8k
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
79.8k
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
79.8k
  new_ptr = realloc(ptr, size);
103
79.8k
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
150M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
150M
  {
108
150M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
79.8k
    {
110
79.8k
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
79.8k
      return new_ptr;
112
79.8k
    }
113
150M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
126
{
91
126
  void *new_ptr;
92
93
126
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
126
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
126
  new_ptr = realloc(ptr, size);
103
126
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
5.86M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
5.86M
  {
108
5.86M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
126
    {
110
126
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
126
      return new_ptr;
112
126
    }
113
5.86M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
541
{
91
541
  void *new_ptr;
92
93
541
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
541
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
541
  new_ptr = realloc(ptr, size);
103
541
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
1.08k
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
1.08k
  {
108
1.08k
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
541
    {
110
541
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
541
      return new_ptr;
112
541
    }
113
1.08k
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
8.54k
{
91
8.54k
  void *new_ptr;
92
93
8.54k
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
8.54k
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
8.54k
  new_ptr = realloc(ptr, size);
103
8.54k
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
4.83M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
4.83M
  {
108
4.83M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
8.54k
    {
110
8.54k
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
8.54k
      return new_ptr;
112
8.54k
    }
113
4.83M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
16.6k
{
91
16.6k
  void *new_ptr;
92
93
16.6k
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
16.6k
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
16.6k
  new_ptr = realloc(ptr, size);
103
16.6k
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
54.2M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
54.2M
  {
108
54.2M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
16.6k
    {
110
16.6k
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
16.6k
      return new_ptr;
112
16.6k
    }
113
54.2M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
46.4k
{
91
46.4k
  void *new_ptr;
92
93
46.4k
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
46.4k
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
46.4k
  new_ptr = realloc(ptr, size);
103
46.4k
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
81.2M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
81.2M
  {
108
81.2M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
46.4k
    {
110
46.4k
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
46.4k
      return new_ptr;
112
46.4k
    }
113
81.2M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
Line
Count
Source
90
7.53k
{
91
7.53k
  void *new_ptr;
92
93
7.53k
  if (ptr == NULL)
94
0
    return postgis_lwgeom_fuzzer_malloc(size);
95
7.53k
  if (size == 0)
96
0
  {
97
0
    postgis_lwgeom_fuzzer_track_remove(ptr);
98
0
    free(ptr);
99
0
    return NULL;
100
0
  }
101
102
7.53k
  new_ptr = realloc(ptr, size);
103
7.53k
  if (new_ptr == NULL)
104
0
    return NULL;
105
106
4.76M
  for (size_t i = 0; i < postgis_lwgeom_fuzzer_count; i++)
107
4.76M
  {
108
4.76M
    if (postgis_lwgeom_fuzzer_ptrs[i] == ptr)
109
7.53k
    {
110
7.53k
      postgis_lwgeom_fuzzer_ptrs[i] = new_ptr;
111
7.53k
      return new_ptr;
112
7.53k
    }
113
4.76M
  }
114
115
0
  if (!postgis_lwgeom_fuzzer_track_add(new_ptr))
116
0
  {
117
0
    free(new_ptr);
118
0
    return NULL;
119
0
  }
120
0
  return new_ptr;
121
0
}
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_realloc(void*, unsigned long)
122
123
static void
124
postgis_lwgeom_fuzzer_free(void *ptr)
125
2.99M
{
126
2.99M
  if (ptr == NULL)
127
0
    return;
128
2.99M
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
2.99M
  free(ptr);
130
2.99M
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
19.1k
{
126
19.1k
  if (ptr == NULL)
127
0
    return;
128
19.1k
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
19.1k
  free(ptr);
130
19.1k
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
711
{
126
711
  if (ptr == NULL)
127
0
    return;
128
711
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
711
  free(ptr);
130
711
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
1.62M
{
126
1.62M
  if (ptr == NULL)
127
0
    return;
128
1.62M
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
1.62M
  free(ptr);
130
1.62M
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
215k
{
126
215k
  if (ptr == NULL)
127
0
    return;
128
215k
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
215k
  free(ptr);
130
215k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
269k
{
126
269k
  if (ptr == NULL)
127
0
    return;
128
269k
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
269k
  free(ptr);
130
269k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
Line
Count
Source
125
861k
{
126
861k
  if (ptr == NULL)
127
0
    return;
128
861k
  postgis_lwgeom_fuzzer_track_remove(ptr);
129
861k
  free(ptr);
130
861k
}
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_free(void*)
131
132
extern "C" {
133
static void
134
postgis_lwgeom_fuzzer_noticereporter(const char *, va_list)
135
8.57k
{}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
Line
Count
Source
135
1.07k
{}
Unexecuted instantiation: encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
Line
Count
Source
135
1.88k
{}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
Line
Count
Source
135
2.77k
{}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
Line
Count
Source
135
2.85k
{}
Unexecuted instantiation: twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_noticereporter(char const*, __va_list_tag*)
136
137
static void
138
postgis_lwgeom_fuzzer_errorreporter(const char *, va_list)
139
11.1k
{
140
11.1k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
11.1k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
11.1k
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
2.07k
{
140
2.07k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
2.07k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
2.07k
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
250
{
140
250
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
250
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
250
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
2.03k
{
140
2.03k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
2.03k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
2.03k
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
2.35k
{
140
2.35k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
2.35k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
2.35k
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
2.32k
{
140
2.32k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
2.32k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
2.32k
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
2.07k
{
140
2.07k
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
2.07k
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
2.07k
}
geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_errorreporter(char const*, __va_list_tag*)
Line
Count
Source
139
25
{
140
25
  postgis_lwgeom_fuzzer_cleanup_allocations();
141
25
  longjmp(postgis_lwgeom_fuzzer_jmp_buf, 1);
142
25
}
143
144
static void
145
postgis_lwgeom_fuzzer_debuglogger(int, const char *, va_list)
146
0
{}
Unexecuted instantiation: gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
Unexecuted instantiation: geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_debuglogger(int, char const*, __va_list_tag*)
147
}
148
149
static void
150
postgis_lwgeom_fuzzer_initialize(void)
151
14
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
14
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
14
          postgis_lwgeom_fuzzer_realloc,
158
14
          postgis_lwgeom_fuzzer_free,
159
14
          postgis_lwgeom_fuzzer_errorreporter,
160
14
          postgis_lwgeom_fuzzer_noticereporter);
161
14
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
14
}
gserialized_from_bytea_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
encoded_polyline_import_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
wkt_import_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
wkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
gserialized_from_lwgeom_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
twkb_import_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
geohash_import_fuzzer.cpp:postgis_lwgeom_fuzzer_initialize()
Line
Count
Source
151
2
{
152
  /* liblwgeom reports parser errors through the configured error reporter.
153
   * Track liblwgeom allocations so longjmp error paths release allocations
154
   * made before the jump.
155
   */
156
2
  lwgeom_set_handlers(postgis_lwgeom_fuzzer_malloc,
157
2
          postgis_lwgeom_fuzzer_realloc,
158
2
          postgis_lwgeom_fuzzer_free,
159
2
          postgis_lwgeom_fuzzer_errorreporter,
160
2
          postgis_lwgeom_fuzzer_noticereporter);
161
2
  lwgeom_set_debuglogger(postgis_lwgeom_fuzzer_debuglogger);
162
2
}
163
164
#endif