1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright 2011 Red Hat, Inc.
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 of the License, or (at your option) any later version.
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.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
26 #include "ginetaddressmask.h"
27 #include "ginetaddress.h"
28 #include "ginitable.h"
30 #include "gioenumtypes.h"
34 * SECTION:ginetaddressmask
35 * @short_description: An IPv4/IPv6 address mask
38 * #GInetAddressMask represents a range of IPv4 or IPv6 addresses
39 * described by a base address and a length indicating how many bits
40 * of the base address are relevant for matching purposes. These are
41 * often given in string form. Eg, "10.0.0.0/8", or "fe80::/10".
47 * A combination of an IPv4 or IPv6 base address and a length,
48 * representing a range of IP addresses.
53 struct _GInetAddressMaskPrivate
59 static void g_inet_address_mask_initable_iface_init (GInitableIface *iface);
61 G_DEFINE_TYPE_WITH_CODE (GInetAddressMask, g_inet_address_mask, G_TYPE_OBJECT,
62 G_ADD_PRIVATE (GInetAddressMask)
63 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
64 g_inet_address_mask_initable_iface_init))
75 g_inet_address_mask_set_property (GObject *object,
80 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
86 g_object_unref (mask->priv->addr);
87 mask->priv->addr = g_value_dup_object (value);
91 mask->priv->length = g_value_get_uint (value);
95 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
102 g_inet_address_mask_get_property (GObject *object,
107 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
112 g_value_set_enum (value, g_inet_address_get_family (mask->priv->addr));
116 g_value_set_object (value, mask->priv->addr);
120 g_value_set_uint (value, mask->priv->length);
124 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
129 g_inet_address_mask_dispose (GObject *object)
131 GInetAddressMask *mask = G_INET_ADDRESS_MASK (object);
133 g_clear_object (&mask->priv->addr);
135 G_OBJECT_CLASS (g_inet_address_mask_parent_class)->dispose (object);
139 g_inet_address_mask_class_init (GInetAddressMaskClass *klass)
141 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
143 gobject_class->set_property = g_inet_address_mask_set_property;
144 gobject_class->get_property = g_inet_address_mask_get_property;
145 gobject_class->dispose = g_inet_address_mask_dispose;
147 g_object_class_install_property (gobject_class, PROP_FAMILY,
148 g_param_spec_enum ("family",
149 P_("Address family"),
150 P_("The address family (IPv4 or IPv6)"),
151 G_TYPE_SOCKET_FAMILY,
152 G_SOCKET_FAMILY_INVALID,
154 G_PARAM_STATIC_STRINGS));
155 g_object_class_install_property (gobject_class, PROP_ADDRESS,
156 g_param_spec_object ("address",
158 P_("The base address"),
161 G_PARAM_STATIC_STRINGS));
162 g_object_class_install_property (gobject_class, PROP_LENGTH,
163 g_param_spec_uint ("length",
165 P_("The prefix length"),
168 G_PARAM_STATIC_STRINGS));
172 g_inet_address_mask_initable_init (GInitable *initable,
173 GCancellable *cancellable,
176 GInetAddressMask *mask = G_INET_ADDRESS_MASK (initable);
177 guint addrlen, nbytes, nbits;
181 if (!mask->priv->addr)
183 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
184 _("No address specified"));
188 addrlen = g_inet_address_get_native_size (mask->priv->addr);
189 if (mask->priv->length > addrlen * 8)
191 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
192 _("Length %u is too long for address"),
197 /* Make sure all the bits after @length are 0 */
198 bytes = g_inet_address_to_bytes (mask->priv->addr);
201 nbytes = mask->priv->length / 8;
205 nbits = mask->priv->length % 8;
208 if (bytes[0] & (0xFF >> nbits))
224 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
225 _("Address has bits set beyond prefix length"));
233 g_inet_address_mask_initable_iface_init (GInitableIface *iface)
235 iface->init = g_inet_address_mask_initable_init;
239 g_inet_address_mask_init (GInetAddressMask *mask)
241 mask->priv = g_inet_address_mask_get_instance_private (mask);
245 * g_inet_address_mask_new:
246 * @addr: a #GInetAddress
247 * @length: number of bits of @addr to use
248 * @error: return location for #GError, or %NULL
250 * Creates a new #GInetAddressMask representing all addresses whose
251 * first @length bits match @addr.
253 * Returns: a new #GInetAddressMask, or %NULL on error
258 g_inet_address_mask_new (GInetAddress *addr,
262 return g_initable_new (G_TYPE_INET_ADDRESS_MASK, NULL, error,
269 * g_inet_address_mask_new_from_string:
270 * @mask_string: an IP address or address/length string
271 * @error: return location for #GError, or %NULL
273 * Parses @mask_string as an IP address and (optional) length, and
274 * creates a new #GInetAddressMask. The length, if present, is
275 * delimited by a "/". If it is not present, then the length is
276 * assumed to be the full length of the address.
278 * Returns: a new #GInetAddressMask corresponding to @string, or %NULL
284 g_inet_address_mask_new_from_string (const gchar *mask_string,
287 GInetAddressMask *mask;
292 slash = strchr (mask_string, '/');
295 gchar *address, *end;
297 length = strtoul (slash + 1, &end, 10);
298 if (*end || !*(slash + 1))
301 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
302 _("Could not parse '%s' as IP address mask"),
307 address = g_strndup (mask_string, slash - mask_string);
308 addr = g_inet_address_new_from_string (address);
316 addr = g_inet_address_new_from_string (mask_string);
320 length = g_inet_address_get_native_size (addr) * 8;
323 mask = g_inet_address_mask_new (addr, length, error);
324 g_object_unref (addr);
330 * g_inet_address_mask_to_string:
331 * @mask: a #GInetAddressMask
333 * Converts @mask back to its corresponding string form.
335 * Return value: a string corresponding to @mask.
340 g_inet_address_mask_to_string (GInetAddressMask *mask)
342 gchar *addr_string, *mask_string;
344 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
346 addr_string = g_inet_address_to_string (mask->priv->addr);
348 if (mask->priv->length == (g_inet_address_get_native_size (mask->priv->addr) * 8))
351 mask_string = g_strdup_printf ("%s/%u", addr_string, mask->priv->length);
352 g_free (addr_string);
358 * g_inet_address_mask_get_family:
359 * @mask: a #GInetAddressMask
361 * Gets the #GSocketFamily of @mask's address
363 * Return value: the #GSocketFamily of @mask's address
368 g_inet_address_mask_get_family (GInetAddressMask *mask)
370 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), G_SOCKET_FAMILY_INVALID);
372 return g_inet_address_get_family (mask->priv->addr);
376 * g_inet_address_mask_get_address:
377 * @mask: a #GInetAddressMask
379 * Gets @mask's base address
381 * Return value: (transfer none): @mask's base address
386 g_inet_address_mask_get_address (GInetAddressMask *mask)
388 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
390 return mask->priv->addr;
394 * g_inet_address_mask_get_length:
395 * @mask: a #GInetAddressMask
397 * Gets @mask's length
399 * Return value: @mask's length
404 g_inet_address_mask_get_length (GInetAddressMask *mask)
406 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), 0);
408 return mask->priv->length;
412 * g_inet_address_mask_matches:
413 * @mask: a #GInetAddressMask
414 * @address: a #GInetAddress
416 * Tests if @address falls within the range described by @mask.
418 * Return value: whether @address falls within the range described by
424 g_inet_address_mask_matches (GInetAddressMask *mask,
425 GInetAddress *address)
427 const guint8 *maskbytes, *addrbytes;
430 g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), FALSE);
431 g_return_val_if_fail (G_IS_INET_ADDRESS (address), FALSE);
433 if (g_inet_address_get_family (mask->priv->addr) !=
434 g_inet_address_get_family (address))
437 if (mask->priv->length == 0)
440 maskbytes = g_inet_address_to_bytes (mask->priv->addr);
441 addrbytes = g_inet_address_to_bytes (address);
443 nbytes = mask->priv->length / 8;
444 if (nbytes != 0 && memcmp (maskbytes, addrbytes, nbytes) != 0)
447 nbits = mask->priv->length % 8;
451 return maskbytes[nbytes] == (addrbytes[nbytes] & (0xFF << (8 - nbits)));
456 * g_inet_address_mask_equal:
457 * @mask: a #GInetAddressMask
458 * @mask2: another #GInetAddressMask
460 * Tests if @mask and @mask2 are the same mask.
462 * Return value: whether @mask and @mask2 are the same mask
467 g_inet_address_mask_equal (GInetAddressMask *mask,
468 GInetAddressMask *mask2)
470 return ((mask->priv->length == mask2->priv->length) &&
471 g_inet_address_equal (mask->priv->addr, mask2->priv->addr));