src/plugins/srv6-ad/node.c

   1 /*
   2  * node.c
   3  *
   4  * Copyright (c) 2015 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vnet/vnet.h>
  20 #include <vppinfra/error.h>
  21 #include <srv6-ad/ad.h>
  22
  23
  24 /******************************* Packet tracing *******************************/
  25
  26 typedef struct
  27 {
  28   u32 localsid_index;
  29 } srv6_ad_localsid_trace_t;
  30
  31 typedef struct
  32 {
  33   u8 error;
  34   ip6_address_t src, dst;
  35 } srv6_ad_rewrite_trace_t;
  36
  37 static u8 *
  38 format_srv6_ad_localsid_trace (u8 * s, va_list * args)
  39 {
  40   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  41   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  42   srv6_ad_localsid_trace_t *t = va_arg (*args, srv6_ad_localsid_trace_t *);
  43
  44   return format (s, "SRv6-AD-localsid: localsid_index %d", t->localsid_index);
  45 }
  46
  47 static u8 *
  48 format_srv6_ad_rewrite_trace (u8 * s, va_list * args)
  49 {
  50   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  51   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  52   srv6_ad_rewrite_trace_t *t = va_arg (*args, srv6_ad_rewrite_trace_t *);
  53
  54   if (PREDICT_FALSE (t->error != 0))
  55     {
  56       return format (s, "SRv6-AD-rewrite: cache is empty");
  57     }
  58
  59   return format (s, "SRv6-AD-rewrite: src %U dst %U",
  60                  format_ip6_address, &t->src, format_ip6_address, &t->dst);
  61 }
  62
  63
  64 /***************************** Nodes registration *****************************/
  65
  66 vlib_node_registration_t srv6_ad4_rewrite_node;
  67 vlib_node_registration_t srv6_ad6_rewrite_node;
  68
  69
  70 /****************************** Packet counters *******************************/
  71
  72 #define foreach_srv6_ad_rewrite_counter \
  73 _(PROCESSED, "srv6-ad rewritten packets") \
  74 _(NO_RW, "(Error) No header for rewriting.")
  75
  76 typedef enum
  77 {
  78 #define _(sym,str) SRV6_AD_REWRITE_COUNTER_##sym,
  79   foreach_srv6_ad_rewrite_counter
  80 #undef _
  81     SRV6_AD_REWRITE_N_COUNTERS,
  82 } srv6_ad_rewrite_counters;
  83
  84 static char *srv6_ad_rewrite_counter_strings[] = {
  85 #define _(sym,string) string,
  86   foreach_srv6_ad_rewrite_counter
  87 #undef _
  88 };
  89
  90
  91 /********************************* Next nodes *********************************/
  92
  93 typedef enum
  94 {
  95   SRV6_AD_LOCALSID_NEXT_ERROR,
  96   SRV6_AD_LOCALSID_NEXT_REWRITE4,
  97   SRV6_AD_LOCALSID_NEXT_REWRITE6,
  98   SRV6_AD_LOCALSID_NEXT_INTERFACE,
  99   SRV6_AD_LOCALSID_N_NEXT,
 100 } srv6_ad_localsid_next_t;
 101
 102 typedef enum
 103 {
 104   SRV6_AD_REWRITE_NEXT_ERROR,
 105   SRV6_AD_REWRITE_NEXT_LOOKUP,
 106   SRV6_AD_REWRITE_N_NEXT,
 107 } srv6_ad_rewrite_next_t;
 108
 109
 110 /******************************* Local SID node *******************************/
 111
 112 /**
 113  * @brief Function doing SRH processing for AD behavior
 114  */
 115 static_always_inline void
 116 end_ad_processing (vlib_buffer_t * b0,
 117                    ip6_header_t * ip0,
 118                    ip6_sr_header_t * sr0,
 119                    ip6_sr_localsid_t * ls0, u32 * next0)
 120 {
 121   ip6_address_t *new_dst0;
 122   u16 total_size;
 123   ip6_ext_header_t *next_ext_header;
 124   u8 next_hdr;
 125   srv6_ad_localsid_t *ls0_mem;
 126
 127   if (PREDICT_FALSE (ip0->protocol != IP_PROTOCOL_IPV6_ROUTE ||
 128                      sr0->type != ROUTING_HEADER_TYPE_SR))
 129     {
 130       return;
 131     }
 132
 133   if (PREDICT_FALSE (sr0->segments_left == 0))
 134     {
 135       return;
 136     }
 137
 138   /* Decrement Segments Left and update Destination Address */
 139   sr0->segments_left -= 1;
 140   new_dst0 = (ip6_address_t *) (sr0->segments) + sr0->segments_left;
 141   ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
 142   ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
 143
 144   /* Compute the total size of the IPv6 header and extensions */
 145   total_size = sizeof (ip6_header_t);
 146   next_ext_header = (ip6_ext_header_t *) (ip0 + 1);
 147   next_hdr = ip0->protocol;
 148
 149   while (ip6_ext_hdr (next_hdr))
 150     {
 151       total_size += ip6_ext_header_len (next_ext_header);
 152       next_hdr = next_ext_header->next_hdr;
 153       next_ext_header = ip6_ext_next_header (next_ext_header);
 154     }
 155
 156   /* Make sure next header is valid */
 157   if (PREDICT_FALSE (next_hdr != IP_PROTOCOL_IPV6 &&
 158                      next_hdr != IP_PROTOCOL_IP_IN_IP &&
 159                      next_hdr != IP_PROTOCOL_IP6_NONXT))
 160     {
 161       return;
 162     }
 163
 164   /* Retrieve SID memory */
 165   ls0_mem = ls0->plugin_mem;
 166
 167   /* Cache IP header and extensions */
 168   if (PREDICT_FALSE (total_size > ls0_mem->rw_len))
 169     {
 170       vec_validate (ls0_mem->rewrite, total_size - 1);
 171     }
 172   clib_memcpy_fast (ls0_mem->rewrite, ip0, total_size);
 173   ls0_mem->rw_len = total_size;
 174
 175   /* Remove IP header and extensions */
 176   vlib_buffer_advance (b0, total_size);
 177
 178   if (next_hdr == IP_PROTOCOL_IP6_NONXT)
 179     {
 180       /* Set output interface */
 181       vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0_mem->sw_if_index_out;
 182
 183       /* Set next node to interface-output */
 184       *next0 = SRV6_AD_LOCALSID_NEXT_INTERFACE;
 185     }
 186   else
 187     {
 188       /* Set Xconnect adjacency to VNF */
 189       vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0_mem->nh_adj;
 190
 191       /* Set next node to ip-rewrite */
 192       *next0 = (next_hdr == IP_PROTOCOL_IPV6) ?
 193         SRV6_AD_LOCALSID_NEXT_REWRITE6 : SRV6_AD_LOCALSID_NEXT_REWRITE4;
 194     }
 195 }
 196
 197 /**
 198  * @brief SRv6 AD Localsid graph node
 199  */
 200 static uword
 201 srv6_ad_localsid_fn (vlib_main_t * vm,
 202                      vlib_node_runtime_t * node, vlib_frame_t * frame)
 203 {
 204   ip6_sr_main_t *sm = &sr_main;
 205   u32 n_left_from, next_index, *from, *to_next;
 206   u32 cnt_packets = 0;
 207
 208   from = vlib_frame_vector_args (frame);
 209   n_left_from = frame->n_vectors;
 210   next_index = node->cached_next_index;
 211
 212   while (n_left_from > 0)
 213     {
 214       u32 n_left_to_next;
 215
 216       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 217
 218       /* TODO: Dual/quad loop */
 219
 220       while (n_left_from > 0 && n_left_to_next > 0)
 221         {
 222           u32 bi0;
 223           vlib_buffer_t *b0;
 224           ip6_header_t *ip0 = 0;
 225           ip6_sr_header_t *sr0;
 226           ip6_sr_localsid_t *ls0;
 227           u32 next0 = SRV6_AD_LOCALSID_NEXT_ERROR;
 228
 229           bi0 = from[0];
 230           to_next[0] = bi0;
 231           from += 1;
 232           to_next += 1;
 233           n_left_from -= 1;
 234           n_left_to_next -= 1;
 235
 236           b0 = vlib_get_buffer (vm, bi0);
 237           ip0 = vlib_buffer_get_current (b0);
 238           sr0 = (ip6_sr_header_t *) (ip0 + 1);
 239
 240           /* Lookup the SR End behavior based on IP DA (adj) */
 241           ls0 = pool_elt_at_index (sm->localsids,
 242                                    vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
 243
 244           /* SRH processing */
 245           end_ad_processing (b0, ip0, sr0, ls0, &next0);
 246
 247           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 248             {
 249               srv6_ad_localsid_trace_t *tr =
 250                 vlib_add_trace (vm, node, b0, sizeof *tr);
 251               tr->localsid_index = ls0 - sm->localsids;
 252             }
 253
 254           /* This increments the SRv6 per LocalSID counters. */
 255           vlib_increment_combined_counter (((next0 ==
 256                                              SRV6_AD_LOCALSID_NEXT_ERROR) ?
 257                                             &(sm->sr_ls_invalid_counters) :
 258                                             &(sm->sr_ls_valid_counters)),
 259                                            vm->thread_index,
 260                                            ls0 - sm->localsids, 1,
 261                                            vlib_buffer_length_in_chain (vm,
 262                                                                         b0));
 263
 264           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 265                                            n_left_to_next, bi0, next0);
 266
 267           cnt_packets++;
 268         }
 269
 270       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 271     }
 272
 273   return frame->n_vectors;
 274 }
 275
 276 /* *INDENT-OFF* */
 277 VLIB_REGISTER_NODE (srv6_ad_localsid_node) = {
 278   .function = srv6_ad_localsid_fn,
 279   .name = "srv6-ad-localsid",
 280   .vector_size = sizeof (u32),
 281   .format_trace = format_srv6_ad_localsid_trace,
 282   .type = VLIB_NODE_TYPE_INTERNAL,
 283   .n_next_nodes = SRV6_AD_LOCALSID_N_NEXT,
 284   .next_nodes = {
 285     [SRV6_AD_LOCALSID_NEXT_REWRITE4] = "ip4-rewrite",
 286     [SRV6_AD_LOCALSID_NEXT_REWRITE6] = "ip6-rewrite",
 287     [SRV6_AD_LOCALSID_NEXT_INTERFACE] = "interface-output",
 288     [SRV6_AD_LOCALSID_NEXT_ERROR] = "error-drop",
 289   },
 290 };
 291 /* *INDENT-ON* */
 292
 293
 294 /******************************* Rewriting node *******************************/
 295
 296 /**
 297  * @brief Graph node for applying a SR policy into an IPv6 packet. Encapsulation
 298  */
 299 static uword
 300 srv6_ad2_rewrite_fn (vlib_main_t * vm,
 301                      vlib_node_runtime_t * node, vlib_frame_t * frame)
 302 {
 303   ip6_sr_main_t *srm = &sr_main;
 304   srv6_ad_main_t *sm = &srv6_ad_main;
 305   u32 n_left_from, next_index, *from, *to_next;
 306   u32 cnt_packets = 0;
 307
 308   from = vlib_frame_vector_args (frame);
 309   n_left_from = frame->n_vectors;
 310   next_index = node->cached_next_index;
 311
 312   while (n_left_from > 0)
 313     {
 314       u32 n_left_to_next;
 315
 316       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 317
 318       /* TODO: Dual/quad loop */
 319
 320       while (n_left_from > 0 && n_left_to_next > 0)
 321         {
 322           u32 bi0;
 323           vlib_buffer_t *b0;
 324           ethernet_header_t *en0;
 325           ip6_header_t *ip0 = 0;
 326           ip6_sr_localsid_t *ls0;
 327           srv6_ad_localsid_t *ls0_mem;
 328           u32 next0 = SRV6_AD_REWRITE_NEXT_LOOKUP;
 329
 330           bi0 = from[0];
 331           to_next[0] = bi0;
 332           from += 1;
 333           to_next += 1;
 334           n_left_from -= 1;
 335           n_left_to_next -= 1;
 336
 337           b0 = vlib_get_buffer (vm, bi0);
 338           en0 = vlib_buffer_get_current (b0);
 339           ls0 = pool_elt_at_index (srm->localsids,
 340                                    sm->sw_iface_localsid2[vnet_buffer
 341                                                           (b0)->sw_if_index
 342                                                           [VLIB_RX]]);
 343           ls0_mem = ls0->plugin_mem;
 344
 345           if (PREDICT_FALSE (ls0_mem == NULL || ls0_mem->rewrite == NULL))
 346             {
 347               next0 = SRV6_AD_REWRITE_NEXT_ERROR;
 348               b0->error = node->errors[SRV6_AD_REWRITE_COUNTER_NO_RW];
 349             }
 350           else
 351             {
 352               ASSERT (VLIB_BUFFER_PRE_DATA_SIZE >=
 353                       (ls0_mem->rw_len + b0->current_data));
 354
 355               clib_memcpy_fast (((u8 *) en0) - ls0_mem->rw_len,
 356                                 ls0_mem->rewrite, ls0_mem->rw_len);
 357               vlib_buffer_advance (b0, -(word) ls0_mem->rw_len);
 358
 359               ip0 = vlib_buffer_get_current (b0);
 360
 361               ip0->payload_length =
 362                 clib_host_to_net_u16 (b0->current_length -
 363                                       sizeof (ip6_header_t));
 364             }
 365
 366           if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
 367               PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 368             {
 369               srv6_ad_rewrite_trace_t *tr =
 370                 vlib_add_trace (vm, node, b0, sizeof *tr);
 371               tr->error = 0;
 372
 373               if (next0 == SRV6_AD_REWRITE_NEXT_ERROR)
 374                 {
 375                   tr->error = 1;
 376                 }
 377               else
 378                 {
 379                   clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
 380                                     sizeof tr->src.as_u8);
 381                   clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
 382                                     sizeof tr->dst.as_u8);
 383                 }
 384             }
 385
 386           /* Increment per-SID AD rewrite counters */
 387           vlib_increment_combined_counter (((next0 ==
 388                                              SRV6_AD_LOCALSID_NEXT_ERROR) ?
 389                                             &(sm->invalid_counters) :
 390                                             &(sm->valid_counters)),
 391                                            vm->thread_index, ls0_mem->index,
 392                                            1, vlib_buffer_length_in_chain (vm,
 393                                                                            b0));
 394
 395           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 396                                            n_left_to_next, bi0, next0);
 397
 398           cnt_packets++;
 399         }
 400
 401       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 402     }
 403
 404   /* Update counters */
 405   vlib_node_increment_counter (vm, srv6_ad4_rewrite_node.index,
 406                                SRV6_AD_REWRITE_COUNTER_PROCESSED,
 407                                cnt_packets);
 408
 409   return frame->n_vectors;
 410 }
 411
 412 /* *INDENT-OFF* */
 413 VLIB_REGISTER_NODE (srv6_ad2_rewrite_node) = {
 414   .function = srv6_ad2_rewrite_fn,
 415   .name = "srv6-ad2-rewrite",
 416   .vector_size = sizeof (u32),
 417   .format_trace = format_srv6_ad_rewrite_trace,
 418   .type = VLIB_NODE_TYPE_INTERNAL,
 419   .n_errors = SRV6_AD_REWRITE_N_COUNTERS,
 420   .error_strings = srv6_ad_rewrite_counter_strings,
 421   .n_next_nodes = SRV6_AD_REWRITE_N_NEXT,
 422   .next_nodes = {
 423     [SRV6_AD_REWRITE_NEXT_LOOKUP] = "ip6-lookup",
 424     [SRV6_AD_REWRITE_NEXT_ERROR] = "error-drop",
 425   },
 426 };
 427 /* *INDENT-ON* */
 428
 429
 430 /**
 431  * @brief Graph node for applying a SR policy into an IPv6 packet. Encapsulation
 432  */
 433 static uword
 434 srv6_ad4_rewrite_fn (vlib_main_t * vm,
 435                      vlib_node_runtime_t * node, vlib_frame_t * frame)
 436 {
 437   ip6_sr_main_t *srm = &sr_main;
 438   srv6_ad_main_t *sm = &srv6_ad_main;
 439   u32 n_left_from, next_index, *from, *to_next;
 440   u32 cnt_packets = 0;
 441
 442   from = vlib_frame_vector_args (frame);
 443   n_left_from = frame->n_vectors;
 444   next_index = node->cached_next_index;
 445
 446   while (n_left_from > 0)
 447     {
 448       u32 n_left_to_next;
 449
 450       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 451
 452       /* TODO: Dual/quad loop */
 453
 454       while (n_left_from > 0 && n_left_to_next > 0)
 455         {
 456           u32 bi0;
 457           vlib_buffer_t *b0;
 458           ip4_header_t *ip0_encap = 0;
 459           ip6_header_t *ip0 = 0;
 460           ip6_sr_localsid_t *ls0;
 461           srv6_ad_localsid_t *ls0_mem;
 462           u32 next0 = SRV6_AD_REWRITE_NEXT_LOOKUP;
 463           u16 new_l0 = 0;
 464
 465           bi0 = from[0];
 466           to_next[0] = bi0;
 467           from += 1;
 468           to_next += 1;
 469           n_left_from -= 1;
 470           n_left_to_next -= 1;
 471
 472           b0 = vlib_get_buffer (vm, bi0);
 473           ip0_encap = vlib_buffer_get_current (b0);
 474           ls0 = pool_elt_at_index (srm->localsids,
 475                                    sm->sw_iface_localsid4[vnet_buffer
 476                                                           (b0)->sw_if_index
 477                                                           [VLIB_RX]]);
 478           ls0_mem = ls0->plugin_mem;
 479
 480           if (PREDICT_FALSE (ls0_mem == NULL || ls0_mem->rewrite == NULL))
 481             {
 482               next0 = SRV6_AD_REWRITE_NEXT_ERROR;
 483               b0->error = node->errors[SRV6_AD_REWRITE_COUNTER_NO_RW];
 484             }
 485           else
 486             {
 487               ASSERT (VLIB_BUFFER_PRE_DATA_SIZE >=
 488                       (ls0_mem->rw_len + b0->current_data));
 489
 490               clib_memcpy_fast (((u8 *) ip0_encap) - ls0_mem->rw_len,
 491                                 ls0_mem->rewrite, ls0_mem->rw_len);
 492               vlib_buffer_advance (b0, -(word) ls0_mem->rw_len);
 493
 494               ip0 = vlib_buffer_get_current (b0);
 495
 496               /* Update inner IPv4 TTL and checksum */
 497               u32 checksum0;
 498               ip0_encap->ttl -= 1;
 499               checksum0 = ip0_encap->checksum + clib_host_to_net_u16 (0x0100);
 500               checksum0 += checksum0 >= 0xffff;
 501               ip0_encap->checksum = checksum0;
 502
 503               /* Update outer IPv6 length (in case it has changed) */
 504               new_l0 = ls0_mem->rw_len - sizeof (ip6_header_t) +
 505                 clib_net_to_host_u16 (ip0_encap->length);
 506               ip0->payload_length = clib_host_to_net_u16 (new_l0);
 507             }
 508
 509           if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
 510               PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 511             {
 512               srv6_ad_rewrite_trace_t *tr =
 513                 vlib_add_trace (vm, node, b0, sizeof *tr);
 514               tr->error = 0;
 515
 516               if (next0 == SRV6_AD_REWRITE_NEXT_ERROR)
 517                 {
 518                   tr->error = 1;
 519                 }
 520               else
 521                 {
 522                   clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
 523                                     sizeof tr->src.as_u8);
 524                   clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
 525                                     sizeof tr->dst.as_u8);
 526                 }
 527             }
 528
 529           /* Increment per-SID AD rewrite counters */
 530           vlib_increment_combined_counter (((next0 ==
 531                                              SRV6_AD_LOCALSID_NEXT_ERROR) ?
 532                                             &(sm->invalid_counters) :
 533                                             &(sm->valid_counters)),
 534                                            vm->thread_index, ls0_mem->index,
 535                                            1, vlib_buffer_length_in_chain (vm,
 536                                                                            b0));
 537
 538           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 539                                            n_left_to_next, bi0, next0);
 540
 541           cnt_packets++;
 542         }
 543
 544       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 545     }
 546
 547   /* Update counters */
 548   vlib_node_increment_counter (vm, srv6_ad4_rewrite_node.index,
 549                                SRV6_AD_REWRITE_COUNTER_PROCESSED,
 550                                cnt_packets);
 551
 552   return frame->n_vectors;
 553 }
 554
 555 /* *INDENT-OFF* */
 556 VLIB_REGISTER_NODE (srv6_ad4_rewrite_node) = {
 557   .function = srv6_ad4_rewrite_fn,
 558   .name = "srv6-ad4-rewrite",
 559   .vector_size = sizeof (u32),
 560   .format_trace = format_srv6_ad_rewrite_trace,
 561   .type = VLIB_NODE_TYPE_INTERNAL,
 562   .n_errors = SRV6_AD_REWRITE_N_COUNTERS,
 563   .error_strings = srv6_ad_rewrite_counter_strings,
 564   .n_next_nodes = SRV6_AD_REWRITE_N_NEXT,
 565   .next_nodes = {
 566       [SRV6_AD_REWRITE_NEXT_LOOKUP] = "ip6-lookup",
 567       [SRV6_AD_REWRITE_NEXT_ERROR] = "error-drop",
 568   },
 569 };
 570 /* *INDENT-ON* */
 571
 572
 573 /**
 574  * @brief Graph node for applying a SR policy into an IPv6 packet. Encapsulation
 575  */
 576 static uword
 577 srv6_ad6_rewrite_fn (vlib_main_t * vm,
 578                      vlib_node_runtime_t * node, vlib_frame_t * frame)
 579 {
 580   ip6_sr_main_t *srm = &sr_main;
 581   srv6_ad_main_t *sm = &srv6_ad_main;
 582   u32 n_left_from, next_index, *from, *to_next;
 583   u32 cnt_packets = 0;
 584
 585   from = vlib_frame_vector_args (frame);
 586   n_left_from = frame->n_vectors;
 587   next_index = node->cached_next_index;
 588
 589   while (n_left_from > 0)
 590     {
 591       u32 n_left_to_next;
 592
 593       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 594
 595       /* TODO: Dual/quad loop */
 596
 597       while (n_left_from > 0 && n_left_to_next > 0)
 598         {
 599           u32 bi0;
 600           vlib_buffer_t *b0;
 601           ip6_header_t *ip0 = 0, *ip0_encap = 0;
 602           ip6_sr_localsid_t *ls0;
 603           srv6_ad_localsid_t *ls0_mem;
 604           u32 next0 = SRV6_AD_REWRITE_NEXT_LOOKUP;
 605           u16 new_l0 = 0;
 606
 607           bi0 = from[0];
 608           to_next[0] = bi0;
 609           from += 1;
 610           to_next += 1;
 611           n_left_from -= 1;
 612           n_left_to_next -= 1;
 613
 614           b0 = vlib_get_buffer (vm, bi0);
 615           ip0_encap = vlib_buffer_get_current (b0);
 616           ls0 = pool_elt_at_index (srm->localsids,
 617                                    sm->sw_iface_localsid6[vnet_buffer
 618                                                           (b0)->sw_if_index
 619                                                           [VLIB_RX]]);
 620           ls0_mem = ls0->plugin_mem;
 621
 622           if (PREDICT_FALSE (ls0_mem == NULL || ls0_mem->rewrite == NULL))
 623             {
 624               next0 = SRV6_AD_REWRITE_NEXT_ERROR;
 625               b0->error = node->errors[SRV6_AD_REWRITE_COUNTER_NO_RW];
 626             }
 627           else
 628             {
 629               ASSERT (VLIB_BUFFER_PRE_DATA_SIZE >=
 630                       (ls0_mem->rw_len + b0->current_data));
 631
 632               clib_memcpy_fast (((u8 *) ip0_encap) - ls0_mem->rw_len,
 633                                 ls0_mem->rewrite, ls0_mem->rw_len);
 634               vlib_buffer_advance (b0, -(word) ls0_mem->rw_len);
 635
 636               ip0 = vlib_buffer_get_current (b0);
 637
 638               /* Update inner IPv6 hop limit */
 639               ip0_encap->hop_limit -= 1;
 640
 641               /* Update outer IPv6 length (in case it has changed) */
 642               new_l0 = ls0_mem->rw_len +
 643                 clib_net_to_host_u16 (ip0_encap->payload_length);
 644               ip0->payload_length = clib_host_to_net_u16 (new_l0);
 645             }
 646
 647           if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
 648               PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 649             {
 650               srv6_ad_rewrite_trace_t *tr =
 651                 vlib_add_trace (vm, node, b0, sizeof *tr);
 652               tr->error = 0;
 653
 654               if (next0 == SRV6_AD_REWRITE_NEXT_ERROR)
 655                 {
 656                   tr->error = 1;
 657                 }
 658               else
 659                 {
 660                   clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
 661                                     sizeof tr->src.as_u8);
 662                   clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
 663                                     sizeof tr->dst.as_u8);
 664                 }
 665             }
 666
 667           /* Increment per-SID AD rewrite counters */
 668           vlib_increment_combined_counter (((next0 ==
 669                                              SRV6_AD_LOCALSID_NEXT_ERROR) ?
 670                                             &(sm->invalid_counters) :
 671                                             &(sm->valid_counters)),
 672                                            vm->thread_index, ls0_mem->index,
 673                                            1, vlib_buffer_length_in_chain (vm,
 674                                                                            b0));
 675
 676           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 677                                            n_left_to_next, bi0, next0);
 678
 679           cnt_packets++;
 680         }
 681
 682       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 683     }
 684
 685   /* Update counters */
 686   vlib_node_increment_counter (vm, srv6_ad6_rewrite_node.index,
 687                                SRV6_AD_REWRITE_COUNTER_PROCESSED,
 688                                cnt_packets);
 689
 690   return frame->n_vectors;
 691 }
 692
 693 /* *INDENT-OFF* */
 694 VLIB_REGISTER_NODE (srv6_ad6_rewrite_node) = {
 695   .function = srv6_ad6_rewrite_fn,
 696   .name = "srv6-ad6-rewrite",
 697   .vector_size = sizeof (u32),
 698   .format_trace = format_srv6_ad_rewrite_trace,
 699   .type = VLIB_NODE_TYPE_INTERNAL,
 700   .n_errors = SRV6_AD_REWRITE_N_COUNTERS,
 701   .error_strings = srv6_ad_rewrite_counter_strings,
 702   .n_next_nodes = SRV6_AD_REWRITE_N_NEXT,
 703   .next_nodes = {
 704       [SRV6_AD_REWRITE_NEXT_LOOKUP] = "ip6-lookup",
 705       [SRV6_AD_REWRITE_NEXT_ERROR] = "error-drop",
 706   },
 707 };
 708 /* *INDENT-ON* */
 709
 710 /*
 711  * fd.io coding-style-patch-verification: ON
 712  *
 713  * Local Variables:
 714  * eval: (c-set-style "gnu")
 715  * End:
 716 */