src/vnet/ip/ip_types.c

   1 /*
   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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  15
  16 #include <vnet/ip/ip_types.h>
  17 #include <vnet/ip/format.h>
  18 #include <vnet/ip/ip.h>
  19
  20 u8 *
  21 format_ip_address (u8 * s, va_list * args)
  22 {
  23   ip_address_t *a = va_arg (*args, ip_address_t *);
  24   u8 ver = ip_addr_version (a);
  25   if (ver == AF_IP4)
  26     {
  27       return format (s, "%U", format_ip4_address, &ip_addr_v4 (a));
  28     }
  29   else if (ver == AF_IP6)
  30     {
  31       return format (s, "%U", format_ip6_address, &ip_addr_v6 (a));
  32     }
  33   else
  34     {
  35       clib_warning ("Can't format IP version %d!", ver);
  36       return 0;
  37     }
  38 }
  39
  40 uword
  41 unformat_ip_address (unformat_input_t * input, va_list * args)
  42 {
  43   ip_address_t *a = va_arg (*args, ip_address_t *);
  44
  45   if (unformat_user (input, unformat_ip46_address, &ip_addr_46 (a),
  46                      IP46_TYPE_ANY))
  47     {
  48       ip_addr_version (a) =
  49         ip46_address_is_ip4 (&ip_addr_46 (a)) ? AF_IP4 : AF_IP6;
  50       return 1;
  51     }
  52
  53   return 0;
  54 }
  55
  56 u8 *
  57 format_ip_prefix (u8 * s, va_list * args)
  58 {
  59   ip_prefix_t *a = va_arg (*args, ip_prefix_t *);
  60   return format (s, "%U/%d", format_ip_address, &ip_prefix_addr (a),
  61                  ip_prefix_len (a));
  62 }
  63
  64 uword
  65 unformat_ip_prefix (unformat_input_t * input, va_list * args)
  66 {
  67   ip_prefix_t *a = va_arg (*args, ip_prefix_t *);
  68   /* %d writes more than a u8 */
  69   int plen;
  70   if (unformat (input, "%U/%d", unformat_ip_address, &ip_prefix_addr (a),
  71                 &plen))
  72     {
  73       ip_prefix_len (a) = plen;
  74       if ((ip_prefix_version (a) == AF_IP4 && 32 < ip_prefix_len (a)) ||
  75           (ip_prefix_version (a) == AF_IP6 && 128 < ip_prefix_len (a)))
  76         {
  77           clib_warning ("Prefix length to big: %d!", ip_prefix_len (a));
  78           return 0;
  79         }
  80       ip_prefix_normalize (a);
  81     }
  82   else
  83     return 0;
  84   return 1;
  85 }
  86
  87 u16
  88 ip_address_size (const ip_address_t * a)
  89 {
  90   switch (ip_addr_version (a))
  91     {
  92     case AF_IP4:
  93       return sizeof (ip4_address_t);
  94       break;
  95     case AF_IP6:
  96       return sizeof (ip6_address_t);
  97       break;
  98     }
  99   return 0;
 100 }
 101
 102 bool
 103 ip_address_is_zero (const ip_address_t * ip)
 104 {
 105   switch (ip_addr_version (ip))
 106     {
 107     case AF_IP4:
 108       return (ip_addr_v4 (ip).as_u32 == 0);
 109     case AF_IP6:
 110       return (ip_addr_v6 (ip).as_u64[0] == 0 &&
 111               ip_addr_v6 (ip).as_u64[1] == 0);
 112       break;
 113     }
 114   return false;
 115 }
 116
 117 int
 118 ip_address_cmp (const ip_address_t * ip1, const ip_address_t * ip2)
 119 {
 120   int res = 0;
 121   if (ip_addr_version (ip1) != ip_addr_version (ip2))
 122     return -1;
 123   res = ip46_address_cmp (&ip_addr_46 (ip1), &ip_addr_46 (ip2));
 124
 125   if (res < 0)
 126     res = 2;
 127   else if (res > 0)
 128     res = 1;
 129
 130   return res;
 131 }
 132
 133 void
 134 ip_address_copy (ip_address_t * dst, const ip_address_t * src)
 135 {
 136   if (AF_IP4 == ip_addr_version (src))
 137     {
 138       /* don't copy any garbage from the union */
 139       clib_memset (dst, 0, sizeof (*dst));
 140       ip_addr_v4 (dst) = ip_addr_v4 (src);
 141       dst->version = AF_IP4;
 142     }
 143   else
 144     {
 145       clib_memcpy (dst, src, sizeof (ip_address_t));
 146     }
 147 }
 148
 149 u8 *
 150 ip_addr_bytes (ip_address_t * ip)
 151 {
 152   switch (ip->version)
 153     {
 154     case AF_IP4:
 155       return (u8 *) & ip_addr_v4 (ip);
 156     case AF_IP6:
 157       return (u8 *) & ip_addr_v6 (ip);
 158       break;
 159     }
 160   ASSERT (0);
 161   return (NULL);
 162 }
 163
 164 void
 165 ip_address_copy_addr (void *dst, const ip_address_t * src)
 166 {
 167   switch (src->version)
 168     {
 169     case AF_IP4:
 170       clib_memcpy (dst, &ip_addr_v4 (src), ip_address_size (src));
 171       break;
 172     case AF_IP6:
 173       clib_memcpy (dst, &ip_addr_v6 (src), ip_address_size (src));
 174       break;
 175     }
 176 }
 177
 178 u16
 179 ip_version_to_size (ip_address_family_t af)
 180 {
 181   switch (af)
 182     {
 183     case AF_IP4:
 184       return sizeof (ip4_address_t);
 185       break;
 186     case AF_IP6:
 187       return sizeof (ip6_address_t);
 188       break;
 189     }
 190   return 0;
 191 }
 192
 193 vnet_link_t
 194 ip_address_family_to_link_type (ip_address_family_t af)
 195 {
 196   switch (af)
 197     {
 198     case AF_IP4:
 199       return (VNET_LINK_IP4);
 200     case AF_IP6:
 201       return (VNET_LINK_IP6);
 202     }
 203   ASSERT (0);
 204   return (VNET_LINK_IP4);
 205 }
 206
 207 void
 208 ip_address_set (ip_address_t *dst, const void *src, ip_address_family_t af)
 209 {
 210   ip_addr_version (dst) = af;
 211
 212   switch (af)
 213     {
 214     case AF_IP4:
 215       ip_addr_v4 (dst) = *(ip4_address_t *) src;
 216       break;
 217     case AF_IP6:
 218       ip_addr_v6 (dst) = *(ip6_address_t *) src;
 219       break;
 220     }
 221 }
 222
 223 fib_protocol_t
 224 ip_address_family_to_fib_proto (ip_address_family_t af)
 225 {
 226   switch (af)
 227     {
 228     case AF_IP4:
 229       return (FIB_PROTOCOL_IP4);
 230     case AF_IP6:
 231       return (FIB_PROTOCOL_IP6);
 232     }
 233   ASSERT (0);
 234   return (FIB_PROTOCOL_IP4);
 235 }
 236
 237 ip_address_family_t
 238 ip_address_family_from_fib_proto (fib_protocol_t fp)
 239 {
 240   switch (fp)
 241     {
 242     case FIB_PROTOCOL_IP4:
 243       return (AF_IP4);
 244     case FIB_PROTOCOL_IP6:
 245       return (AF_IP6);
 246     case FIB_PROTOCOL_MPLS:
 247       ASSERT (0);
 248     }
 249   return (AF_IP4);
 250 }
 251
 252 fib_protocol_t
 253 ip_address_to_46 (const ip_address_t * addr, ip46_address_t * a)
 254 {
 255   *a = ip_addr_46 (addr);
 256   return (ip_address_family_to_fib_proto (ip_addr_version (addr)));
 257 }
 258
 259 void
 260 ip_address_from_46 (const ip46_address_t * nh,
 261                     fib_protocol_t fproto, ip_address_t * ip)
 262 {
 263   ip_addr_46 (ip) = *nh;
 264   ip_addr_version (ip) = ip_address_family_from_fib_proto (fproto);
 265 }
 266
 267 /**
 268  * convert from a IP address to a FIB prefix
 269  */
 270 void
 271 ip_address_to_fib_prefix (const ip_address_t * addr, fib_prefix_t * prefix)
 272 {
 273   if (addr->version == AF_IP4)
 274     {
 275       prefix->fp_len = 32;
 276       prefix->fp_proto = FIB_PROTOCOL_IP4;
 277       clib_memset (&prefix->fp_addr.pad, 0, sizeof (prefix->fp_addr.pad));
 278       memcpy (&prefix->fp_addr.ip4, &addr->ip.ip4,
 279               sizeof (prefix->fp_addr.ip4));
 280     }
 281   else
 282     {
 283       prefix->fp_len = 128;
 284       prefix->fp_proto = FIB_PROTOCOL_IP6;
 285       memcpy (&prefix->fp_addr.ip6, &addr->ip.ip6,
 286               sizeof (prefix->fp_addr.ip6));
 287     }
 288   prefix->___fp___pad = 0;
 289 }
 290
 291 void
 292 ip_address_to_prefix (const ip_address_t *addr, ip_prefix_t *prefix)
 293 {
 294   prefix->len = (addr->version == AF_IP4 ? 32 : 128);
 295   clib_memcpy (&prefix->addr, addr, sizeof (prefix->addr));
 296 }
 297
 298 void
 299 ip_address_increment (ip_address_t * ip)
 300 {
 301   ip46_address_increment ((ip_addr_version (ip) == AF_IP4 ?
 302                            IP46_TYPE_IP4 : IP46_TYPE_IP6), &ip_addr_46 (ip));
 303 }
 304
 305 void
 306 ip_address_reset (ip_address_t * ip)
 307 {
 308   clib_memset (ip, 0, sizeof (*ip));
 309 }
 310
 311 static void
 312 ip_prefix_normalize_ip4 (ip4_address_t * ip4, u8 preflen)
 313 {
 314   u32 mask = ~0;
 315
 316   ASSERT (ip4);
 317
 318   if (32 <= preflen)
 319     {
 320       return;
 321     }
 322
 323   mask = pow2_mask (preflen) << (32 - preflen);
 324   mask = clib_host_to_net_u32 (mask);
 325   ip4->data_u32 &= mask;
 326 }
 327
 328 static void
 329 ip_prefix_normalize_ip6 (ip6_address_t * ip6, u8 preflen)
 330 {
 331   u8 mask_6[16];
 332   u32 *m;
 333   u8 j, i0, i1;
 334
 335   ASSERT (ip6);
 336
 337   clib_memset (mask_6, 0, sizeof (mask_6));
 338
 339   if (128 <= preflen)
 340     {
 341       return;
 342     }
 343
 344   i1 = preflen % 32;
 345   i0 = preflen / 32;
 346   m = (u32 *) & mask_6[0];
 347
 348   for (j = 0; j < i0; j++)
 349     {
 350       m[j] = ~0;
 351     }
 352
 353   if (i1)
 354     {
 355       m[i0] = clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
 356     }
 357
 358   for (j = 0; j < sizeof (mask_6); j++)
 359     {
 360       ip6->as_u8[j] &= mask_6[j];
 361     }
 362 }
 363
 364 void
 365 ip_prefix_normalize (ip_prefix_t * a)
 366 {
 367   u8 preflen = ip_prefix_len (a);
 368
 369   switch (ip_prefix_version (a))
 370     {
 371     case AF_IP4:
 372       ip_prefix_normalize_ip4 (&ip_prefix_v4 (a), preflen);
 373       break;
 374
 375     case AF_IP6:
 376       ip_prefix_normalize_ip6 (&ip_prefix_v6 (a), preflen);
 377       break;
 378
 379     default:
 380       ASSERT (0);
 381     }
 382 }
 383
 384 void
 385 ip_prefix_copy (void *dst, void *src)
 386 {
 387   clib_memcpy (dst, src, sizeof (ip_prefix_t));
 388 }
 389
 390 int
 391 ip_prefix_cmp (const ip_prefix_t *ipp1, const ip_prefix_t *ipp2)
 392 {
 393   ip_prefix_t p1 = *ipp1, p2 = *ipp2;
 394   int cmp = 0;
 395
 396   ip_prefix_normalize (&p1);
 397   ip_prefix_normalize (&p2);
 398
 399   cmp = ip_address_cmp (&ip_prefix_addr (&p1), &ip_prefix_addr (&p2));
 400   if (cmp == 0)
 401     {
 402       if (ip_prefix_len (&p1) < ip_prefix_len (&p2))
 403         {
 404           cmp = 1;
 405         }
 406       else
 407         {
 408           if (ip_prefix_len (&p1) > ip_prefix_len (&p2))
 409             cmp = 2;
 410         }
 411     }
 412   return cmp;
 413 }
 414
 415 /**
 416  * convert from a LISP to a FIB prefix
 417  */
 418 void
 419 ip_prefix_to_fib_prefix (const ip_prefix_t * ip_prefix,
 420                          fib_prefix_t * fib_prefix)
 421 {
 422   ip_address_to_fib_prefix (&ip_prefix->addr, fib_prefix);
 423   fib_prefix->fp_len = ip_prefix->len;
 424 }
 425
 426 static bool
 427 ip4_prefix_validate (const ip_prefix_t * ip)
 428 {
 429   ip4_address_t ip4_addr, ip4_mask;
 430
 431   if (ip_prefix_len (ip) > 32)
 432     return (false);
 433
 434   ip4_addr = ip_prefix_v4 (ip);
 435   ip4_preflen_to_mask (ip_prefix_len (ip), &ip4_mask);
 436
 437   return ((ip4_addr.as_u32 & ip4_mask.as_u32) == ip4_addr.as_u32);
 438 }
 439
 440 static bool
 441 ip6_prefix_validate (const ip_prefix_t * ip)
 442 {
 443   ip6_address_t ip6_addr, ip6_mask;
 444
 445   if (ip_prefix_len (ip) > 128)
 446     return (false);
 447
 448   ip6_addr = ip_prefix_v6 (ip);
 449   ip6_preflen_to_mask (ip_prefix_len (ip), &ip6_mask);
 450
 451   return (((ip6_addr.as_u64[0] & ip6_mask.as_u64[0]) == ip6_addr.as_u64[0]) &&
 452           ((ip6_addr.as_u64[1] & ip6_mask.as_u64[1]) == ip6_addr.as_u64[1]));
 453 }
 454
 455 bool
 456 ip_prefix_validate (const ip_prefix_t * ip)
 457 {
 458   switch (ip_prefix_version (ip))
 459     {
 460     case AF_IP4:
 461       return (ip4_prefix_validate (ip));
 462     case AF_IP6:
 463       return (ip6_prefix_validate (ip));
 464     }
 465   ASSERT (0);
 466   return (false);
 467 }
 468
 469 void
 470 ip4_address_normalize (ip4_address_t * ip4, u8 preflen)
 471 {
 472   ASSERT (preflen <= 32);
 473   if (preflen == 0)
 474     ip4->data_u32 = 0;
 475   else
 476     ip4->data_u32 &= clib_net_to_host_u32 (0xffffffff << (32 - preflen));
 477 }
 478
 479 void
 480 ip6_address_normalize (ip6_address_t * ip6, u8 preflen)
 481 {
 482   ASSERT (preflen <= 128);
 483   if (preflen == 0)
 484     {
 485       ip6->as_u64[0] = 0;
 486       ip6->as_u64[1] = 0;
 487     }
 488   else if (preflen <= 64)
 489     {
 490       ip6->as_u64[0] &=
 491         clib_host_to_net_u64 (0xffffffffffffffffL << (64 - preflen));
 492       ip6->as_u64[1] = 0;
 493     }
 494   else
 495     ip6->as_u64[1] &=
 496       clib_host_to_net_u64 (0xffffffffffffffffL << (128 - preflen));
 497 }
 498
 499 void
 500 ip4_preflen_to_mask (u8 pref_len, ip4_address_t * ip)
 501 {
 502   if (pref_len == 0)
 503     ip->as_u32 = 0;
 504   else
 505     ip->as_u32 = clib_host_to_net_u32 (~((1 << (32 - pref_len)) - 1));
 506 }
 507
 508 u32
 509 ip4_mask_to_preflen (ip4_address_t * mask)
 510 {
 511   if (mask->as_u32 == 0)
 512     return 0;
 513   return (32 - log2_first_set (clib_net_to_host_u32 (mask->as_u32)));
 514 }
 515
 516 void
 517 ip4_prefix_max_address_host_order (ip4_address_t * ip, u8 plen,
 518                                    ip4_address_t * res)
 519 {
 520   u32 not_mask;
 521   not_mask = (1 << (32 - plen)) - 1;
 522   res->as_u32 = clib_net_to_host_u32 (ip->as_u32) + not_mask;
 523 }
 524
 525 void
 526 ip6_preflen_to_mask (u8 pref_len, ip6_address_t * mask)
 527 {
 528   if (pref_len == 0)
 529     {
 530       mask->as_u64[0] = 0;
 531       mask->as_u64[1] = 0;
 532     }
 533   else if (pref_len <= 64)
 534     {
 535       mask->as_u64[0] =
 536         clib_host_to_net_u64 (0xffffffffffffffffL << (64 - pref_len));
 537       mask->as_u64[1] = 0;
 538     }
 539   else
 540     {
 541       mask->as_u64[0] = 0xffffffffffffffffL;
 542       mask->as_u64[1] =
 543         clib_host_to_net_u64 (0xffffffffffffffffL << (128 - pref_len));
 544     }
 545 }
 546
 547 void
 548 ip6_prefix_max_address_host_order (ip6_address_t * ip, u8 plen,
 549                                    ip6_address_t * res)
 550 {
 551   u64 not_mask;
 552   if (plen == 0)
 553     {
 554       res->as_u64[0] = 0xffffffffffffffffL;
 555       res->as_u64[1] = 0xffffffffffffffffL;
 556     }
 557   else if (plen <= 64)
 558     {
 559       not_mask = ((u64) 1 << (64 - plen)) - 1;
 560       res->as_u64[0] = clib_net_to_host_u64 (ip->as_u64[0]) + not_mask;
 561       res->as_u64[1] = 0xffffffffffffffffL;
 562     }
 563   else
 564     {
 565       not_mask = ((u64) 1 << (128 - plen)) - 1;
 566       res->as_u64[1] = clib_net_to_host_u64 (ip->as_u64[1]) + not_mask;
 567     }
 568 }
 569
 570 u32
 571 ip6_mask_to_preflen (ip6_address_t * mask)
 572 {
 573   if (mask->as_u64[1] != 0)
 574     return 128 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[1]));
 575   if (mask->as_u64[0] != 0)
 576     return 64 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[0]));
 577   return 0;
 578 }
 579
 580 /*
 581  * fd.io coding-style-patch-verification: ON
 582  *
 583  * Local Variables:
 584  * eval: (c-set-style "gnu")
 585  * End:
 586  */