vnet/vnet/ip/icmp6.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  * ip/icmp6.c: ip6 icmp
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vlib/vlib.h>
  41 #include <vnet/ip/ip.h>
  42 #include <vnet/pg/pg.h>
  43
  44 static u8 * format_ip6_icmp_type_and_code (u8 * s, va_list * args)
  45 {
  46   icmp6_type_t type = va_arg (*args, int);
  47   u8 code = va_arg (*args, int);
  48   char * t = 0;
  49
  50 #define _(n,f) case n: t = #f; break;
  51
  52   switch (type)
  53     {
  54       foreach_icmp6_type;
  55
  56     default:
  57       break;
  58     }
  59
  60 #undef _
  61
  62   if (! t)
  63     return format (s, "unknown 0x%x", type);
  64
  65   s = format (s, "%s", t);
  66
  67   t = 0;
  68   switch ((type << 8) | code)
  69     {
  70 #define _(a,n,f) case (ICMP6_##a << 8) | (n): t = #f; break;
  71
  72       foreach_icmp6_code;
  73
  74 #undef _
  75     }
  76
  77   if (t)
  78     s = format (s, " %s", t);
  79
  80   return s;
  81 }
  82
  83 static u8 * format_icmp6_header (u8 * s, va_list * args)
  84 {
  85   icmp46_header_t * icmp = va_arg (*args, icmp46_header_t *);
  86   u32 max_header_bytes = va_arg (*args, u32);
  87
  88   /* Nothing to do. */
  89   if (max_header_bytes < sizeof (icmp[0]))
  90     return format (s, "ICMP header truncated");
  91
  92   s = format (s, "ICMP %U checksum 0x%x",
  93               format_ip6_icmp_type_and_code, icmp->type, icmp->code,
  94               clib_net_to_host_u16 (icmp->checksum));
  95
  96   if (max_header_bytes >=
  97       sizeof(icmp6_neighbor_solicitation_or_advertisement_header_t) &&
  98       (icmp->type == ICMP6_neighbor_solicitation ||
  99        icmp->type == ICMP6_neighbor_advertisement))
 100    {
 101      icmp6_neighbor_solicitation_or_advertisement_header_t *icmp6_nd =
 102          (icmp6_neighbor_solicitation_or_advertisement_header_t *) icmp;
 103      s = format (s, "\n    target address %U",
 104                  format_ip6_address, &icmp6_nd->target_address);
 105    }
 106
 107   return s;
 108 }
 109
 110 u8 * format_icmp6_input_trace (u8 * s, va_list * va)
 111 {
 112   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
 113   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 114   icmp6_input_trace_t * t = va_arg (*va, icmp6_input_trace_t *);
 115
 116   s = format (s, "%U",
 117               format_ip6_header,
 118               t->packet_data, sizeof (t->packet_data));
 119
 120   return s;
 121 }
 122
 123 static char * icmp_error_strings[] = {
 124 #define _(f,s) s,
 125   foreach_icmp6_error
 126 #undef _
 127 };
 128
 129 typedef enum {
 130   ICMP_INPUT_NEXT_DROP,
 131   ICMP_INPUT_N_NEXT,
 132 } icmp_input_next_t;
 133
 134 typedef struct {
 135   uword * type_and_code_by_name;
 136
 137   uword * type_by_name;
 138
 139   /* Vector dispatch table indexed by [icmp type]. */
 140   u8 input_next_index_by_type[256];
 141
 142   /* Max valid code indexed by icmp type. */
 143   u8 max_valid_code_by_type[256];
 144
 145   /* hop_limit must be >= this value for this icmp type. */
 146   u8 min_valid_hop_limit_by_type[256];
 147
 148   u8 min_valid_length_by_type[256];
 149 } icmp6_main_t;
 150
 151 icmp6_main_t icmp6_main;
 152
 153 static uword
 154 ip6_icmp_input (vlib_main_t * vm,
 155                 vlib_node_runtime_t * node,
 156                 vlib_frame_t * frame)
 157 {
 158   icmp6_main_t * im = &icmp6_main;
 159   u32 * from, * to_next;
 160   u32 n_left_from, n_left_to_next, next_index;
 161
 162   from = vlib_frame_vector_args (frame);
 163   n_left_from = frame->n_vectors;
 164   next_index = node->cached_next_index;
 165
 166   if (node->flags & VLIB_NODE_FLAG_TRACE)
 167     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 168                                    /* stride */ 1,
 169                                    sizeof (icmp6_input_trace_t));
 170
 171   while (n_left_from > 0)
 172     {
 173       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 174
 175       while (n_left_from > 0 && n_left_to_next > 0)
 176         {
 177           vlib_buffer_t * b0;
 178           ip6_header_t * ip0;
 179           icmp46_header_t * icmp0;
 180           icmp6_type_t type0;
 181           u32 bi0, next0, error0, len0;
 182
 183           bi0 = to_next[0] = from[0];
 184
 185           from += 1;
 186           n_left_from -= 1;
 187           to_next += 1;
 188           n_left_to_next -= 1;
 189
 190           b0 = vlib_get_buffer (vm, bi0);
 191           ip0 = vlib_buffer_get_current (b0);
 192           icmp0 = ip6_next_header (ip0);
 193           type0 = icmp0->type;
 194
 195           error0 = ICMP6_ERROR_NONE;
 196
 197           next0 = im->input_next_index_by_type[type0];
 198           error0 = next0 == ICMP_INPUT_NEXT_DROP ? ICMP6_ERROR_UNKNOWN_TYPE : error0;
 199
 200           /* Check code is valid for type. */
 201           error0 = icmp0->code > im->max_valid_code_by_type[type0] ? ICMP6_ERROR_INVALID_CODE_FOR_TYPE : error0;
 202
 203           /* Checksum is already validated by ip6_local node so we don't need to check that. */
 204
 205           /* Check that hop limit == 255 for certain types. */
 206           error0 = ip0->hop_limit < im->min_valid_hop_limit_by_type[type0] ? ICMP6_ERROR_INVALID_HOP_LIMIT_FOR_TYPE : error0;
 207
 208           len0 = clib_net_to_host_u16 (ip0->payload_length);
 209           error0 = len0 < im->min_valid_length_by_type[type0] ? ICMP6_ERROR_LENGTH_TOO_SMALL_FOR_TYPE : error0;
 210
 211           b0->error = node->errors[error0];
 212
 213           next0 = error0 != ICMP6_ERROR_NONE ? ICMP_INPUT_NEXT_DROP : next0;
 214
 215           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 216                                            to_next, n_left_to_next,
 217                                            bi0, next0);
 218         }
 219
 220       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 221     }
 222
 223   return frame->n_vectors;
 224 }
 225
 226 VLIB_REGISTER_NODE (ip6_icmp_input_node) = {
 227   .function = ip6_icmp_input,
 228   .name = "ip6-icmp-input",
 229
 230   .vector_size = sizeof (u32),
 231
 232   .format_trace = format_icmp6_input_trace,
 233
 234   .n_errors = ARRAY_LEN (icmp_error_strings),
 235   .error_strings = icmp_error_strings,
 236
 237   .n_next_nodes = 1,
 238   .next_nodes = {
 239     [ICMP_INPUT_NEXT_DROP] = "error-drop",
 240   },
 241 };
 242
 243 typedef enum {
 244   ICMP6_ECHO_REQUEST_NEXT_LOOKUP,
 245   ICMP6_ECHO_REQUEST_NEXT_OUTPUT,
 246   ICMP6_ECHO_REQUEST_N_NEXT,
 247 } icmp6_echo_request_next_t;
 248
 249 static uword
 250 ip6_icmp_echo_request (vlib_main_t * vm,
 251                        vlib_node_runtime_t * node,
 252                        vlib_frame_t * frame)
 253 {
 254   u32 * from, * to_next;
 255   u32 n_left_from, n_left_to_next, next_index;
 256   ip6_main_t * im = &ip6_main;
 257
 258   from = vlib_frame_vector_args (frame);
 259   n_left_from = frame->n_vectors;
 260   next_index = node->cached_next_index;
 261
 262   if (node->flags & VLIB_NODE_FLAG_TRACE)
 263     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 264                                    /* stride */ 1,
 265                                    sizeof (icmp6_input_trace_t));
 266
 267   while (n_left_from > 0)
 268     {
 269       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 270
 271       while (n_left_from > 2 && n_left_to_next > 2)
 272         {
 273           vlib_buffer_t * p0, * p1;
 274           ip6_header_t * ip0, * ip1;
 275           icmp46_header_t * icmp0, * icmp1;
 276           ip6_address_t tmp0, tmp1;
 277           ip_csum_t sum0, sum1;
 278           u32 bi0, bi1;
 279           u32 fib_index0, fib_index1;
 280           u32 next0 = ICMP6_ECHO_REQUEST_NEXT_LOOKUP;
 281           u32 next1 = ICMP6_ECHO_REQUEST_NEXT_LOOKUP;
 282
 283           bi0 = to_next[0] = from[0];
 284           bi1 = to_next[1] = from[1];
 285
 286           from += 2;
 287           n_left_from -= 2;
 288           to_next += 2;
 289           n_left_to_next -= 2;
 290
 291           p0 = vlib_get_buffer (vm, bi0);
 292           p1 = vlib_get_buffer (vm, bi1);
 293           ip0 = vlib_buffer_get_current (p0);
 294           ip1 = vlib_buffer_get_current (p1);
 295           icmp0 = ip6_next_header (ip0);
 296           icmp1 = ip6_next_header (ip1);
 297
 298           /* Check icmp type to echo reply and update icmp checksum. */
 299           sum0 = icmp0->checksum;
 300           sum1 = icmp1->checksum;
 301
 302           ASSERT (icmp0->type == ICMP6_echo_request);
 303           ASSERT (icmp1->type == ICMP6_echo_request);
 304           sum0 = ip_csum_update (sum0, ICMP6_echo_request, ICMP6_echo_reply,
 305                                  icmp46_header_t, type);
 306           sum1 = ip_csum_update (sum1, ICMP6_echo_request, ICMP6_echo_reply,
 307                                  icmp46_header_t, type);
 308
 309           icmp0->checksum = ip_csum_fold (sum0);
 310           icmp1->checksum = ip_csum_fold (sum1);
 311
 312           icmp0->type = ICMP6_echo_reply;
 313           icmp1->type = ICMP6_echo_reply;
 314
 315           /* Swap source and destination address. */
 316           tmp0 = ip0->src_address;
 317           tmp1 = ip1->src_address;
 318
 319           ip0->src_address = ip0->dst_address;
 320           ip1->src_address = ip1->dst_address;
 321
 322           ip0->dst_address = tmp0;
 323           ip1->dst_address = tmp1;
 324
 325           /* New hop count. */
 326           ip0->hop_limit = im->host_config.ttl;
 327           ip1->hop_limit = im->host_config.ttl;
 328
 329           if (ip6_address_is_link_local_unicast (&ip0->dst_address))
 330             {
 331               ethernet_header_t *eth0;
 332               u8 tmp_mac[6];
 333               /* For link local, reuse current MAC header by sawpping
 334                *  SMAC to DMAC instead of IP6 lookup since link local
 335                *  is not in the IP6 FIB */
 336               vlib_buffer_reset (p0);
 337               eth0 = vlib_buffer_get_current (p0);
 338               memcpy (tmp_mac, eth0->dst_address, 6);
 339               memcpy (eth0->dst_address, eth0->src_address, 6);
 340               memcpy (eth0->src_address, tmp_mac, 6);
 341               vnet_buffer(p0)->sw_if_index[VLIB_TX] =
 342                   vnet_buffer (p0)->sw_if_index[VLIB_RX];
 343               next0 = ICMP6_ECHO_REQUEST_NEXT_OUTPUT;
 344             }
 345           else
 346             {
 347               /* Determine the correct lookup fib indices... */
 348               fib_index0 = vec_elt (im->fib_index_by_sw_if_index,
 349                                     vnet_buffer (p0)->sw_if_index[VLIB_RX]);
 350               vnet_buffer (p0)->sw_if_index[VLIB_TX] = fib_index0;
 351             }
 352
 353           if (ip6_address_is_link_local_unicast (&ip1->dst_address))
 354             {
 355               ethernet_header_t *eth1;
 356               u8 tmp_mac[6];
 357               /* For link local, reuse current MAC header by sawpping
 358                *  SMAC to DMAC instead of IP6 lookup since link local
 359                *  is not in the IP6 FIB */
 360               vlib_buffer_reset (p1);
 361               eth1 = vlib_buffer_get_current (p1);
 362               memcpy (tmp_mac, eth1->dst_address, 6);
 363               memcpy (eth1->dst_address, eth1->src_address, 6);
 364               memcpy (eth1->src_address, tmp_mac, 6);
 365               vnet_buffer(p1)->sw_if_index[VLIB_TX] =
 366                   vnet_buffer (p1)->sw_if_index[VLIB_RX];
 367               next1 = ICMP6_ECHO_REQUEST_NEXT_OUTPUT;
 368             }
 369           else
 370             {
 371               /* Determine the correct lookup fib indices... */
 372               fib_index1 = vec_elt (im->fib_index_by_sw_if_index,
 373                                     vnet_buffer (p1)->sw_if_index[VLIB_RX]);
 374               vnet_buffer (p1)->sw_if_index[VLIB_TX] = fib_index1;
 375             }
 376
 377           vnet_buffer (p0)->sw_if_index[VLIB_RX]
 378               = vnet_main.local_interface_sw_if_index;
 379           vnet_buffer (p1)->sw_if_index[VLIB_RX]
 380               = vnet_main.local_interface_sw_if_index;
 381
 382           /* verify speculative enqueues, maybe switch current next frame */
 383           /* if next0==next1==next_index then nothing special needs to be done */
 384           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 385                                            to_next, n_left_to_next,
 386                                            bi0, bi1, next0, next1);
 387         }
 388
 389       while (n_left_from > 0 && n_left_to_next > 0)
 390         {
 391           vlib_buffer_t * p0;
 392           ip6_header_t * ip0;
 393           icmp46_header_t * icmp0;
 394           u32 bi0;
 395           ip6_address_t tmp0;
 396           ip_csum_t sum0;
 397           u32 fib_index0;
 398           u32 next0 = ICMP6_ECHO_REQUEST_NEXT_LOOKUP;
 399
 400           bi0 = to_next[0] = from[0];
 401
 402           from += 1;
 403           n_left_from -= 1;
 404           to_next += 1;
 405           n_left_to_next -= 1;
 406
 407           p0 = vlib_get_buffer (vm, bi0);
 408           ip0 = vlib_buffer_get_current (p0);
 409           icmp0 = ip6_next_header (ip0);
 410
 411           /* Check icmp type to echo reply and update icmp checksum. */
 412           sum0 = icmp0->checksum;
 413
 414           ASSERT (icmp0->type == ICMP6_echo_request);
 415           sum0 = ip_csum_update (sum0, ICMP6_echo_request, ICMP6_echo_reply,
 416                                  icmp46_header_t, type);
 417
 418           icmp0->checksum = ip_csum_fold (sum0);
 419
 420           icmp0->type = ICMP6_echo_reply;
 421
 422           /* Swap source and destination address. */
 423           tmp0 = ip0->src_address;
 424           ip0->src_address = ip0->dst_address;
 425           ip0->dst_address = tmp0;
 426
 427           ip0->hop_limit = im->host_config.ttl;
 428
 429           if (ip6_address_is_link_local_unicast (&ip0->dst_address))
 430             {
 431               ethernet_header_t *eth0;
 432               u8 tmp_mac[6];
 433               /* For link local, reuse current MAC header by sawpping
 434                *  SMAC to DMAC instead of IP6 lookup since link local
 435                *  is not in the IP6 FIB */
 436               vlib_buffer_reset (p0);
 437               eth0 = vlib_buffer_get_current (p0);
 438               memcpy (tmp_mac, eth0->dst_address, 6);
 439               memcpy (eth0->dst_address, eth0->src_address, 6);
 440               memcpy (eth0->src_address, tmp_mac, 6);
 441               vnet_buffer(p0)->sw_if_index[VLIB_TX] =
 442                   vnet_buffer (p0)->sw_if_index[VLIB_RX];
 443               next0 = ICMP6_ECHO_REQUEST_NEXT_OUTPUT;
 444             }
 445           else
 446             {
 447               fib_index0 = vec_elt (im->fib_index_by_sw_if_index,
 448                                     vnet_buffer (p0)->sw_if_index[VLIB_RX]);
 449               vnet_buffer (p0)->sw_if_index[VLIB_TX] = fib_index0;
 450             }
 451           vnet_buffer (p0)->sw_if_index[VLIB_RX]
 452               = vnet_main.local_interface_sw_if_index;
 453
 454           /* Verify speculative enqueue, maybe switch current next frame */
 455           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 456                                            to_next, n_left_to_next,
 457                                            bi0, next0);
 458         }
 459
 460       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 461     }
 462
 463   vlib_error_count (vm, ip6_icmp_input_node.index,
 464                     ICMP6_ERROR_ECHO_REPLIES_SENT,
 465                     frame->n_vectors);
 466
 467   return frame->n_vectors;
 468 }
 469
 470 VLIB_REGISTER_NODE (ip6_icmp_echo_request_node,static) = {
 471   .function = ip6_icmp_echo_request,
 472   .name = "ip6-icmp-echo-request",
 473
 474   .vector_size = sizeof (u32),
 475
 476   .format_trace = format_icmp6_input_trace,
 477
 478   .n_next_nodes = ICMP6_ECHO_REQUEST_N_NEXT,
 479   .next_nodes = {
 480     [ICMP6_ECHO_REQUEST_NEXT_LOOKUP] = "ip6-lookup",
 481     [ICMP6_ECHO_REQUEST_NEXT_OUTPUT] = "interface-output",
 482   },
 483 };
 484
 485 typedef enum {
 486   ICMP6_TTL_EXPIRE_NEXT_DROP,
 487   ICMP6_TTL_EXPIRE_NEXT_LOOKUP,
 488   ICMP6_TTL_EXPIRE_N_NEXT,
 489 } icmp_ttl_expire_next_t;
 490
 491 static uword
 492 ip6_icmp_ttl_expire (vlib_main_t * vm,
 493                      vlib_node_runtime_t * node,
 494                      vlib_frame_t * frame)
 495 {
 496   u32 * from, * to_next;
 497   uword n_left_from, n_left_to_next;
 498   icmp_ttl_expire_next_t next_index;
 499   ip6_main_t *im = &ip6_main;
 500   ip_lookup_main_t * lm = &im->lookup_main;
 501
 502   from = vlib_frame_vector_args(frame);
 503   n_left_from = frame->n_vectors;
 504   next_index = node->cached_next_index;
 505
 506   if (node->flags & VLIB_NODE_FLAG_TRACE)
 507     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 508                                    /* stride */ 1, sizeof (icmp6_input_trace_t));
 509
 510   while (n_left_from > 0)
 511     {
 512       vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
 513
 514       while (n_left_from > 0 && n_left_to_next > 0)
 515         {
 516           u32 pi0 = from[0];
 517           u32 next0 = ICMP6_TTL_EXPIRE_NEXT_LOOKUP;
 518           u8 error0 = ICMP6_ERROR_TTL_EXPIRE_RESP_SENT;
 519           vlib_buffer_t * p0;
 520           ip6_header_t * ip0, * out_ip0;
 521           icmp46_header_t * icmp0;
 522           u32 sw_if_index0, if_add_index0;
 523           int bogus_length;
 524
 525           /* Speculatively enqueue p0 to the current next frame */
 526           to_next[0] = pi0;
 527           from += 1;
 528           to_next += 1;
 529           n_left_from -= 1;
 530           n_left_to_next -= 1;
 531
 532           p0 = vlib_get_buffer(vm, pi0);
 533           ip0 = vlib_buffer_get_current(p0);
 534           sw_if_index0 = vnet_buffer(p0)->sw_if_index[VLIB_RX];
 535
 536           /* RFC2463 says to keep as much of the original packet as possible
 537            * within the MTU. We cheat "a little" here by keeping whatever fits
 538            * in the first buffer, to be more efficient */
 539           if (PREDICT_FALSE(p0->total_length_not_including_first_buffer))
 540             { /* clear current_length of all other buffers in chain */
 541               vlib_buffer_t *b = p0;
 542               p0->total_length_not_including_first_buffer = 0;
 543               while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 544                 {
 545                   b = vlib_get_buffer (vm, b->next_buffer);
 546                   b->current_length = 0;
 547                 }
 548             }
 549
 550           /* Add IP header and ICMPv6 header including a 4 byte ununsed field */
 551           vlib_buffer_advance(p0,
 552                               -sizeof(ip6_header_t)-sizeof(icmp46_header_t)-4);
 553           out_ip0 = vlib_buffer_get_current(p0);
 554           icmp0 = (icmp46_header_t *) &out_ip0[1];
 555
 556           /* Fill ip header fields */
 557           out_ip0->ip_version_traffic_class_and_flow_label =
 558               clib_host_to_net_u32(0x6<<28);
 559           out_ip0->payload_length =
 560               clib_host_to_net_u16(p0->current_length - sizeof(ip6_header_t));
 561           out_ip0->protocol = IP_PROTOCOL_ICMP6;
 562           out_ip0->hop_limit = 0xff;
 563           out_ip0->dst_address = ip0->src_address;
 564           if_add_index0 =
 565               lm->if_address_pool_index_by_sw_if_index[sw_if_index0];
 566           if (PREDICT_TRUE(if_add_index0 != ~0))
 567             {
 568               ip_interface_address_t *if_add =
 569                   pool_elt_at_index(lm->if_address_pool, if_add_index0);
 570               ip6_address_t *if_ip =
 571                   ip_interface_address_get_address(lm, if_add);
 572               out_ip0->src_address = *if_ip;
 573               vlib_error_count (vm, node->node_index, error0, 1);
 574             }
 575           else   /* interface has no IP6 address - should not happen */
 576             {
 577               next0 = ICMP6_TTL_EXPIRE_NEXT_DROP;
 578               error0 = ICMP6_ERROR_TTL_EXPIRE_RESP_DROP;
 579             }
 580
 581           /* Fill icmp header fields */
 582           icmp0->type = ICMP6_time_exceeded;
 583           icmp0->code = ICMP6_time_exceeded_ttl_exceeded_in_transit;
 584           icmp0->checksum = 0;
 585           icmp0->checksum = ip6_tcp_udp_icmp_compute_checksum(
 586               vm, p0, out_ip0, &bogus_length);
 587
 588           /* Update error status */
 589           p0->error = node->errors[error0];
 590
 591           /* Verify speculative enqueue, maybe switch current next frame */
 592           vlib_validate_buffer_enqueue_x1(vm, node, next_index,
 593                                           to_next, n_left_to_next,
 594                                           pi0, next0);
 595         }
 596       vlib_put_next_frame(vm, node, next_index, n_left_to_next);
 597     }
 598
 599   return frame->n_vectors;
 600 }
 601
 602 VLIB_REGISTER_NODE (ip6_icmp_ttl_expire_node) = {
 603   .function = ip6_icmp_ttl_expire,
 604   .name = "ip6-icmp-ttl-expire",
 605   .vector_size = sizeof (u32),
 606
 607   .n_errors = ARRAY_LEN (icmp_error_strings),
 608   .error_strings = icmp_error_strings,
 609
 610   .n_next_nodes = ICMP6_TTL_EXPIRE_N_NEXT,
 611   .next_nodes = {
 612     [ICMP6_TTL_EXPIRE_NEXT_DROP] = "error-drop",
 613     [ICMP6_TTL_EXPIRE_NEXT_LOOKUP] = "ip6-lookup",
 614   },
 615
 616   .format_trace = format_icmp6_input_trace,
 617 };
 618
 619
 620 static uword unformat_icmp_type_and_code (unformat_input_t * input, va_list * args)
 621 {
 622   icmp46_header_t * h = va_arg (*args, icmp46_header_t *);
 623   icmp6_main_t * cm = &icmp6_main;
 624   u32 i;
 625
 626   if (unformat_user (input, unformat_vlib_number_by_name,
 627                      cm->type_and_code_by_name, &i))
 628     {
 629       h->type = (i >> 8) & 0xff;
 630       h->code = (i >> 0) & 0xff;
 631     }
 632   else if (unformat_user (input, unformat_vlib_number_by_name,
 633                           cm->type_by_name, &i))
 634     {
 635       h->type = i;
 636       h->code = 0;
 637     }
 638   else
 639     return 0;
 640
 641   return 1;
 642 }
 643
 644 static void
 645 icmp6_pg_edit_function (pg_main_t * pg,
 646                         pg_stream_t * s,
 647                         pg_edit_group_t * g,
 648                         u32 * packets,
 649                         u32 n_packets)
 650 {
 651   vlib_main_t * vm = pg->vlib_main;
 652   u32 ip_offset, icmp_offset;
 653   int bogus_length;
 654
 655   icmp_offset = g->start_byte_offset;
 656   ip_offset = (g-1)->start_byte_offset;
 657
 658   while (n_packets >= 1)
 659     {
 660       vlib_buffer_t * p0;
 661       ip6_header_t * ip0;
 662       icmp46_header_t * icmp0;
 663
 664       p0 = vlib_get_buffer (vm, packets[0]);
 665       n_packets -= 1;
 666       packets += 1;
 667
 668       ASSERT (p0->current_data == 0);
 669       ip0 = (void *) (p0->data + ip_offset);
 670       icmp0 = (void *) (p0->data + icmp_offset);
 671
 672       icmp0->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0,
 673                                                            &bogus_length);
 674       ASSERT (bogus_length == 0);
 675     }
 676 }
 677
 678 typedef struct {
 679   pg_edit_t type, code;
 680   pg_edit_t checksum;
 681 } pg_icmp46_header_t;
 682
 683 always_inline void
 684 pg_icmp_header_init (pg_icmp46_header_t * p)
 685 {
 686   /* Initialize fields that are not bit fields in the IP header. */
 687 #define _(f) pg_edit_init (&p->f, icmp46_header_t, f);
 688   _ (type);
 689   _ (code);
 690   _ (checksum);
 691 #undef _
 692 }
 693
 694 static uword
 695 unformat_pg_icmp_header (unformat_input_t * input, va_list * args)
 696 {
 697   pg_stream_t * s = va_arg (*args, pg_stream_t *);
 698   pg_icmp46_header_t * p;
 699   u32 group_index;
 700
 701   p = pg_create_edit_group (s, sizeof (p[0]), sizeof (icmp46_header_t),
 702                             &group_index);
 703   pg_icmp_header_init (p);
 704
 705   p->checksum.type = PG_EDIT_UNSPECIFIED;
 706
 707   {
 708     icmp46_header_t tmp;
 709
 710     if (! unformat (input, "ICMP %U", unformat_icmp_type_and_code, &tmp))
 711       goto error;
 712
 713     pg_edit_set_fixed (&p->type, tmp.type);
 714     pg_edit_set_fixed (&p->code, tmp.code);
 715   }
 716
 717   /* Parse options. */
 718   while (1)
 719     {
 720       if (unformat (input, "checksum %U",
 721                     unformat_pg_edit,
 722                     unformat_pg_number, &p->checksum))
 723         ;
 724
 725       /* Can't parse input: try next protocol level. */
 726       else
 727         break;
 728     }
 729
 730   if (! unformat_user (input, unformat_pg_payload, s))
 731     goto error;
 732
 733   if (p->checksum.type == PG_EDIT_UNSPECIFIED)
 734     {
 735       pg_edit_group_t * g = pg_stream_get_group (s, group_index);
 736       g->edit_function = icmp6_pg_edit_function;
 737       g->edit_function_opaque = 0;
 738     }
 739
 740   return 1;
 741
 742  error:
 743   /* Free up any edits we may have added. */
 744   pg_free_edit_group (s);
 745   return 0;
 746 }
 747
 748 void icmp6_register_type (vlib_main_t * vm, icmp6_type_t type, u32 node_index)
 749 {
 750   icmp6_main_t * im = &icmp6_main;
 751
 752   ASSERT ((int) type < ARRAY_LEN (im->input_next_index_by_type));
 753   im->input_next_index_by_type[type]
 754     = vlib_node_add_next (vm, ip6_icmp_input_node.index, node_index);
 755 }
 756
 757 static clib_error_t *
 758 icmp6_init (vlib_main_t * vm)
 759 {
 760   ip_main_t * im = &ip_main;
 761   ip_protocol_info_t * pi;
 762   icmp6_main_t * cm = &icmp6_main;
 763   clib_error_t * error;
 764
 765   error = vlib_call_init_function (vm, ip_main_init);
 766
 767   if (error)
 768     return error;
 769
 770   pi = ip_get_protocol_info (im, IP_PROTOCOL_ICMP6);
 771   pi->format_header = format_icmp6_header;
 772   pi->unformat_pg_edit = unformat_pg_icmp_header;
 773
 774   cm->type_by_name = hash_create_string (0, sizeof (uword));
 775 #define _(n,t) hash_set_mem (cm->type_by_name, #t, (n));
 776   foreach_icmp6_type;
 777 #undef _
 778
 779   cm->type_and_code_by_name = hash_create_string (0, sizeof (uword));
 780 #define _(a,n,t) hash_set_mem (cm->type_by_name, #t, (n) | (ICMP6_##a << 8));
 781   foreach_icmp6_code;
 782 #undef _
 783
 784   memset (cm->input_next_index_by_type,
 785           ICMP_INPUT_NEXT_DROP,
 786           sizeof (cm->input_next_index_by_type));
 787   memset (cm->max_valid_code_by_type, 0, sizeof (cm->max_valid_code_by_type));
 788
 789 #define _(a,n,t) cm->max_valid_code_by_type[ICMP6_##a] = clib_max (cm->max_valid_code_by_type[ICMP6_##a], n);
 790   foreach_icmp6_code;
 791 #undef _
 792
 793   memset (cm->min_valid_hop_limit_by_type, 0, sizeof (cm->min_valid_hop_limit_by_type));
 794   cm->min_valid_hop_limit_by_type[ICMP6_router_solicitation] = 255;
 795   cm->min_valid_hop_limit_by_type[ICMP6_router_advertisement] = 255;
 796   cm->min_valid_hop_limit_by_type[ICMP6_neighbor_solicitation] = 255;
 797   cm->min_valid_hop_limit_by_type[ICMP6_neighbor_advertisement] = 255;
 798   cm->min_valid_hop_limit_by_type[ICMP6_redirect] = 255;
 799
 800   memset (cm->min_valid_length_by_type, sizeof (icmp46_header_t), sizeof (cm->min_valid_length_by_type));
 801   cm->min_valid_length_by_type[ICMP6_router_solicitation] = sizeof (icmp6_neighbor_discovery_header_t);
 802   cm->min_valid_length_by_type[ICMP6_router_advertisement] = sizeof (icmp6_router_advertisement_header_t);
 803   cm->min_valid_length_by_type[ICMP6_neighbor_solicitation]
 804     = sizeof (icmp6_neighbor_solicitation_or_advertisement_header_t);
 805   cm->min_valid_length_by_type[ICMP6_neighbor_advertisement]
 806     = sizeof (icmp6_neighbor_solicitation_or_advertisement_header_t);
 807   cm->min_valid_length_by_type[ICMP6_redirect] = sizeof (icmp6_redirect_header_t);
 808
 809   icmp6_register_type (vm, ICMP6_echo_request, ip6_icmp_echo_request_node.index);
 810
 811   return vlib_call_init_function (vm, ip6_neighbor_init);
 812 }
 813
 814 VLIB_INIT_FUNCTION (icmp6_init);