src/vnet/ip/icmp4.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/icmp4.c: ipv4 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
  45 static char *icmp_error_strings[] = {
  46 #define _(f,s) s,
  47   foreach_icmp4_error
  48 #undef _
  49 };
  50
  51 static u8 *
  52 format_ip4_icmp_type_and_code (u8 * s, va_list * args)
  53 {
  54   icmp4_type_t type = va_arg (*args, int);
  55   u8 code = va_arg (*args, int);
  56   char *t = 0;
  57
  58 #define _(n,f) case n: t = #f; break;
  59
  60   switch (type)
  61     {
  62       foreach_icmp4_type;
  63
  64     default:
  65       break;
  66     }
  67
  68 #undef _
  69
  70   if (!t)
  71     return format (s, "unknown 0x%x", type);
  72
  73   s = format (s, "%s", t);
  74
  75   t = 0;
  76   switch ((type << 8) | code)
  77     {
  78 #define _(a,n,f) case (ICMP4_##a << 8) | (n): t = #f; break;
  79
  80       foreach_icmp4_code;
  81
  82 #undef _
  83     }
  84
  85   if (t)
  86     s = format (s, " %s", t);
  87
  88   return s;
  89 }
  90
  91 static u8 *
  92 format_ip4_icmp_header (u8 * s, va_list * args)
  93 {
  94   icmp46_header_t *icmp = va_arg (*args, icmp46_header_t *);
  95   u32 max_header_bytes = va_arg (*args, u32);
  96
  97   /* Nothing to do. */
  98   if (max_header_bytes < sizeof (icmp[0]))
  99     return format (s, "ICMP header truncated");
 100
 101   s = format (s, "ICMP %U checksum 0x%x",
 102               format_ip4_icmp_type_and_code, icmp->type, icmp->code,
 103               clib_net_to_host_u16 (icmp->checksum));
 104
 105   return s;
 106 }
 107
 108 static u8 *
 109 format_icmp_input_trace (u8 * s, va_list * va)
 110 {
 111   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
 112   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 113   icmp_input_trace_t *t = va_arg (*va, icmp_input_trace_t *);
 114
 115   s = format (s, "%U",
 116               format_ip4_header, t->packet_data, sizeof (t->packet_data));
 117
 118   return s;
 119 }
 120
 121 typedef enum
 122 {
 123   ICMP_INPUT_NEXT_ERROR,
 124   ICMP_INPUT_N_NEXT,
 125 } icmp_input_next_t;
 126
 127 typedef struct
 128 {
 129   uword *type_and_code_by_name;
 130
 131   uword *type_by_name;
 132
 133   /* Vector dispatch table indexed by [icmp type]. */
 134   u8 ip4_input_next_index_by_type[256];
 135 } icmp4_main_t;
 136
 137 icmp4_main_t icmp4_main;
 138
 139 static uword
 140 ip4_icmp_input (vlib_main_t * vm,
 141                 vlib_node_runtime_t * node, vlib_frame_t * frame)
 142 {
 143   icmp4_main_t *im = &icmp4_main;
 144   uword n_packets = frame->n_vectors;
 145   u32 *from, *to_next;
 146   u32 n_left_from, n_left_to_next, next;
 147
 148   from = vlib_frame_vector_args (frame);
 149   n_left_from = n_packets;
 150   next = node->cached_next_index;
 151
 152   if (node->flags & VLIB_NODE_FLAG_TRACE)
 153     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 154                                    /* stride */ 1,
 155                                    sizeof (icmp_input_trace_t));
 156
 157   while (n_left_from > 0)
 158     {
 159       vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
 160
 161       while (n_left_from > 0 && n_left_to_next > 0)
 162         {
 163           vlib_buffer_t *p0;
 164           ip4_header_t *ip0;
 165           icmp46_header_t *icmp0;
 166           icmp4_type_t type0;
 167           u32 bi0, next0;
 168
 169           if (PREDICT_TRUE (n_left_from > 2))
 170             {
 171               vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
 172               p0 = vlib_get_buffer (vm, from[1]);
 173               ip0 = vlib_buffer_get_current (p0);
 174               CLIB_PREFETCH (ip0, CLIB_CACHE_LINE_BYTES, LOAD);
 175             }
 176
 177           bi0 = to_next[0] = from[0];
 178
 179           from += 1;
 180           n_left_from -= 1;
 181           to_next += 1;
 182           n_left_to_next -= 1;
 183
 184           p0 = vlib_get_buffer (vm, bi0);
 185           ip0 = vlib_buffer_get_current (p0);
 186           icmp0 = ip4_next_header (ip0);
 187           type0 = icmp0->type;
 188           next0 = im->ip4_input_next_index_by_type[type0];
 189
 190           p0->error = node->errors[ICMP4_ERROR_UNKNOWN_TYPE];
 191           if (PREDICT_FALSE (next0 != next))
 192             {
 193               vlib_put_next_frame (vm, node, next, n_left_to_next + 1);
 194               next = next0;
 195               vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
 196               to_next[0] = bi0;
 197               to_next += 1;
 198               n_left_to_next -= 1;
 199             }
 200         }
 201
 202       vlib_put_next_frame (vm, node, next, n_left_to_next);
 203     }
 204
 205   return frame->n_vectors;
 206 }
 207
 208 /* *INDENT-OFF* */
 209 VLIB_REGISTER_NODE (ip4_icmp_input_node,static) = {
 210   .function = ip4_icmp_input,
 211   .name = "ip4-icmp-input",
 212
 213   .vector_size = sizeof (u32),
 214
 215   .format_trace = format_icmp_input_trace,
 216
 217   .n_errors = ARRAY_LEN (icmp_error_strings),
 218   .error_strings = icmp_error_strings,
 219
 220   .n_next_nodes = 1,
 221   .next_nodes = {
 222     [ICMP_INPUT_NEXT_ERROR] = "ip4-punt",
 223   },
 224 };
 225 /* *INDENT-ON* */
 226
 227 static uword
 228 ip4_icmp_echo_request (vlib_main_t * vm,
 229                        vlib_node_runtime_t * node, vlib_frame_t * frame)
 230 {
 231   uword n_packets = frame->n_vectors;
 232   u32 *from, *to_next;
 233   u32 n_left_from, n_left_to_next, next;
 234   ip4_main_t *i4m = &ip4_main;
 235   u16 *fragment_ids, *fid;
 236   u8 host_config_ttl = i4m->host_config.ttl;
 237
 238   from = vlib_frame_vector_args (frame);
 239   n_left_from = n_packets;
 240   next = node->cached_next_index;
 241
 242   if (node->flags & VLIB_NODE_FLAG_TRACE)
 243     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 244                                    /* stride */ 1,
 245                                    sizeof (icmp_input_trace_t));
 246
 247   /* Get random fragment IDs for replies. */
 248   fid = fragment_ids = clib_random_buffer_get_data (&vm->random_buffer,
 249                                                     n_packets *
 250                                                     sizeof (fragment_ids[0]));
 251
 252   while (n_left_from > 0)
 253     {
 254       vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
 255
 256       while (n_left_from > 2 && n_left_to_next > 2)
 257         {
 258           vlib_buffer_t *p0, *p1;
 259           ip4_header_t *ip0, *ip1;
 260           icmp46_header_t *icmp0, *icmp1;
 261           u32 bi0, src0, dst0;
 262           u32 bi1, src1, dst1;
 263           ip_csum_t sum0, sum1;
 264
 265           bi0 = to_next[0] = from[0];
 266           bi1 = to_next[1] = from[1];
 267
 268           from += 2;
 269           n_left_from -= 2;
 270           to_next += 2;
 271           n_left_to_next -= 2;
 272
 273           p0 = vlib_get_buffer (vm, bi0);
 274           p1 = vlib_get_buffer (vm, bi1);
 275           ip0 = vlib_buffer_get_current (p0);
 276           ip1 = vlib_buffer_get_current (p1);
 277           icmp0 = ip4_next_header (ip0);
 278           icmp1 = ip4_next_header (ip1);
 279
 280           vnet_buffer (p0)->sw_if_index[VLIB_RX] =
 281             vnet_main.local_interface_sw_if_index;
 282           vnet_buffer (p1)->sw_if_index[VLIB_RX] =
 283             vnet_main.local_interface_sw_if_index;
 284
 285           /* Update ICMP checksum. */
 286           sum0 = icmp0->checksum;
 287           sum1 = icmp1->checksum;
 288
 289           ASSERT (icmp0->type == ICMP4_echo_request);
 290           ASSERT (icmp1->type == ICMP4_echo_request);
 291           sum0 = ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
 292                                  icmp46_header_t, type);
 293           sum1 = ip_csum_update (sum1, ICMP4_echo_request, ICMP4_echo_reply,
 294                                  icmp46_header_t, type);
 295           icmp0->type = ICMP4_echo_reply;
 296           icmp1->type = ICMP4_echo_reply;
 297
 298           icmp0->checksum = ip_csum_fold (sum0);
 299           icmp1->checksum = ip_csum_fold (sum1);
 300
 301           src0 = ip0->src_address.data_u32;
 302           src1 = ip1->src_address.data_u32;
 303           dst0 = ip0->dst_address.data_u32;
 304           dst1 = ip1->dst_address.data_u32;
 305
 306           /* Swap source and destination address.
 307              Does not change checksum. */
 308           ip0->src_address.data_u32 = dst0;
 309           ip1->src_address.data_u32 = dst1;
 310           ip0->dst_address.data_u32 = src0;
 311           ip1->dst_address.data_u32 = src1;
 312
 313           /* Update IP checksum. */
 314           sum0 = ip0->checksum;
 315           sum1 = ip1->checksum;
 316
 317           sum0 = ip_csum_update (sum0, ip0->ttl, host_config_ttl,
 318                                  ip4_header_t, ttl);
 319           sum1 = ip_csum_update (sum1, ip1->ttl, host_config_ttl,
 320                                  ip4_header_t, ttl);
 321           ip0->ttl = host_config_ttl;
 322           ip1->ttl = host_config_ttl;
 323
 324           /* New fragment id. */
 325           sum0 = ip_csum_update (sum0, ip0->fragment_id, fid[0],
 326                                  ip4_header_t, fragment_id);
 327           sum1 = ip_csum_update (sum1, ip1->fragment_id, fid[1],
 328                                  ip4_header_t, fragment_id);
 329           ip0->fragment_id = fid[0];
 330           ip1->fragment_id = fid[1];
 331           fid += 2;
 332
 333           ip0->checksum = ip_csum_fold (sum0);
 334           ip1->checksum = ip_csum_fold (sum1);
 335
 336           ASSERT (ip0->checksum == ip4_header_checksum (ip0));
 337           ASSERT (ip1->checksum == ip4_header_checksum (ip1));
 338
 339           p0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 340           p1->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 341         }
 342
 343       while (n_left_from > 0 && n_left_to_next > 0)
 344         {
 345           vlib_buffer_t *p0;
 346           ip4_header_t *ip0;
 347           icmp46_header_t *icmp0;
 348           u32 bi0, src0, dst0;
 349           ip_csum_t sum0;
 350
 351           bi0 = to_next[0] = from[0];
 352
 353           from += 1;
 354           n_left_from -= 1;
 355           to_next += 1;
 356           n_left_to_next -= 1;
 357
 358           p0 = vlib_get_buffer (vm, bi0);
 359           ip0 = vlib_buffer_get_current (p0);
 360           icmp0 = ip4_next_header (ip0);
 361
 362           vnet_buffer (p0)->sw_if_index[VLIB_RX] =
 363             vnet_main.local_interface_sw_if_index;
 364
 365           /* Update ICMP checksum. */
 366           sum0 = icmp0->checksum;
 367
 368           ASSERT (icmp0->type == ICMP4_echo_request);
 369           sum0 = ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
 370                                  icmp46_header_t, type);
 371           icmp0->type = ICMP4_echo_reply;
 372           icmp0->checksum = ip_csum_fold (sum0);
 373
 374           src0 = ip0->src_address.data_u32;
 375           dst0 = ip0->dst_address.data_u32;
 376           ip0->src_address.data_u32 = dst0;
 377           ip0->dst_address.data_u32 = src0;
 378
 379           /* Update IP checksum. */
 380           sum0 = ip0->checksum;
 381
 382           sum0 = ip_csum_update (sum0, ip0->ttl, host_config_ttl,
 383                                  ip4_header_t, ttl);
 384           ip0->ttl = host_config_ttl;
 385
 386           sum0 = ip_csum_update (sum0, ip0->fragment_id, fid[0],
 387                                  ip4_header_t, fragment_id);
 388           ip0->fragment_id = fid[0];
 389           fid += 1;
 390
 391           ip0->checksum = ip_csum_fold (sum0);
 392
 393           ASSERT (ip0->checksum == ip4_header_checksum (ip0));
 394
 395           p0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 396         }
 397
 398       vlib_put_next_frame (vm, node, next, n_left_to_next);
 399     }
 400
 401   vlib_error_count (vm, ip4_icmp_input_node.index,
 402                     ICMP4_ERROR_ECHO_REPLIES_SENT, frame->n_vectors);
 403
 404   return frame->n_vectors;
 405 }
 406
 407 /* *INDENT-OFF* */
 408 VLIB_REGISTER_NODE (ip4_icmp_echo_request_node,static) = {
 409   .function = ip4_icmp_echo_request,
 410   .name = "ip4-icmp-echo-request",
 411
 412   .vector_size = sizeof (u32),
 413
 414   .format_trace = format_icmp_input_trace,
 415
 416   .n_next_nodes = 1,
 417   .next_nodes = {
 418     [0] = "ip4-load-balance",
 419   },
 420 };
 421 /* *INDENT-ON* */
 422
 423 typedef enum
 424 {
 425   IP4_ICMP_ERROR_NEXT_DROP,
 426   IP4_ICMP_ERROR_NEXT_LOOKUP,
 427   IP4_ICMP_ERROR_N_NEXT,
 428 } ip4_icmp_error_next_t;
 429
 430 void
 431 icmp4_error_set_vnet_buffer (vlib_buffer_t * b, u8 type, u8 code, u32 data)
 432 {
 433   vnet_buffer (b)->ip.icmp.type = type;
 434   vnet_buffer (b)->ip.icmp.code = code;
 435   vnet_buffer (b)->ip.icmp.data = data;
 436 }
 437
 438 static u8
 439 icmp4_icmp_type_to_error (u8 type)
 440 {
 441   switch (type)
 442     {
 443     case ICMP4_destination_unreachable:
 444       return ICMP4_ERROR_DEST_UNREACH_SENT;
 445     case ICMP4_time_exceeded:
 446       return ICMP4_ERROR_TTL_EXPIRE_SENT;
 447     case ICMP4_parameter_problem:
 448       return ICMP4_ERROR_PARAM_PROBLEM_SENT;
 449     default:
 450       return ICMP4_ERROR_DROP;
 451     }
 452 }
 453
 454 static uword
 455 ip4_icmp_error (vlib_main_t * vm,
 456                 vlib_node_runtime_t * node, vlib_frame_t * frame)
 457 {
 458   u32 *from, *to_next;
 459   uword n_left_from, n_left_to_next;
 460   ip4_icmp_error_next_t next_index;
 461   ip4_main_t *im = &ip4_main;
 462   ip_lookup_main_t *lm = &im->lookup_main;
 463
 464   from = vlib_frame_vector_args (frame);
 465   n_left_from = frame->n_vectors;
 466   next_index = node->cached_next_index;
 467
 468   if (node->flags & VLIB_NODE_FLAG_TRACE)
 469     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 470                                    /* stride */ 1,
 471                                    sizeof (icmp_input_trace_t));
 472
 473   while (n_left_from > 0)
 474     {
 475       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 476
 477       while (n_left_from > 0 && n_left_to_next > 0)
 478         {
 479           u32 pi0 = from[0];
 480           u32 next0 = IP4_ICMP_ERROR_NEXT_LOOKUP;
 481           u8 error0 = ICMP4_ERROR_NONE;
 482           vlib_buffer_t *p0;
 483           ip4_header_t *ip0, *out_ip0;
 484           icmp46_header_t *icmp0;
 485           u32 sw_if_index0, if_add_index0;
 486           ip_csum_t sum;
 487
 488           /* Speculatively enqueue p0 to the current next frame */
 489           to_next[0] = pi0;
 490           from += 1;
 491           to_next += 1;
 492           n_left_from -= 1;
 493           n_left_to_next -= 1;
 494
 495           p0 = vlib_get_buffer (vm, pi0);
 496           ip0 = vlib_buffer_get_current (p0);
 497           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
 498
 499           /*
 500            * RFC1812 says to keep as much of the original packet as
 501            * possible within the minimum MTU (576). We cheat "a little"
 502            * here by keeping whatever fits in the first buffer, to be more
 503            * efficient
 504            */
 505           if (PREDICT_FALSE (p0->total_length_not_including_first_buffer))
 506             {
 507               /* clear current_length of all other buffers in chain */
 508               vlib_buffer_t *b = p0;
 509               p0->total_length_not_including_first_buffer = 0;
 510               while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 511                 {
 512                   b = vlib_get_buffer (vm, b->next_buffer);
 513                   b->current_length = 0;
 514                 }
 515             }
 516           p0->current_length =
 517             p0->current_length > 576 ? 576 : p0->current_length;
 518
 519           /* Add IP header and ICMPv4 header including a 4 byte data field */
 520           vlib_buffer_advance (p0,
 521                                -sizeof (ip4_header_t) -
 522                                sizeof (icmp46_header_t) - 4);
 523           out_ip0 = vlib_buffer_get_current (p0);
 524           icmp0 = (icmp46_header_t *) & out_ip0[1];
 525
 526           /* Fill ip header fields */
 527           out_ip0->ip_version_and_header_length = 0x45;
 528           out_ip0->tos = 0;
 529           out_ip0->length = clib_host_to_net_u16 (p0->current_length);
 530           out_ip0->fragment_id = 0;
 531           out_ip0->flags_and_fragment_offset = 0;
 532           out_ip0->ttl = 0xff;
 533           out_ip0->protocol = IP_PROTOCOL_ICMP;
 534           out_ip0->dst_address = ip0->src_address;
 535           if_add_index0 = ~0;
 536           if (PREDICT_TRUE (vec_len (lm->if_address_pool_index_by_sw_if_index)
 537                             > sw_if_index0))
 538             if_add_index0 =
 539               lm->if_address_pool_index_by_sw_if_index[sw_if_index0];
 540           if (PREDICT_TRUE (if_add_index0 != ~0))
 541             {
 542               ip_interface_address_t *if_add =
 543                 pool_elt_at_index (lm->if_address_pool, if_add_index0);
 544               ip4_address_t *if_ip =
 545                 ip_interface_address_get_address (lm, if_add);
 546               out_ip0->src_address = *if_ip;
 547             }
 548           else
 549             {
 550               /* interface has no IP4 address - should not happen */
 551               next0 = IP4_ICMP_ERROR_NEXT_DROP;
 552               error0 = ICMP4_ERROR_DROP;
 553             }
 554           out_ip0->checksum = ip4_header_checksum (out_ip0);
 555
 556           /* Fill icmp header fields */
 557           icmp0->type = vnet_buffer (p0)->ip.icmp.type;
 558           icmp0->code = vnet_buffer (p0)->ip.icmp.code;
 559           *((u32 *) (icmp0 + 1)) =
 560             clib_host_to_net_u32 (vnet_buffer (p0)->ip.icmp.data);
 561           icmp0->checksum = 0;
 562           sum =
 563             ip_incremental_checksum (0, icmp0,
 564                                      p0->current_length -
 565                                      sizeof (ip4_header_t));
 566           icmp0->checksum = ~ip_csum_fold (sum);
 567
 568           /* Update error status */
 569           if (error0 == ICMP4_ERROR_NONE)
 570             error0 = icmp4_icmp_type_to_error (icmp0->type);
 571           vlib_error_count (vm, node->node_index, error0, 1);
 572
 573           /* Verify speculative enqueue, maybe switch current next frame */
 574           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 575                                            to_next, n_left_to_next,
 576                                            pi0, next0);
 577         }
 578       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 579     }
 580
 581   return frame->n_vectors;
 582 }
 583
 584 /* *INDENT-OFF* */
 585 VLIB_REGISTER_NODE (ip4_icmp_error_node) = {
 586   .function = ip4_icmp_error,
 587   .name = "ip4-icmp-error",
 588   .vector_size = sizeof (u32),
 589
 590   .n_errors = ARRAY_LEN (icmp_error_strings),
 591   .error_strings = icmp_error_strings,
 592
 593   .n_next_nodes = IP4_ICMP_ERROR_N_NEXT,
 594   .next_nodes = {
 595     [IP4_ICMP_ERROR_NEXT_DROP] = "ip4-drop",
 596     [IP4_ICMP_ERROR_NEXT_LOOKUP] = "ip4-lookup",
 597   },
 598
 599   .format_trace = format_icmp_input_trace,
 600 };
 601 /* *INDENT-ON* */
 602
 603
 604 static uword
 605 unformat_icmp_type_and_code (unformat_input_t * input, va_list * args)
 606 {
 607   icmp46_header_t *h = va_arg (*args, icmp46_header_t *);
 608   icmp4_main_t *cm = &icmp4_main;
 609   u32 i;
 610
 611   if (unformat_user (input, unformat_vlib_number_by_name,
 612                      cm->type_and_code_by_name, &i))
 613     {
 614       h->type = (i >> 8) & 0xff;
 615       h->code = (i >> 0) & 0xff;
 616     }
 617   else if (unformat_user (input, unformat_vlib_number_by_name,
 618                           cm->type_by_name, &i))
 619     {
 620       h->type = i;
 621       h->code = 0;
 622     }
 623   else
 624     return 0;
 625
 626   return 1;
 627 }
 628
 629 static void
 630 icmp4_pg_edit_function (pg_main_t * pg,
 631                         pg_stream_t * s,
 632                         pg_edit_group_t * g, u32 * packets, u32 n_packets)
 633 {
 634   vlib_main_t *vm = vlib_get_main ();
 635   u32 ip_offset, icmp_offset;
 636
 637   icmp_offset = g->start_byte_offset;
 638   ip_offset = (g - 1)->start_byte_offset;
 639
 640   while (n_packets >= 1)
 641     {
 642       vlib_buffer_t *p0;
 643       ip4_header_t *ip0;
 644       icmp46_header_t *icmp0;
 645       u32 len0;
 646
 647       p0 = vlib_get_buffer (vm, packets[0]);
 648       n_packets -= 1;
 649       packets += 1;
 650
 651       ASSERT (p0->current_data == 0);
 652       ip0 = (void *) (p0->data + ip_offset);
 653       icmp0 = (void *) (p0->data + icmp_offset);
 654       len0 = clib_net_to_host_u16 (ip0->length) - ip4_header_bytes (ip0);
 655       icmp0->checksum =
 656         ~ip_csum_fold (ip_incremental_checksum (0, icmp0, len0));
 657     }
 658 }
 659
 660 typedef struct
 661 {
 662   pg_edit_t type, code;
 663   pg_edit_t checksum;
 664 } pg_icmp46_header_t;
 665
 666 always_inline void
 667 pg_icmp_header_init (pg_icmp46_header_t * p)
 668 {
 669   /* Initialize fields that are not bit fields in the IP header. */
 670 #define _(f) pg_edit_init (&p->f, icmp46_header_t, f);
 671   _(type);
 672   _(code);
 673   _(checksum);
 674 #undef _
 675 }
 676
 677 static uword
 678 unformat_pg_icmp_header (unformat_input_t * input, va_list * args)
 679 {
 680   pg_stream_t *s = va_arg (*args, pg_stream_t *);
 681   pg_icmp46_header_t *p;
 682   u32 group_index;
 683
 684   p = pg_create_edit_group (s, sizeof (p[0]), sizeof (icmp46_header_t),
 685                             &group_index);
 686   pg_icmp_header_init (p);
 687
 688   p->checksum.type = PG_EDIT_UNSPECIFIED;
 689
 690   {
 691     icmp46_header_t tmp;
 692
 693     if (!unformat (input, "ICMP %U", unformat_icmp_type_and_code, &tmp))
 694       goto error;
 695
 696     pg_edit_set_fixed (&p->type, tmp.type);
 697     pg_edit_set_fixed (&p->code, tmp.code);
 698   }
 699
 700   /* Parse options. */
 701   while (1)
 702     {
 703       if (unformat (input, "checksum %U",
 704                     unformat_pg_edit, unformat_pg_number, &p->checksum))
 705         ;
 706
 707       /* Can't parse input: try next protocol level. */
 708       else
 709         break;
 710     }
 711
 712   if (!unformat_user (input, unformat_pg_payload, s))
 713     goto error;
 714
 715   if (p->checksum.type == PG_EDIT_UNSPECIFIED)
 716     {
 717       pg_edit_group_t *g = pg_stream_get_group (s, group_index);
 718       g->edit_function = icmp4_pg_edit_function;
 719       g->edit_function_opaque = 0;
 720     }
 721
 722   return 1;
 723
 724 error:
 725   /* Free up any edits we may have added. */
 726   pg_free_edit_group (s);
 727   return 0;
 728 }
 729
 730 void
 731 ip4_icmp_register_type (vlib_main_t * vm, icmp4_type_t type, u32 node_index)
 732 {
 733   icmp4_main_t *im = &icmp4_main;
 734
 735   ASSERT ((int) type < ARRAY_LEN (im->ip4_input_next_index_by_type));
 736   im->ip4_input_next_index_by_type[type]
 737     = vlib_node_add_next (vm, ip4_icmp_input_node.index, node_index);
 738 }
 739
 740 static clib_error_t *
 741 icmp4_init (vlib_main_t * vm)
 742 {
 743   ip_main_t *im = &ip_main;
 744   ip_protocol_info_t *pi;
 745   icmp4_main_t *cm = &icmp4_main;
 746   clib_error_t *error;
 747
 748   error = vlib_call_init_function (vm, ip_main_init);
 749
 750   if (error)
 751     return error;
 752
 753   pi = ip_get_protocol_info (im, IP_PROTOCOL_ICMP);
 754   pi->format_header = format_ip4_icmp_header;
 755   pi->unformat_pg_edit = unformat_pg_icmp_header;
 756
 757   cm->type_by_name = hash_create_string (0, sizeof (uword));
 758 #define _(n,t) hash_set_mem (cm->type_by_name, #t, (n));
 759   foreach_icmp4_type;
 760 #undef _
 761
 762   cm->type_and_code_by_name = hash_create_string (0, sizeof (uword));
 763 #define _(a,n,t) hash_set_mem (cm->type_by_name, #t, (n) | (ICMP4_##a << 8));
 764   foreach_icmp4_code;
 765 #undef _
 766
 767   memset (cm->ip4_input_next_index_by_type,
 768           ICMP_INPUT_NEXT_ERROR, sizeof (cm->ip4_input_next_index_by_type));
 769
 770   ip4_icmp_register_type (vm, ICMP4_echo_request,
 771                           ip4_icmp_echo_request_node.index);
 772
 773   return 0;
 774 }
 775
 776 VLIB_INIT_FUNCTION (icmp4_init);
 777
 778 /*
 779  * fd.io coding-style-patch-verification: ON
 780  *
 781  * Local Variables:
 782  * eval: (c-set-style "gnu")
 783  * End:
 784  */