src/plugins/ping/ping.c

   1 /*
   2  * Copyright (c) 2016 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 #include <stddef.h>
  17
  18 #include <vlib/vlib.h>
  19 #include <vlib/unix/unix.h>
  20 #include <vnet/fib/ip6_fib.h>
  21 #include <vnet/fib/ip4_fib.h>
  22 #include <vnet/fib/fib_sas.h>
  23 #include <vnet/ip/ip6_link.h>
  24 #include <vnet/plugin/plugin.h>
  25 #include <vpp/app/version.h>
  26
  27 #include <vnet/ip/icmp4.h>
  28 #include <ping/ping.h>
  29
  30 ping_main_t ping_main;
  31
  32 /**
  33  * @file
  34  * @brief IPv4 and IPv6 ICMP Ping.
  35  *
  36  * This file contains code to support IPv4 or IPv6 ICMP ECHO_REQUEST to
  37  * network hosts.
  38  *
  39  */
  40
  41 typedef struct
  42 {
  43   u16 id;
  44   u16 seq;
  45   u32 cli_process_node;
  46   u8 is_ip6;
  47 } icmp_echo_trace_t;
  48
  49
  50 u8 *
  51 format_icmp_echo_trace (u8 * s, va_list * va)
  52 {
  53   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
  54   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
  55   icmp_echo_trace_t *t = va_arg (*va, icmp_echo_trace_t *);
  56
  57   s =
  58     format (s, "ICMP%s echo id %d seq %d", t->is_ip6 ? "6" : "4", t->id,
  59             t->seq);
  60   if (t->cli_process_node == PING_CLI_UNKNOWN_NODE)
  61     {
  62       s = format (s, " (unknown)");
  63     }
  64   else
  65     {
  66       s = format (s, " send to cli node %d", t->cli_process_node);
  67     }
  68
  69   return s;
  70 }
  71
  72
  73 static u8 *
  74 format_ip46_ping_result (u8 * s, va_list * args)
  75 {
  76   send_ip46_ping_result_t res = va_arg (*args, send_ip46_ping_result_t);
  77
  78   switch (res)
  79     {
  80 #define _(v, n) case SEND_PING_##v: s = format(s, "%s", n);break;
  81       foreach_ip46_ping_result
  82 #undef _
  83     }
  84
  85   return (s);
  86 }
  87
  88
  89 /*
  90  * Poor man's get-set-clear functions
  91  * for manipulation of icmp_id -> cli_process_id
  92  * mappings.
  93  *
  94  * There should normally be very few (0..1..2) of these
  95  * mappings, so the linear search is a good strategy.
  96  *
  97  * Make them thread-safe via a simple spinlock.
  98  *
  99  */
 100
 101
 102 static_always_inline uword
 103 get_cli_process_id_by_icmp_id_mt (vlib_main_t * vm, u16 icmp_id)
 104 {
 105   ping_main_t *pm = &ping_main;
 106   uword cli_process_id = PING_CLI_UNKNOWN_NODE;
 107   ping_run_t *pr;
 108
 109   clib_spinlock_lock_if_init (&pm->ping_run_check_lock);
 110   vec_foreach (pr, pm->active_ping_runs)
 111   {
 112     if (pr->icmp_id == icmp_id)
 113       {
 114         cli_process_id = pr->cli_process_id;
 115         break;
 116       }
 117   }
 118   clib_spinlock_unlock_if_init (&pm->ping_run_check_lock);
 119   return cli_process_id;
 120 }
 121
 122
 123 static_always_inline void
 124 set_cli_process_id_by_icmp_id_mt (vlib_main_t * vm, u16 icmp_id,
 125                                   uword cli_process_id)
 126 {
 127   ping_main_t *pm = &ping_main;
 128   ping_run_t *pr;
 129
 130   clib_spinlock_lock_if_init (&pm->ping_run_check_lock);
 131   vec_foreach (pr, pm->active_ping_runs)
 132   {
 133     if (pr->icmp_id == icmp_id)
 134       {
 135         pr->cli_process_id = cli_process_id;
 136         goto have_found_and_set;
 137       }
 138   }
 139   /* no such key yet - add a new one */
 140   ping_run_t new_pr = {.icmp_id = icmp_id,.cli_process_id = cli_process_id };
 141   vec_add1 (pm->active_ping_runs, new_pr);
 142 have_found_and_set:
 143   clib_spinlock_unlock_if_init (&pm->ping_run_check_lock);
 144 }
 145
 146
 147 static_always_inline void
 148 clear_cli_process_id_by_icmp_id_mt (vlib_main_t * vm, u16 icmp_id)
 149 {
 150   ping_main_t *pm = &ping_main;
 151   ping_run_t *pr;
 152
 153   clib_spinlock_lock_if_init (&pm->ping_run_check_lock);
 154   vec_foreach (pr, pm->active_ping_runs)
 155   {
 156     if (pr->icmp_id == icmp_id)
 157       {
 158         vec_del1 (pm->active_ping_runs, pm->active_ping_runs - pr);
 159         break;
 160       }
 161   }
 162   clib_spinlock_unlock_if_init (&pm->ping_run_check_lock);
 163 }
 164
 165 static_always_inline int
 166 ip46_get_icmp_id_and_seq (vlib_main_t * vm, vlib_buffer_t * b0,
 167                           u16 * out_icmp_id, u16 * out_icmp_seq, int is_ip6)
 168 {
 169   int l4_offset;
 170   if (is_ip6)
 171     {
 172       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
 173       if (ip6->protocol != IP_PROTOCOL_ICMP6)
 174         {
 175           return 0;
 176         }
 177       l4_offset = sizeof (*ip6);        // IPv6 EH
 178     }
 179   else
 180     {
 181       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
 182       l4_offset = ip4_header_bytes (ip4);
 183
 184     }
 185   icmp46_header_t *icmp46 = vlib_buffer_get_current (b0) + l4_offset;
 186   icmp46_echo_request_t *icmp46_echo = (icmp46_echo_request_t *) (icmp46 + 1);
 187
 188   *out_icmp_id = clib_net_to_host_u16 (icmp46_echo->id);
 189   *out_icmp_seq = clib_net_to_host_u16 (icmp46_echo->seq);
 190   return 1;
 191 }
 192
 193 /*
 194  * post the buffer to a given cli process node - the caller should forget bi0 after return.
 195  */
 196
 197 static_always_inline void
 198 ip46_post_icmp_reply_event (vlib_main_t * vm, uword cli_process_id, u32 bi0,
 199                             int is_ip6)
 200 {
 201   vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
 202   u64 nowts = clib_cpu_time_now ();
 203
 204   /* Pass the timestamp to the cli_process thanks to the vnet_buffer unused metadata field */
 205
 206   /* Camping on unused data... just ensure statically that there is enough space */
 207   STATIC_ASSERT (ARRAY_LEN (vnet_buffer (b0)->unused) *
 208                  sizeof (vnet_buffer (b0)->unused[0]) > sizeof (nowts),
 209                  "ping reply timestamp fits within remaining space of vnet_buffer unused data");
 210   u64 *pnowts = (void *) &vnet_buffer (b0)->unused[0];
 211   *pnowts = nowts;
 212
 213   u32 event_id = is_ip6 ? PING_RESPONSE_IP6 : PING_RESPONSE_IP4;
 214   vlib_process_signal_event_mt (vm, cli_process_id, event_id, bi0);
 215 }
 216
 217
 218 static_always_inline void
 219 ip46_echo_reply_maybe_trace_buffer (vlib_main_t * vm,
 220                                     vlib_node_runtime_t * node,
 221                                     uword cli_process_id, u16 id, u16 seq,
 222                                     vlib_buffer_t * b0, int is_ip6)
 223 {
 224   if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 225     {
 226       icmp_echo_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
 227       tr->id = id;
 228       tr->seq = seq;
 229       tr->cli_process_node = cli_process_id;
 230       tr->is_ip6 = is_ip6;
 231     }
 232 }
 233
 234
 235 static_always_inline uword
 236 ip46_icmp_echo_reply_inner_node_fn (vlib_main_t * vm,
 237                                     vlib_node_runtime_t * node,
 238                                     vlib_frame_t * frame, int do_trace,
 239                                     int is_ip6)
 240 {
 241   u32 n_left_from, *from, *to_next;
 242   icmp46_echo_reply_next_t next_index;
 243
 244   from = vlib_frame_vector_args (frame);
 245   n_left_from = frame->n_vectors;
 246
 247   next_index = node->cached_next_index;
 248
 249   while (n_left_from > 0)
 250     {
 251       u32 n_left_to_next;
 252       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 253
 254       while (n_left_from > 0 && n_left_to_next > 0)
 255         {
 256           u32 bi0;
 257           vlib_buffer_t *b0;
 258           /*
 259            * The buffers (replies) are either posted to the CLI thread
 260            * awaiting for them for subsequent analysis and disposal,
 261            * or are sent to the punt node.
 262            *
 263            * So the only "next" node is a punt, normally.
 264            */
 265           u32 next0 = ICMP46_ECHO_REPLY_NEXT_PUNT;
 266
 267           bi0 = from[0];
 268           b0 = vlib_get_buffer (vm, bi0);
 269           from += 1;
 270           n_left_from -= 1;
 271
 272           u16 icmp_id = ~0;
 273           u16 icmp_seq = ~0;
 274           uword cli_process_id = PING_CLI_UNKNOWN_NODE;
 275
 276           if (ip46_get_icmp_id_and_seq (vm, b0, &icmp_id, &icmp_seq, is_ip6))
 277             {
 278               cli_process_id = get_cli_process_id_by_icmp_id_mt (vm, icmp_id);
 279             }
 280
 281           if (do_trace)
 282             ip46_echo_reply_maybe_trace_buffer (vm, node, cli_process_id,
 283                                                 icmp_id, icmp_seq, b0,
 284                                                 is_ip6);
 285
 286           if (~0 == cli_process_id)
 287             {
 288               /* no outstanding requests for this reply, punt */
 289               /* speculatively enqueue b0 to the current next frame */
 290               to_next[0] = bi0;
 291               to_next += 1;
 292               n_left_to_next -= 1;
 293               /* verify speculative enqueue, maybe switch current next frame */
 294               vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 295                                                to_next, n_left_to_next,
 296                                                bi0, next0);
 297             }
 298           else
 299             {
 300               /* Post the buffer to CLI thread. It will take care of freeing it. */
 301               ip46_post_icmp_reply_event (vm, cli_process_id, bi0, is_ip6);
 302             }
 303         }
 304       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 305     }
 306   return frame->n_vectors;
 307 }
 308
 309 /*
 310  * select "with-trace" or "without-trace" codepaths upfront.
 311  */
 312 static_always_inline uword
 313 ip46_icmp_echo_reply_outer_node_fn (vlib_main_t * vm,
 314                                     vlib_node_runtime_t * node,
 315                                     vlib_frame_t * frame, int is_ip6)
 316 {
 317   if (node->flags & VLIB_NODE_FLAG_TRACE)
 318     return ip46_icmp_echo_reply_inner_node_fn (vm, node, frame,
 319                                                1 /* do_trace */ , is_ip6);
 320   else
 321     return ip46_icmp_echo_reply_inner_node_fn (vm, node, frame,
 322                                                0 /* do_trace */ , is_ip6);
 323 }
 324
 325 static uword
 326 ip4_icmp_echo_reply_node_fn (vlib_main_t * vm,
 327                              vlib_node_runtime_t * node, vlib_frame_t * frame)
 328 {
 329   return ip46_icmp_echo_reply_outer_node_fn (vm, node, frame,
 330                                              0 /* is_ip6 */ );
 331 }
 332
 333 static uword
 334 ip6_icmp_echo_reply_node_fn (vlib_main_t * vm,
 335                              vlib_node_runtime_t * node, vlib_frame_t * frame)
 336 {
 337   return ip46_icmp_echo_reply_outer_node_fn (vm, node, frame,
 338                                              1 /* is_ip6 */ );
 339 }
 340
 341 /* *INDENT-OFF* */
 342 VLIB_REGISTER_NODE (ip6_icmp_echo_reply_node, static) =
 343 {
 344   .function = ip6_icmp_echo_reply_node_fn,
 345   .name = "ip6-icmp-echo-reply",
 346   .vector_size = sizeof (u32),
 347   .format_trace = format_icmp_echo_trace,
 348   .n_next_nodes = ICMP46_ECHO_REPLY_N_NEXT,
 349   .next_nodes = {
 350     [ICMP46_ECHO_REPLY_NEXT_DROP] = "ip6-drop",
 351     [ICMP46_ECHO_REPLY_NEXT_PUNT] = "ip6-punt",
 352   },
 353 };
 354
 355 VLIB_REGISTER_NODE (ip4_icmp_echo_reply_node, static) =
 356 {
 357   .function = ip4_icmp_echo_reply_node_fn,
 358   .name = "ip4-icmp-echo-reply",
 359   .vector_size = sizeof (u32),
 360   .format_trace = format_icmp_echo_trace,
 361   .n_next_nodes = ICMP46_ECHO_REPLY_N_NEXT,
 362   .next_nodes = {
 363     [ICMP46_ECHO_REPLY_NEXT_DROP] = "ip4-drop",
 364     [ICMP46_ECHO_REPLY_NEXT_PUNT] = "ip4-punt",
 365   },
 366 };
 367 /* *INDENT-ON* */
 368
 369 static uword
 370 ip4_icmp_echo_request (vlib_main_t * vm,
 371                        vlib_node_runtime_t * node, vlib_frame_t * frame)
 372 {
 373   uword n_packets = frame->n_vectors;
 374   u32 *from, *to_next;
 375   u32 n_left_from, n_left_to_next, next;
 376   ip4_main_t *i4m = &ip4_main;
 377   u16 *fragment_ids, *fid;
 378   u8 host_config_ttl = i4m->host_config.ttl;
 379
 380   from = vlib_frame_vector_args (frame);
 381   n_left_from = n_packets;
 382   next = node->cached_next_index;
 383
 384   if (node->flags & VLIB_NODE_FLAG_TRACE)
 385     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 386                                    /* stride */ 1,
 387                                    sizeof (icmp_input_trace_t));
 388
 389   /* Get random fragment IDs for replies. */
 390   fid = fragment_ids = clib_random_buffer_get_data (&vm->random_buffer,
 391                                                     n_packets *
 392                                                     sizeof (fragment_ids[0]));
 393
 394   while (n_left_from > 0)
 395     {
 396       vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
 397
 398       while (n_left_from > 2 && n_left_to_next > 2)
 399         {
 400           vlib_buffer_t *p0, *p1;
 401           ip4_header_t *ip0, *ip1;
 402           icmp46_header_t *icmp0, *icmp1;
 403           u32 bi0, src0, dst0;
 404           u32 bi1, src1, dst1;
 405           ip_csum_t sum0, sum1;
 406
 407           bi0 = to_next[0] = from[0];
 408           bi1 = to_next[1] = from[1];
 409
 410           from += 2;
 411           n_left_from -= 2;
 412           to_next += 2;
 413           n_left_to_next -= 2;
 414
 415           p0 = vlib_get_buffer (vm, bi0);
 416           p1 = vlib_get_buffer (vm, bi1);
 417           ip0 = vlib_buffer_get_current (p0);
 418           ip1 = vlib_buffer_get_current (p1);
 419           icmp0 = ip4_next_header (ip0);
 420           icmp1 = ip4_next_header (ip1);
 421
 422           vnet_buffer (p0)->sw_if_index[VLIB_RX] =
 423             vnet_main.local_interface_sw_if_index;
 424           vnet_buffer (p1)->sw_if_index[VLIB_RX] =
 425             vnet_main.local_interface_sw_if_index;
 426
 427           /* Update ICMP checksum. */
 428           sum0 = icmp0->checksum;
 429           sum1 = icmp1->checksum;
 430
 431           ASSERT (icmp0->type == ICMP4_echo_request);
 432           ASSERT (icmp1->type == ICMP4_echo_request);
 433           sum0 = ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
 434                                  icmp46_header_t, type);
 435           sum1 = ip_csum_update (sum1, ICMP4_echo_request, ICMP4_echo_reply,
 436                                  icmp46_header_t, type);
 437           icmp0->type = ICMP4_echo_reply;
 438           icmp1->type = ICMP4_echo_reply;
 439
 440           icmp0->checksum = ip_csum_fold (sum0);
 441           icmp1->checksum = ip_csum_fold (sum1);
 442
 443           src0 = ip0->src_address.data_u32;
 444           src1 = ip1->src_address.data_u32;
 445           dst0 = ip0->dst_address.data_u32;
 446           dst1 = ip1->dst_address.data_u32;
 447
 448           /* Swap source and destination address.
 449              Does not change checksum. */
 450           ip0->src_address.data_u32 = dst0;
 451           ip1->src_address.data_u32 = dst1;
 452           ip0->dst_address.data_u32 = src0;
 453           ip1->dst_address.data_u32 = src1;
 454
 455           /* Update IP checksum. */
 456           sum0 = ip0->checksum;
 457           sum1 = ip1->checksum;
 458
 459           sum0 = ip_csum_update (sum0, ip0->ttl, host_config_ttl,
 460                                  ip4_header_t, ttl);
 461           sum1 = ip_csum_update (sum1, ip1->ttl, host_config_ttl,
 462                                  ip4_header_t, ttl);
 463           ip0->ttl = host_config_ttl;
 464           ip1->ttl = host_config_ttl;
 465
 466           /* New fragment id. */
 467           sum0 = ip_csum_update (sum0, ip0->fragment_id, fid[0],
 468                                  ip4_header_t, fragment_id);
 469           sum1 = ip_csum_update (sum1, ip1->fragment_id, fid[1],
 470                                  ip4_header_t, fragment_id);
 471           ip0->fragment_id = fid[0];
 472           ip1->fragment_id = fid[1];
 473           fid += 2;
 474
 475           ip0->checksum = ip_csum_fold (sum0);
 476           ip1->checksum = ip_csum_fold (sum1);
 477
 478           ASSERT (ip4_header_checksum_is_valid (ip0));
 479           ASSERT (ip4_header_checksum_is_valid (ip1));
 480
 481           p0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 482           p1->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 483         }
 484
 485       while (n_left_from > 0 && n_left_to_next > 0)
 486         {
 487           vlib_buffer_t *p0;
 488           ip4_header_t *ip0;
 489           icmp46_header_t *icmp0;
 490           u32 bi0, src0, dst0;
 491           ip_csum_t sum0;
 492
 493           bi0 = to_next[0] = from[0];
 494
 495           from += 1;
 496           n_left_from -= 1;
 497           to_next += 1;
 498           n_left_to_next -= 1;
 499
 500           p0 = vlib_get_buffer (vm, bi0);
 501           ip0 = vlib_buffer_get_current (p0);
 502           icmp0 = ip4_next_header (ip0);
 503
 504           vnet_buffer (p0)->sw_if_index[VLIB_RX] =
 505             vnet_main.local_interface_sw_if_index;
 506
 507           /* Update ICMP checksum. */
 508           sum0 = icmp0->checksum;
 509
 510           ASSERT (icmp0->type == ICMP4_echo_request);
 511           sum0 = ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
 512                                  icmp46_header_t, type);
 513           icmp0->type = ICMP4_echo_reply;
 514           icmp0->checksum = ip_csum_fold (sum0);
 515
 516           src0 = ip0->src_address.data_u32;
 517           dst0 = ip0->dst_address.data_u32;
 518           ip0->src_address.data_u32 = dst0;
 519           ip0->dst_address.data_u32 = src0;
 520
 521           /* Update IP checksum. */
 522           sum0 = ip0->checksum;
 523
 524           sum0 = ip_csum_update (sum0, ip0->ttl, host_config_ttl,
 525                                  ip4_header_t, ttl);
 526           ip0->ttl = host_config_ttl;
 527
 528           sum0 = ip_csum_update (sum0, ip0->fragment_id, fid[0],
 529                                  ip4_header_t, fragment_id);
 530           ip0->fragment_id = fid[0];
 531           fid += 1;
 532
 533           ip0->checksum = ip_csum_fold (sum0);
 534
 535           ASSERT (ip4_header_checksum_is_valid (ip0));
 536
 537           p0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 538         }
 539
 540       vlib_put_next_frame (vm, node, next, n_left_to_next);
 541     }
 542
 543   vlib_error_count (vm, ip4_icmp_input_node.index,
 544                     ICMP4_ERROR_ECHO_REPLIES_SENT, frame->n_vectors);
 545
 546   return frame->n_vectors;
 547 }
 548
 549 static u8 *
 550 format_icmp_input_trace (u8 * s, va_list * va)
 551 {
 552   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
 553   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 554   icmp_input_trace_t *t = va_arg (*va, icmp_input_trace_t *);
 555
 556   s = format (s, "%U",
 557               format_ip4_header, t->packet_data, sizeof (t->packet_data));
 558
 559   return s;
 560 }
 561
 562 /* *INDENT-OFF* */
 563 VLIB_REGISTER_NODE (ip4_icmp_echo_request_node,static) = {
 564   .function = ip4_icmp_echo_request,
 565   .name = "ip4-icmp-echo-request",
 566
 567   .vector_size = sizeof (u32),
 568
 569   .format_trace = format_icmp_input_trace,
 570
 571   .n_next_nodes = 1,
 572   .next_nodes = {
 573     [0] = "ip4-load-balance",
 574   },
 575 };
 576 /* *INDENT-ON* */
 577
 578 /*
 579  * A swarm of address-family agnostic helper functions
 580  * for building and sending the ICMP echo request.
 581  *
 582  * Deliberately mostly "static" rather than "static inline"
 583  * so one can trace them sanely if needed in debugger, if needed.
 584  *
 585  */
 586
 587 static_always_inline u8
 588 get_icmp_echo_payload_byte (int offset)
 589 {
 590   return (offset % 256);
 591 }
 592
 593 /* Fill in the ICMP ECHO structure, return the safety-checked and possibly shrunk data_len */
 594 static u16
 595 init_icmp46_echo_request (vlib_main_t * vm, vlib_buffer_t * b0,
 596                           int l4_header_offset,
 597                           icmp46_echo_request_t * icmp46_echo, u16 seq_host,
 598                           u16 id_host, u64 now, u16 data_len)
 599 {
 600   int i;
 601
 602
 603   int l34_len =
 604     l4_header_offset + sizeof (icmp46_header_t) +
 605     offsetof (icmp46_echo_request_t, data);
 606   int max_data_len = vlib_buffer_get_default_data_size (vm) - l34_len;
 607
 608   int first_buf_data_len = data_len < max_data_len ? data_len : max_data_len;
 609
 610   int payload_offset = 0;
 611   for (i = 0; i < first_buf_data_len; i++)
 612     icmp46_echo->data[i] = get_icmp_echo_payload_byte (payload_offset++);
 613
 614   /* inspired by vlib_buffer_add_data */
 615   vlib_buffer_t *hb = b0;
 616   int remaining_data_len = data_len - first_buf_data_len;
 617   while (remaining_data_len)
 618     {
 619       int this_buf_data_len =
 620         remaining_data_len <
 621         vlib_buffer_get_default_data_size (vm) ? remaining_data_len :
 622         vlib_buffer_get_default_data_size (vm);
 623       int n_alloc = vlib_buffer_alloc (vm, &b0->next_buffer, 1);
 624       if (n_alloc < 1)
 625         {
 626           /* That is how much we have so far - return it... */
 627           return (data_len - remaining_data_len);
 628         }
 629       b0->flags |= VLIB_BUFFER_NEXT_PRESENT;
 630       /* move on to the newly acquired buffer */
 631       b0 = vlib_get_buffer (vm, b0->next_buffer);
 632       /* initialize the data */
 633       for (i = 0; i < this_buf_data_len; i++)
 634         {
 635           b0->data[i] = get_icmp_echo_payload_byte (payload_offset++);
 636         }
 637       b0->current_length = this_buf_data_len;
 638       b0->current_data = 0;
 639       remaining_data_len -= this_buf_data_len;
 640     }
 641   hb->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
 642   hb->current_length = l34_len + first_buf_data_len;
 643   hb->total_length_not_including_first_buffer = data_len - first_buf_data_len;
 644
 645   icmp46_echo->time_sent = now;
 646   icmp46_echo->seq = clib_host_to_net_u16 (seq_host);
 647   icmp46_echo->id = clib_host_to_net_u16 (id_host);
 648   return data_len;
 649 }
 650
 651
 652 static u32
 653 ip46_fib_index_from_table_id (u32 table_id, int is_ip6)
 654 {
 655   u32 fib_index = is_ip6 ?
 656     ip6_fib_index_from_table_id (table_id) :
 657     ip4_fib_index_from_table_id (table_id);
 658   return fib_index;
 659 }
 660
 661 static fib_node_index_t
 662 ip46_fib_table_lookup_host (u32 fib_index, ip46_address_t * pa46, int is_ip6)
 663 {
 664   fib_node_index_t fib_entry_index = is_ip6 ?
 665     ip6_fib_table_lookup (fib_index, &pa46->ip6, 128) :
 666     ip4_fib_table_lookup (ip4_fib_get (fib_index), &pa46->ip4, 32);
 667   return fib_entry_index;
 668 }
 669
 670 static u32
 671 ip46_get_resolving_interface (u32 fib_index, ip46_address_t * pa46,
 672                               int is_ip6)
 673 {
 674   u32 sw_if_index = ~0;
 675   if (~0 != fib_index)
 676     {
 677       fib_node_index_t fib_entry_index;
 678       fib_entry_index = ip46_fib_table_lookup_host (fib_index, pa46, is_ip6);
 679       sw_if_index = fib_entry_get_resolving_interface (fib_entry_index);
 680     }
 681   return sw_if_index;
 682 }
 683
 684 static u32
 685 ip46_fib_table_get_index_for_sw_if_index (u32 sw_if_index, int is_ip6)
 686 {
 687   u32 fib_table_index = is_ip6 ?
 688     ip6_fib_table_get_index_for_sw_if_index (sw_if_index) :
 689     ip4_fib_table_get_index_for_sw_if_index (sw_if_index);
 690   return fib_table_index;
 691
 692 }
 693
 694
 695 static int
 696 ip46_fill_l3_header (ip46_address_t * pa46, vlib_buffer_t * b0, int is_ip6)
 697 {
 698   if (is_ip6)
 699     {
 700       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
 701       /* Fill in ip6 header fields */
 702       ip6->ip_version_traffic_class_and_flow_label =
 703         clib_host_to_net_u32 (0x6 << 28);
 704       ip6->payload_length = 0;  /* will be set later */
 705       ip6->protocol = IP_PROTOCOL_ICMP6;
 706       ip6->hop_limit = 255;
 707       ip6->dst_address = pa46->ip6;
 708       ip6->src_address = pa46->ip6;
 709       return (sizeof (ip6_header_t));
 710     }
 711   else
 712     {
 713       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
 714       /* Fill in ip4 header fields */
 715       ip4->checksum = 0;
 716       ip4->ip_version_and_header_length = 0x45;
 717       ip4->tos = 0;
 718       ip4->length = 0;          /* will be set later */
 719       ip4->fragment_id = 0;
 720       ip4->flags_and_fragment_offset = 0;
 721       ip4->ttl = 0xff;
 722       ip4->protocol = IP_PROTOCOL_ICMP;
 723       ip4->src_address = pa46->ip4;
 724       ip4->dst_address = pa46->ip4;
 725       return (sizeof (ip4_header_t));
 726     }
 727 }
 728
 729 static bool
 730 ip46_set_src_address (u32 sw_if_index, vlib_buffer_t * b0, int is_ip6)
 731 {
 732   bool res = false;
 733
 734   if (is_ip6)
 735     {
 736       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
 737
 738       res = fib_sas6_get (sw_if_index, &ip6->dst_address, &ip6->src_address);
 739     }
 740   else
 741     {
 742       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
 743
 744       res = fib_sas4_get (sw_if_index, &ip4->dst_address, &ip4->src_address);
 745     }
 746   return res;
 747 }
 748
 749 static void
 750 ip46_print_buffer_src_address (vlib_main_t * vm, vlib_buffer_t * b0,
 751                                int is_ip6)
 752 {
 753   void *format_addr_func;
 754   void *paddr;
 755   if (is_ip6)
 756     {
 757       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
 758       format_addr_func = format_ip6_address;
 759       paddr = &ip6->src_address;
 760     }
 761   else
 762     {
 763       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
 764       format_addr_func = format_ip4_address;
 765       paddr = &ip4->src_address;
 766     }
 767   vlib_cli_output (vm, "Source address: %U ", format_addr_func, paddr);
 768 }
 769
 770 static u16
 771 ip46_fill_icmp_request_at (vlib_main_t * vm, int l4_offset, u16 seq_host,
 772                            u16 id_host, u16 data_len, vlib_buffer_t * b0,
 773                            int is_ip6)
 774 {
 775   icmp46_header_t *icmp46 = vlib_buffer_get_current (b0) + l4_offset;
 776
 777   icmp46->type = is_ip6 ? ICMP6_echo_request : ICMP4_echo_request;
 778   icmp46->code = 0;
 779   icmp46->checksum = 0;
 780
 781   icmp46_echo_request_t *icmp46_echo = (icmp46_echo_request_t *) (icmp46 + 1);
 782
 783   data_len =
 784     init_icmp46_echo_request (vm, b0, l4_offset, icmp46_echo, seq_host,
 785                               id_host, clib_cpu_time_now (), data_len);
 786   return data_len;
 787 }
 788
 789
 790 /* Compute ICMP4 checksum with multibuffer support. */
 791 u16
 792 ip4_icmp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
 793                            ip4_header_t * ip0)
 794 {
 795   ip_csum_t sum0;
 796   u32 ip_header_length, payload_length_host_byte_order;
 797   u32 n_this_buffer, n_bytes_left, n_ip_bytes_this_buffer;
 798   u16 sum16;
 799   void *data_this_buffer;
 800
 801   ip_header_length = ip4_header_bytes (ip0);
 802   payload_length_host_byte_order =
 803     clib_net_to_host_u16 (ip0->length) - ip_header_length;
 804
 805   /* ICMP4 checksum does not include the IP header */
 806   sum0 = 0;
 807
 808   n_bytes_left = n_this_buffer = payload_length_host_byte_order;
 809   data_this_buffer = (void *) ip0 + ip_header_length;
 810   n_ip_bytes_this_buffer =
 811     p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data);
 812   if (n_this_buffer + ip_header_length > n_ip_bytes_this_buffer)
 813     {
 814       n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
 815         n_ip_bytes_this_buffer - ip_header_length : 0;
 816     }
 817   while (1)
 818     {
 819       sum0 = ip_incremental_checksum (sum0, data_this_buffer, n_this_buffer);
 820       n_bytes_left -= n_this_buffer;
 821       if (n_bytes_left == 0)
 822         break;
 823
 824       ASSERT (p0->flags & VLIB_BUFFER_NEXT_PRESENT);
 825       p0 = vlib_get_buffer (vm, p0->next_buffer);
 826       data_this_buffer = vlib_buffer_get_current (p0);
 827       n_this_buffer = p0->current_length;
 828     }
 829
 830   sum16 = ~ip_csum_fold (sum0);
 831
 832   return sum16;
 833 }
 834
 835
 836 static void
 837 ip46_fix_len_and_csum (vlib_main_t * vm, int l4_offset, u16 data_len,
 838                        vlib_buffer_t * b0, int is_ip6)
 839 {
 840   u16 payload_length =
 841     data_len + sizeof (icmp46_header_t) + offsetof (icmp46_echo_request_t,
 842                                                     data);
 843   u16 total_length = payload_length + l4_offset;
 844   icmp46_header_t *icmp46 = vlib_buffer_get_current (b0) + l4_offset;
 845   icmp46->checksum = 0;
 846
 847   if (is_ip6)
 848     {
 849       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
 850       ip6->payload_length = clib_host_to_net_u16 (payload_length);
 851
 852       int bogus_length = 0;
 853       icmp46->checksum =
 854         ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip6, &bogus_length);
 855     }
 856   else
 857     {
 858       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
 859       ip4->length = clib_host_to_net_u16 (total_length);
 860
 861       ip4->checksum = ip4_header_checksum (ip4);
 862       icmp46->checksum = ip4_icmp_compute_checksum (vm, b0, ip4);
 863     }
 864 }
 865
 866 static u16
 867 at_most_a_frame (u32 count)
 868 {
 869   return count > VLIB_FRAME_SIZE ? VLIB_FRAME_SIZE : count;
 870 }
 871
 872 static int
 873 ip46_enqueue_packet (vlib_main_t * vm, vlib_buffer_t * b0, u32 burst,
 874                      int is_ip6)
 875 {
 876   vlib_frame_t *f = 0;
 877   u32 lookup_node_index =
 878     is_ip6 ? ip6_lookup_node.index : ip4_lookup_node.index;
 879   int n_sent = 0;
 880
 881   u16 n_to_send;
 882
 883   /*
 884    * Enqueue the packet, possibly as one or more frames of copies to make
 885    * bursts. We enqueue b0 as the very last buffer, when there is no possibility
 886    * for error in vlib_buffer_copy, so as to allow the caller to free it
 887    * in case we encounter the error in the middle of the loop.
 888    */
 889   for (n_to_send = at_most_a_frame (burst), burst -= n_to_send; n_to_send > 0;
 890        n_to_send = at_most_a_frame (burst), burst -= n_to_send)
 891     {
 892       f = vlib_get_frame_to_node (vm, lookup_node_index);
 893       /* f can not be NULL here - frame allocation failure causes panic */
 894
 895       u32 *to_next = vlib_frame_vector_args (f);
 896       f->n_vectors = n_to_send;
 897
 898       while (n_to_send > 1)
 899         {
 900           vlib_buffer_t *b0copy = vlib_buffer_copy (vm, b0);
 901           if (PREDICT_FALSE (b0copy == NULL))
 902             goto ship_and_ret;
 903           *to_next++ = vlib_get_buffer_index (vm, b0copy);
 904           n_to_send--;
 905           n_sent++;
 906         }
 907
 908       /* n_to_send is guaranteed to equal 1 here */
 909       if (burst > 0)
 910         {
 911           /* not the last burst, so still make a copy for the last buffer */
 912           vlib_buffer_t *b0copy = vlib_buffer_copy (vm, b0);
 913           if (PREDICT_FALSE (b0copy == NULL))
 914             goto ship_and_ret;
 915           n_to_send--;
 916           *to_next++ = vlib_get_buffer_index (vm, b0copy);
 917         }
 918       else
 919         {
 920           /* put the original buffer as the last one of an error-free run */
 921           *to_next++ = vlib_get_buffer_index (vm, b0);
 922         }
 923       vlib_put_frame_to_node (vm, lookup_node_index, f);
 924       n_sent += f->n_vectors;
 925     }
 926   return n_sent;
 927   /*
 928    * We reach here in case we already enqueued one or more buffers
 929    * and maybe one or more frames but could not make more copies.
 930    * There is an outstanding frame - so ship it and return.
 931    * Caller will have to free the b0 in this case, since
 932    * we did not enqueue it here yet.
 933    */
 934 ship_and_ret:
 935   ASSERT (n_to_send <= f->n_vectors);
 936   f->n_vectors -= n_to_send;
 937   n_sent += f->n_vectors;
 938   vlib_put_frame_to_node (vm, lookup_node_index, f);
 939   return n_sent;
 940 }
 941
 942
 943 /*
 944  * An address-family agnostic ping send function.
 945  */
 946
 947 #define ERROR_OUT(e) do { err = e; goto done; } while (0)
 948
 949 static send_ip46_ping_result_t
 950 send_ip46_ping (vlib_main_t * vm,
 951                 u32 table_id,
 952                 ip46_address_t * pa46,
 953                 u32 sw_if_index,
 954                 u16 seq_host, u16 id_host, u16 data_len, u32 burst,
 955                 u8 verbose, int is_ip6)
 956 {
 957   int err = SEND_PING_OK;
 958   u32 bi0 = 0;
 959   int n_buf0 = 0;
 960   vlib_buffer_t *b0;
 961
 962   n_buf0 = vlib_buffer_alloc (vm, &bi0, 1);
 963   if (n_buf0 < 1)
 964     ERROR_OUT (SEND_PING_ALLOC_FAIL);
 965
 966   b0 = vlib_get_buffer (vm, bi0);
 967   VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 968
 969   /*
 970    * if the user did not provide a source interface,
 971    * perform a resolution and use an interface
 972    * via which it succeeds.
 973    */
 974   u32 fib_index;
 975   if (~0 == sw_if_index)
 976     {
 977       fib_index = ip46_fib_index_from_table_id (table_id, is_ip6);
 978       sw_if_index = ip46_get_resolving_interface (fib_index, pa46, is_ip6);
 979     }
 980   else
 981     fib_index =
 982       ip46_fib_table_get_index_for_sw_if_index (sw_if_index, is_ip6);
 983
 984   if (~0 == fib_index)
 985     ERROR_OUT (SEND_PING_NO_TABLE);
 986   if (~0 == sw_if_index)
 987     ERROR_OUT (SEND_PING_NO_INTERFACE);
 988
 989   vnet_buffer (b0)->sw_if_index[VLIB_RX] = sw_if_index;
 990   vnet_buffer (b0)->sw_if_index[VLIB_TX] = fib_index;
 991
 992   int l4_header_offset = ip46_fill_l3_header (pa46, b0, is_ip6);
 993
 994   /* set the src address in the buffer */
 995   if (!ip46_set_src_address (sw_if_index, b0, is_ip6))
 996     ERROR_OUT (SEND_PING_NO_SRC_ADDRESS);
 997   if (verbose)
 998     ip46_print_buffer_src_address (vm, b0, is_ip6);
 999
1000   data_len =
1001     ip46_fill_icmp_request_at (vm, l4_header_offset, seq_host, id_host,
1002                                data_len, b0, is_ip6);
1003
1004   ip46_fix_len_and_csum (vm, l4_header_offset, data_len, b0, is_ip6);
1005
1006   int n_sent = ip46_enqueue_packet (vm, b0, burst, is_ip6);
1007   if (n_sent < burst)
1008     err = SEND_PING_NO_BUFFERS;
1009
1010 done:
1011   if (err != SEND_PING_OK)
1012     {
1013       if (n_buf0 > 0)
1014         vlib_buffer_free (vm, &bi0, 1);
1015     }
1016   return err;
1017 }
1018
1019 static send_ip46_ping_result_t
1020 send_ip6_ping (vlib_main_t * vm,
1021                u32 table_id, ip6_address_t * pa6,
1022                u32 sw_if_index, u16 seq_host, u16 id_host, u16 data_len,
1023                u32 burst, u8 verbose)
1024 {
1025   ip46_address_t target;
1026   target.ip6 = *pa6;
1027   return send_ip46_ping (vm, table_id, &target, sw_if_index, seq_host,
1028                          id_host, data_len, burst, verbose, 1 /* is_ip6 */ );
1029 }
1030
1031 static send_ip46_ping_result_t
1032 send_ip4_ping (vlib_main_t * vm,
1033                u32 table_id, ip4_address_t * pa4,
1034                u32 sw_if_index, u16 seq_host, u16 id_host, u16 data_len,
1035                u32 burst, u8 verbose)
1036 {
1037   ip46_address_t target;
1038   ip46_address_set_ip4 (&target, pa4);
1039   return send_ip46_ping (vm, table_id, &target, sw_if_index, seq_host,
1040                          id_host, data_len, burst, verbose, 0 /* is_ip6 */ );
1041 }
1042
1043 static void
1044 print_ip46_icmp_reply (vlib_main_t * vm, u32 bi0, int is_ip6)
1045 {
1046   vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
1047   int l4_offset;
1048   void *paddr;
1049   void *format_addr_func;
1050   u16 payload_length;
1051   u8 ttl;
1052   if (is_ip6)
1053     {
1054       ip6_header_t *ip6 = vlib_buffer_get_current (b0);
1055       paddr = (void *) &ip6->src_address;
1056       format_addr_func = (void *) format_ip6_address;
1057       ttl = ip6->hop_limit;
1058       l4_offset = sizeof (ip6_header_t);        // FIXME - EH processing ?
1059       payload_length = clib_net_to_host_u16 (ip6->payload_length);
1060     }
1061   else
1062     {
1063       ip4_header_t *ip4 = vlib_buffer_get_current (b0);
1064       paddr = (void *) &ip4->src_address;
1065       format_addr_func = (void *) format_ip4_address;
1066       ttl = ip4->ttl;
1067       l4_offset = ip4_header_bytes (ip4);
1068       payload_length =
1069         clib_net_to_host_u16 (ip4->length) + ip4_header_bytes (ip4);
1070     }
1071   icmp46_header_t *icmp = vlib_buffer_get_current (b0) + l4_offset;
1072   icmp46_echo_request_t *icmp_echo = (icmp46_echo_request_t *) (icmp + 1);
1073   u64 *dataplane_ts = (u64 *) & vnet_buffer (b0)->unused[0];
1074
1075   f64 clocks_per_second = ((f64) vm->clib_time.clocks_per_second);
1076   f64 rtt =
1077     ((f64) (*dataplane_ts - icmp_echo->time_sent)) / clocks_per_second;
1078
1079   vlib_cli_output (vm,
1080                    "%d bytes from %U: icmp_seq=%d ttl=%d time=%.4f ms",
1081                    payload_length,
1082                    format_addr_func,
1083                    paddr,
1084                    clib_host_to_net_u16 (icmp_echo->seq), ttl, rtt * 1000.0);
1085 }
1086
1087 /*
1088  * Perform the ping run with the given parameters in the current CLI process.
1089  * Depending on whether pa4 or pa6 is set, runs IPv4 or IPv6 ping.
1090  * The amusing side effect is of course if both are set, then both pings are sent.
1091  * This behavior can be used to ping a dualstack host over IPv4 and IPv6 at once.
1092  */
1093
1094 static void
1095 run_ping_ip46_address (vlib_main_t * vm, u32 table_id, ip4_address_t * pa4,
1096                        ip6_address_t * pa6, u32 sw_if_index,
1097                        f64 ping_interval, u32 ping_repeat, u32 data_len,
1098                        u32 ping_burst, u32 verbose)
1099 {
1100   int i;
1101   uword curr_proc = vlib_current_process (vm);
1102   u32 n_replies = 0;
1103   u32 n_requests = 0;
1104   u16 icmp_id;
1105
1106   static u32 rand_seed = 0;
1107
1108   if (PREDICT_FALSE (!rand_seed))
1109     rand_seed = random_default_seed ();
1110
1111   icmp_id = random_u32 (&rand_seed) & 0xffff;
1112
1113   while (~0 != get_cli_process_id_by_icmp_id_mt (vm, icmp_id))
1114     {
1115       vlib_cli_output (vm, "ICMP ID collision at %d, incrementing", icmp_id);
1116       icmp_id++;
1117     }
1118
1119   set_cli_process_id_by_icmp_id_mt (vm, icmp_id, curr_proc);
1120
1121   for (i = 1; i <= ping_repeat; i++)
1122     {
1123       send_ip46_ping_result_t res = SEND_PING_OK;
1124       f64 sleep_interval;
1125       f64 time_ping_sent = vlib_time_now (vm);
1126       if (pa6)
1127         {
1128           res = send_ip6_ping (vm, table_id,
1129                                pa6, sw_if_index, i, icmp_id,
1130                                data_len, ping_burst, verbose);
1131           if (SEND_PING_OK == res)
1132             n_requests += ping_burst;
1133           else
1134             vlib_cli_output (vm, "Failed: %U", format_ip46_ping_result, res);
1135         }
1136       if (pa4)
1137         {
1138           res = send_ip4_ping (vm, table_id, pa4,
1139                                sw_if_index, i, icmp_id, data_len,
1140                                ping_burst, verbose);
1141           if (SEND_PING_OK == res)
1142             n_requests += ping_burst;
1143           else
1144             vlib_cli_output (vm, "Failed: %U", format_ip46_ping_result, res);
1145         }
1146
1147       /* Collect and print the responses until it is time to send a next ping */
1148
1149       while ((i <= ping_repeat)
1150              &&
1151              ((sleep_interval =
1152                time_ping_sent + ping_interval - vlib_time_now (vm)) > 0.0))
1153         {
1154           uword event_type, *event_data = 0;
1155           vlib_process_wait_for_event_or_clock (vm, sleep_interval);
1156           event_type = vlib_process_get_events (vm, &event_data);
1157           switch (event_type)
1158             {
1159             case ~0:            /* no events => timeout */
1160               break;
1161             case PING_RESPONSE_IP6:
1162               /* fall-through */
1163             case PING_RESPONSE_IP4:
1164               {
1165                 int ii;
1166                 int is_ip6 = (event_type == PING_RESPONSE_IP6);
1167                 for (ii = 0; ii < vec_len (event_data); ii++)
1168                   {
1169                     u32 bi0 = event_data[ii];
1170                     print_ip46_icmp_reply (vm, bi0, is_ip6);
1171                     n_replies++;
1172                     if (0 != bi0)
1173                       vlib_buffer_free (vm, &bi0, 1);
1174                   }
1175               }
1176               break;
1177             case UNIX_CLI_PROCESS_EVENT_READ_READY:
1178             case UNIX_CLI_PROCESS_EVENT_QUIT:
1179               /* someone pressed a key, abort */
1180               vlib_cli_output (vm, "Aborted due to a keypress.");
1181               goto double_break;
1182             }
1183           vec_free (event_data);
1184         }
1185     }
1186 double_break:
1187   vlib_cli_output (vm, "\n");
1188   {
1189     float loss =
1190       (0 ==
1191        n_requests) ? 0 : 100.0 * ((float) n_requests -
1192                                   (float) n_replies) / (float) n_requests;
1193     vlib_cli_output (vm,
1194                      "Statistics: %u sent, %u received, %f%% packet loss\n",
1195                      n_requests, n_replies, loss);
1196     clear_cli_process_id_by_icmp_id_mt (vm, icmp_id);
1197   }
1198 }
1199
1200
1201
1202 static clib_error_t *
1203 ping_ip_address (vlib_main_t * vm,
1204                  unformat_input_t * input, vlib_cli_command_t * cmd)
1205 {
1206   ip4_address_t a4;
1207   ip6_address_t a6;
1208   clib_error_t *error = 0;
1209   u32 ping_repeat = 5;
1210   u32 ping_burst = 1;
1211   u8 ping_ip4, ping_ip6;
1212   vnet_main_t *vnm = vnet_get_main ();
1213   u32 data_len = PING_DEFAULT_DATA_LEN;
1214   u32 verbose = 0;
1215   f64 ping_interval = PING_DEFAULT_INTERVAL;
1216   u32 sw_if_index, table_id;
1217
1218   table_id = 0;
1219   ping_ip4 = ping_ip6 = 0;
1220   sw_if_index = ~0;
1221
1222   if (unformat (input, "%U", unformat_ip4_address, &a4))
1223     {
1224       ping_ip4 = 1;
1225     }
1226   else if (unformat (input, "%U", unformat_ip6_address, &a6))
1227     {
1228       ping_ip6 = 1;
1229     }
1230   else if (unformat (input, "ipv4"))
1231     {
1232       if (unformat (input, "%U", unformat_ip4_address, &a4))
1233         {
1234           ping_ip4 = 1;
1235         }
1236       else
1237         {
1238           error =
1239             clib_error_return (0,
1240                                "expecting IPv4 address but got `%U'",
1241                                format_unformat_error, input);
1242         }
1243     }
1244   else if (unformat (input, "ipv6"))
1245     {
1246       if (unformat (input, "%U", unformat_ip6_address, &a6))
1247         {
1248           ping_ip6 = 1;
1249         }
1250       else
1251         {
1252           error =
1253             clib_error_return (0,
1254                                "expecting IPv6 address but got `%U'",
1255                                format_unformat_error, input);
1256         }
1257     }
1258   else
1259     {
1260       error =
1261         clib_error_return (0,
1262                            "expecting IP4/IP6 address `%U'. Usage: ping <addr> [source <intf>] [size <datasz>] [repeat <count>] [verbose]",
1263                            format_unformat_error, input);
1264       goto done;
1265     }
1266
1267   /* allow for the second AF in the same ping */
1268   if (!ping_ip4 && (unformat (input, "ipv4")))
1269     {
1270       if (unformat (input, "%U", unformat_ip4_address, &a4))
1271         {
1272           ping_ip4 = 1;
1273         }
1274     }
1275   else if (!ping_ip6 && (unformat (input, "ipv6")))
1276     {
1277       if (unformat (input, "%U", unformat_ip6_address, &a6))
1278         {
1279           ping_ip6 = 1;
1280         }
1281     }
1282
1283   /* parse the rest of the parameters  in a cycle */
1284   while (!unformat_eof (input, NULL))
1285     {
1286       if (unformat (input, "source"))
1287         {
1288           if (!unformat_user
1289               (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
1290             {
1291               error =
1292                 clib_error_return (0,
1293                                    "unknown interface `%U'",
1294                                    format_unformat_error, input);
1295               goto done;
1296             }
1297         }
1298       else if (unformat (input, "size"))
1299         {
1300           if (!unformat (input, "%u", &data_len))
1301             {
1302               error =
1303                 clib_error_return (0,
1304                                    "expecting size but got `%U'",
1305                                    format_unformat_error, input);
1306               goto done;
1307             }
1308           if (data_len > PING_MAXIMUM_DATA_SIZE)
1309             {
1310               error =
1311                 clib_error_return (0,
1312                                    "%d is bigger than maximum allowed payload size %d",
1313                                    data_len, PING_MAXIMUM_DATA_SIZE);
1314               goto done;
1315             }
1316         }
1317       else if (unformat (input, "table-id"))
1318         {
1319           if (!unformat (input, "%u", &table_id))
1320             {
1321               error =
1322                 clib_error_return (0,
1323                                    "expecting table-id but got `%U'",
1324                                    format_unformat_error, input);
1325               goto done;
1326             }
1327         }
1328       else if (unformat (input, "interval"))
1329         {
1330           if (!unformat (input, "%f", &ping_interval))
1331             {
1332               error =
1333                 clib_error_return (0,
1334                                    "expecting interval (floating point number) got `%U'",
1335                                    format_unformat_error, input);
1336               goto done;
1337             }
1338         }
1339       else if (unformat (input, "repeat"))
1340         {
1341           if (!unformat (input, "%u", &ping_repeat))
1342             {
1343               error =
1344                 clib_error_return (0,
1345                                    "expecting repeat count but got `%U'",
1346                                    format_unformat_error, input);
1347               goto done;
1348             }
1349         }
1350       else if (unformat (input, "burst"))
1351         {
1352           if (!unformat (input, "%u", &ping_burst))
1353             {
1354               error =
1355                 clib_error_return (0,
1356                                    "expecting burst count but got `%U'",
1357                                    format_unformat_error, input);
1358               goto done;
1359             }
1360         }
1361       else if (unformat (input, "verbose"))
1362         {
1363           verbose = 1;
1364         }
1365       else
1366         {
1367           error = clib_error_return (0, "unknown input `%U'",
1368                                      format_unformat_error, input);
1369           goto done;
1370         }
1371     }
1372
1373 /*
1374  * Operationally, one won't (and shouldn't) need to send more than a frame worth of pings.
1375  * But it may be handy during the debugging.
1376  */
1377
1378 #ifdef CLIB_DEBUG
1379 #define MAX_PING_BURST (10*VLIB_FRAME_SIZE)
1380 #else
1381 #define MAX_PING_BURST (VLIB_FRAME_SIZE)
1382 #endif
1383
1384   if (ping_burst < 1 || ping_burst > MAX_PING_BURST)
1385     return clib_error_return (0, "burst size must be between 1 and %u",
1386                               MAX_PING_BURST);
1387
1388   run_ping_ip46_address (vm, table_id, ping_ip4 ? &a4 : NULL,
1389                          ping_ip6 ? &a6 : NULL, sw_if_index, ping_interval,
1390                          ping_repeat, data_len, ping_burst, verbose);
1391 done:
1392   return error;
1393 }
1394
1395 /*?
1396  * This command sends an ICMP ECHO_REQUEST to network hosts. The address
1397  * can be an IPv4 or IPv6 address (or both at the same time).
1398  *
1399  * @cliexpar
1400  * @parblock
1401  * Example of how ping an IPv4 address:
1402  * @cliexstart{ping 172.16.1.2 source GigabitEthernet2/0/0 repeat 2}
1403  * 64 bytes from 172.16.1.2: icmp_seq=1 ttl=64 time=.1090 ms
1404  * 64 bytes from 172.16.1.2: icmp_seq=2 ttl=64 time=.0914 ms
1405  *
1406  * Statistics: 2 sent, 2 received, 0% packet loss
1407  * @cliexend
1408  *
1409  * Example of how ping both an IPv4 address and IPv6 address at the same time:
1410  * @cliexstart{ping 172.16.1.2 ipv6 fe80::24a5:f6ff:fe9c:3a36 source GigabitEthernet2/0/0 repeat 2 verbose}
1411  * Adjacency index: 10, sw_if_index: 1
1412  * Adj: ip6-discover-neighbor
1413  * Adj Interface: 0
1414  * Forced set interface: 1
1415  * Adjacency index: 0, sw_if_index: 4294967295
1416  * Adj: ip4-miss
1417  * Adj Interface: 0
1418  * Forced set interface: 1
1419  * Source address: 172.16.1.1
1420  * 64 bytes from 172.16.1.2: icmp_seq=1 ttl=64 time=.1899 ms
1421  * Adjacency index: 10, sw_if_index: 1
1422  * Adj: ip6-discover-neighbor
1423  * Adj Interface: 0
1424  * Forced set interface: 1
1425  * Adjacency index: 0, sw_if_index: 4294967295
1426  * Adj: ip4-miss
1427  * Adj Interface: 0
1428  * Forced set interface: 1
1429  * Source address: 172.16.1.1
1430  * 64 bytes from 172.16.1.2: icmp_seq=2 ttl=64 time=.0910 ms
1431  *
1432  * Statistics: 4 sent, 2 received, 50% packet loss
1433  * @cliexend
1434  * @endparblock
1435 ?*/
1436 /* *INDENT-OFF* */
1437 VLIB_CLI_COMMAND (ping_command, static) =
1438 {
1439   .path = "ping",
1440   .function = ping_ip_address,
1441   .short_help = "ping {<ip-addr> | ipv4 <ip4-addr> | ipv6 <ip6-addr>}"
1442   " [ipv4 <ip4-addr> | ipv6 <ip6-addr>] [source <interface>]"
1443   " [size <pktsize:60>] [interval <sec:1>] [repeat <cnt:5>] [table-id <id:0>]"
1444   " [burst <count:1>] [verbose]",
1445   .is_mp_safe = 1,
1446 };
1447 /* *INDENT-ON* */
1448
1449 static clib_error_t *
1450 ping_cli_init (vlib_main_t * vm)
1451 {
1452   vlib_thread_main_t *tm = vlib_get_thread_main ();
1453   ping_main_t *pm = &ping_main;
1454
1455   pm->ip6_main = &ip6_main;
1456   pm->ip4_main = &ip4_main;
1457   icmp6_register_type (vm, ICMP6_echo_reply, ip6_icmp_echo_reply_node.index);
1458   ip4_icmp_register_type (vm, ICMP4_echo_reply,
1459                           ip4_icmp_echo_reply_node.index);
1460   if (tm->n_vlib_mains > 1)
1461     clib_spinlock_init (&pm->ping_run_check_lock);
1462
1463   ip4_icmp_register_type (vm, ICMP4_echo_request,
1464                           ip4_icmp_echo_request_node.index);
1465
1466   return 0;
1467 }
1468
1469 VLIB_INIT_FUNCTION (ping_cli_init);
1470
1471 /* *INDENT-OFF* */
1472 VLIB_PLUGIN_REGISTER () = {
1473     .version = VPP_BUILD_VER,
1474     .description = "Ping (ping)",
1475 };
1476 /* *INDENT-ON* */
1477
1478 /*
1479  * fd.io coding-style-patch-verification: ON
1480  *
1481  * Local Variables:
1482  * eval: (c-set-style "gnu")
1483  * End:
1484  */