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