]>
Commit | Line | Data |
---|---|---|
1f2c3ccb JS |
1 | /* |
2 | libloc - A library to determine the location of someone on the Internet | |
3 | ||
4 | Copyright (C) 2022 IPFire Development Team <info@ipfire.org> | |
5 | ||
6 | This library is free software; you can redistribute it and/or | |
7 | modify it under the terms of the GNU Lesser General Public | |
8 | License as published by the Free Software Foundation; either | |
9 | version 2.1 of the License, or (at your option) any later version. | |
10 | ||
11 | This library is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | Lesser General Public License for more details. | |
15 | */ | |
16 | ||
17 | #ifndef LIBLOC_ADDRESS_H | |
18 | #define LIBLOC_ADDRESS_H | |
19 | ||
20 | #ifdef LIBLOC_PRIVATE | |
21 | ||
22 | #include <errno.h> | |
23 | #include <netinet/in.h> | |
aa9346d8 JS |
24 | |
25 | #include <libloc/compat.h> | |
1f2c3ccb JS |
26 | |
27 | /* | |
28 | All of these functions are private and for internal use only | |
29 | */ | |
30 | ||
31 | const char* loc_address_str(const struct in6_addr* address); | |
32 | int loc_address_parse(struct in6_addr* address, unsigned int* prefix, const char* string); | |
33 | ||
34 | static inline int loc_address_family(const struct in6_addr* address) { | |
35 | if (IN6_IS_ADDR_V4MAPPED(address)) | |
36 | return AF_INET; | |
37 | else | |
38 | return AF_INET6; | |
39 | } | |
40 | ||
41 | static inline unsigned int loc_address_family_bit_length(const int family) { | |
42 | switch (family) { | |
43 | case AF_INET6: | |
44 | return 128; | |
45 | ||
46 | case AF_INET: | |
47 | return 32; | |
48 | ||
49 | default: | |
50 | return 0; | |
51 | } | |
52 | } | |
53 | ||
54 | /* | |
55 | Checks whether prefix is valid for the given address | |
56 | */ | |
57 | static inline int loc_address_valid_prefix(const struct in6_addr* address, unsigned int prefix) { | |
58 | const int family = loc_address_family(address); | |
59 | ||
60 | // What is the largest possible prefix? | |
61 | const unsigned int bit_length = loc_address_family_bit_length(family); | |
62 | ||
63 | if (prefix <= bit_length) | |
64 | return 1; | |
65 | ||
66 | return 0; | |
67 | } | |
68 | ||
69 | static inline int loc_address_cmp(const struct in6_addr* a1, const struct in6_addr* a2) { | |
70 | for (unsigned int i = 0; i < 16; i++) { | |
71 | if (a1->s6_addr[i] > a2->s6_addr[i]) | |
72 | return 1; | |
73 | ||
74 | else if (a1->s6_addr[i] < a2->s6_addr[i]) | |
75 | return -1; | |
76 | } | |
77 | ||
78 | return 0; | |
79 | } | |
80 | ||
81 | #define foreach_octet_in_address(octet, address) \ | |
82 | for (octet = (IN6_IS_ADDR_V4MAPPED(address) ? 12 : 0); octet <= 15; octet++) | |
83 | ||
84 | #define foreach_octet_in_address_reverse(octet, address) \ | |
85 | for (octet = 15; octet >= (IN6_IS_ADDR_V4MAPPED(address) ? 12 : 0); octet--) | |
86 | ||
87 | static inline int loc_address_all_zeroes(const struct in6_addr* address) { | |
88 | int octet = 0; | |
89 | ||
90 | foreach_octet_in_address(octet, address) { | |
91 | if (address->s6_addr[octet]) | |
92 | return 0; | |
93 | } | |
94 | ||
95 | return 1; | |
96 | } | |
97 | ||
98 | static inline int loc_address_all_ones(const struct in6_addr* address) { | |
99 | int octet = 0; | |
100 | ||
101 | foreach_octet_in_address(octet, address) { | |
102 | if (address->s6_addr[octet] < 255) | |
103 | return 0; | |
104 | } | |
105 | ||
106 | return 1; | |
107 | } | |
108 | ||
109 | static inline int loc_address_get_bit(const struct in6_addr* address, unsigned int i) { | |
110 | return ((address->s6_addr[i / 8] >> (7 - (i % 8))) & 1); | |
111 | } | |
112 | ||
113 | static inline void loc_address_set_bit(struct in6_addr* address, unsigned int i, unsigned int val) { | |
114 | address->s6_addr[i / 8] ^= (-val ^ address->s6_addr[i / 8]) & (1 << (7 - (i % 8))); | |
115 | } | |
116 | ||
117 | static inline struct in6_addr loc_prefix_to_bitmask(const unsigned int prefix) { | |
118 | struct in6_addr bitmask; | |
119 | ||
120 | for (unsigned int i = 0; i < 16; i++) | |
121 | bitmask.s6_addr[i] = 0; | |
122 | ||
123 | for (int i = prefix, j = 0; i > 0; i -= 8, j++) { | |
124 | if (i >= 8) | |
125 | bitmask.s6_addr[j] = 0xff; | |
126 | else | |
127 | bitmask.s6_addr[j] = 0xff << (8 - i); | |
128 | } | |
129 | ||
130 | return bitmask; | |
131 | } | |
132 | ||
133 | static inline unsigned int loc_address_bit_length(const struct in6_addr* address) { | |
134 | int octet = 0; | |
135 | foreach_octet_in_address(octet, address) { | |
136 | if (address->s6_addr[octet]) | |
137 | return (15 - octet) * 8 + 32 - __builtin_clz(address->s6_addr[octet]); | |
138 | } | |
139 | ||
140 | return 0; | |
141 | } | |
142 | ||
143 | static inline int loc_address_reset(struct in6_addr* address, int family) { | |
144 | switch (family) { | |
145 | case AF_INET6: | |
146 | address->s6_addr32[0] = 0x00000000; | |
147 | address->s6_addr32[1] = 0x00000000; | |
148 | address->s6_addr32[2] = 0x00000000; | |
149 | address->s6_addr32[3] = 0x00000000; | |
150 | return 0; | |
151 | ||
152 | case AF_INET: | |
153 | address->s6_addr32[0] = 0x00000000; | |
154 | address->s6_addr32[1] = 0x00000000; | |
155 | address->s6_addr32[2] = htonl(0xffff); | |
156 | address->s6_addr32[3] = 0x00000000; | |
157 | return 0; | |
158 | } | |
159 | ||
160 | return -1; | |
161 | } | |
162 | ||
163 | static inline int loc_address_reset_last(struct in6_addr* address, int family) { | |
164 | switch (family) { | |
165 | case AF_INET6: | |
166 | address->s6_addr32[0] = 0xffffffff; | |
167 | address->s6_addr32[1] = 0xffffffff; | |
168 | address->s6_addr32[2] = 0xffffffff; | |
169 | address->s6_addr32[3] = 0xffffffff; | |
170 | return 0; | |
171 | ||
172 | case AF_INET: | |
173 | address->s6_addr32[0] = 0x00000000; | |
174 | address->s6_addr32[1] = 0x00000000; | |
175 | address->s6_addr32[2] = htonl(0xffff); | |
176 | address->s6_addr32[3] = 0xffffffff; | |
177 | return 0; | |
178 | } | |
179 | ||
180 | return -1; | |
181 | } | |
182 | ||
183 | static inline struct in6_addr loc_address_and( | |
184 | const struct in6_addr* address, const struct in6_addr* bitmask) { | |
185 | struct in6_addr a; | |
186 | ||
187 | // Perform bitwise AND | |
188 | for (unsigned int i = 0; i < 4; i++) | |
189 | a.s6_addr32[i] = address->s6_addr32[i] & bitmask->s6_addr32[i]; | |
190 | ||
191 | return a; | |
192 | } | |
193 | ||
194 | static inline struct in6_addr loc_address_or( | |
195 | const struct in6_addr* address, const struct in6_addr* bitmask) { | |
196 | struct in6_addr a; | |
197 | ||
198 | // Perform bitwise OR | |
199 | for (unsigned int i = 0; i < 4; i++) | |
200 | a.s6_addr32[i] = address->s6_addr32[i] | ~bitmask->s6_addr32[i]; | |
201 | ||
202 | return a; | |
203 | } | |
204 | ||
205 | static inline int loc_address_sub(struct in6_addr* result, | |
206 | const struct in6_addr* address1, const struct in6_addr* address2) { | |
207 | int family1 = loc_address_family(address1); | |
208 | int family2 = loc_address_family(address2); | |
209 | ||
210 | // Address family must match | |
211 | if (family1 != family2) { | |
212 | errno = EINVAL; | |
213 | return 1; | |
214 | } | |
215 | ||
216 | // Clear result | |
217 | int r = loc_address_reset(result, family1); | |
218 | if (r) | |
219 | return r; | |
220 | ||
221 | int octet = 0; | |
222 | int remainder = 0; | |
223 | ||
224 | foreach_octet_in_address_reverse(octet, address1) { | |
225 | int x = address1->s6_addr[octet] - address2->s6_addr[octet] + remainder; | |
226 | ||
227 | // Store remainder for the next iteration | |
228 | remainder = (x >> 8); | |
229 | ||
230 | result->s6_addr[octet] = x & 0xff; | |
231 | } | |
232 | ||
233 | return 0; | |
234 | } | |
235 | ||
236 | static inline void loc_address_increment(struct in6_addr* address) { | |
237 | // Prevent overflow when everything is ones | |
238 | if (loc_address_all_ones(address)) | |
239 | return; | |
240 | ||
241 | int octet = 0; | |
242 | foreach_octet_in_address_reverse(octet, address) { | |
243 | if (address->s6_addr[octet] < 255) { | |
244 | address->s6_addr[octet]++; | |
245 | break; | |
246 | } else { | |
247 | address->s6_addr[octet] = 0; | |
248 | } | |
249 | } | |
250 | } | |
251 | ||
252 | static inline void loc_address_decrement(struct in6_addr* address) { | |
253 | // Prevent underflow when everything is ones | |
254 | if (loc_address_all_zeroes(address)) | |
255 | return; | |
256 | ||
257 | int octet = 0; | |
258 | foreach_octet_in_address_reverse(octet, address) { | |
259 | if (address->s6_addr[octet] > 0) { | |
260 | address->s6_addr[octet]--; | |
261 | break; | |
262 | } else { | |
263 | address->s6_addr[octet] = 255; | |
264 | } | |
265 | } | |
266 | } | |
267 | ||
268 | static inline int loc_address_count_trailing_zero_bits(const struct in6_addr* address) { | |
269 | int zeroes = 0; | |
270 | ||
271 | int octet = 0; | |
272 | foreach_octet_in_address_reverse(octet, address) { | |
273 | if (address->s6_addr[octet]) { | |
274 | zeroes += __builtin_ctz(address->s6_addr[octet]); | |
275 | break; | |
276 | } else | |
277 | zeroes += 8; | |
278 | } | |
279 | ||
280 | return zeroes; | |
281 | } | |
282 | ||
283 | #endif /* LIBLOC_PRIVATE */ | |
284 | ||
285 | #endif /* LIBLOC_ADDRESS_H */ |