2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <vnet/ip/ip_types.h>
17 #include <vnet/ip/format.h>
18 #include <vnet/ip/ip.h>
21 format_ip_address (u8 * s, va_list * args)
23 ip_address_t *a = va_arg (*args, ip_address_t *);
24 u8 ver = ip_addr_version (a);
27 return format (s, "%U", format_ip4_address, &ip_addr_v4 (a));
29 else if (ver == AF_IP6)
31 return format (s, "%U", format_ip6_address, &ip_addr_v6 (a));
35 clib_warning ("Can't format IP version %d!", ver);
41 unformat_ip_address (unformat_input_t * input, va_list * args)
43 ip_address_t *a = va_arg (*args, ip_address_t *);
44 ip_address_t tmp, *p_tmp = &tmp;
46 clib_memset (p_tmp, 0, sizeof (*p_tmp));
47 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (p_tmp)))
48 ip_addr_version (p_tmp) = AF_IP4;
49 else if (unformat_user (input, unformat_ip6_address, &ip_addr_v6 (p_tmp)))
50 ip_addr_version (p_tmp) = AF_IP6;
58 format_ip_prefix (u8 * s, va_list * args)
60 ip_prefix_t *a = va_arg (*args, ip_prefix_t *);
61 return format (s, "%U/%d", format_ip_address, &ip_prefix_addr (a),
66 unformat_ip_prefix (unformat_input_t * input, va_list * args)
68 ip_prefix_t *a = va_arg (*args, ip_prefix_t *);
69 /* %d writes more than a u8 */
71 if (unformat (input, "%U/%d", unformat_ip_address, &ip_prefix_addr (a),
74 ip_prefix_len (a) = plen;
75 if ((ip_prefix_version (a) == AF_IP4 && 32 < ip_prefix_len (a)) ||
76 (ip_prefix_version (a) == AF_IP6 && 128 < ip_prefix_len (a)))
78 clib_warning ("Prefix length to big: %d!", ip_prefix_len (a));
81 ip_prefix_normalize (a);
89 ip_address_size (const ip_address_t * a)
91 switch (ip_addr_version (a))
94 return sizeof (ip4_address_t);
97 return sizeof (ip6_address_t);
104 ip_address_is_zero (const ip_address_t * ip)
106 switch (ip_addr_version (ip))
109 return (ip_addr_v4 (ip).as_u32 == 0);
111 return (ip_addr_v6 (ip).as_u64[0] == 0 &&
112 ip_addr_v6 (ip).as_u64[1] == 0);
119 ip_address_cmp (const ip_address_t * ip1, const ip_address_t * ip2)
122 if (ip_addr_version (ip1) != ip_addr_version (ip2))
124 res = ip46_address_cmp (&ip_addr_46 (ip1), &ip_addr_46 (ip2));
135 ip_address_copy (ip_address_t * dst, const ip_address_t * src)
137 if (AF_IP4 == ip_addr_version (src))
139 /* don't copy any garbage from the union */
140 clib_memset (dst, 0, sizeof (*dst));
141 ip_addr_v4 (dst) = ip_addr_v4 (src);
142 dst->version = AF_IP4;
146 clib_memcpy (dst, src, sizeof (ip_address_t));
151 ip_addr_bytes (ip_address_t * ip)
156 return (u8 *) & ip_addr_v4 (ip);
158 return (u8 *) & ip_addr_v6 (ip);
166 ip_address_copy_addr (void *dst, const ip_address_t * src)
168 switch (src->version)
171 clib_memcpy (dst, &ip_addr_v4 (src), ip_address_size (src));
174 clib_memcpy (dst, &ip_addr_v6 (src), ip_address_size (src));
180 ip_version_to_size (ip_address_family_t af)
185 return sizeof (ip4_address_t);
188 return sizeof (ip6_address_t);
195 ip_address_family_to_link_type (ip_address_family_t af)
200 return (VNET_LINK_IP4);
202 return (VNET_LINK_IP6);
205 return (VNET_LINK_IP4);
209 ip_address_set (ip_address_t *dst, const void *src, ip_address_family_t af)
211 ip_addr_version (dst) = af;
216 ip_addr_v4 (dst) = *(ip4_address_t *) src;
219 ip_addr_v6 (dst) = *(ip6_address_t *) src;
225 ip_address_family_to_fib_proto (ip_address_family_t af)
230 return (FIB_PROTOCOL_IP4);
232 return (FIB_PROTOCOL_IP6);
235 return (FIB_PROTOCOL_IP4);
239 ip_address_family_from_fib_proto (fib_protocol_t fp)
243 case FIB_PROTOCOL_IP4:
245 case FIB_PROTOCOL_IP6:
247 case FIB_PROTOCOL_MPLS:
254 ip_address_to_46 (const ip_address_t * addr, ip46_address_t * a)
256 *a = ip_addr_46 (addr);
257 return (ip_address_family_to_fib_proto (ip_addr_version (addr)));
261 ip_address_from_46 (const ip46_address_t * nh,
262 fib_protocol_t fproto, ip_address_t * ip)
264 ip_addr_46 (ip) = *nh;
265 ip_addr_version (ip) = ip_address_family_from_fib_proto (fproto);
269 * convert from a IP address to a FIB prefix
272 ip_address_to_fib_prefix (const ip_address_t * addr, fib_prefix_t * prefix)
274 if (addr->version == AF_IP4)
277 prefix->fp_proto = FIB_PROTOCOL_IP4;
278 clib_memset (&prefix->fp_addr.pad, 0, sizeof (prefix->fp_addr.pad));
279 memcpy (&prefix->fp_addr.ip4, &addr->ip.ip4,
280 sizeof (prefix->fp_addr.ip4));
284 prefix->fp_len = 128;
285 prefix->fp_proto = FIB_PROTOCOL_IP6;
286 memcpy (&prefix->fp_addr.ip6, &addr->ip.ip6,
287 sizeof (prefix->fp_addr.ip6));
289 prefix->___fp___pad = 0;
293 ip_address_to_prefix (const ip_address_t *addr, ip_prefix_t *prefix)
295 prefix->len = (addr->version == AF_IP4 ? 32 : 128);
296 clib_memcpy (&prefix->addr, addr, sizeof (prefix->addr));
300 ip_address_increment (ip_address_t * ip)
302 ip46_address_increment ((ip_addr_version (ip) == AF_IP4 ?
303 IP46_TYPE_IP4 : IP46_TYPE_IP6), &ip_addr_46 (ip));
307 ip_address_reset (ip_address_t * ip)
309 clib_memset (ip, 0, sizeof (*ip));
313 ip_prefix_normalize_ip4 (ip4_address_t * ip4, u8 preflen)
324 mask = pow2_mask (preflen) << (32 - preflen);
325 mask = clib_host_to_net_u32 (mask);
326 ip4->data_u32 &= mask;
330 ip_prefix_normalize_ip6 (ip6_address_t * ip6, u8 preflen)
338 clib_memset (mask_6, 0, sizeof (mask_6));
347 m = (u32 *) & mask_6[0];
349 for (j = 0; j < i0; j++)
356 m[i0] = clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
359 for (j = 0; j < sizeof (mask_6); j++)
361 ip6->as_u8[j] &= mask_6[j];
366 ip_prefix_normalize (ip_prefix_t * a)
368 u8 preflen = ip_prefix_len (a);
370 switch (ip_prefix_version (a))
373 ip_prefix_normalize_ip4 (&ip_prefix_v4 (a), preflen);
377 ip_prefix_normalize_ip6 (&ip_prefix_v6 (a), preflen);
386 ip_prefix_copy (void *dst, void *src)
388 clib_memcpy (dst, src, sizeof (ip_prefix_t));
392 ip_prefix_cmp (const ip_prefix_t *ipp1, const ip_prefix_t *ipp2)
394 ip_prefix_t p1 = *ipp1, p2 = *ipp2;
397 ip_prefix_normalize (&p1);
398 ip_prefix_normalize (&p2);
400 cmp = ip_address_cmp (&ip_prefix_addr (&p1), &ip_prefix_addr (&p2));
403 if (ip_prefix_len (&p1) < ip_prefix_len (&p2))
409 if (ip_prefix_len (&p1) > ip_prefix_len (&p2))
417 * convert from a LISP to a FIB prefix
420 ip_prefix_to_fib_prefix (const ip_prefix_t * ip_prefix,
421 fib_prefix_t * fib_prefix)
423 ip_address_to_fib_prefix (&ip_prefix->addr, fib_prefix);
424 fib_prefix->fp_len = ip_prefix->len;
428 ip4_prefix_validate (const ip_prefix_t * ip)
430 ip4_address_t ip4_addr, ip4_mask;
432 if (ip_prefix_len (ip) > 32)
435 ip4_addr = ip_prefix_v4 (ip);
436 ip4_preflen_to_mask (ip_prefix_len (ip), &ip4_mask);
438 return ((ip4_addr.as_u32 & ip4_mask.as_u32) == ip4_addr.as_u32);
442 ip6_prefix_validate (const ip_prefix_t * ip)
444 ip6_address_t ip6_addr, ip6_mask;
446 if (ip_prefix_len (ip) > 128)
449 ip6_addr = ip_prefix_v6 (ip);
450 ip6_preflen_to_mask (ip_prefix_len (ip), &ip6_mask);
452 return (((ip6_addr.as_u64[0] & ip6_mask.as_u64[0]) == ip6_addr.as_u64[0]) &&
453 ((ip6_addr.as_u64[1] & ip6_mask.as_u64[1]) == ip6_addr.as_u64[1]));
457 ip_prefix_validate (const ip_prefix_t * ip)
459 switch (ip_prefix_version (ip))
462 return (ip4_prefix_validate (ip));
464 return (ip6_prefix_validate (ip));
471 ip4_address_normalize (ip4_address_t * ip4, u8 preflen)
473 ASSERT (preflen <= 32);
477 ip4->data_u32 &= clib_net_to_host_u32 (0xffffffff << (32 - preflen));
481 ip6_address_normalize (ip6_address_t * ip6, u8 preflen)
483 ASSERT (preflen <= 128);
489 else if (preflen <= 64)
492 clib_host_to_net_u64 (0xffffffffffffffffL << (64 - preflen));
497 clib_host_to_net_u64 (0xffffffffffffffffL << (128 - preflen));
501 ip4_preflen_to_mask (u8 pref_len, ip4_address_t * ip)
506 ip->as_u32 = clib_host_to_net_u32 (~((1 << (32 - pref_len)) - 1));
510 ip4_mask_to_preflen (ip4_address_t * mask)
512 if (mask->as_u32 == 0)
514 return (32 - log2_first_set (clib_net_to_host_u32 (mask->as_u32)));
518 ip4_prefix_max_address_host_order (ip4_address_t * ip, u8 plen,
522 not_mask = (1 << (32 - plen)) - 1;
523 res->as_u32 = clib_net_to_host_u32 (ip->as_u32) + not_mask;
527 ip6_preflen_to_mask (u8 pref_len, ip6_address_t * mask)
534 else if (pref_len <= 64)
537 clib_host_to_net_u64 (0xffffffffffffffffL << (64 - pref_len));
542 mask->as_u64[0] = 0xffffffffffffffffL;
544 clib_host_to_net_u64 (0xffffffffffffffffL << (128 - pref_len));
549 ip6_prefix_max_address_host_order (ip6_address_t * ip, u8 plen,
555 res->as_u64[0] = 0xffffffffffffffffL;
556 res->as_u64[1] = 0xffffffffffffffffL;
560 not_mask = ((u64) 1 << (64 - plen)) - 1;
561 res->as_u64[0] = clib_net_to_host_u64 (ip->as_u64[0]) + not_mask;
562 res->as_u64[1] = 0xffffffffffffffffL;
566 not_mask = ((u64) 1 << (128 - plen)) - 1;
567 res->as_u64[1] = clib_net_to_host_u64 (ip->as_u64[1]) + not_mask;
572 ip6_mask_to_preflen (ip6_address_t * mask)
574 if (mask->as_u64[1] != 0)
575 return 128 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[1]));
576 if (mask->as_u64[0] != 0)
577 return 64 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[0]));
582 * fd.io coding-style-patch-verification: ON
585 * eval: (c-set-style "gnu")