1 /* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright 2011 Red Hat, Inc.
4 *
5 * SPDX-License-Identifier: LGPL-2.1-or-later
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include <config.h>
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "ginetaddressmask.h"
27 #include "ginetaddress.h"
28 #include "ginitable.h"
29 #include "gioerror.h"
30 #include "gioenumtypes.h"
31 #include "glibintl.h"
32
33 /**
34 * GInetAddressMask:
35 *
36 * `GInetAddressMask` represents a range of IPv4 or IPv6 addresses
37 * described by a base address and a length indicating how many bits
38 * of the base address are relevant for matching purposes. These are
39 * often given in string form. For example, `10.0.0.0/8`, or `fe80::/10`.
40 *
41 * Since: 2.32
42 */
43
44 struct _GInetAddressMaskPrivate
45 {
46 GInetAddress *addr;
47 guint length;
48 };
49
50 static void g_inet_address_mask_initable_iface_init (GInitableIface *iface);
51
52 G_DEFINE_TYPE_WITH_CODE (GInetAddressMask, g_inet_address_mask, G_TYPE_OBJECT,
53 G_ADD_PRIVATE (GInetAddressMask)
54 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
55 g_inet_address_mask_initable_iface_init))
56
57 enum
58 {
59 PROP_0,
60 PROP_FAMILY,
61 PROP_ADDRESS,
62 PROP_LENGTH
63 };
64
65 static void
66 g_inet_address_mask_set_property (GObject *object,
67 guint prop_id,
68 const GValue *value,
69 GParamSpec *pspec)
70 {
71 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
72
73 switch (prop_id)
74 {
75 case PROP_ADDRESS:
76 if (mask->priv->addr)
77 g_object_unref (mask->priv->addr);
78 mask->priv->addr = g_value_dup_object (value);
79 break;
80
81 case PROP_LENGTH:
82 mask->priv->length = g_value_get_uint (value);
83 break;
84
85 default:
86 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
87 break;
88 }
89
90 }
91
92 static void
93 g_inet_address_mask_get_property (GObject *object,
94 guint prop_id,
95 GValue *value,
96 GParamSpec *pspec)
97 {
98 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
99
100 switch (prop_id)
101 {
102 case PROP_FAMILY:
103 g_value_set_enum (value, g_inet_address_get_family (mask->priv->addr));
104 break;
105
106 case PROP_ADDRESS:
107 g_value_set_object (value, mask->priv->addr);
108 break;
109
110 case PROP_LENGTH:
111 g_value_set_uint (value, mask->priv->length);
112 break;
113
114 default:
115 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
116 }
117 }
118
119 static void
120 g_inet_address_mask_dispose (GObject *object)
121 {
122 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
123
124 g_clear_object (&mask->priv->addr);
125
126 G_OBJECT_CLASS (g_inet_address_mask_parent_class)->dispose (object);
127 }
128
129 static void
130 g_inet_address_mask_class_init (GInetAddressMaskClass *klass)
131 {
132 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
133
134 gobject_class->set_property = g_inet_address_mask_set_property;
135 gobject_class->get_property = g_inet_address_mask_get_property;
136 gobject_class->dispose = g_inet_address_mask_dispose;
137
138 /**
139 * GInetAddressMask:family:
140 *
141 * The address family (IPv4 or IPv6).
142 *
143 * Since: 2.32
144 */
145 g_object_class_install_property (gobject_class, PROP_FAMILY,
146 g_param_spec_enum ("family", NULL, NULL,
147 G_TYPE_SOCKET_FAMILY,
148 G_SOCKET_FAMILY_INVALID,
149 G_PARAM_READABLE |
150 G_PARAM_STATIC_STRINGS));
151
152 /**
153 * GInetAddressMask:address:
154 *
155 * The base address.
156 *
157 * Since: 2.32
158 */
159 g_object_class_install_property (gobject_class, PROP_ADDRESS,
160 g_param_spec_object ("address", NULL, NULL,
161 G_TYPE_INET_ADDRESS,
162 G_PARAM_READWRITE |
163 G_PARAM_STATIC_STRINGS));
164
165 /**
166 * GInetAddressMask:length:
167 *
168 * The prefix length, in bytes.
169 *
170 * Since: 2.32
171 */
172 g_object_class_install_property (gobject_class, PROP_LENGTH,
173 g_param_spec_uint ("length", NULL, NULL,
174 0, 128, 0,
175 G_PARAM_READWRITE |
176 G_PARAM_STATIC_STRINGS));
177 }
178
179 static gboolean
180 g_inet_address_mask_initable_init (GInitable *initable,
181 GCancellable *cancellable,
182 GError **error)
183 {
184 GInetAddressMask *mask = G_INET_ADDRESS_MASK (initable);
185 guint addrlen, nbytes, nbits;
186 const guint8 *bytes;
187 gboolean ok;
188
189 if (!mask->priv->addr)
190 {
191 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
192 _("No address specified"));
193 return FALSE;
194 }
195
196 addrlen = g_inet_address_get_native_size (mask->priv->addr);
197 if (mask->priv->length > addrlen * 8)
198 {
199 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
200 _("Length %u is too long for address"),
201 mask->priv->length);
202 return FALSE;
203 }
204
205 /* Make sure all the bits after @length are 0 */
206 bytes = g_inet_address_to_bytes (mask->priv->addr);
207 ok = TRUE;
208
209 nbytes = mask->priv->length / 8;
210 bytes += nbytes;
211 addrlen -= nbytes;
212
213 nbits = mask->priv->length % 8;
214 if (nbits)
215 {
216 if (bytes[0] & (0xFF >> nbits))
217 ok = FALSE;
218 bytes++;
219 addrlen--;
220 }
221
222 while (addrlen)
223 {
224 if (bytes[0])
225 ok = FALSE;
226 bytes++;
227 addrlen--;
228 }
229
230 if (!ok)
231 {
232 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
233 _("Address has bits set beyond prefix length"));
234 return FALSE;
235 }
236
237 return TRUE;
238 }
239
240 static void
241 g_inet_address_mask_initable_iface_init (GInitableIface *iface)
242 {
243 iface->init = g_inet_address_mask_initable_init;
244 }
245
246 static void
247 g_inet_address_mask_init (GInetAddressMask *mask)
248 {
249 mask->priv = g_inet_address_mask_get_instance_private (mask);
250 }
251
252 /**
253 * g_inet_address_mask_new:
254 * @addr: a #GInetAddress
255 * @length: number of bits of @addr to use
256 * @error: return location for #GError, or %NULL
257 *
258 * Creates a new #GInetAddressMask representing all addresses whose
259 * first @length bits match @addr.
260 *
261 * Returns: a new #GInetAddressMask, or %NULL on error
262 *
263 * Since: 2.32
264 */
265 GInetAddressMask *
266 g_inet_address_mask_new (GInetAddress *addr,
267 guint length,
268 GError **error)
269 {
270 return g_initable_new (G_TYPE_INET_ADDRESS_MASK, NULL, error,
271 "address", addr,
272 "length", length,
273 NULL);
274 }
275
276 /**
277 * g_inet_address_mask_new_from_string:
278 * @mask_string: an IP address or address/length string
279 * @error: return location for #GError, or %NULL
280 *
281 * Parses @mask_string as an IP address and (optional) length, and
282 * creates a new #GInetAddressMask. The length, if present, is
283 * delimited by a "/". If it is not present, then the length is
284 * assumed to be the full length of the address.
285 *
286 * Returns: a new #GInetAddressMask corresponding to @string, or %NULL
287 * on error.
288 *
289 * Since: 2.32
290 */
291 GInetAddressMask *
292 g_inet_address_mask_new_from_string (const gchar *mask_string,
293 GError **error)
294 {
295 GInetAddressMask *mask;
296 GInetAddress *addr;
297 gchar *slash;
298 guint length;
299
300 slash = strchr (mask_string, '/');
301 if (slash)
302 {
303 gchar *address, *end;
304
305 length = strtoul (slash + 1, &end, 10);
306 if (*end || !*(slash + 1))
307 {
308 parse_error:
309 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
310 _("Could not parse “%s” as IP address mask"),
311 mask_string);
312 return NULL;
313 }
314
315 address = g_strndup (mask_string, slash - mask_string);
316 addr = g_inet_address_new_from_string (address);
317 g_free (address);
318
319 if (!addr)
320 goto parse_error;
321 }
322 else
323 {
324 addr = g_inet_address_new_from_string (mask_string);
325 if (!addr)
326 goto parse_error;
327
328 length = g_inet_address_get_native_size (addr) * 8;
329 }
330
331 mask = g_inet_address_mask_new (addr, length, error);
332 g_object_unref (addr);
333
334 return mask;
335 }
336
337 /**
338 * g_inet_address_mask_to_string:
339 * @mask: a #GInetAddressMask
340 *
341 * Converts @mask back to its corresponding string form.
342 *
343 * Returns: a string corresponding to @mask.
344 *
345 * Since: 2.32
346 */
347 gchar *
348 g_inet_address_mask_to_string (GInetAddressMask *mask)
349 {
350 gchar *addr_string, *mask_string;
351
352 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
353
354 addr_string = g_inet_address_to_string (mask->priv->addr);
355
356 if (mask->priv->length == (g_inet_address_get_native_size (mask->priv->addr) * 8))
357 return addr_string;
358
359 mask_string = g_strdup_printf ("%s/%u", addr_string, mask->priv->length);
360 g_free (addr_string);
361
362 return mask_string;
363 }
364
365 /**
366 * g_inet_address_mask_get_family:
367 * @mask: a #GInetAddressMask
368 *
369 * Gets the #GSocketFamily of @mask's address
370 *
371 * Returns: the #GSocketFamily of @mask's address
372 *
373 * Since: 2.32
374 */
375 GSocketFamily
376 g_inet_address_mask_get_family (GInetAddressMask *mask)
377 {
378 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), G_SOCKET_FAMILY_INVALID);
379
380 return g_inet_address_get_family (mask->priv->addr);
381 }
382
383 /**
384 * g_inet_address_mask_get_address:
385 * @mask: a #GInetAddressMask
386 *
387 * Gets @mask's base address
388 *
389 * Returns: (transfer none): @mask's base address
390 *
391 * Since: 2.32
392 */
393 GInetAddress *
394 g_inet_address_mask_get_address (GInetAddressMask *mask)
395 {
396 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
397
398 return mask->priv->addr;
399 }
400
401 /**
402 * g_inet_address_mask_get_length:
403 * @mask: a #GInetAddressMask
404 *
405 * Gets @mask's length
406 *
407 * Returns: @mask's length
408 *
409 * Since: 2.32
410 */
411 guint
412 g_inet_address_mask_get_length (GInetAddressMask *mask)
413 {
414 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), 0);
415
416 return mask->priv->length;
417 }
418
419 /**
420 * g_inet_address_mask_matches:
421 * @mask: a #GInetAddressMask
422 * @address: a #GInetAddress
423 *
424 * Tests if @address falls within the range described by @mask.
425 *
426 * Returns: whether @address falls within the range described by
427 * @mask.
428 *
429 * Since: 2.32
430 */
431 gboolean
432 g_inet_address_mask_matches (GInetAddressMask *mask,
433 GInetAddress *address)
434 {
435 const guint8 *maskbytes, *addrbytes;
436 int nbytes, nbits;
437
438 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), FALSE);
439 g_return_val_if_fail (G_IS_INET_ADDRESS (address), FALSE);
440
441 if (g_inet_address_get_family (mask->priv->addr) !=
442 g_inet_address_get_family (address))
443 return FALSE;
444
445 if (mask->priv->length == 0)
446 return TRUE;
447
448 maskbytes = g_inet_address_to_bytes (mask->priv->addr);
449 addrbytes = g_inet_address_to_bytes (address);
450
451 nbytes = mask->priv->length / 8;
452 if (nbytes != 0 && memcmp (maskbytes, addrbytes, nbytes) != 0)
453 return FALSE;
454
455 nbits = mask->priv->length % 8;
456 if (nbits == 0)
457 return TRUE;
458
459 return maskbytes[nbytes] == (addrbytes[nbytes] & (0xFF << (8 - nbits)));
460 }
461
462
463 /**
464 * g_inet_address_mask_equal:
465 * @mask: a #GInetAddressMask
466 * @mask2: another #GInetAddressMask
467 *
468 * Tests if @mask and @mask2 are the same mask.
469 *
470 * Returns: whether @mask and @mask2 are the same mask
471 *
472 * Since: 2.32
473 */
474 gboolean
475 g_inet_address_mask_equal (GInetAddressMask *mask,
476 GInetAddressMask *mask2)
477 {
478 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), FALSE);
479 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask2), FALSE);
480
481 return ((mask->priv->length == mask2->priv->length) &&
482 g_inet_address_equal (mask->priv->addr, mask2->priv->addr));
483 }