src/vat/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
 208 void
 209 ip_address_set (ip_address_t * dst, const void *src, u8 version)
 210 {
 211   ip_addr_version (dst) = version;
 212
 213   switch (version)
 214     {
 215     case AF_IP4:
 216       ip_addr_v4 (dst) = *(ip4_address_t *) src;
 217       break;
 218     case AF_IP6:
 219       ip_addr_v6 (dst) = *(ip6_address_t *) src;
 220       break;
 221     }
 222 }
 223
 224 fib_protocol_t
 225 ip_address_family_to_fib_proto (ip_address_family_t af)
 226 {
 227   switch (af)
 228     {
 229     case AF_IP4:
 230       return (FIB_PROTOCOL_IP4);
 231     case AF_IP6:
 232       return (FIB_PROTOCOL_IP6);
 233     }
 234   ASSERT (0);
 235   return (FIB_PROTOCOL_IP4);
 236 }
 237
 238 ip_address_family_t
 239 ip_address_family_from_fib_proto (fib_protocol_t fp)
 240 {
 241   switch (fp)
 242     {
 243     case FIB_PROTOCOL_IP4:
 244       return (AF_IP4);
 245     case FIB_PROTOCOL_IP6:
 246       return (AF_IP6);
 247     case FIB_PROTOCOL_MPLS:
 248       ASSERT (0);
 249     }
 250   return (AF_IP4);
 251 }
 252
 253 fib_protocol_t
 254 ip_address_to_46 (const ip_address_t * addr, ip46_address_t * a)
 255 {
 256   *a = ip_addr_46 (addr);
 257   return (ip_address_family_to_fib_proto (ip_addr_version (addr)));
 258 }
 259
 260 void
 261 ip_address_from_46 (const ip46_address_t * nh,
 262                     fib_protocol_t fproto, ip_address_t * ip)
 263 {
 264   ip_addr_46 (ip) = *nh;
 265   ip_addr_version (ip) = ip_address_family_from_fib_proto (fproto);
 266 }
 267
 268 static void
 269 ip_prefix_normalize_ip4 (ip4_address_t * ip4, u8 preflen)
 270 {
 271   u32 mask = ~0;
 272
 273   ASSERT (ip4);
 274
 275   if (32 <= preflen)
 276     {
 277       return;
 278     }
 279
 280   mask = pow2_mask (preflen) << (32 - preflen);
 281   mask = clib_host_to_net_u32 (mask);
 282   ip4->data_u32 &= mask;
 283 }
 284
 285 static void
 286 ip_prefix_normalize_ip6 (ip6_address_t * ip6, u8 preflen)
 287 {
 288   u8 mask_6[16];
 289   u32 *m;
 290   u8 j, i0, i1;
 291
 292   ASSERT (ip6);
 293
 294   clib_memset (mask_6, 0, sizeof (mask_6));
 295
 296   if (128 <= preflen)
 297     {
 298       return;
 299     }
 300
 301   i1 = preflen % 32;
 302   i0 = preflen / 32;
 303   m = (u32 *) & mask_6[0];
 304
 305   for (j = 0; j < i0; j++)
 306     {
 307       m[j] = ~0;
 308     }
 309
 310   if (i1)
 311     {
 312       m[i0] = clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
 313     }
 314
 315   for (j = 0; j < sizeof (mask_6); j++)
 316     {
 317       ip6->as_u8[j] &= mask_6[j];
 318     }
 319 }
 320
 321 void
 322 ip_prefix_normalize (ip_prefix_t * a)
 323 {
 324   u8 preflen = ip_prefix_len (a);
 325
 326   switch (ip_prefix_version (a))
 327     {
 328     case AF_IP4:
 329       ip_prefix_normalize_ip4 (&ip_prefix_v4 (a), preflen);
 330       break;
 331
 332     case AF_IP6:
 333       ip_prefix_normalize_ip6 (&ip_prefix_v6 (a), preflen);
 334       break;
 335
 336     default:
 337       ASSERT (0);
 338     }
 339 }
 340
 341 void
 342 ip_prefix_copy (void *dst, void *src)
 343 {
 344   clib_memcpy (dst, src, sizeof (ip_prefix_t));
 345 }
 346
 347 int
 348 ip_prefix_cmp (const ip_prefix_t *ipp1, const ip_prefix_t *ipp2)
 349 {
 350   ip_prefix_t p1 = *ipp1, p2 = *ipp2;
 351   int cmp = 0;
 352
 353   ip_prefix_normalize (&p1);
 354   ip_prefix_normalize (&p2);
 355
 356   cmp = ip_address_cmp (&ip_prefix_addr (&p1), &ip_prefix_addr (&p2));
 357   if (cmp == 0)
 358     {
 359       if (ip_prefix_len (&p1) < ip_prefix_len (&p2))
 360         {
 361           cmp = 1;
 362         }
 363       else
 364         {
 365           if (ip_prefix_len (&p1) > ip_prefix_len (&p2))
 366             cmp = 2;
 367         }
 368     }
 369   return cmp;
 370 }
 371
 372 static bool
 373 ip4_prefix_validate (const ip_prefix_t * ip)
 374 {
 375   ip4_address_t ip4_addr, ip4_mask;
 376
 377   if (ip_prefix_len (ip) > 32)
 378     return (false);
 379
 380   ip4_addr = ip_prefix_v4 (ip);
 381   ip4_preflen_to_mask (ip_prefix_len (ip), &ip4_mask);
 382
 383   return ((ip4_addr.as_u32 & ip4_mask.as_u32) == ip4_addr.as_u32);
 384 }
 385
 386 static bool
 387 ip6_prefix_validate (const ip_prefix_t * ip)
 388 {
 389   ip6_address_t ip6_addr, ip6_mask;
 390
 391   if (ip_prefix_len (ip) > 128)
 392     return (false);
 393
 394   ip6_addr = ip_prefix_v6 (ip);
 395   ip6_preflen_to_mask (ip_prefix_len (ip), &ip6_mask);
 396
 397   return (((ip6_addr.as_u64[0] & ip6_mask.as_u64[0]) == ip6_addr.as_u64[0]) &&
 398           ((ip6_addr.as_u64[1] & ip6_mask.as_u64[1]) == ip6_addr.as_u64[1]));
 399 }
 400
 401 bool
 402 ip_prefix_validate (const ip_prefix_t * ip)
 403 {
 404   switch (ip_prefix_version (ip))
 405     {
 406     case AF_IP4:
 407       return (ip4_prefix_validate (ip));
 408     case AF_IP6:
 409       return (ip6_prefix_validate (ip));
 410     }
 411   ASSERT (0);
 412   return (false);
 413 }
 414
 415 void
 416 ip4_address_normalize (ip4_address_t * ip4, u8 preflen)
 417 {
 418   ASSERT (preflen <= 32);
 419   if (preflen == 0)
 420     ip4->data_u32 = 0;
 421   else
 422     ip4->data_u32 &= clib_net_to_host_u32 (0xffffffff << (32 - preflen));
 423 }
 424
 425 void
 426 ip6_address_normalize (ip6_address_t * ip6, u8 preflen)
 427 {
 428   ASSERT (preflen <= 128);
 429   if (preflen == 0)
 430     {
 431       ip6->as_u64[0] = 0;
 432       ip6->as_u64[1] = 0;
 433     }
 434   else if (preflen <= 64)
 435     {
 436       ip6->as_u64[0] &=
 437         clib_host_to_net_u64 (0xffffffffffffffffL << (64 - preflen));
 438       ip6->as_u64[1] = 0;
 439     }
 440   else
 441     ip6->as_u64[1] &=
 442       clib_host_to_net_u64 (0xffffffffffffffffL << (128 - preflen));
 443 }
 444
 445 void
 446 ip4_preflen_to_mask (u8 pref_len, ip4_address_t * ip)
 447 {
 448   if (pref_len == 0)
 449     ip->as_u32 = 0;
 450   else
 451     ip->as_u32 = clib_host_to_net_u32 (~((1 << (32 - pref_len)) - 1));
 452 }
 453
 454 u32
 455 ip4_mask_to_preflen (ip4_address_t * mask)
 456 {
 457   if (mask->as_u32 == 0)
 458     return 0;
 459   return (32 - log2_first_set (clib_net_to_host_u32 (mask->as_u32)));
 460 }
 461
 462 void
 463 ip4_prefix_max_address_host_order (ip4_address_t * ip, u8 plen,
 464                                    ip4_address_t * res)
 465 {
 466   u32 not_mask;
 467   not_mask = (1 << (32 - plen)) - 1;
 468   res->as_u32 = clib_net_to_host_u32 (ip->as_u32) + not_mask;
 469 }
 470
 471 void
 472 ip6_preflen_to_mask (u8 pref_len, ip6_address_t * mask)
 473 {
 474   if (pref_len == 0)
 475     {
 476       mask->as_u64[0] = 0;
 477       mask->as_u64[1] = 0;
 478     }
 479   else if (pref_len <= 64)
 480     {
 481       mask->as_u64[0] =
 482         clib_host_to_net_u64 (0xffffffffffffffffL << (64 - pref_len));
 483       mask->as_u64[1] = 0;
 484     }
 485   else
 486     {
 487       mask->as_u64[0] = 0xffffffffffffffffL;
 488       mask->as_u64[1] =
 489         clib_host_to_net_u64 (0xffffffffffffffffL << (128 - pref_len));
 490     }
 491 }
 492
 493 void
 494 ip6_prefix_max_address_host_order (ip6_address_t * ip, u8 plen,
 495                                    ip6_address_t * res)
 496 {
 497   u64 not_mask;
 498   if (plen == 0)
 499     {
 500       res->as_u64[0] = 0xffffffffffffffffL;
 501       res->as_u64[1] = 0xffffffffffffffffL;
 502     }
 503   else if (plen <= 64)
 504     {
 505       not_mask = ((u64) 1 << (64 - plen)) - 1;
 506       res->as_u64[0] = clib_net_to_host_u64 (ip->as_u64[0]) + not_mask;
 507       res->as_u64[1] = 0xffffffffffffffffL;
 508     }
 509   else
 510     {
 511       not_mask = ((u64) 1 << (128 - plen)) - 1;
 512       res->as_u64[1] = clib_net_to_host_u64 (ip->as_u64[1]) + not_mask;
 513     }
 514 }
 515
 516 u32
 517 ip6_mask_to_preflen (ip6_address_t * mask)
 518 {
 519   if (mask->as_u64[1] != 0)
 520     return 128 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[1]));
 521   if (mask->as_u64[0] != 0)
 522     return 64 - log2_first_set (clib_net_to_host_u64 (mask->as_u64[0]));
 523   return 0;
 524 }
 525
 526 /*
 527  * fd.io coding-style-patch-verification: ON
 528  *
 529  * Local Variables:
 530  * eval: (c-set-style "gnu")
 531  * End:
 532  */