Debian Codegraph @

net/ip/ip.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use bytes;
5 use endian;
6 use fmt;
7 use io;
8 use memio;
9 use strconv;
10 use strings;
11
12 // An IPv4 address.
13 export type addr4 = [4]u8;
14
15 // An IPv6 address.
16 export type addr6 = [16]u8;
17
18 // An IP address.
19 export type addr = (addr4 | addr6);
20
21 // An IP subnet.
22 export type subnet = struct {
23 addr: addr,
24 mask: addr,
25 };
26
27 // An IPv4 address which represents "any" address, i.e. "0.0.0.0". Binding to
28 // this address will listen on all available IPv4 interfaces on most systems.
29 export const ANY_V4: addr4 = [0, 0, 0, 0];
30
31 // An IPv6 address which represents "any" address, i.e. "::". Binding to this
32 // address will listen on all available IPv6 interfaces on most systems.
33 export const ANY_V6: addr6 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
34
35 // An IPv4 address which represents the loopback address, i.e. "127.0.0.1".
36 export const LOCAL_V4: addr4 = [127, 0, 0, 1];
37
38 // An IPv6 address which represents the loopback address, i.e. "::1".
39 export const LOCAL_V6: addr6 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
40
41 // Invalid parse result.
42 export type invalid = !void;
43
44 // Test if two [[addr]]s are equal.
45 export fn equal(l: addr, r: addr) bool = {
46 match (l) {
47 case let l: addr4 =>
48 if (!(r is addr4)) {
49 return false;
50 };
51 let r = r as addr4;
52 return bytes::equal(l, r);
53 case let l: addr6 =>
54 if (!(r is addr6)) {
55 return false;
56 };
57 let r = r as addr6;
58 return bytes::equal(l, r);
59 };
60 };
61
62 // Parses an IPv4 address.
63 export fn parsev4(st: str) (addr4 | invalid) = {
64 let ret: addr4 = [0...];
65 let tok = strings::tokenize(st, ".");
66 let i = 0z;
67 for (i < 4; i += 1) {
68 let s = wanttoken(&tok)?;
69 if (len(s) != 1 && strings::hasprefix(s, "0")) {
70 return invalid;
71 };
72 ret[i] = match (strconv::stou8(s)) {
73 case let term: u8 =>
74 yield term;
75 case =>
76 return invalid;
77 };
78 };
79 if (i < 4 || !(strings::next_token(&tok) is done)) {
80 return invalid;
81 };
82 return ret;
83 };
84
85 // Parses an IPv6 address.
86 export fn parsev6(st: str) (addr6 | invalid) = {
87 let ret: addr6 = [0...];
88 if (st == "::") {
89 return ret;
90 };
91 let tok = strings::tokenize(st, ":");
92 let ells = -1;
93 if (strings::hasprefix(st, "::")) {
94 wanttoken(&tok)?;
95 wanttoken(&tok)?;
96 ells = 0;
97 } else if (strings::hasprefix(st, ":")) {
98 return invalid;
99 };
100 let i = 0;
101 for (i < 16) {
102 let s = match (strings::next_token(&tok)) {
103 case let s: str =>
104 yield s;
105 case done =>
106 break;
107 };
108 if (s == "") {
109 if (ells != -1) {
110 return invalid;
111 };
112 ells = i;
113 continue;
114 };
115 match (strconv::stou16(s, strconv::base::HEX)) {
116 case let val: u16 =>
117 endian::beputu16(ret[i..], val);
118 i += 2;
119 case =>
120 ret[i..i + 4] = parsev4(s)?;
121 i += 4;
122 break;
123 };
124 };
125 if (!(strings::next_token(&tok) is done)) {
126 return invalid;
127 };
128 if (ells >= 0) {
129 if (i >= 15) {
130 return invalid;
131 };
132 const n = i - ells;
133 ret[16 - n..16] = ret[ells..ells + n];
134 ret[ells..ells + n] = [0...];
135 } else if (i != 16) {
136 return invalid;
137 };
138
139 return ret;
140 };
141
142
143 // Parses an IP address.
144 export fn parse(s: str) (addr | invalid) = {
145 match (parsev4(s)) {
146 case let v4: addr4 =>
147 return v4;
148 case invalid => void;
149 };
150 match (parsev6(s)) {
151 case let v6: addr6 =>
152 return v6;
153 case invalid => void;
154 };
155 return invalid;
156 };
157
158 fn fmtv4(s: io::handle, a: addr4) (size | io::error) = {
159 let ret = 0z;
160 for (let i = 0; i < 4; i += 1) {
161 if (i > 0) {
162 ret += fmt::fprintf(s, ".")?;
163 };
164 ret += fmt::fprintf(s, "{}", a[i])?;
165 };
166 return ret;
167 };
168
169 fn fmtv6(s: io::handle, a: addr6) (size | io::error) = {
170 let ret = 0z;
171 let zstart: int = -1;
172 let zend: int = -1;
173 for (let i = 0; i < 16; i += 2) {
174 let j = i;
175 for (j < 16 && a[j] == 0 && a[j + 1] == 0) {
176 j += 2;
177 };
178
179 if (j > i && j - i > zend - zstart) {
180 zstart = i;
181 zend = j;
182 i = j;
183 };
184 };
185
186 if (zend - zstart <= 2) {
187 zstart = -1;
188 zend = -1;
189 };
190
191 for (let i = 0; i < 16; i += 2) {
192 if (i == zstart) {
193 ret += fmt::fprintf(s, "::")?;
194 i = zend;
195 if (i >= 16)
196 break;
197 } else if (i > 0) {
198 ret += fmt::fprintf(s, ":")?;
199 };
200 let term = (a[i]: u16) << 8 | a[i + 1];
201 ret += fmt::fprintf(s, "{:x}", term)?;
202 };
203 return ret;
204 };
205
206 // Fills a netmask according to the CIDR value
207 // e.g. 23 -> [0xFF, 0xFF, 0xFD, 0x00]
208 fn fillmask(mask: []u8, val: u8) void = {
209 mask[..] = [0xFF...];
210 let i: int = len(mask): int - 1;
211 val = len(mask): u8 * 8 - val;
212 for (val >= 8) {
213 mask[i] = 0x00;
214 val -= 8;
215 i -= 1;
216 };
217 if (i >= 0) {
218 mask[i] = ~((1 << val) - 1);
219 };
220 };
221
222 // Returns an addr representing a netmask
223 fn cidrmask(addr: addr, val: u8) (addr | invalid) = {
224 let a_len: u8 = match (addr) {
225 case addr4 =>
226 yield 4;
227 case addr6 =>
228 yield 16;
229 };
230
231 if (val > 8 * a_len)
232 return invalid;
233 if (a_len == 4) {
234 let ret: addr4 = [0...];
235 fillmask(ret[..], val);
236 return ret;
237 };
238 if (a_len == 16) {
239 let ret: addr6 = [0...];
240 fillmask(ret[..], val);
241 return ret;
242 };
243 return invalid;
244 };
245
246 // Parse an IP subnet in CIDR notation e.g. 192.168.1.0/24
247 export fn parsecidr(st: str) (subnet | invalid) = {
248 let tok = strings::tokenize(st, "/");
249 let ips = wanttoken(&tok)?;
250 let addr = parse(ips)?;
251 let masks = wanttoken(&tok)?;
252 let val = match (strconv::stou8(masks)) {
253 case let x: u8 =>
254 yield x;
255 case =>
256 return invalid;
257 };
258 if (!(strings::next_token(&tok) is done)) {
259 return invalid;
260 };
261 return subnet {
262 addr = addr,
263 mask = cidrmask(addr, val)?
264 };
265 };
266
267 fn masklen(addr: []u8) (void | size) = {
268 let n = 0z;
269 for (let i = 0z; i < len(addr); i += 1) {
270 if (addr[i] == 0xff) {
271 n += 8;
272 continue;
273 };
274 let val = addr[i];
275 for (val & 0x80 != 0) {
276 n += 1;
277 val <<= 1;
278 };
279 if (val != 0)
280 return;
281 for (let j = i + 1; j < len(addr); j += 1) {
282 if (addr[j] != 0)
283 return;
284 };
285 break;
286 };
287 return n;
288 };
289
290 fn fmtmask(s: io::handle, mask: addr) (size | io::error) = {
291 let ret = 0z;
292 let slice = match (mask) {
293 case let v4: addr4 =>
294 yield v4[..];
295 case let v6: addr6 =>
296 yield v6[..];
297 };
298 match (masklen(slice)) {
299 case void =>
300 // Format as hex, if zero runs are not contiguous
301 // (like golang does)
302 for (let part .. slice) {
303 ret += fmt::fprintf(s, "{:x}", part)?;
304 };
305 case let n: size =>
306 // Standard CIDR integer
307 ret += fmt::fprintf(s, "{}", n)?;
308 };
309 return ret;
310 };
311
312 fn fmtsubnet(s: io::handle, subnet: subnet) (size | io::error) = {
313 let ret = 0z;
314 ret += fmt(s, subnet.addr)?;
315 ret += fmt::fprintf(s, "/")?;
316 ret += fmtmask(s, subnet.mask)?;
317 return ret;
318 };
319
320 // Formats an [[addr]] or [[subnet]] and prints it to a stream.
321 export fn fmt(s: io::handle, item: (...addr | subnet)) (size | io::error) = {
322 match (item) {
323 case let v4: addr4 =>
324 return fmtv4(s, v4)?;
325 case let v6: addr6 =>
326 return fmtv6(s, v6)?;
327 case let sub: subnet =>
328 return fmtsubnet(s, sub);
329 };
330 };
331
332 // Formats an [[addr]] or [[subnet]] as a string. The return value is statically
333 // allocated and will be overwritten on subsequent calls; see [[strings::dup]] to
334 // extend its lifetime.
335 export fn string(item: (...addr | subnet)) str = {
336 // Maximum length of an IPv6 address plus its netmask in hexadecimal
337 static let buf: [64]u8 = [0...];
338 let stream = memio::fixed(buf);
339 fmt(&stream, item) as size;
340 return memio::string(&stream)!;
341 };
342
343 fn wanttoken(tok: *strings::tokenizer) (str | invalid) = {
344 match (strings::next_token(tok)) {
345 case let s: str =>
346 return s;
347 case done =>
348 return invalid;
349 };
350 };
351
352 // Returns whether an [[addr]] (or another [[subnet]]) is contained
353 // within a [[subnet]].
354 export fn subnet_contains(sub: subnet, item: (addr | subnet)) bool = {
355 let a: subnet = match (item) {
356 case let a: addr =>
357 yield subnet {
358 addr = a,
359 mask = sub.mask,
360 };
361 case let sub: subnet =>
362 yield sub;
363 };
364 // Get byte slices for both addresses and masks.
365 let ipa = match (sub.addr) {
366 case let v4: addr4 => yield v4[..];
367 case let v6: addr6 => yield v6[..];
368 };
369 let maska = match (sub.mask) {
370 case let v4: addr4 => yield v4[..];
371 case let v6: addr6 => yield v6[..];
372 };
373 let ipb = match (a.addr) {
374 case let v4: addr4 => yield v4[..];
375 case let v6: addr6 => yield v6[..];
376 };
377 let maskb = match (a.mask) {
378 case let v4: addr4 => yield v4[..];
379 case let v6: addr6 => yield v6[..];
380 };
381 if (len(ipa) != len(ipb) || len(maska) != len(maskb) || len(ipa) != len(maska)) {
382 // Mismatched addr4 and addr6 addresses / masks.
383 return false;
384 };
385
386 for (let i = 0z; i < len(ipa); i += 1) {
387 if (ipa[i] & maska[i] != ipb[i] & maska[i] || maska[i] > maskb[i]) {
388 return false;
389 };
390 };
391 return true;
392 };