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   IP6_ICMP_ERROR_NEXT_DROP,
 487   IP6_ICMP_ERROR_NEXT_LOOKUP,
 488   IP6_ICMP_ERROR_N_NEXT,
 489 } ip6_icmp_error_next_t;
 490
 491 void
 492 icmp6_error_set_vnet_buffer (vlib_buffer_t *b, u8 type, u8 code, u32 data)
 493 {
 494   vnet_buffer(b)->ip.icmp.type = type;
 495   vnet_buffer(b)->ip.icmp.code = code;
 496   vnet_buffer(b)->ip.icmp.data = data;
 497 }
 498
 499 static u8
 500 icmp6_icmp_type_to_error (u8 type)
 501 {
 502   switch (type) {
 503   case ICMP6_destination_unreachable:
 504     return ICMP6_ERROR_DEST_UNREACH_SENT;
 505   case ICMP6_packet_too_big:
 506     return ICMP6_ERROR_PACKET_TOO_BIG_SENT;
 507   case ICMP6_time_exceeded:
 508     return ICMP6_ERROR_TTL_EXPIRE_SENT;
 509   case ICMP6_parameter_problem:
 510     return ICMP6_ERROR_PARAM_PROBLEM_SENT;
 511   default:
 512     return ICMP6_ERROR_DROP;
 513   }
 514 }
 515
 516 static uword
 517 ip6_icmp_error (vlib_main_t * vm,
 518                 vlib_node_runtime_t * node,
 519                 vlib_frame_t * frame)
 520 {
 521   u32 * from, * to_next;
 522   uword n_left_from, n_left_to_next;
 523   ip6_icmp_error_next_t next_index;
 524   ip6_main_t *im = &ip6_main;
 525   ip_lookup_main_t * lm = &im->lookup_main;
 526
 527   from = vlib_frame_vector_args(frame);
 528   n_left_from = frame->n_vectors;
 529   next_index = node->cached_next_index;
 530
 531   if (node->flags & VLIB_NODE_FLAG_TRACE)
 532     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 533                                    /* stride */ 1, sizeof (icmp6_input_trace_t));
 534
 535   while (n_left_from > 0)
 536     {
 537       vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
 538
 539       while (n_left_from > 0 && n_left_to_next > 0)
 540         {
 541           u32 pi0 = from[0];
 542           u32 next0 = IP6_ICMP_ERROR_NEXT_LOOKUP;
 543           u8 error0 = ICMP6_ERROR_NONE;
 544           vlib_buffer_t * p0;
 545           ip6_header_t * ip0, * out_ip0;
 546           icmp46_header_t * icmp0;
 547           u32 sw_if_index0, if_add_index0;
 548           int bogus_length;
 549
 550           /* Speculatively enqueue p0 to the current next frame */
 551           to_next[0] = pi0;
 552           from += 1;
 553           to_next += 1;
 554           n_left_from -= 1;
 555           n_left_to_next -= 1;
 556
 557           p0 = vlib_get_buffer(vm, pi0);
 558           ip0 = vlib_buffer_get_current(p0);
 559           sw_if_index0 = vnet_buffer(p0)->sw_if_index[VLIB_RX];
 560
 561           /* RFC4443 says to keep as much of the original packet as possible
 562            * within the minimum MTU. We cheat "a little" here by keeping whatever fits
 563            * in the first buffer, to be more efficient */
 564           if (PREDICT_FALSE(p0->total_length_not_including_first_buffer))
 565             { /* clear current_length of all other buffers in chain */
 566               vlib_buffer_t *b = p0;
 567               p0->total_length_not_including_first_buffer = 0;
 568               while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 569                 {
 570                   b = vlib_get_buffer (vm, b->next_buffer);
 571                   b->current_length = 0;
 572                 }
 573             }
 574
 575           /* Add IP header and ICMPv6 header including a 4 byte data field */
 576           vlib_buffer_advance(p0,
 577                               -sizeof(ip6_header_t)-sizeof(icmp46_header_t)-4);
 578           out_ip0 = vlib_buffer_get_current(p0);
 579           icmp0 = (icmp46_header_t *) &out_ip0[1];
 580
 581           /* Fill ip header fields */
 582           out_ip0->ip_version_traffic_class_and_flow_label =
 583               clib_host_to_net_u32(0x6<<28);
 584           u16 plen = p0->current_length > 1280 ? 1280 : p0->current_length;
 585           out_ip0->payload_length = clib_host_to_net_u16(plen - sizeof(ip6_header_t));
 586           out_ip0->protocol = IP_PROTOCOL_ICMP6;
 587           out_ip0->hop_limit = 0xff;
 588           out_ip0->dst_address = ip0->src_address;
 589           if_add_index0 =
 590               lm->if_address_pool_index_by_sw_if_index[sw_if_index0];
 591           if (PREDICT_TRUE(if_add_index0 != ~0))
 592             {
 593               ip_interface_address_t *if_add =
 594                   pool_elt_at_index(lm->if_address_pool, if_add_index0);
 595               ip6_address_t *if_ip =
 596                   ip_interface_address_get_address(lm, if_add);
 597               out_ip0->src_address = *if_ip;
 598             }
 599           else   /* interface has no IP6 address - should not happen */
 600             {
 601               next0 = IP6_ICMP_ERROR_NEXT_DROP;
 602               error0 = ICMP6_ERROR_DROP;
 603             }
 604
 605           /* Fill icmp header fields */
 606           icmp0->type = vnet_buffer(p0)->ip.icmp.type;
 607           icmp0->code = vnet_buffer(p0)->ip.icmp.code;
 608           *((u32 *)(icmp0 + 1)) = clib_host_to_net_u32(vnet_buffer(p0)->ip.icmp.data);
 609           icmp0->checksum = 0;
 610           icmp0->checksum = ip6_tcp_udp_icmp_compute_checksum(
 611               vm, p0, out_ip0, &bogus_length);
 612
 613
 614
 615           /* Update error status */
 616           if (error0 == ICMP6_ERROR_NONE)
 617             error0 = icmp6_icmp_type_to_error(icmp0->type);
 618           vlib_error_count(vm, node->node_index, error0, 1);
 619
 620           /* Verify speculative enqueue, maybe switch current next frame */
 621           vlib_validate_buffer_enqueue_x1(vm, node, next_index,
 622                                           to_next, n_left_to_next,
 623                                           pi0, next0);
 624         }
 625       vlib_put_next_frame(vm, node, next_index, n_left_to_next);
 626     }
 627
 628   return frame->n_vectors;
 629 }
 630
 631 VLIB_REGISTER_NODE (ip6_icmp_error_node) = {
 632   .function = ip6_icmp_error,
 633   .name = "ip6-icmp-error",
 634   .vector_size = sizeof (u32),
 635
 636   .n_errors = ARRAY_LEN (icmp_error_strings),
 637   .error_strings = icmp_error_strings,
 638
 639   .n_next_nodes = IP6_ICMP_ERROR_N_NEXT,
 640   .next_nodes = {
 641     [IP6_ICMP_ERROR_NEXT_DROP] = "error-drop",
 642     [IP6_ICMP_ERROR_NEXT_LOOKUP] = "ip6-lookup",
 643   },
 644
 645   .format_trace = format_icmp6_input_trace,
 646 };
 647
 648
 649 static uword unformat_icmp_type_and_code (unformat_input_t * input, va_list * args)
 650 {
 651   icmp46_header_t * h = va_arg (*args, icmp46_header_t *);
 652   icmp6_main_t * cm = &icmp6_main;
 653   u32 i;
 654
 655   if (unformat_user (input, unformat_vlib_number_by_name,
 656                      cm->type_and_code_by_name, &i))
 657     {
 658       h->type = (i >> 8) & 0xff;
 659       h->code = (i >> 0) & 0xff;
 660     }
 661   else if (unformat_user (input, unformat_vlib_number_by_name,
 662                           cm->type_by_name, &i))
 663     {
 664       h->type = i;
 665       h->code = 0;
 666     }
 667   else
 668     return 0;
 669
 670   return 1;
 671 }
 672
 673 static void
 674 icmp6_pg_edit_function (pg_main_t * pg,
 675                         pg_stream_t * s,
 676                         pg_edit_group_t * g,
 677                         u32 * packets,
 678                         u32 n_packets)
 679 {
 680   vlib_main_t * vm = pg->vlib_main;
 681   u32 ip_offset, icmp_offset;
 682   int bogus_length;
 683
 684   icmp_offset = g->start_byte_offset;
 685   ip_offset = (g-1)->start_byte_offset;
 686
 687   while (n_packets >= 1)
 688     {
 689       vlib_buffer_t * p0;
 690       ip6_header_t * ip0;
 691       icmp46_header_t * icmp0;
 692
 693       p0 = vlib_get_buffer (vm, packets[0]);
 694       n_packets -= 1;
 695       packets += 1;
 696
 697       ASSERT (p0->current_data == 0);
 698       ip0 = (void *) (p0->data + ip_offset);
 699       icmp0 = (void *) (p0->data + icmp_offset);
 700
 701       icmp0->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0,
 702                                                            &bogus_length);
 703       ASSERT (bogus_length == 0);
 704     }
 705 }
 706
 707 typedef struct {
 708   pg_edit_t type, code;
 709   pg_edit_t checksum;
 710 } pg_icmp46_header_t;
 711
 712 always_inline void
 713 pg_icmp_header_init (pg_icmp46_header_t * p)
 714 {
 715   /* Initialize fields that are not bit fields in the IP header. */
 716 #define _(f) pg_edit_init (&p->f, icmp46_header_t, f);
 717   _ (type);
 718   _ (code);
 719   _ (checksum);
 720 #undef _
 721 }
 722
 723 static uword
 724 unformat_pg_icmp_header (unformat_input_t * input, va_list * args)
 725 {
 726   pg_stream_t * s = va_arg (*args, pg_stream_t *);
 727   pg_icmp46_header_t * p;
 728   u32 group_index;
 729
 730   p = pg_create_edit_group (s, sizeof (p[0]), sizeof (icmp46_header_t),
 731                             &group_index);
 732   pg_icmp_header_init (p);
 733
 734   p->checksum.type = PG_EDIT_UNSPECIFIED;
 735
 736   {
 737     icmp46_header_t tmp;
 738
 739     if (! unformat (input, "ICMP %U", unformat_icmp_type_and_code, &tmp))
 740       goto error;
 741
 742     pg_edit_set_fixed (&p->type, tmp.type);
 743     pg_edit_set_fixed (&p->code, tmp.code);
 744   }
 745
 746   /* Parse options. */
 747   while (1)
 748     {
 749       if (unformat (input, "checksum %U",
 750                     unformat_pg_edit,
 751                     unformat_pg_number, &p->checksum))
 752         ;
 753
 754       /* Can't parse input: try next protocol level. */
 755       else
 756         break;
 757     }
 758
 759   if (! unformat_user (input, unformat_pg_payload, s))
 760     goto error;
 761
 762   if (p->checksum.type == PG_EDIT_UNSPECIFIED)
 763     {
 764       pg_edit_group_t * g = pg_stream_get_group (s, group_index);
 765       g->edit_function = icmp6_pg_edit_function;
 766       g->edit_function_opaque = 0;
 767     }
 768
 769   return 1;
 770
 771  error:
 772   /* Free up any edits we may have added. */
 773   pg_free_edit_group (s);
 774   return 0;
 775 }
 776
 777 void icmp6_register_type (vlib_main_t * vm, icmp6_type_t type, u32 node_index)
 778 {
 779   icmp6_main_t * im = &icmp6_main;
 780
 781   ASSERT ((int) type < ARRAY_LEN (im->input_next_index_by_type));
 782   im->input_next_index_by_type[type]
 783     = vlib_node_add_next (vm, ip6_icmp_input_node.index, node_index);
 784 }
 785
 786 static clib_error_t *
 787 icmp6_init (vlib_main_t * vm)
 788 {
 789   ip_main_t * im = &ip_main;
 790   ip_protocol_info_t * pi;
 791   icmp6_main_t * cm = &icmp6_main;
 792   clib_error_t * error;
 793
 794   error = vlib_call_init_function (vm, ip_main_init);
 795
 796   if (error)
 797     return error;
 798
 799   pi = ip_get_protocol_info (im, IP_PROTOCOL_ICMP6);
 800   pi->format_header = format_icmp6_header;
 801   pi->unformat_pg_edit = unformat_pg_icmp_header;
 802
 803   cm->type_by_name = hash_create_string (0, sizeof (uword));
 804 #define _(n,t) hash_set_mem (cm->type_by_name, #t, (n));
 805   foreach_icmp6_type;
 806 #undef _
 807
 808   cm->type_and_code_by_name = hash_create_string (0, sizeof (uword));
 809 #define _(a,n,t) hash_set_mem (cm->type_by_name, #t, (n) | (ICMP6_##a << 8));
 810   foreach_icmp6_code;
 811 #undef _
 812
 813   memset (cm->input_next_index_by_type,
 814           ICMP_INPUT_NEXT_DROP,
 815           sizeof (cm->input_next_index_by_type));
 816   memset (cm->max_valid_code_by_type, 0, sizeof (cm->max_valid_code_by_type));
 817
 818 #define _(a,n,t) cm->max_valid_code_by_type[ICMP6_##a] = clib_max (cm->max_valid_code_by_type[ICMP6_##a], n);
 819   foreach_icmp6_code;
 820 #undef _
 821
 822   memset (cm->min_valid_hop_limit_by_type, 0, sizeof (cm->min_valid_hop_limit_by_type));
 823   cm->min_valid_hop_limit_by_type[ICMP6_router_solicitation] = 255;
 824   cm->min_valid_hop_limit_by_type[ICMP6_router_advertisement] = 255;
 825   cm->min_valid_hop_limit_by_type[ICMP6_neighbor_solicitation] = 255;
 826   cm->min_valid_hop_limit_by_type[ICMP6_neighbor_advertisement] = 255;
 827   cm->min_valid_hop_limit_by_type[ICMP6_redirect] = 255;
 828
 829   memset (cm->min_valid_length_by_type, sizeof (icmp46_header_t), sizeof (cm->min_valid_length_by_type));
 830   cm->min_valid_length_by_type[ICMP6_router_solicitation] = sizeof (icmp6_neighbor_discovery_header_t);
 831   cm->min_valid_length_by_type[ICMP6_router_advertisement] = sizeof (icmp6_router_advertisement_header_t);
 832   cm->min_valid_length_by_type[ICMP6_neighbor_solicitation]
 833     = sizeof (icmp6_neighbor_solicitation_or_advertisement_header_t);
 834   cm->min_valid_length_by_type[ICMP6_neighbor_advertisement]
 835     = sizeof (icmp6_neighbor_solicitation_or_advertisement_header_t);
 836   cm->min_valid_length_by_type[ICMP6_redirect] = sizeof (icmp6_redirect_header_t);
 837
 838   icmp6_register_type (vm, ICMP6_echo_request, ip6_icmp_echo_request_node.index);
 839
 840   return vlib_call_init_function (vm, ip6_neighbor_init);
 841 }
 842
 843 VLIB_INIT_FUNCTION (icmp6_init);