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 |
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 (object: 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, v_enum: g_inet_address_get_family (address: mask->priv->addr)); |
111 | break; |
112 | |
113 | case PROP_ADDRESS: |
114 | g_value_set_object (value, v_object: mask->priv->addr); |
115 | break; |
116 | |
117 | case PROP_LENGTH: |
118 | g_value_set_uint (value, v_uint: 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_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 |
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 (oclass: gobject_class, property_id: PROP_FAMILY, |
146 | pspec: g_param_spec_enum (name: "family" , |
147 | P_("Address family" ), |
148 | P_("The address family (IPv4 or IPv6)" ), |
149 | enum_type: G_TYPE_SOCKET_FAMILY, |
150 | default_value: G_SOCKET_FAMILY_INVALID, |
151 | flags: G_PARAM_READABLE | |
152 | G_PARAM_STATIC_STRINGS)); |
153 | g_object_class_install_property (oclass: gobject_class, property_id: PROP_ADDRESS, |
154 | pspec: g_param_spec_object (name: "address" , |
155 | P_("Address" ), |
156 | P_("The base address" ), |
157 | G_TYPE_INET_ADDRESS, |
158 | flags: G_PARAM_READWRITE | |
159 | G_PARAM_STATIC_STRINGS)); |
160 | g_object_class_install_property (oclass: gobject_class, property_id: PROP_LENGTH, |
161 | pspec: g_param_spec_uint (name: "length" , |
162 | P_("Length" ), |
163 | P_("The prefix length" ), |
164 | minimum: 0, maximum: 128, default_value: 0, |
165 | flags: G_PARAM_READWRITE | |
166 | G_PARAM_STATIC_STRINGS)); |
167 | } |
168 | |
169 | static gboolean |
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 (err: error, G_IO_ERROR, code: G_IO_ERROR_INVALID_ARGUMENT, |
182 | _("No address specified" )); |
183 | return FALSE; |
184 | } |
185 | |
186 | addrlen = g_inet_address_get_native_size (address: mask->priv->addr); |
187 | if (mask->priv->length > addrlen * 8) |
188 | { |
189 | g_set_error (err: error, G_IO_ERROR, code: 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 (address: 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 (err: error, G_IO_ERROR, code: 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 |
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 |
237 | g_inet_address_mask_init (GInetAddressMask *mask) |
238 | { |
239 | mask->priv = g_inet_address_mask_get_instance_private (self: 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 * |
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 | first_property_name: "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 * |
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 (s: mask_string, c: '/'); |
291 | if (slash) |
292 | { |
293 | gchar *address, *end; |
294 | |
295 | length = strtoul (nptr: slash + 1, endptr: &end, base: 10); |
296 | if (*end || !*(slash + 1)) |
297 | { |
298 | parse_error: |
299 | g_set_error (err: error, G_IO_ERROR, code: 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 (str: mask_string, n: slash - mask_string); |
306 | addr = g_inet_address_new_from_string (string: address); |
307 | g_free (mem: address); |
308 | |
309 | if (!addr) |
310 | goto parse_error; |
311 | } |
312 | else |
313 | { |
314 | addr = g_inet_address_new_from_string (string: mask_string); |
315 | if (!addr) |
316 | goto parse_error; |
317 | |
318 | length = g_inet_address_get_native_size (address: addr) * 8; |
319 | } |
320 | |
321 | mask = g_inet_address_mask_new (addr, length, error); |
322 | g_object_unref (object: 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 * |
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 (address: mask->priv->addr); |
345 | |
346 | if (mask->priv->length == (g_inet_address_get_native_size (address: mask->priv->addr) * 8)) |
347 | return addr_string; |
348 | |
349 | mask_string = g_strdup_printf (format: "%s/%u" , addr_string, mask->priv->length); |
350 | g_free (mem: 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 |
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 (address: 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 * |
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 |
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 |
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 (address: 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 (address: mask->priv->addr); |
439 | addrbytes = g_inet_address_to_bytes (address); |
440 | |
441 | nbytes = mask->priv->length / 8; |
442 | if (nbytes != 0 && memcmp (s1: maskbytes, s2: addrbytes, n: 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 |
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 (address: mask->priv->addr, other_address: mask2->priv->addr)); |
473 | } |
474 | |