Debian Codegraph @

test-data/pkg/writer/maxmind.go

raw
1 package writer
2
3 import (
4 "fmt"
5 "net/netip"
6
7 "github.com/maxmind/mmdbwriter"
8 "github.com/maxmind/mmdbwriter/mmdbtype"
9 "go4.org/netipx"
10 )
11
12 // WriteIPv4TestDB writes mmdb files for an ip range between 1.1.1.1 and 1.1.1.32
13 // with various record sizes.
14 func (w *Writer) WriteIPv4TestDB() error {
15 ipRange, err := parseIPRange("1.1.1.1", "1.1.1.32")
16 if err != nil {
17 return fmt.Errorf("parsing ip range: %w", err)
18 }
19
20 for _, recordSize := range []int{24, 28, 32} {
21 err := w.writeMaxMindTestDB(
22 recordSize,
23 []netipx.IPRange{ipRange},
24 "ipv4",
25 )
26 if err != nil {
27 return fmt.Errorf("writing test database: %w", err)
28 }
29 }
30
31 return nil
32 }
33
34 // WriteIPv6TestDB writes mmdb files for an ip range between ::1:ffff:ffff and ::2:0000:0059
35 // with various record sizes.
36 func (w *Writer) WriteIPv6TestDB() error {
37 ipRange, err := parseIPRange("::1:ffff:ffff", "::2:0000:0059")
38 if err != nil {
39 return fmt.Errorf("parsing ip range: %w", err)
40 }
41
42 for _, recordSize := range []int{24, 28, 32} {
43 err := w.writeMaxMindTestDB(
44 recordSize,
45 []netipx.IPRange{ipRange},
46 "ipv6",
47 )
48 if err != nil {
49 return fmt.Errorf("writing test database: %w", err)
50 }
51 }
52
53 return nil
54 }
55
56 // WriteMixedIPTestDB writes mmdb files for a mixed ip version range between ::1:ffff:ffff and
57 // ::2:0000:0059
58 // with various record sizes.
59 func (w *Writer) WriteMixedIPTestDB() error {
60 ipv6Range, err := parseIPRange("::1:ffff:ffff", "::2:0000:0059")
61 if err != nil {
62 return fmt.Errorf("parsing ip range: %w", err)
63 }
64
65 ipv4Range, err := parseIPRange("1.1.1.1", "1.1.1.32")
66 if err != nil {
67 return fmt.Errorf("parsing ip range: %w", err)
68 }
69
70 for _, recordSize := range []int{24, 28, 32} {
71 err := w.writeMaxMindTestDB(
72 recordSize,
73 []netipx.IPRange{ipv6Range, ipv4Range},
74 "mixed",
75 )
76 if err != nil {
77 return fmt.Errorf("writing test database: %w", err)
78 }
79 }
80
81 return nil
82 }
83
84 // writeMaxMindTestDB writes test mmdb files.
85 func (w *Writer) writeMaxMindTestDB(
86 recordSize int,
87 ipRange []netipx.IPRange,
88 ipVersionName string,
89 ) error {
90 ipVersion := 6
91 if ipRange[0].From().Is4() {
92 ipVersion = 4
93 }
94
95 metadata := map[string]string{}
96 metadata["en"] = "Test Database"
97 metadata["zh"] = "Test Database Chinese"
98
99 dbWriter, err := mmdbwriter.New(
100 mmdbwriter.Options{
101 DatabaseType: "Test",
102 Description: metadata,
103 DisableIPv4Aliasing: ipVersion == 4,
104 IPVersion: ipVersion,
105 Languages: []string{"en", "zh"},
106 RecordSize: recordSize,
107 },
108 )
109 if err != nil {
110 return fmt.Errorf("creating mmdbwriter: %w", err)
111 }
112
113 for _, ir := range ipRange {
114 for _, prefix := range ir.Prefixes() {
115 ipString := prefix.Addr().String()
116 if ipVersion == 6 && prefix.Addr().Is4() {
117 ipString = "::" + ipString
118 }
119
120 err := dbWriter.Insert(
121 netipx.PrefixIPNet(prefix),
122 mmdbtype.Map{
123 "ip": mmdbtype.String(ipString),
124 },
125 )
126 if err != nil {
127 return fmt.Errorf("inserting ip: %w", err)
128 }
129 }
130 }
131
132 fileName := fmt.Sprintf("MaxMind-DB-test-%s-%d.mmdb", ipVersionName, recordSize)
133 if err := w.write(dbWriter, fileName); err != nil {
134 return fmt.Errorf("writing database: %w", err)
135 }
136
137 return nil
138 }
139
140 // WriteNoIPv4TestDB writes an mmdb file with no ipv4 records.
141 func (w *Writer) WriteNoIPv4TestDB() error {
142 dbWriter, err := mmdbwriter.New(
143 mmdbwriter.Options{
144 DatabaseType: "MaxMind DB No IPv4 Search Tree",
145 Description: map[string]string{
146 "en": "MaxMind DB No IPv4 Search Tree",
147 },
148 DisableIPv4Aliasing: true,
149 IncludeReservedNetworks: true,
150 IPVersion: 6,
151 Languages: []string{"en"},
152 RecordSize: 24,
153 },
154 )
155 if err != nil {
156 return fmt.Errorf("creating mmdbwriter: %w", err)
157 }
158
159 addr, err := netip.ParsePrefix("::/64")
160 if err != nil {
161 return fmt.Errorf("parsing ip: %w", err)
162 }
163
164 err = dbWriter.Insert(
165 netipx.PrefixIPNet(addr),
166 mmdbtype.String(addr.String()),
167 )
168 if err != nil {
169 return fmt.Errorf("inserting ip: %w", err)
170 }
171
172 if err := w.write(dbWriter, "MaxMind-DB-no-ipv4-search-tree.mmdb"); err != nil {
173 return fmt.Errorf("writing database: %w", err)
174 }
175 return nil
176 }
177
178 // WriteNoMapTestDB writes an mmdb file where each record points to
179 // a string value.
180 func (w *Writer) WriteNoMapTestDB() error {
181 dbWriter, err := mmdbwriter.New(
182 mmdbwriter.Options{
183 DatabaseType: "MaxMind DB String Value Entries",
184 Description: map[string]string{
185 "en": "MaxMind DB String Value Entries (no maps or arrays as values)",
186 },
187 IPVersion: 4,
188 Languages: []string{"en"},
189 RecordSize: 24,
190 },
191 )
192 if err != nil {
193 return fmt.Errorf("creating mmdbwriter: %w", err)
194 }
195
196 ipRange, err := parseIPRange("1.1.1.1", "1.1.1.32")
197 if err != nil {
198 return fmt.Errorf("parsing ip range: %w", err)
199 }
200
201 for _, prefix := range ipRange.Prefixes() {
202 err := dbWriter.Insert(
203 netipx.PrefixIPNet(prefix),
204 mmdbtype.String(prefix.String()),
205 )
206 if err != nil {
207 return fmt.Errorf("inserting ip: %w", err)
208 }
209 }
210
211 if err := w.write(dbWriter, "MaxMind-DB-string-value-entries.mmdb"); err != nil {
212 return fmt.Errorf("writing database: %w", err)
213 }
214 return nil
215 }
216
217 // WriteMetadataPointersTestDB writes an mmdb file with metadata pointers allowed.
218 func (w *Writer) WriteMetadataPointersTestDB() error {
219 repeatedString := "Lots of pointers in metadata"
220 dbWriter, err := mmdbwriter.New(
221 mmdbwriter.Options{
222 DatabaseType: repeatedString,
223 Description: map[string]string{
224 "en": repeatedString,
225 "es": repeatedString,
226 "zh": repeatedString,
227 },
228 DisableIPv4Aliasing: true,
229 IPVersion: 6,
230 Languages: []string{"en", "es", "zh"},
231 RecordSize: 24,
232 },
233 )
234 if err != nil {
235 return fmt.Errorf("creating mmdbwriter: %w", err)
236 }
237
238 if err := populateAllNetworks(dbWriter); err != nil {
239 return fmt.Errorf("inserting all networks: %w", err)
240 }
241
242 if err := w.write(dbWriter, "MaxMind-DB-test-metadata-pointers.mmdb"); err != nil {
243 return fmt.Errorf("writing database: %w", err)
244 }
245 return nil
246 }