src/vnet/lisp-gpe/lisp_gpe.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  * @file
  17  * @brief Common utility functions for IPv4, IPv6 and L2 LISP-GPE tunnels.
  18  *
  19  */
  20
  21 #include <vnet/lisp-gpe/lisp_gpe.h>
  22 #include <vnet/lisp-gpe/lisp_gpe_fwd_entry.h>
  23 #include <vnet/lisp-gpe/lisp_gpe_adjacency.h>
  24 #include <vnet/lisp-gpe/lisp_gpe_tenant.h>
  25 #include <vnet/fib/fib_path_list.h>
  26 #include <vnet/fib/fib_table.h>
  27 #include <vnet/fib/fib_internal.h>
  28
  29 /** LISP-GPE global state */
  30 lisp_gpe_main_t lisp_gpe_main;
  31
  32
  33 /** CLI command to add/del forwarding entry. */
  34 static clib_error_t *
  35 lisp_gpe_add_del_fwd_entry_command_fn (vlib_main_t * vm,
  36                                        unformat_input_t * input,
  37                                        vlib_cli_command_t * cmd)
  38 {
  39   unformat_input_t _line_input, *line_input = &_line_input;
  40   u8 is_add = 1;
  41   ip_address_t lloc, rloc;
  42   clib_error_t *error = 0;
  43   gid_address_t _reid, *reid = &_reid, _leid, *leid = &_leid;
  44   u8 reid_set = 0, leid_set = 0, is_negative = 0, dp_table_set = 0,
  45     vni_set = 0;
  46   u32 vni = 0, dp_table = 0, action = ~0, w;
  47   locator_pair_t pair, *pairs = 0;
  48   int rv;
  49
  50   memset (leid, 0, sizeof (*leid));
  51   memset (reid, 0, sizeof (*reid));
  52
  53   /* Get a line of input. */
  54   if (!unformat_user (input, unformat_line_input, line_input))
  55     return 0;
  56
  57   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
  58     {
  59       if (unformat (line_input, "del"))
  60         is_add = 0;
  61       else if (unformat (line_input, "add"))
  62         is_add = 1;
  63       else if (unformat (line_input, "leid %U", unformat_gid_address, leid))
  64         {
  65           leid_set = 1;
  66         }
  67       else if (unformat (line_input, "reid %U", unformat_gid_address, reid))
  68         {
  69           reid_set = 1;
  70         }
  71       else if (unformat (line_input, "vni %u", &vni))
  72         {
  73           gid_address_vni (leid) = vni;
  74           gid_address_vni (reid) = vni;
  75           vni_set = 1;
  76         }
  77       else if (unformat (line_input, "vrf %u", &dp_table))
  78         {
  79           dp_table_set = 1;
  80         }
  81       else if (unformat (line_input, "bd %u", &dp_table))
  82         {
  83           dp_table_set = 1;
  84         }
  85       else if (unformat (line_input, "negative action %U",
  86                          unformat_negative_mapping_action, &action))
  87         {
  88           is_negative = 1;
  89         }
  90       else if (unformat (line_input, "loc-pair %U %U w %d",
  91                          unformat_ip_address, &lloc,
  92                          unformat_ip_address, &rloc, &w))
  93         {
  94           pair.lcl_loc = lloc;
  95           pair.rmt_loc = rloc;
  96           pair.weight = w;
  97           pair.priority = 0;
  98           vec_add1 (pairs, pair);
  99         }
 100       else
 101         {
 102           error = unformat_parse_error (line_input);
 103           vlib_cli_output (vm, "parse error: '%U'",
 104                            format_unformat_error, line_input);
 105           goto done;
 106         }
 107     }
 108
 109   if (!reid_set)
 110     {
 111       vlib_cli_output (vm, "remote eid must be set!");
 112       goto done;
 113     }
 114
 115   if (gid_address_type (reid) != GID_ADDR_NSH && (!vni_set || !dp_table_set))
 116     {
 117       vlib_cli_output (vm, "vni and vrf/bd must be set!");
 118       goto done;
 119     }
 120
 121   if (is_negative)
 122     {
 123       if (~0 == action)
 124         {
 125           vlib_cli_output (vm, "no action set for negative tunnel!");
 126           goto done;
 127         }
 128     }
 129   else
 130     {
 131       if (vec_len (pairs) == 0)
 132         {
 133           vlib_cli_output (vm, "expected ip4/ip6 locators");
 134           goto done;
 135         }
 136     }
 137
 138   if (!leid_set)
 139     {
 140       /* if leid not set, make sure it's the same AFI like reid */
 141       gid_address_type (leid) = gid_address_type (reid);
 142       if (GID_ADDR_IP_PREFIX == gid_address_type (reid))
 143         gid_address_ip_version (leid) = gid_address_ip_version (reid);
 144     }
 145
 146   /* add fwd entry */
 147   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
 148   memset (a, 0, sizeof (a[0]));
 149
 150   a->is_add = is_add;
 151   a->is_negative = is_negative;
 152   a->vni = vni;
 153   a->table_id = dp_table;
 154   gid_address_copy (&a->lcl_eid, leid);
 155   gid_address_copy (&a->rmt_eid, reid);
 156   a->locator_pairs = pairs;
 157   a->action = action;
 158
 159   rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0);
 160   if (0 != rv)
 161     {
 162       vlib_cli_output (vm, "failed to %s gpe tunnel!",
 163                        is_add ? "add" : "delete");
 164     }
 165
 166 done:
 167   unformat_free (line_input);
 168   vec_free (pairs);
 169   return error;
 170 }
 171
 172 /* *INDENT-OFF* */
 173 VLIB_CLI_COMMAND (lisp_gpe_add_del_fwd_entry_command, static) = {
 174   .path = "gpe entry",
 175   .short_help = "gpe entry add/del vni <vni> vrf/bd <id> [leid <leid>]"
 176       "reid <reid> [loc-pair <lloc> <rloc> w <weight>] "
 177       "[negative action <action>]",
 178   .function = lisp_gpe_add_del_fwd_entry_command_fn,
 179 };
 180 /* *INDENT-ON* */
 181
 182 /** Check if LISP-GPE is enabled. */
 183 u8
 184 vnet_lisp_gpe_enable_disable_status (void)
 185 {
 186   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 187
 188   return lgm->is_en;
 189 }
 190
 191 /** Enable/disable LISP-GPE. */
 192 clib_error_t *
 193 vnet_lisp_gpe_enable_disable (vnet_lisp_gpe_enable_disable_args_t * a)
 194 {
 195   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 196
 197   if (a->is_en)
 198     {
 199       lgm->is_en = 1;
 200     }
 201   else
 202     {
 203       /* remove all entries */
 204       vnet_lisp_gpe_fwd_entry_flush ();
 205
 206       /* disable all l3 ifaces */
 207       lisp_gpe_tenant_flush ();
 208
 209       lgm->is_en = 0;
 210     }
 211
 212   return 0;
 213 }
 214
 215 /** Set GPE encapsulation mode. */
 216 int
 217 vnet_gpe_set_encap_mode (gpe_encap_mode_t mode)
 218 {
 219   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 220
 221   if (mode >= GPE_ENCAP_COUNT)
 222     return VNET_API_ERROR_INVALID_GPE_MODE;
 223
 224   if (pool_elts (lgm->lisp_fwd_entry_pool) != 0)
 225     return VNET_API_ERROR_LISP_GPE_ENTRIES_PRESENT;
 226
 227   lgm->encap_mode = mode;
 228   return 0;
 229 }
 230
 231 /** CLI command to set GPE encap */
 232 static clib_error_t *
 233 gpe_set_encap_mode_command_fn (vlib_main_t * vm,
 234                                unformat_input_t * input,
 235                                vlib_cli_command_t * cmd)
 236 {
 237   unformat_input_t _line_input, *line_input = &_line_input;
 238   gpe_encap_mode_t mode = GPE_ENCAP_COUNT;
 239   vnet_api_error_t rv;
 240
 241   /* Get a line of input. */
 242   if (!unformat_user (input, unformat_line_input, line_input))
 243     return 0;
 244
 245   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 246     {
 247       if (unformat (line_input, "lisp"))
 248         mode = GPE_ENCAP_LISP;
 249       else if (unformat (line_input, "vxlan"))
 250         mode = GPE_ENCAP_VXLAN;
 251       else
 252         {
 253           return clib_error_return (0, "parse error: '%U'",
 254                                     format_unformat_error, line_input);
 255         }
 256     }
 257   rv = vnet_gpe_set_encap_mode (mode);
 258   if (rv)
 259     {
 260       return clib_error_return (0,
 261                                 "Error: invalid mode or GPE entries are present!");
 262     }
 263
 264   return 0;
 265 }
 266
 267 /* *INDENT-OFF* */
 268 VLIB_CLI_COMMAND (gpe_set_encap_mode_command, static) = {
 269   .path = "gpe encap",
 270   .short_help = "gpe encap [lisp|vxlan]",
 271   .function = gpe_set_encap_mode_command_fn,
 272 };
 273 /* *INDENT-ON* */
 274
 275 /** Format GPE encap mode. */
 276 u8 *
 277 format_vnet_gpe_encap_mode (u8 * s, va_list * args)
 278 {
 279   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 280
 281   switch (lgm->encap_mode)
 282     {
 283     case GPE_ENCAP_LISP:
 284       return format (s, "lisp");
 285     case GPE_ENCAP_VXLAN:
 286       return format (s, "vxlan");
 287     default:
 288       return 0;
 289     }
 290   return 0;
 291 }
 292
 293 /** CLI command to show GPE encap */
 294 static clib_error_t *
 295 gpe_show_encap_mode_command_fn (vlib_main_t * vm,
 296                                 unformat_input_t * input,
 297                                 vlib_cli_command_t * cmd)
 298 {
 299   vlib_cli_output (vm, "encap mode: %U", format_vnet_gpe_encap_mode);
 300   return 0;
 301 }
 302
 303 /* *INDENT-OFF* */
 304 VLIB_CLI_COMMAND (gpe_show_encap_mode_command, static) = {
 305   .path = "show gpe encap",
 306   .short_help = "show GPE encapulation mode",
 307   .function = gpe_show_encap_mode_command_fn,
 308 };
 309 /* *INDENT-ON* */
 310
 311 /** CLI command to enable/disable LISP-GPE. */
 312 static clib_error_t *
 313 lisp_gpe_enable_disable_command_fn (vlib_main_t * vm,
 314                                     unformat_input_t * input,
 315                                     vlib_cli_command_t * cmd)
 316 {
 317   unformat_input_t _line_input, *line_input = &_line_input;
 318   u8 is_en = 1;
 319   vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a;
 320   clib_error_t *error = NULL;
 321
 322   /* Get a line of input. */
 323   if (!unformat_user (input, unformat_line_input, line_input))
 324     return 0;
 325
 326   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 327     {
 328       if (unformat (line_input, "enable"))
 329         is_en = 1;
 330       else if (unformat (line_input, "disable"))
 331         is_en = 0;
 332       else
 333         {
 334           error = clib_error_return (0, "parse error: '%U'",
 335                                      format_unformat_error, line_input);
 336           goto done;
 337         }
 338     }
 339   a->is_en = is_en;
 340   error = vnet_lisp_gpe_enable_disable (a);
 341
 342 done:
 343   unformat_free (line_input);
 344
 345   return error;
 346 }
 347
 348 /* *INDENT-OFF* */
 349 VLIB_CLI_COMMAND (enable_disable_lisp_gpe_command, static) = {
 350   .path = "gpe",
 351   .short_help = "gpe [enable|disable]",
 352   .function = lisp_gpe_enable_disable_command_fn,
 353 };
 354 /* *INDENT-ON* */
 355
 356 /** CLI command to show LISP-GPE interfaces. */
 357 static clib_error_t *
 358 lisp_show_iface_command_fn (vlib_main_t * vm,
 359                             unformat_input_t * input,
 360                             vlib_cli_command_t * cmd)
 361 {
 362   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 363   hash_pair_t *p;
 364
 365   vlib_cli_output (vm, "%=10s%=12s", "vrf", "hw_if_index");
 366
 367   /* *INDENT-OFF* */
 368   hash_foreach_pair (p, lgm->l3_ifaces.hw_if_index_by_dp_table, ({
 369     vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
 370   }));
 371   /* *INDENT-ON* */
 372
 373   if (0 != lgm->l2_ifaces.hw_if_index_by_dp_table)
 374     {
 375       vlib_cli_output (vm, "%=10s%=12s", "bd_id", "hw_if_index");
 376       /* *INDENT-OFF* */
 377       hash_foreach_pair (p, lgm->l2_ifaces.hw_if_index_by_dp_table, ({
 378         vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
 379       }));
 380       /* *INDENT-ON* */
 381     }
 382   return 0;
 383 }
 384
 385 /* *INDENT-OFF* */
 386 VLIB_CLI_COMMAND (lisp_show_iface_command) = {
 387     .path = "show gpe interface",
 388     .short_help = "show gpe interface",
 389     .function = lisp_show_iface_command_fn,
 390 };
 391 /* *INDENT-ON* */
 392
 393 /** CLI command to show GPE fwd native route path. */
 394 static clib_error_t *
 395 gpe_show_native_fwd_rpath_command_fn (vlib_main_t * vm,
 396                                       unformat_input_t * input,
 397                                       vlib_cli_command_t * cmd)
 398 {
 399   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 400   fib_route_path_t *rpath;
 401
 402   if (vec_len (lgm->native_fwd_rpath[IP4]))
 403     {
 404       vec_foreach (rpath, lgm->native_fwd_rpath[IP4])
 405       {
 406         vlib_cli_output (vm, "nh: %U fib_index %u sw_if_index %u",
 407                          format_ip46_address, &rpath->frp_addr,
 408                          IP46_TYPE_IP4, rpath->frp_fib_index,
 409                          rpath->frp_sw_if_index);
 410       }
 411     }
 412   if (vec_len (lgm->native_fwd_rpath[IP6]))
 413     {
 414       vec_foreach (rpath, lgm->native_fwd_rpath[IP6])
 415       {
 416         vlib_cli_output (vm, "nh: %U fib_index %u sw_if_index %u",
 417                          format_ip46_address, &rpath->frp_addr, IP46_TYPE_IP6,
 418                          rpath->frp_fib_index, rpath->frp_sw_if_index);
 419       }
 420     }
 421   return 0;
 422 }
 423
 424 /* *INDENT-OFF* */
 425 VLIB_CLI_COMMAND (gpe_show_native_fwd_rpath_command) = {
 426     .path = "show gpe native-forward",
 427     .short_help = "show gpe native-forward",
 428     .function = gpe_show_native_fwd_rpath_command_fn,
 429 };
 430 /* *INDENT-ON* */
 431
 432 void
 433 gpe_update_native_fwd_path (u8 ip_version)
 434 {
 435   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
 436   lisp_gpe_fwd_entry_t *lfe;
 437   fib_prefix_t fib_prefix;
 438   u32 *lfei;
 439
 440   vec_foreach (lfei, lgm->native_fwd_lfes[ip_version])
 441   {
 442     lfe = pool_elt_at_index (lgm->lisp_fwd_entry_pool, lfei[0]);
 443     ip_prefix_to_fib_prefix (&lfe->key->rmt.ippref, &fib_prefix);
 444     fib_table_entry_update (lfe->eid_fib_index, &fib_prefix, FIB_SOURCE_LISP,
 445                             FIB_ENTRY_FLAG_NONE,
 446                             lgm->native_fwd_rpath[ip_version]);
 447   }
 448 }
 449
 450 int
 451 vnet_gpe_add_del_native_fwd_rpath (vnet_gpe_native_fwd_rpath_args_t * a)
 452 {
 453   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
 454   fib_route_path_t *rpath;
 455   u8 ip_version;
 456
 457   ip_version = a->rpath.frp_proto == FIB_PROTOCOL_IP4 ? IP4 : IP6;
 458
 459   if (a->is_add)
 460     {
 461       vec_add1 (lgm->native_fwd_rpath[ip_version], a->rpath);
 462     }
 463   else
 464     {
 465       vec_foreach (rpath, lgm->native_fwd_rpath[ip_version])
 466       {
 467         if (!fib_route_path_cmp (rpath, &a->rpath))
 468           {
 469             vec_del1 (lgm->native_fwd_rpath[ip_version],
 470                       rpath - lgm->native_fwd_rpath[ip_version]);
 471             break;
 472           }
 473       }
 474     }
 475   gpe_update_native_fwd_path (ip_version);
 476   return 0;
 477 }
 478
 479 /**
 480  * CLI command to add action for native forward.
 481  */
 482 static clib_error_t *
 483 gpe_native_forward_command_fn (vlib_main_t * vm, unformat_input_t * input,
 484                                vlib_cli_command_t * cmd)
 485 {
 486   vnet_main_t *vnm = vnet_get_main ();
 487   unformat_input_t _line_input, *line_input = &_line_input;
 488   vnet_api_error_t rv;
 489   fib_route_path_t rpath;
 490   u32 table_id = ~0;
 491   vnet_gpe_native_fwd_rpath_args_t _a, *a = &_a;
 492   u8 is_add = 1;
 493   clib_error_t *error = 0;
 494
 495   /* Get a line of input. */
 496   if (!unformat_user (input, unformat_line_input, line_input))
 497     return 0;
 498
 499   memset (&rpath, 0, sizeof (rpath));
 500
 501   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 502     {
 503       if (unformat (line_input, "table %d", &table_id))
 504         ;
 505       else if (unformat (line_input, "del"))
 506         is_add = 0;
 507       else if (unformat (line_input, "via %U %U",
 508                          unformat_ip4_address,
 509                          &rpath.frp_addr.ip4,
 510                          unformat_vnet_sw_interface, vnm,
 511                          &rpath.frp_sw_if_index))
 512         {
 513           rpath.frp_weight = 1;
 514           rpath.frp_proto = FIB_PROTOCOL_IP4;
 515         }
 516       else if (unformat (line_input, "via %U %U",
 517                          unformat_ip6_address,
 518                          &rpath.frp_addr.ip6,
 519                          unformat_vnet_sw_interface, vnm,
 520                          &rpath.frp_sw_if_index))
 521         {
 522           rpath.frp_weight = 1;
 523           rpath.frp_proto = FIB_PROTOCOL_IP6;
 524         }
 525       else if (unformat (line_input, "via %U",
 526                          unformat_ip4_address, &rpath.frp_addr.ip4))
 527         {
 528           rpath.frp_weight = 1;
 529           rpath.frp_sw_if_index = ~0;
 530           rpath.frp_proto = FIB_PROTOCOL_IP4;
 531         }
 532       else if (unformat (line_input, "via %U",
 533                          unformat_ip6_address, &rpath.frp_addr.ip6))
 534         {
 535           rpath.frp_weight = 1;
 536           rpath.frp_sw_if_index = ~0;
 537           rpath.frp_proto = FIB_PROTOCOL_IP6;
 538         }
 539       else
 540         {
 541           return clib_error_return (0, "parse error: '%U'",
 542                                     format_unformat_error, line_input);
 543         }
 544     }
 545
 546   if ((u32) ~ 0 == table_id)
 547     {
 548       rpath.frp_fib_index = 0;
 549     }
 550   else
 551     {
 552       rpath.frp_fib_index = fib_table_find (rpath.frp_proto, table_id);
 553       if ((u32) ~ 0 == rpath.frp_fib_index)
 554         {
 555           error = clib_error_return (0, "Nonexistent table id %d", table_id);
 556           goto done;
 557         }
 558     }
 559
 560   a->rpath = rpath;
 561   a->is_add = is_add;
 562
 563   rv = vnet_gpe_add_del_native_fwd_rpath (a);
 564   if (rv)
 565     {
 566       return clib_error_return (0, "Error: couldn't add path!");
 567     }
 568
 569 done:
 570   return error;
 571 }
 572
 573 /* *INDENT-OFF* */
 574 VLIB_CLI_COMMAND (gpe_native_forward_command) = {
 575     .path = "gpe native-forward",
 576     .short_help = "gpe native-forward [del] via <nh-ip-addr> [iface] "
 577         "[table <table>]",
 578     .function = gpe_native_forward_command_fn,
 579 };
 580 /* *INDENT-ON* */
 581
 582 /** Format LISP-GPE status. */
 583 u8 *
 584 format_vnet_lisp_gpe_status (u8 * s, va_list * args)
 585 {
 586   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 587   return format (s, "%s", lgm->is_en ? "enabled" : "disabled");
 588 }
 589
 590 /** LISP-GPE init function. */
 591 clib_error_t *
 592 lisp_gpe_init (vlib_main_t * vm)
 593 {
 594   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 595   clib_error_t *error = 0;
 596
 597   if ((error = vlib_call_init_function (vm, ip_main_init)))
 598     return error;
 599
 600   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
 601     return error;
 602
 603   lgm->vnet_main = vnet_get_main ();
 604   lgm->vlib_main = vm;
 605   lgm->im4 = &ip4_main;
 606   lgm->im6 = &ip6_main;
 607   lgm->lm4 = &ip4_main.lookup_main;
 608   lgm->lm6 = &ip6_main.lookup_main;
 609   lgm->encap_mode = GPE_ENCAP_LISP;
 610
 611   lgm->lisp_gpe_fwd_entries =
 612     hash_create_mem (0, sizeof (lisp_gpe_fwd_entry_key_t), sizeof (uword));
 613
 614   udp_register_dst_port (vm, UDP_DST_PORT_lisp_gpe,
 615                          lisp_gpe_ip4_input_node.index, 1 /* is_ip4 */ );
 616   udp_register_dst_port (vm, UDP_DST_PORT_lisp_gpe6,
 617                          lisp_gpe_ip6_input_node.index, 0 /* is_ip4 */ );
 618
 619   lgm->lisp_stats_index_by_key =
 620     hash_create_mem (0, sizeof (lisp_stats_key_t), sizeof (uword));
 621   memset (&lgm->counters, 0, sizeof (lgm->counters));
 622   lgm->counters.name = "LISP counters";
 623
 624   return 0;
 625 }
 626
 627 gpe_encap_mode_t
 628 vnet_gpe_get_encap_mode (void)
 629 {
 630   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 631   return lgm->encap_mode;
 632 }
 633
 634 static clib_error_t *
 635 lisp_gpe_test_send_nsh_packet (u8 * file_name)
 636 {
 637   vlib_frame_t *f;
 638   vlib_buffer_t *b;
 639   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
 640   pcap_main_t pm;
 641   clib_error_t *error = 0;
 642
 643   if (!file_name)
 644     return clib_error_create ("no pcap file specified!");
 645
 646   memset (&pm, 0, sizeof (pm));
 647   pm.file_name = (char *) file_name;
 648   error = pcap_read (&pm);
 649   if (error)
 650     return error;
 651
 652   u32 bi;
 653   if (vlib_buffer_alloc (lgm->vlib_main, &bi, 1) != 1)
 654     return clib_error_create ("cannot allocate memory!");
 655
 656   b = vlib_get_buffer (lgm->vlib_main, bi);
 657   tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
 658   uword *hip;
 659   vnet_hw_interface_t *hi;
 660
 661   hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
 662   if (hip == 0)
 663     return clib_error_create ("The NSH 0 interface doesn't exist");
 664
 665   hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
 666
 667   vnet_buffer (b)->sw_if_index[VLIB_TX] = hi->sw_if_index;
 668   u8 *p = vlib_buffer_put_uninit (b, vec_len (pm.packets_read[0]));
 669   clib_memcpy (p, pm.packets_read[0], vec_len (pm.packets_read[0]));
 670   vlib_buffer_pull (b, sizeof (ethernet_header_t));
 671
 672   vlib_node_t *n = vlib_get_node_by_name (lgm->vlib_main,
 673                                           (u8 *) "interface-tx");
 674   f = vlib_get_frame_to_node (lgm->vlib_main, n->index);
 675   u32 *to_next = vlib_frame_vector_args (f);
 676   to_next[0] = bi;
 677   f->n_vectors = 1;
 678   vlib_put_frame_to_node (lgm->vlib_main, n->index, f);
 679
 680   return error;
 681 }
 682
 683 static clib_error_t *
 684 lisp_test_nsh_command_fn (vlib_main_t * vm, unformat_input_t * input,
 685                           vlib_cli_command_t * cmd)
 686 {
 687   clib_error_t *error = 0;
 688   u8 *file_name = 0;
 689
 690   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 691     {
 692       if (unformat (input, "pcap %v", &file_name))
 693         {
 694           error = lisp_gpe_test_send_nsh_packet (file_name);
 695           goto done;
 696         }
 697       else
 698         {
 699           error = clib_error_create ("unknown input `%U'",
 700                                      format_unformat_error, input);
 701           goto done;
 702         }
 703     }
 704
 705 done:
 706   return error;
 707 }
 708
 709 /* *INDENT-OFF* */
 710 VLIB_CLI_COMMAND (lisp_test_nsh_command, static) = {
 711   .path = "test one nsh",
 712   .short_help = "test gpe nsh pcap <path-to-pcap-file>",
 713   .function = lisp_test_nsh_command_fn,
 714 };
 715 /* *INDENT-ON* */
 716
 717 VLIB_INIT_FUNCTION (lisp_gpe_init);
 718
 719 /*
 720  * fd.io coding-style-patch-verification: ON
 721  *
 722  * Local Variables:
 723  * eval: (c-set-style "gnu")
 724  * End:
 725  */