gio/ginetaddressmask.c

   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 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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  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  * SECTION:ginetaddressmask
  35  * @short_description: An IPv4/IPv6 address mask
  36  *
  37  * #GInetAddressMask represents a range of IPv4 or IPv6 addresses
  38  * described by a base address and a length indicating how many bits
  39  * of the base address are relevant for matching purposes. These are
  40  * often given in string form. Eg, "10.0.0.0/8", or "fe80::/10".
  41  */
  42
  43 /**
  44  * GInetAddressMask:
  45  *
  46  * A combination of an IPv4 or IPv6 base address and a length,
  47  * representing a range of IP addresses.
  48  *
  49  * Since: 2.32
  50  */
  51
  52 static void     g_inet_address_mask_initable_iface_init (GInitableIface  *iface);
  53
  54 G_DEFINE_TYPE_WITH_CODE (GInetAddressMask, g_inet_address_mask, G_TYPE_OBJECT,
  55                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  56                                                 g_inet_address_mask_initable_iface_init));
  57
  58 struct _GInetAddressMaskPrivate
  59 {
  60   GInetAddress *addr;
  61   guint         length;
  62 };
  63
  64 enum
  65 {
  66   PROP_0,
  67   PROP_FAMILY,
  68   PROP_ADDRESS,
  69   PROP_LENGTH
  70 };
  71
  72 static void
  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
 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
 127 g_inet_address_mask_class_init (GInetAddressMaskClass *klass)
 128 {
 129   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 130
 131   g_type_class_add_private (klass, sizeof (GInetAddressMaskPrivate));
 132
 133   gobject_class->set_property = g_inet_address_mask_set_property;
 134   gobject_class->get_property = g_inet_address_mask_get_property;
 135
 136   g_object_class_install_property (gobject_class, PROP_FAMILY,
 137                                    g_param_spec_enum ("family",
 138                                                       P_("Address family"),
 139                                                       P_("The address family (IPv4 or IPv6)"),
 140                                                       G_TYPE_SOCKET_FAMILY,
 141                                                       G_SOCKET_FAMILY_INVALID,
 142                                                       G_PARAM_READABLE |
 143                                                       G_PARAM_STATIC_STRINGS));
 144   g_object_class_install_property (gobject_class, PROP_ADDRESS,
 145                                    g_param_spec_object ("address",
 146                                                         P_("Address"),
 147                                                         P_("The base address"),
 148                                                         G_TYPE_INET_ADDRESS,
 149                                                         G_PARAM_READWRITE |
 150                                                         G_PARAM_STATIC_STRINGS));
 151   g_object_class_install_property (gobject_class, PROP_LENGTH,
 152                                    g_param_spec_uint ("length",
 153                                                       P_("Length"),
 154                                                       P_("The prefix length"),
 155                                                       0, 128, 0,
 156                                                       G_PARAM_READWRITE |
 157                                                       G_PARAM_STATIC_STRINGS));
 158 }
 159
 160 static gboolean
 161 g_inet_address_mask_initable_init (GInitable     *initable,
 162                                    GCancellable  *cancellable,
 163                                    GError       **error)
 164 {
 165   GInetAddressMask *mask = G_INET_ADDRESS_MASK (initable);
 166   guint addrlen, nbytes, nbits;
 167   const guint8 *bytes;
 168   gboolean ok;
 169
 170   if (!mask->priv->addr)
 171     {
 172       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 173                            _("No address specified"));
 174       return FALSE;
 175     }
 176
 177   addrlen = g_inet_address_get_native_size (mask->priv->addr);
 178   if (mask->priv->length > addrlen * 8)
 179     {
 180       g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 181                    _("Length %u is too long for address"),
 182                    mask->priv->length);
 183       return FALSE;
 184     }
 185
 186   /* Make sure all the bits after @length are 0 */
 187   bytes = g_inet_address_to_bytes (mask->priv->addr);
 188   ok = TRUE;
 189
 190   nbytes = mask->priv->length / 8;
 191   bytes += nbytes;
 192   addrlen -= nbytes;
 193
 194   nbits = mask->priv->length % 8;
 195   if (nbits)
 196     {
 197       if (bytes[0] & (0xFF >> nbits))
 198         ok = FALSE;
 199       bytes++;
 200       addrlen--;
 201     }
 202
 203   while (addrlen)
 204     {
 205       if (bytes[0])
 206         ok = FALSE;
 207       bytes++;
 208       addrlen--;
 209     }
 210
 211   if (!ok)
 212     {
 213       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 214                            _("Address has bits set beyond prefix length"));
 215       return FALSE;
 216     }
 217
 218   return TRUE;
 219 }
 220
 221 static void
 222 g_inet_address_mask_initable_iface_init (GInitableIface  *iface)
 223 {
 224   iface->init = g_inet_address_mask_initable_init;
 225 }
 226
 227 static void
 228 g_inet_address_mask_init (GInetAddressMask *mask)
 229 {
 230   mask->priv = G_TYPE_INSTANCE_GET_PRIVATE (mask,
 231                                             G_TYPE_INET_ADDRESS_MASK,
 232                                             GInetAddressMaskPrivate);
 233 }
 234
 235 /**
 236  * g_inet_address_mask_new:
 237  * @addr: a #GInetAddress
 238  * @length: number of bits of @addr to use
 239  * @error: return location for #GError, or %NULL
 240  *
 241  * Creates a new #GInetAddressMask representing all addresses whose
 242  * first @length bits match @addr.
 243  *
 244  * Returns: a new #GInetAddressMask, or %NULL on error
 245  *
 246  * Since: 2.32
 247  */
 248 GInetAddressMask *
 249 g_inet_address_mask_new (GInetAddress  *addr,
 250                          guint          length,
 251                          GError       **error)
 252 {
 253   return g_initable_new (G_TYPE_INET_ADDRESS_MASK, NULL, error,
 254                          "address", addr,
 255                          "length", length,
 256                          NULL);
 257 }
 258
 259 /**
 260  * g_inet_address_mask_new_from_string:
 261  * @mask_string: an IP address or address/length string
 262  * @error: return location for #GError, or %NULL
 263  *
 264  * Parses @mask_string as an IP address and (optional) length, and
 265  * creates a new #GInetAddressMask. The length, if present, is
 266  * delimited by a "/". If it is not present, then the length is
 267  * assumed to be the full length of the address.
 268  *
 269  * Returns: a new #GInetAddressMask corresponding to @string, or %NULL
 270  * on error.
 271  *
 272  * Since: 2.32
 273  */
 274 GInetAddressMask *
 275 g_inet_address_mask_new_from_string (const gchar  *mask_string,
 276                                      GError      **error)
 277 {
 278   GInetAddressMask *mask;
 279   GInetAddress *addr;
 280   gchar *slash;
 281   guint length;
 282
 283   slash = strchr (mask_string, '/');
 284   if (slash)
 285     {
 286       gchar *address, *end;
 287
 288       length = strtoul (slash + 1, &end, 10);
 289       if (*end || !*(slash + 1))
 290         {
 291         parse_error:
 292           g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 293                        _("Could not parse '%s' as IP address mask"),
 294                        mask_string);
 295           return NULL;
 296         }
 297
 298       address = g_strndup (mask_string, slash - mask_string);
 299       addr = g_inet_address_new_from_string (address);
 300       g_free (address);
 301
 302       if (!addr)
 303         goto parse_error;
 304     }
 305   else
 306     {
 307       addr = g_inet_address_new_from_string (mask_string);
 308       if (!addr)
 309         goto parse_error;
 310
 311       length = g_inet_address_get_native_size (addr) * 8;
 312     }
 313
 314   mask = g_inet_address_mask_new (addr, length, error);
 315   g_object_unref (addr);
 316
 317   return mask;
 318 }
 319
 320 /**
 321  * g_inet_address_mask_to_string:
 322  * @mask: a #GInetAddressMask
 323  *
 324  * Converts @mask back to its corresponding string form.
 325  *
 326  * Return value: a string corresponding to @mask.
 327  *
 328  * Since: 2.32
 329  */
 330 gchar *
 331 g_inet_address_mask_to_string (GInetAddressMask *mask)
 332 {
 333   gchar *addr_string, *mask_string;
 334
 335   g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
 336
 337   addr_string = g_inet_address_to_string (mask->priv->addr);
 338
 339   if (mask->priv->length == (g_inet_address_get_native_size (mask->priv->addr) * 8))
 340     return addr_string;
 341
 342   mask_string = g_strdup_printf ("%s/%u", addr_string, mask->priv->length);
 343   g_free (addr_string);
 344
 345   return mask_string;
 346 }
 347
 348 /**
 349  * g_inet_address_mask_get_family:
 350  * @mask: a #GInetAddressMask
 351  *
 352  * Gets the #GSocketFamily of @mask's address
 353  *
 354  * Return value: the #GSocketFamily of @mask's address
 355  *
 356  * Since: 2.32
 357  */
 358 GSocketFamily
 359 g_inet_address_mask_get_family (GInetAddressMask *mask)
 360 {
 361   g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), G_SOCKET_FAMILY_INVALID);
 362
 363   return g_inet_address_get_family (mask->priv->addr);
 364 }
 365
 366 /**
 367  * g_inet_address_mask_get_address:
 368  * @mask: a #GInetAddressMask
 369  *
 370  * Gets @mask's base address
 371  *
 372  * Return value: (transfer none): @mask's base address
 373  *
 374  * Since: 2.32
 375  */
 376 GInetAddress *
 377 g_inet_address_mask_get_address (GInetAddressMask *mask)
 378 {
 379   g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), NULL);
 380
 381   return mask->priv->addr;
 382 }
 383
 384 /**
 385  * g_inet_address_mask_get_length:
 386  * @mask: a #GInetAddressMask
 387  *
 388  * Gets @mask's length
 389  *
 390  * Return value: @mask's length
 391  *
 392  * Since: 2.32
 393  */
 394 guint
 395 g_inet_address_mask_get_length (GInetAddressMask *mask)
 396 {
 397   g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), 0);
 398
 399   return mask->priv->length;
 400 }
 401
 402 /**
 403  * g_inet_address_mask_matches:
 404  * @mask: a #GInetAddressMask
 405  * @address: a #GInetAddress
 406  *
 407  * Tests if @address falls within the range described by @mask.
 408  *
 409  * Return value: whether @address falls within the range described by
 410  * @mask.
 411  *
 412  * Since: 2.32
 413  */
 414 gboolean
 415 g_inet_address_mask_matches (GInetAddressMask *mask,
 416                              GInetAddress     *address)
 417 {
 418   const guint8 *maskbytes, *addrbytes;
 419   int nbytes, nbits;
 420
 421   g_return_val_if_fail (G_IS_INET_ADDRESS_MASK (mask), FALSE);
 422   g_return_val_if_fail (G_IS_INET_ADDRESS (address), FALSE);
 423
 424   if (g_inet_address_get_family (mask->priv->addr) !=
 425       g_inet_address_get_family (address))
 426     return FALSE;
 427
 428   if (mask->priv->length == 0)
 429     return TRUE;
 430
 431   maskbytes = g_inet_address_to_bytes (mask->priv->addr);
 432   addrbytes = g_inet_address_to_bytes (address);
 433
 434   nbytes = mask->priv->length / 8;
 435   if (nbytes != 0 && memcmp (maskbytes, addrbytes, nbytes) != 0)
 436     return FALSE;
 437
 438   nbits = mask->priv->length % 8;
 439   if (nbits == 0)
 440     return TRUE;
 441
 442   return maskbytes[nbytes] == (addrbytes[nbytes] & (0xFF << (8 - nbits)));
 443 }
 444
 445
 446 /**
 447  * g_inet_address_mask_equal:
 448  * @mask: a #GInetAddressMask
 449  * @mask2: another #GInetAddressMask
 450  *
 451  * Tests if @mask and @mask2 are the same mask.
 452  *
 453  * Return value: whether @mask and @mask2 are the same mask
 454  *
 455  * Since: 2.32
 456  */
 457 gboolean
 458 g_inet_address_mask_equal (GInetAddressMask  *mask,
 459                            GInetAddressMask  *mask2)
 460 {
 461   return ((mask->priv->length == mask2->priv->length) &&
 462           g_inet_address_equal (mask->priv->addr, mask2->priv->addr));
 463 }