src/plugins/srv6-as/as.c

   1 /*
   2  * Copyright (c) 2015 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  *------------------------------------------------------------------
  17  * as.c - SRv6 Static Proxy (AS) function
  18  *------------------------------------------------------------------
  19  */
  20
  21 #include <vnet/vnet.h>
  22 #include <vnet/adj/adj.h>
  23 #include <vnet/plugin/plugin.h>
  24 #include <vpp/app/version.h>
  25 #include <srv6-as/as.h>
  26
  27 #define SID_CREATE_IFACE_FEATURE_ERROR  -1
  28 #define SID_CREATE_INVALID_IFACE_TYPE   -3
  29 #define SID_CREATE_INVALID_IFACE_INDEX  -4
  30 #define SID_CREATE_INVALID_ADJ_INDEX    -5
  31
  32 unsigned char function_name[] = "SRv6-AS-plugin";
  33 unsigned char keyword_str[] = "End.AS";
  34 unsigned char def_str[] =
  35   "Endpoint with static proxy to SR-unaware appliance";
  36 unsigned char params_str[] =
  37   "nh <next-hop> oif <iface-out> iif <iface-in> src <src-addr> next <sid> [next <sid> ...]";
  38
  39
  40 static inline u8 *
  41 prepare_rewrite (ip6_address_t src_addr, ip6_address_t * sid_list,
  42                  u8 protocol)
  43 {
  44   u8 *rewrite_str = NULL;
  45   u32 rewrite_len = IPv6_DEFAULT_HEADER_LENGTH;
  46
  47   u8 num_sids = vec_len (sid_list);
  48   u32 sr_hdr_len = 0;
  49
  50   if (num_sids > 1)
  51     {
  52       sr_hdr_len =
  53         sizeof (ip6_sr_header_t) + num_sids * sizeof (ip6_address_t);
  54       rewrite_len += sr_hdr_len;
  55     }
  56
  57   vec_validate (rewrite_str, rewrite_len - 1);
  58
  59   /* Fill IP header */
  60   ip6_header_t *iph = (ip6_header_t *) rewrite_str;
  61   iph->ip_version_traffic_class_and_flow_label =
  62     clib_host_to_net_u32 (0 | ((6 & 0xF) << 28));
  63   iph->src_address = src_addr;
  64   iph->dst_address = sid_list[0];
  65   iph->payload_length = sr_hdr_len;
  66   iph->hop_limit = IPv6_DEFAULT_HOP_LIMIT;
  67
  68   if (num_sids > 1)
  69     {
  70       /* Set Next Header value to Routing Extension */
  71       iph->protocol = IP_PROTOCOL_IPV6_ROUTE;
  72
  73       /* Fill SR header */
  74       ip6_sr_header_t *srh = (ip6_sr_header_t *) (iph + 1);
  75       srh->protocol = protocol;
  76       srh->length = sr_hdr_len / 8 - 1;
  77       srh->type = ROUTING_HEADER_TYPE_SR;
  78       srh->segments_left = num_sids - 1;
  79       srh->first_segment = num_sids - 1;
  80       srh->flags = 0x00;
  81       srh->reserved = 0x00;
  82
  83       /* Fill segment list */
  84       ip6_address_t *this_address;
  85       ip6_address_t *addrp = srh->segments + srh->first_segment;
  86       vec_foreach (this_address, sid_list)
  87       {
  88         *addrp = *this_address;
  89         addrp--;
  90       }
  91     }
  92   else
  93     {
  94       /* Set Next Header value to inner protocol */
  95       iph->protocol = protocol;
  96     }
  97
  98   return rewrite_str;
  99 }
 100
 101 static inline void
 102 free_ls_mem (srv6_as_localsid_t * ls_mem)
 103 {
 104   vec_free (ls_mem->rewrite);
 105   vec_free (ls_mem->sid_list);
 106   clib_mem_free (ls_mem);
 107 }
 108
 109
 110 /*****************************************/
 111 /* SRv6 LocalSID instantiation and removal functions */
 112 static int
 113 srv6_as_localsid_creation_fn (ip6_sr_localsid_t * localsid)
 114 {
 115   ip6_sr_main_t *srm = &sr_main;
 116   srv6_as_main_t *sm = &srv6_as_main;
 117   srv6_as_localsid_t *ls_mem = localsid->plugin_mem;
 118   u32 localsid_index = localsid - srm->localsids;
 119
 120   /* Step 1: Prepare xconnect adjacency for sending packets to the VNF */
 121
 122   /* Retrieve the adjacency corresponding to the (OIF, next_hop) */
 123   adj_index_t nh_adj_index = ADJ_INDEX_INVALID;
 124   if (ls_mem->inner_type != AS_TYPE_L2)
 125     {
 126       if (ls_mem->inner_type == AS_TYPE_IP4)
 127         nh_adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4,
 128                                             VNET_LINK_IP4, &ls_mem->nh_addr,
 129                                             ls_mem->sw_if_index_out);
 130       else if (ls_mem->inner_type == AS_TYPE_IP6)
 131         nh_adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP6,
 132                                             VNET_LINK_IP6, &ls_mem->nh_addr,
 133                                             ls_mem->sw_if_index_out);
 134       if (nh_adj_index == ADJ_INDEX_INVALID)
 135         {
 136           free_ls_mem (ls_mem);
 137           return SID_CREATE_INVALID_ADJ_INDEX;
 138         }
 139     }
 140
 141   ls_mem->nh_adj = nh_adj_index;
 142
 143
 144   /* Step 2: Prepare inbound policy for packets returning from the VNF */
 145
 146   /* Make sure the provided incoming interface index is valid */
 147   if (pool_is_free_index (sm->vnet_main->interface_main.sw_interfaces,
 148                           ls_mem->sw_if_index_in))
 149     {
 150       adj_unlock (ls_mem->nh_adj);
 151       free_ls_mem (ls_mem);
 152       return SID_CREATE_INVALID_IFACE_INDEX;
 153     }
 154
 155   /* Retrieve associated interface structure */
 156   vnet_sw_interface_t *sw = vnet_get_sw_interface (sm->vnet_main,
 157                                                    ls_mem->sw_if_index_in);
 158   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
 159     {
 160       adj_unlock (ls_mem->nh_adj);
 161       free_ls_mem (ls_mem);
 162       return SID_CREATE_INVALID_IFACE_TYPE;
 163     }
 164
 165   if (ls_mem->inner_type == AS_TYPE_L2)
 166     {
 167       /* Enable End.AS2 rewrite node for this interface */
 168       int ret =
 169         vnet_feature_enable_disable ("device-input", "srv6-as2-rewrite",
 170                                      ls_mem->sw_if_index_in, 1, 0, 0);
 171       if (ret != 0)
 172         {
 173           free_ls_mem (ls_mem);
 174           return SID_CREATE_IFACE_FEATURE_ERROR;
 175         }
 176
 177       /* Set interface in promiscuous mode */
 178       vnet_main_t *vnm = vnet_get_main ();
 179       ethernet_set_flags (vnm, ls_mem->sw_if_index_in,
 180                           ETHERNET_INTERFACE_FLAG_ACCEPT_ALL);
 181
 182       /* Prepare rewrite string */
 183       ls_mem->rewrite = prepare_rewrite (ls_mem->src_addr, ls_mem->sid_list,
 184                                          IP_PROTOCOL_IP6_NONXT);
 185
 186       /* Associate local SID index to this interface (resize vector if needed) */
 187       if (ls_mem->sw_if_index_in >= vec_len (sm->sw_iface_localsid2))
 188         {
 189           vec_resize (sm->sw_iface_localsid2,
 190                       (pool_len (sm->vnet_main->interface_main.sw_interfaces)
 191                        - vec_len (sm->sw_iface_localsid2)));
 192         }
 193       sm->sw_iface_localsid2[ls_mem->sw_if_index_in] = localsid_index;
 194     }
 195   else if (ls_mem->inner_type == AS_TYPE_IP4)
 196     {
 197       /* Enable End.AS4 rewrite node for this interface */
 198       int ret =
 199         vnet_feature_enable_disable ("ip4-unicast", "srv6-as4-rewrite",
 200                                      ls_mem->sw_if_index_in, 1, 0, 0);
 201       if (ret != 0)
 202         {
 203           adj_unlock (ls_mem->nh_adj);
 204           free_ls_mem (ls_mem);
 205           return SID_CREATE_IFACE_FEATURE_ERROR;
 206         }
 207
 208       /* Prepare rewrite string */
 209       ls_mem->rewrite = prepare_rewrite (ls_mem->src_addr, ls_mem->sid_list,
 210                                          IP_PROTOCOL_IP_IN_IP);
 211
 212       /* Associate local SID index to this interface (resize vector if needed) */
 213       if (ls_mem->sw_if_index_in >= vec_len (sm->sw_iface_localsid4))
 214         {
 215           vec_resize (sm->sw_iface_localsid4,
 216                       (pool_len (sm->vnet_main->interface_main.sw_interfaces)
 217                        - vec_len (sm->sw_iface_localsid4)));
 218         }
 219       sm->sw_iface_localsid4[ls_mem->sw_if_index_in] = localsid_index;
 220     }
 221   else if (ls_mem->inner_type == AS_TYPE_IP6)
 222     {
 223       /* Enable End.AS6 rewrite node for this interface */
 224       int ret =
 225         vnet_feature_enable_disable ("ip6-unicast", "srv6-as6-rewrite",
 226                                      ls_mem->sw_if_index_in, 1, 0, 0);
 227       if (ret != 0)
 228         {
 229           adj_unlock (ls_mem->nh_adj);
 230           free_ls_mem (ls_mem);
 231           return SID_CREATE_IFACE_FEATURE_ERROR;
 232         }
 233
 234       /* Prepare rewrite string */
 235       ls_mem->rewrite = prepare_rewrite (ls_mem->src_addr, ls_mem->sid_list,
 236                                          IP_PROTOCOL_IPV6);
 237
 238       /* Associate local SID index to this interface (resize vector if needed) */
 239       if (ls_mem->sw_if_index_in >= vec_len (sm->sw_iface_localsid6))
 240         {
 241           vec_resize (sm->sw_iface_localsid6,
 242                       (pool_len (sm->vnet_main->interface_main.sw_interfaces)
 243                        - vec_len (sm->sw_iface_localsid6)));
 244         }
 245       sm->sw_iface_localsid6[ls_mem->sw_if_index_in] = localsid_index;
 246     }
 247
 248   /* Step 3: Initialize rewrite counters */
 249   srv6_as_localsid_t **ls_p;
 250   pool_get (sm->sids, ls_p);
 251   *ls_p = ls_mem;
 252   ls_mem->index = ls_p - sm->sids;
 253
 254   vlib_validate_combined_counter (&(sm->valid_counters), ls_mem->index);
 255   vlib_validate_combined_counter (&(sm->invalid_counters), ls_mem->index);
 256
 257   vlib_zero_combined_counter (&(sm->valid_counters), ls_mem->index);
 258   vlib_zero_combined_counter (&(sm->invalid_counters), ls_mem->index);
 259
 260   return 0;
 261 }
 262
 263 static int
 264 srv6_as_localsid_removal_fn (ip6_sr_localsid_t * localsid)
 265 {
 266   srv6_as_main_t *sm = &srv6_as_main;
 267   srv6_as_localsid_t *ls_mem = localsid->plugin_mem;
 268
 269   if (ls_mem->inner_type == AS_TYPE_L2)
 270     {
 271       /* Disable End.AS2 rewrite node for this interface */
 272       int ret;
 273       ret = vnet_feature_enable_disable ("device-input", "srv6-as2-rewrite",
 274                                          ls_mem->sw_if_index_in, 0, 0, 0);
 275       if (ret != 0)
 276         return -1;
 277
 278       /* Disable promiscuous mode on the interface */
 279       vnet_main_t *vnm = vnet_get_main ();
 280       ethernet_set_flags (vnm, ls_mem->sw_if_index_in, 0);
 281
 282       /* Remove local SID index from interface table */
 283       sm->sw_iface_localsid2[ls_mem->sw_if_index_in] = ~(u32) 0;
 284     }
 285   else if (ls_mem->inner_type == AS_TYPE_IP4)
 286     {
 287       /* Disable End.AS4 rewrite node for this interface */
 288       int ret;
 289       ret = vnet_feature_enable_disable ("ip4-unicast", "srv6-as4-rewrite",
 290                                          ls_mem->sw_if_index_in, 0, 0, 0);
 291       if (ret != 0)
 292         return -1;
 293
 294       /* Remove local SID index from interface table */
 295       sm->sw_iface_localsid4[ls_mem->sw_if_index_in] = ~(u32) 0;
 296     }
 297   else if (ls_mem->inner_type == AS_TYPE_IP6)
 298     {
 299       /* Disable End.AS6 rewrite node for this interface */
 300       int ret;
 301       ret = vnet_feature_enable_disable ("ip6-unicast", "srv6-as6-rewrite",
 302                                          ls_mem->sw_if_index_in, 0, 0, 0);
 303       if (ret != 0)
 304         return -1;
 305
 306       /* Remove local SID index from interface table */
 307       sm->sw_iface_localsid6[ls_mem->sw_if_index_in] = ~(u32) 0;
 308     }
 309
 310
 311   /* Unlock (OIF, NHOP) adjacency (from sr_localsid.c:103) */
 312   adj_unlock (ls_mem->nh_adj);
 313
 314   /* Delete SID entry */
 315   pool_put (sm->sids, pool_elt_at_index (sm->sids, ls_mem->index));
 316
 317   /* Clean up local SID memory */
 318   free_ls_mem (ls_mem);
 319
 320   return 0;
 321 }
 322
 323 /**********************************/
 324 /* SRv6 LocalSID format functions */
 325 /*
 326  * Prints nicely the parameters of a localsid
 327  * Example: print "Table 5"
 328  */
 329 u8 *
 330 format_srv6_as_localsid (u8 * s, va_list * args)
 331 {
 332   srv6_as_localsid_t *ls_mem = va_arg (*args, void *);
 333
 334   vnet_main_t *vnm = vnet_get_main ();
 335   srv6_as_main_t *sm = &srv6_as_main;
 336
 337   if (ls_mem->inner_type == AS_TYPE_IP4)
 338     {
 339       s =
 340         format (s, "Next-hop:\t%U\n\t", format_ip4_address,
 341                 &ls_mem->nh_addr.ip4);
 342     }
 343   else if (ls_mem->inner_type == AS_TYPE_IP6)
 344     {
 345       s =
 346         format (s, "Next-hop:\t%U\n\t", format_ip6_address,
 347                 &ls_mem->nh_addr.ip6);
 348     }
 349
 350   s = format (s, "Outgoing iface:\t%U\n", format_vnet_sw_if_index_name, vnm,
 351               ls_mem->sw_if_index_out);
 352   s = format (s, "\tIncoming iface:\t%U\n", format_vnet_sw_if_index_name, vnm,
 353               ls_mem->sw_if_index_in);
 354   s = format (s, "\tSource address:\t%U\n", format_ip6_address,
 355               &ls_mem->src_addr);
 356
 357   s = format (s, "\tSegment list:\t< ");
 358   ip6_address_t *addr;
 359   vec_foreach (addr, ls_mem->sid_list)
 360   {
 361     s = format (s, "%U, ", format_ip6_address, addr);
 362   }
 363   s = format (s, "\b\b >\n");
 364
 365   vlib_counter_t valid, invalid;
 366   vlib_get_combined_counter (&(sm->valid_counters), ls_mem->index, &valid);
 367   vlib_get_combined_counter (&(sm->invalid_counters), ls_mem->index,
 368                              &invalid);
 369   s =
 370     format (s, "\tGood rewrite traffic: \t[%Ld packets : %Ld bytes]\n",
 371             valid.packets, valid.bytes);
 372   s =
 373     format (s, "\tBad rewrite traffic:  \t[%Ld packets : %Ld bytes]\n",
 374             invalid.packets, invalid.bytes);
 375
 376   return s;
 377 }
 378
 379 /*
 380  * Process the parameters of a localsid
 381  * Example: process from:
 382  * sr localsid address cafe::1 behavior new_srv6_localsid 5
 383  * everything from behavior on... so in this case 'new_srv6_localsid 5'
 384  * Notice that it MUST match the keyword_str and params_str defined above.
 385  */
 386 uword
 387 unformat_srv6_as_localsid (unformat_input_t * input, va_list * args)
 388 {
 389   void **plugin_mem_p = va_arg (*args, void **);
 390   srv6_as_localsid_t *ls_mem;
 391
 392   vnet_main_t *vnm = vnet_get_main ();
 393
 394   u8 inner_type = AS_TYPE_L2;
 395   ip46_address_t nh_addr;
 396   u32 sw_if_index_out;
 397   u32 sw_if_index_in;
 398   ip6_address_t src_addr;
 399   ip6_address_t next_sid;
 400   ip6_address_t *sid_list = NULL;
 401
 402   u8 params = 0;
 403 #define PARAM_AS_NH   (1 << 0)
 404 #define PARAM_AS_OIF  (1 << 1)
 405 #define PARAM_AS_IIF  (1 << 2)
 406 #define PARAM_AS_SRC  (1 << 3)
 407
 408   if (!unformat (input, "end.as"))
 409     return 0;
 410
 411   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 412     {
 413       if (!(params & PARAM_AS_NH) && unformat (input, "nh %U",
 414                                                unformat_ip4_address,
 415                                                &nh_addr.ip4))
 416         {
 417           inner_type = AS_TYPE_IP4;
 418           params |= PARAM_AS_NH;
 419         }
 420       if (!(params & PARAM_AS_NH) && unformat (input, "nh %U",
 421                                                unformat_ip6_address,
 422                                                &nh_addr.ip6))
 423         {
 424           inner_type = AS_TYPE_IP6;
 425           params |= PARAM_AS_NH;
 426         }
 427       else if (!(params & PARAM_AS_OIF) && unformat (input, "oif %U",
 428                                                      unformat_vnet_sw_interface,
 429                                                      vnm, &sw_if_index_out))
 430         {
 431           params |= PARAM_AS_OIF;
 432         }
 433       else if (!(params & PARAM_AS_IIF) && unformat (input, "iif %U",
 434                                                      unformat_vnet_sw_interface,
 435                                                      vnm, &sw_if_index_in))
 436         {
 437           params |= PARAM_AS_IIF;
 438         }
 439       else if (!(params & PARAM_AS_SRC) && unformat (input, "src %U",
 440                                                      unformat_ip6_address,
 441                                                      &src_addr))
 442         {
 443           params |= PARAM_AS_SRC;
 444         }
 445       else if (unformat (input, "next %U", unformat_ip6_address, &next_sid))
 446         {
 447           vec_add1 (sid_list, next_sid);
 448         }
 449       else
 450         {
 451           break;
 452         }
 453     }
 454
 455   /* Make sure that all parameters are supplied */
 456   u8 params_chk = (PARAM_AS_OIF | PARAM_AS_IIF | PARAM_AS_SRC);
 457   if ((params & params_chk) != params_chk || sid_list == NULL)
 458     {
 459       vec_free (sid_list);
 460       return 0;
 461     }
 462
 463   /* Allocate and initialize memory block for local SID parameters */
 464   ls_mem = clib_mem_alloc_aligned_at_offset (sizeof *ls_mem, 0, 0, 1);
 465   memset (ls_mem, 0, sizeof *ls_mem);
 466   *plugin_mem_p = ls_mem;
 467
 468   /* Set local SID parameters */
 469   ls_mem->inner_type = inner_type;
 470   if (inner_type == AS_TYPE_IP4)
 471     ls_mem->nh_addr.ip4 = nh_addr.ip4;
 472   else if (inner_type == AS_TYPE_IP6)
 473     ls_mem->nh_addr.ip6 = nh_addr.ip6;
 474   ls_mem->sw_if_index_out = sw_if_index_out;
 475   ls_mem->sw_if_index_in = sw_if_index_in;
 476   ls_mem->src_addr = src_addr;
 477   ls_mem->sid_list = sid_list;
 478
 479   return 1;
 480 }
 481
 482 /*************************/
 483 /* SRv6 LocalSID FIB DPO */
 484 static u8 *
 485 format_srv6_as_dpo (u8 * s, va_list * args)
 486 {
 487   index_t index = va_arg (*args, index_t);
 488   CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
 489
 490   return (format (s, "SR: static_proxy_index:[%u]", index));
 491 }
 492
 493 void
 494 srv6_as_dpo_lock (dpo_id_t * dpo)
 495 {
 496 }
 497
 498 void
 499 srv6_as_dpo_unlock (dpo_id_t * dpo)
 500 {
 501 }
 502
 503 const static dpo_vft_t srv6_as_vft = {
 504   .dv_lock = srv6_as_dpo_lock,
 505   .dv_unlock = srv6_as_dpo_unlock,
 506   .dv_format = format_srv6_as_dpo,
 507 };
 508
 509 const static char *const srv6_as_ip6_nodes[] = {
 510   "srv6-as-localsid",
 511   NULL,
 512 };
 513
 514 const static char *const *const srv6_as_nodes[DPO_PROTO_NUM] = {
 515   [DPO_PROTO_IP6] = srv6_as_ip6_nodes,
 516 };
 517
 518 /**********************/
 519 static clib_error_t *
 520 srv6_as_init (vlib_main_t * vm)
 521 {
 522   srv6_as_main_t *sm = &srv6_as_main;
 523   int rv = 0;
 524
 525   sm->vlib_main = vm;
 526   sm->vnet_main = vnet_get_main ();
 527
 528   /* Create DPO */
 529   sm->srv6_as_dpo_type = dpo_register_new_type (&srv6_as_vft, srv6_as_nodes);
 530
 531   /* Register SRv6 LocalSID */
 532   rv = sr_localsid_register_function (vm,
 533                                       function_name,
 534                                       keyword_str,
 535                                       def_str,
 536                                       params_str,
 537                                       &sm->srv6_as_dpo_type,
 538                                       format_srv6_as_localsid,
 539                                       unformat_srv6_as_localsid,
 540                                       srv6_as_localsid_creation_fn,
 541                                       srv6_as_localsid_removal_fn);
 542   if (rv < 0)
 543     clib_error_return (0, "SRv6 LocalSID function could not be registered.");
 544   else
 545     sm->srv6_localsid_behavior_id = rv;
 546
 547   return 0;
 548 }
 549
 550 /* *INDENT-OFF* */
 551 VNET_FEATURE_INIT (srv6_as2_rewrite, static) =
 552 {
 553   .arc_name = "device-input",
 554   .node_name = "srv6-as2-rewrite",
 555   .runs_before = VNET_FEATURES ("ethernet-input"),
 556 };
 557
 558 VNET_FEATURE_INIT (srv6_as4_rewrite, static) =
 559 {
 560   .arc_name = "ip4-unicast",
 561   .node_name = "srv6-as4-rewrite",
 562   .runs_before = 0,
 563 };
 564
 565 VNET_FEATURE_INIT (srv6_as6_rewrite, static) =
 566 {
 567   .arc_name = "ip6-unicast",
 568   .node_name = "srv6-as6-rewrite",
 569   .runs_before = 0,
 570 };
 571
 572 VLIB_INIT_FUNCTION (srv6_as_init);
 573
 574 VLIB_PLUGIN_REGISTER () = {
 575   .version = VPP_BUILD_VER,
 576   .description = "Static SRv6 proxy",
 577 };
 578 /* *INDENT-ON* */
 579
 580 /*
 581 * fd.io coding-style-patch-verification: ON
 582 *
 583 * Local Variables:
 584 * eval: (c-set-style "gnu")
 585 * End:
 586 */