src/vnet/ip/ip_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * ip_api.c - vnet ip api
   4  *
   5  * Copyright (c) 2016 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <vnet/vnet.h>
  21 #include <vlibmemory/api.h>
  22
  23 #include <vnet/interface.h>
  24 #include <vnet/api_errno.h>
  25 #include <vnet/ethernet/ethernet.h>
  26 #include <vnet/ip/ip.h>
  27 #include <vnet/ip/ip6_neighbor.h>
  28 #include <vnet/fib/fib_table.h>
  29 #include <vnet/fib/fib_api.h>
  30 #include <vnet/dpo/drop_dpo.h>
  31 #include <vnet/dpo/receive_dpo.h>
  32 #include <vnet/dpo/lookup_dpo.h>
  33 #include <vnet/dpo/classify_dpo.h>
  34 #include <vnet/dpo/ip_null_dpo.h>
  35 #include <vnet/ethernet/arp_packet.h>
  36 #include <vnet/mfib/ip6_mfib.h>
  37 #include <vnet/mfib/ip4_mfib.h>
  38 #include <vnet/mfib/mfib_signal.h>
  39 #include <vnet/mfib/mfib_entry.h>
  40
  41 #include <vnet/vnet_msg_enum.h>
  42
  43 #define vl_typedefs             /* define message structures */
  44 #include <vnet/vnet_all_api_h.h>
  45 #undef vl_typedefs
  46
  47 #define vl_endianfun            /* define message structures */
  48 #include <vnet/vnet_all_api_h.h>
  49 #undef vl_endianfun
  50
  51 /* instantiate all the print functions we know about */
  52 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  53 #define vl_printfun
  54 #include <vnet/vnet_all_api_h.h>
  55 #undef vl_printfun
  56
  57 #include <vlibapi/api_helper_macros.h>
  58
  59
  60 #define foreach_ip_api_msg                                              \
  61 _(IP_FIB_DUMP, ip_fib_dump)                                             \
  62 _(IP_FIB_DETAILS, ip_fib_details)                                       \
  63 _(IP6_FIB_DUMP, ip6_fib_dump)                                           \
  64 _(IP6_FIB_DETAILS, ip6_fib_details)                                     \
  65 _(IP_MFIB_DUMP, ip_mfib_dump)                                           \
  66 _(IP_MFIB_DETAILS, ip_mfib_details)                                     \
  67 _(IP6_MFIB_DUMP, ip6_mfib_dump)                                         \
  68 _(IP6_MFIB_DETAILS, ip6_mfib_details)                                   \
  69 _(IP_NEIGHBOR_DUMP, ip_neighbor_dump)                                   \
  70 _(IP_MROUTE_ADD_DEL, ip_mroute_add_del)                                 \
  71 _(MFIB_SIGNAL_DUMP, mfib_signal_dump)                                   \
  72 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details)                             \
  73 _(IP_ADDRESS_DUMP, ip_address_dump)                                     \
  74 _(IP_DUMP, ip_dump)                                                     \
  75 _(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del)                             \
  76 _(IP_ADD_DEL_ROUTE, ip_add_del_route)                                   \
  77 _(SET_IP_FLOW_HASH,set_ip_flow_hash)                                    \
  78 _(SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config)           \
  79 _(SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix)           \
  80 _(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable )    \
  81 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,                              \
  82   sw_interface_ip6_set_link_local_address)
  83
  84 extern void stats_dslock_with_hint (int hint, int tag);
  85 extern void stats_dsunlock (void);
  86
  87 static void
  88 send_ip_neighbor_details (u8 is_ipv6,
  89                           u8 is_static,
  90                           u8 * mac_address,
  91                           u8 * ip_address,
  92                           unix_shared_memory_queue_t * q, u32 context)
  93 {
  94   vl_api_ip_neighbor_details_t *mp;
  95
  96   mp = vl_msg_api_alloc (sizeof (*mp));
  97   memset (mp, 0, sizeof (*mp));
  98   mp->_vl_msg_id = ntohs (VL_API_IP_NEIGHBOR_DETAILS);
  99   mp->context = context;
 100   mp->is_ipv6 = is_ipv6;
 101   mp->is_static = is_static;
 102   memcpy (mp->mac_address, mac_address, 6);
 103   memcpy (mp->ip_address, ip_address, (is_ipv6) ? 16 : 4);
 104
 105   vl_msg_api_send_shmem (q, (u8 *) & mp);
 106 }
 107
 108 static void
 109 vl_api_ip_neighbor_details_t_handler (vl_api_ip_neighbor_details_t * mp)
 110 {
 111   clib_warning ("BUG");
 112 }
 113
 114 static void
 115 vl_api_ip_neighbor_dump_t_handler (vl_api_ip_neighbor_dump_t * mp)
 116 {
 117   unix_shared_memory_queue_t *q;
 118
 119   q = vl_api_client_index_to_input_queue (mp->client_index);
 120   if (q == 0)
 121     return;
 122
 123   u32 sw_if_index = ntohl (mp->sw_if_index);
 124
 125   if (mp->is_ipv6)
 126     {
 127       ip6_neighbor_t *n, *ns;
 128
 129       ns = ip6_neighbors_entries (sw_if_index);
 130       /* *INDENT-OFF* */
 131       vec_foreach (n, ns)
 132       {
 133         send_ip_neighbor_details
 134           (mp->is_ipv6, ((n->flags & IP6_NEIGHBOR_FLAG_STATIC) ? 1 : 0),
 135            (u8 *) n->link_layer_address,
 136            (u8 *) & (n->key.ip6_address.as_u8),
 137            q, mp->context);
 138       }
 139       /* *INDENT-ON* */
 140       vec_free (ns);
 141     }
 142   else
 143     {
 144       ethernet_arp_ip4_entry_t *n, *ns;
 145
 146       ns = ip4_neighbor_entries (sw_if_index);
 147       /* *INDENT-OFF* */
 148       vec_foreach (n, ns)
 149       {
 150         send_ip_neighbor_details (mp->is_ipv6,
 151           ((n->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC) ? 1 : 0),
 152           (u8*) n->ethernet_address,
 153           (u8*) & (n->ip4_address.as_u8),
 154           q, mp->context);
 155       }
 156       /* *INDENT-ON* */
 157       vec_free (ns);
 158     }
 159 }
 160
 161
 162 void
 163 copy_fib_next_hop (fib_route_path_encode_t * api_rpath, void *fp_arg)
 164 {
 165   int is_ip4;
 166   vl_api_fib_path_t *fp = (vl_api_fib_path_t *) fp_arg;
 167
 168   if (api_rpath->rpath.frp_proto == FIB_PROTOCOL_IP4)
 169     fp->afi = IP46_TYPE_IP4;
 170   else if (api_rpath->rpath.frp_proto == FIB_PROTOCOL_IP6)
 171     fp->afi = IP46_TYPE_IP6;
 172   else
 173     {
 174       is_ip4 = ip46_address_is_ip4 (&api_rpath->rpath.frp_addr);
 175       if (is_ip4)
 176         fp->afi = IP46_TYPE_IP4;
 177       else
 178         fp->afi = IP46_TYPE_IP6;
 179     }
 180   if (fp->afi == IP46_TYPE_IP4)
 181     memcpy (fp->next_hop, &api_rpath->rpath.frp_addr.ip4,
 182             sizeof (api_rpath->rpath.frp_addr.ip4));
 183   else
 184     memcpy (fp->next_hop, &api_rpath->rpath.frp_addr.ip6,
 185             sizeof (api_rpath->rpath.frp_addr.ip6));
 186 }
 187
 188 static void
 189 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
 190 {
 191   clib_warning ("BUG");
 192 }
 193
 194 static void
 195 vl_api_ip_fib_details_t_endian (vl_api_ip_fib_details_t * mp)
 196 {
 197   clib_warning ("BUG");
 198 }
 199
 200 static void
 201 vl_api_ip_fib_details_t_print (vl_api_ip_fib_details_t * mp)
 202 {
 203   clib_warning ("BUG");
 204 }
 205
 206 static void
 207 send_ip_fib_details (vpe_api_main_t * am,
 208                      unix_shared_memory_queue_t * q,
 209                      u32 table_id, fib_prefix_t * pfx,
 210                      fib_route_path_encode_t * api_rpaths, u32 context)
 211 {
 212   vl_api_ip_fib_details_t *mp;
 213   fib_route_path_encode_t *api_rpath;
 214   vl_api_fib_path_t *fp;
 215   int path_count;
 216
 217   path_count = vec_len (api_rpaths);
 218   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
 219   if (!mp)
 220     return;
 221   memset (mp, 0, sizeof (*mp));
 222   mp->_vl_msg_id = ntohs (VL_API_IP_FIB_DETAILS);
 223   mp->context = context;
 224
 225   mp->table_id = htonl (table_id);
 226   mp->address_length = pfx->fp_len;
 227   memcpy (mp->address, &pfx->fp_addr.ip4, sizeof (pfx->fp_addr.ip4));
 228
 229   mp->count = htonl (path_count);
 230   fp = mp->path;
 231   vec_foreach (api_rpath, api_rpaths)
 232   {
 233     memset (fp, 0, sizeof (*fp));
 234     switch (api_rpath->dpo.dpoi_type)
 235       {
 236       case DPO_RECEIVE:
 237         fp->is_local = true;
 238         break;
 239       case DPO_DROP:
 240         fp->is_drop = true;
 241         break;
 242       case DPO_IP_NULL:
 243         switch (api_rpath->dpo.dpoi_index)
 244           {
 245           case IP_NULL_ACTION_NONE:
 246             fp->is_drop = true;
 247             break;
 248           case IP_NULL_ACTION_SEND_ICMP_UNREACH:
 249             fp->is_unreach = true;
 250             break;
 251           case IP_NULL_ACTION_SEND_ICMP_PROHIBIT:
 252             fp->is_prohibit = true;
 253             break;
 254           default:
 255             break;
 256           }
 257         break;
 258       default:
 259         break;
 260       }
 261     fp->weight = htonl (api_rpath->rpath.frp_weight);
 262     fp->sw_if_index = htonl (api_rpath->rpath.frp_sw_if_index);
 263     copy_fib_next_hop (api_rpath, fp);
 264     fp++;
 265   }
 266
 267   vl_msg_api_send_shmem (q, (u8 *) & mp);
 268 }
 269
 270 static void
 271 vl_api_ip_fib_dump_t_handler (vl_api_ip_fib_dump_t * mp)
 272 {
 273   vpe_api_main_t *am = &vpe_api_main;
 274   unix_shared_memory_queue_t *q;
 275   ip4_main_t *im = &ip4_main;
 276   fib_table_t *fib_table;
 277   fib_node_index_t lfei, *lfeip, *lfeis = NULL;
 278   mpls_label_t key;
 279   fib_prefix_t pfx;
 280   u32 fib_index;
 281   fib_route_path_encode_t *api_rpaths;
 282   int i;
 283
 284   q = vl_api_client_index_to_input_queue (mp->client_index);
 285   if (q == 0)
 286     return;
 287
 288   /* *INDENT-OFF* */
 289   pool_foreach (fib_table, im->fibs,
 290   ({
 291     for (i = 0; i < ARRAY_LEN (fib_table->v4.fib_entry_by_dst_address); i++)
 292       {
 293         hash_foreach(key, lfei, fib_table->v4.fib_entry_by_dst_address[i],
 294         ({
 295           vec_add1(lfeis, lfei);
 296         }));
 297       }
 298   }));
 299   /* *INDENT-ON* */
 300
 301   vec_sort_with_function (lfeis, fib_entry_cmp_for_sort);
 302
 303   vec_foreach (lfeip, lfeis)
 304   {
 305     fib_entry_get_prefix (*lfeip, &pfx);
 306     fib_index = fib_entry_get_fib_index (*lfeip);
 307     fib_table = fib_table_get (fib_index, pfx.fp_proto);
 308     api_rpaths = NULL;
 309     fib_entry_encode (*lfeip, &api_rpaths);
 310     send_ip_fib_details (am, q,
 311                          fib_table->ft_table_id, &pfx, api_rpaths,
 312                          mp->context);
 313     vec_free (api_rpaths);
 314   }
 315
 316   vec_free (lfeis);
 317 }
 318
 319 static void
 320 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
 321 {
 322   clib_warning ("BUG");
 323 }
 324
 325 static void
 326 vl_api_ip6_fib_details_t_endian (vl_api_ip6_fib_details_t * mp)
 327 {
 328   clib_warning ("BUG");
 329 }
 330
 331 static void
 332 vl_api_ip6_fib_details_t_print (vl_api_ip6_fib_details_t * mp)
 333 {
 334   clib_warning ("BUG");
 335 }
 336
 337 static void
 338 send_ip6_fib_details (vpe_api_main_t * am,
 339                       unix_shared_memory_queue_t * q,
 340                       u32 table_id, fib_prefix_t * pfx,
 341                       fib_route_path_encode_t * api_rpaths, u32 context)
 342 {
 343   vl_api_ip6_fib_details_t *mp;
 344   fib_route_path_encode_t *api_rpath;
 345   vl_api_fib_path_t *fp;
 346   int path_count;
 347
 348   path_count = vec_len (api_rpaths);
 349   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
 350   if (!mp)
 351     return;
 352   memset (mp, 0, sizeof (*mp));
 353   mp->_vl_msg_id = ntohs (VL_API_IP6_FIB_DETAILS);
 354   mp->context = context;
 355
 356   mp->table_id = htonl (table_id);
 357   mp->address_length = pfx->fp_len;
 358   memcpy (mp->address, &pfx->fp_addr.ip6, sizeof (pfx->fp_addr.ip6));
 359
 360   mp->count = htonl (path_count);
 361   fp = mp->path;
 362   vec_foreach (api_rpath, api_rpaths)
 363   {
 364     memset (fp, 0, sizeof (*fp));
 365     switch (api_rpath->dpo.dpoi_type)
 366       {
 367       case DPO_RECEIVE:
 368         fp->is_local = true;
 369         break;
 370       case DPO_DROP:
 371         fp->is_drop = true;
 372         break;
 373       case DPO_IP_NULL:
 374         switch (api_rpath->dpo.dpoi_index)
 375           {
 376           case IP_NULL_DPO_ACTION_NUM + IP_NULL_ACTION_NONE:
 377             fp->is_drop = true;
 378             break;
 379           case IP_NULL_DPO_ACTION_NUM + IP_NULL_ACTION_SEND_ICMP_UNREACH:
 380             fp->is_unreach = true;
 381             break;
 382           case IP_NULL_DPO_ACTION_NUM + IP_NULL_ACTION_SEND_ICMP_PROHIBIT:
 383             fp->is_prohibit = true;
 384             break;
 385           default:
 386             break;
 387           }
 388         break;
 389       default:
 390         break;
 391       }
 392     fp->weight = htonl (api_rpath->rpath.frp_weight);
 393     fp->sw_if_index = htonl (api_rpath->rpath.frp_sw_if_index);
 394     copy_fib_next_hop (api_rpath, fp);
 395     fp++;
 396   }
 397
 398   vl_msg_api_send_shmem (q, (u8 *) & mp);
 399 }
 400
 401 typedef struct apt_ip6_fib_show_ctx_t_
 402 {
 403   u32 fib_index;
 404   fib_node_index_t *entries;
 405 } api_ip6_fib_show_ctx_t;
 406
 407 static void
 408 api_ip6_fib_table_put_entries (clib_bihash_kv_24_8_t * kvp, void *arg)
 409 {
 410   api_ip6_fib_show_ctx_t *ctx = arg;
 411
 412   if ((kvp->key[2] >> 32) == ctx->fib_index)
 413     {
 414       vec_add1 (ctx->entries, kvp->value);
 415     }
 416 }
 417
 418 static void
 419 api_ip6_fib_table_get_all (unix_shared_memory_queue_t * q,
 420                            vl_api_ip6_fib_dump_t * mp,
 421                            fib_table_t * fib_table)
 422 {
 423   vpe_api_main_t *am = &vpe_api_main;
 424   ip6_main_t *im6 = &ip6_main;
 425   ip6_fib_t *fib = &fib_table->v6;
 426   fib_node_index_t *fib_entry_index;
 427   api_ip6_fib_show_ctx_t ctx = {
 428     .fib_index = fib->index,.entries = NULL,
 429   };
 430   fib_route_path_encode_t *api_rpaths;
 431   fib_prefix_t pfx;
 432
 433   BV (clib_bihash_foreach_key_value_pair)
 434     ((BVT (clib_bihash) *) & im6->ip6_table[IP6_FIB_TABLE_NON_FWDING].
 435      ip6_hash, api_ip6_fib_table_put_entries, &ctx);
 436
 437   vec_sort_with_function (ctx.entries, fib_entry_cmp_for_sort);
 438
 439   vec_foreach (fib_entry_index, ctx.entries)
 440   {
 441     fib_entry_get_prefix (*fib_entry_index, &pfx);
 442     api_rpaths = NULL;
 443     fib_entry_encode (*fib_entry_index, &api_rpaths);
 444     send_ip6_fib_details (am, q,
 445                           fib_table->ft_table_id,
 446                           &pfx, api_rpaths, mp->context);
 447     vec_free (api_rpaths);
 448   }
 449
 450   vec_free (ctx.entries);
 451 }
 452
 453 static void
 454 vl_api_ip6_fib_dump_t_handler (vl_api_ip6_fib_dump_t * mp)
 455 {
 456   unix_shared_memory_queue_t *q;
 457   ip6_main_t *im6 = &ip6_main;
 458   fib_table_t *fib_table;
 459
 460   q = vl_api_client_index_to_input_queue (mp->client_index);
 461   if (q == 0)
 462     return;
 463
 464   /* *INDENT-OFF* */
 465   pool_foreach (fib_table, im6->fibs,
 466   ({
 467     api_ip6_fib_table_get_all(q, mp, fib_table);
 468   }));
 469   /* *INDENT-ON* */
 470 }
 471
 472 static void
 473 vl_api_ip_mfib_details_t_handler (vl_api_ip_mfib_details_t * mp)
 474 {
 475   clib_warning ("BUG");
 476 }
 477
 478 static void
 479 vl_api_ip_mfib_details_t_endian (vl_api_ip_mfib_details_t * mp)
 480 {
 481   clib_warning ("BUG");
 482 }
 483
 484 static void
 485 vl_api_ip_mfib_details_t_print (vl_api_ip_mfib_details_t * mp)
 486 {
 487   clib_warning ("BUG");
 488 }
 489
 490 static void
 491 send_ip_mfib_details (vpe_api_main_t * am,
 492                       unix_shared_memory_queue_t * q,
 493                       u32 table_id,
 494                       mfib_prefix_t * pfx,
 495                       fib_route_path_encode_t * api_rpaths, u32 context)
 496 {
 497   vl_api_ip_mfib_details_t *mp;
 498   fib_route_path_encode_t *api_rpath;
 499   vl_api_fib_path_t *fp;
 500   int path_count;
 501
 502   path_count = vec_len (api_rpaths);
 503   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
 504   if (!mp)
 505     return;
 506   memset (mp, 0, sizeof (*mp));
 507   mp->_vl_msg_id = ntohs (VL_API_IP_FIB_DETAILS);
 508   mp->context = context;
 509
 510   mp->table_id = htonl (table_id);
 511   mp->address_length = pfx->fp_len;
 512   memcpy (mp->grp_address, &pfx->fp_grp_addr.ip4,
 513           sizeof (pfx->fp_grp_addr.ip4));
 514   memcpy (mp->src_address, &pfx->fp_src_addr.ip4,
 515           sizeof (pfx->fp_src_addr.ip4));
 516
 517   mp->count = htonl (path_count);
 518   fp = mp->path;
 519   vec_foreach (api_rpath, api_rpaths)
 520   {
 521     memset (fp, 0, sizeof (*fp));
 522
 523     fp->weight = 0;
 524     fp->sw_if_index = htonl (api_rpath->rpath.frp_sw_if_index);
 525     copy_fib_next_hop (api_rpath, fp);
 526     fp++;
 527   }
 528
 529   vl_msg_api_send_shmem (q, (u8 *) & mp);
 530 }
 531
 532 typedef struct vl_api_ip_mfib_dump_ctc_t_
 533 {
 534   fib_node_index_t *entries;
 535 } vl_api_ip_mfib_dump_ctc_t;
 536
 537 static int
 538 vl_api_ip_mfib_table_dump_walk (fib_node_index_t fei, void *arg)
 539 {
 540   vl_api_ip_mfib_dump_ctc_t *ctx = arg;
 541
 542   vec_add1 (ctx->entries, fei);
 543
 544   return (0);
 545 }
 546
 547 static void
 548 vl_api_ip_mfib_dump_t_handler (vl_api_ip_mfib_dump_t * mp)
 549 {
 550   vpe_api_main_t *am = &vpe_api_main;
 551   unix_shared_memory_queue_t *q;
 552   ip4_main_t *im = &ip4_main;
 553   mfib_table_t *mfib_table;
 554   fib_node_index_t *mfeip;
 555   mfib_prefix_t pfx;
 556   fib_route_path_encode_t *api_rpaths = NULL;
 557   vl_api_ip_mfib_dump_ctc_t ctx = {
 558     .entries = NULL,
 559   };
 560
 561   q = vl_api_client_index_to_input_queue (mp->client_index);
 562   if (q == 0)
 563     return;
 564
 565
 566   /* *INDENT-OFF* */
 567   pool_foreach (mfib_table, im->mfibs,
 568   ({
 569     ip4_mfib_table_walk(&mfib_table->v4,
 570                         vl_api_ip_mfib_table_dump_walk,
 571                         &ctx);
 572
 573     vec_sort_with_function (ctx.entries, mfib_entry_cmp_for_sort);
 574
 575     vec_foreach (mfeip, ctx.entries)
 576     {
 577       mfib_entry_get_prefix (*mfeip, &pfx);
 578       mfib_entry_encode (*mfeip, &api_rpaths);
 579       send_ip_mfib_details (am, q,
 580                             mfib_table->mft_table_id,
 581                             &pfx, api_rpaths,
 582                             mp->context);
 583     }
 584     vec_reset_length (api_rpaths);
 585     vec_reset_length (ctx.entries);
 586
 587   }));
 588   /* *INDENT-ON* */
 589
 590   vec_free (ctx.entries);
 591   vec_free (api_rpaths);
 592 }
 593
 594 static void
 595 vl_api_ip6_mfib_details_t_handler (vl_api_ip6_mfib_details_t * mp)
 596 {
 597   clib_warning ("BUG");
 598 }
 599
 600 static void
 601 vl_api_ip6_mfib_details_t_endian (vl_api_ip6_mfib_details_t * mp)
 602 {
 603   clib_warning ("BUG");
 604 }
 605
 606 static void
 607 vl_api_ip6_mfib_details_t_print (vl_api_ip6_mfib_details_t * mp)
 608 {
 609   clib_warning ("BUG");
 610 }
 611
 612 static void
 613 send_ip6_mfib_details (vpe_api_main_t * am,
 614                        unix_shared_memory_queue_t * q,
 615                        u32 table_id,
 616                        mfib_prefix_t * pfx,
 617                        fib_route_path_encode_t * api_rpaths, u32 context)
 618 {
 619   vl_api_ip6_mfib_details_t *mp;
 620   fib_route_path_encode_t *api_rpath;
 621   vl_api_fib_path_t *fp;
 622   int path_count;
 623
 624   path_count = vec_len (api_rpaths);
 625   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
 626   if (!mp)
 627     return;
 628   memset (mp, 0, sizeof (*mp));
 629   mp->_vl_msg_id = ntohs (VL_API_IP6_FIB_DETAILS);
 630   mp->context = context;
 631
 632   mp->table_id = htonl (table_id);
 633   mp->address_length = pfx->fp_len;
 634   memcpy (mp->grp_address, &pfx->fp_grp_addr.ip6,
 635           sizeof (pfx->fp_grp_addr.ip6));
 636   memcpy (mp->src_address, &pfx->fp_src_addr.ip6,
 637           sizeof (pfx->fp_src_addr.ip6));
 638
 639   mp->count = htonl (path_count);
 640   fp = mp->path;
 641   vec_foreach (api_rpath, api_rpaths)
 642   {
 643     memset (fp, 0, sizeof (*fp));
 644
 645     fp->weight = 0;
 646     fp->sw_if_index = htonl (api_rpath->rpath.frp_sw_if_index);
 647     copy_fib_next_hop (api_rpath, fp);
 648     fp++;
 649   }
 650
 651   vl_msg_api_send_shmem (q, (u8 *) & mp);
 652 }
 653
 654 typedef struct vl_api_ip6_mfib_dump_ctc_t_
 655 {
 656   fib_node_index_t *entries;
 657 } vl_api_ip6_mfib_dump_ctc_t;
 658
 659 static int
 660 vl_api_ip6_mfib_table_dump_walk (fib_node_index_t fei, void *arg)
 661 {
 662   vl_api_ip6_mfib_dump_ctc_t *ctx = arg;
 663
 664   vec_add1 (ctx->entries, fei);
 665
 666   return (0);
 667 }
 668
 669 static void
 670 vl_api_ip6_mfib_dump_t_handler (vl_api_ip6_mfib_dump_t * mp)
 671 {
 672   vpe_api_main_t *am = &vpe_api_main;
 673   unix_shared_memory_queue_t *q;
 674   ip6_main_t *im = &ip6_main;
 675   mfib_table_t *mfib_table;
 676   fib_node_index_t *mfeip;
 677   mfib_prefix_t pfx;
 678   fib_route_path_encode_t *api_rpaths = NULL;
 679   vl_api_ip6_mfib_dump_ctc_t ctx = {
 680     .entries = NULL,
 681   };
 682
 683   q = vl_api_client_index_to_input_queue (mp->client_index);
 684   if (q == 0)
 685     return;
 686
 687
 688   /* *INDENT-OFF* */
 689   pool_foreach (mfib_table, im->mfibs,
 690   ({
 691     ip6_mfib_table_walk(&mfib_table->v6,
 692                         vl_api_ip6_mfib_table_dump_walk,
 693                         &ctx);
 694
 695     vec_sort_with_function (ctx.entries, mfib_entry_cmp_for_sort);
 696
 697     vec_foreach(mfeip, ctx.entries)
 698     {
 699       mfib_entry_get_prefix (*mfeip, &pfx);
 700       mfib_entry_encode (*mfeip, &api_rpaths);
 701       send_ip6_mfib_details (am, q,
 702                              mfib_table->mft_table_id,
 703                              &pfx, api_rpaths,
 704                              mp->context);
 705     }
 706     vec_reset_length (api_rpaths);
 707     vec_reset_length (ctx.entries);
 708
 709   }));
 710   /* *INDENT-ON* */
 711
 712   vec_free (ctx.entries);
 713   vec_free (api_rpaths);
 714 }
 715
 716 static void
 717 vl_api_ip_neighbor_add_del_t_handler (vl_api_ip_neighbor_add_del_t * mp,
 718                                       vlib_main_t * vm)
 719 {
 720   vl_api_ip_neighbor_add_del_reply_t *rmp;
 721   vnet_main_t *vnm = vnet_get_main ();
 722   int rv = 0;
 723
 724   VALIDATE_SW_IF_INDEX (mp);
 725
 726   stats_dslock_with_hint (1 /* release hint */ , 7 /* tag */ );
 727
 728   /*
 729    * there's no validation here of the ND/ARP entry being added.
 730    * The expectation is that the FIB will ensure that nothing bad
 731    * will come of adding bogus entries.
 732    */
 733   if (mp->is_ipv6)
 734     {
 735       if (mp->is_add)
 736         rv = vnet_set_ip6_ethernet_neighbor
 737           (vm, ntohl (mp->sw_if_index),
 738            (ip6_address_t *) (mp->dst_address),
 739            mp->mac_address, sizeof (mp->mac_address), mp->is_static);
 740       else
 741         rv = vnet_unset_ip6_ethernet_neighbor
 742           (vm, ntohl (mp->sw_if_index),
 743            (ip6_address_t *) (mp->dst_address),
 744            mp->mac_address, sizeof (mp->mac_address));
 745     }
 746   else
 747     {
 748       ethernet_arp_ip4_over_ethernet_address_t a;
 749
 750       clib_memcpy (&a.ethernet, mp->mac_address, 6);
 751       clib_memcpy (&a.ip4, mp->dst_address, 4);
 752
 753       if (mp->is_add)
 754         rv = vnet_arp_set_ip4_over_ethernet (vnm, ntohl (mp->sw_if_index),
 755                                              &a, mp->is_static);
 756       else
 757         rv =
 758           vnet_arp_unset_ip4_over_ethernet (vnm, ntohl (mp->sw_if_index), &a);
 759     }
 760
 761   BAD_SW_IF_INDEX_LABEL;
 762
 763   stats_dsunlock ();
 764   REPLY_MACRO (VL_API_IP_NEIGHBOR_ADD_DEL_REPLY);
 765 }
 766
 767 int
 768 add_del_route_t_handler (u8 is_multipath,
 769                          u8 is_add,
 770                          u8 is_drop,
 771                          u8 is_unreach,
 772                          u8 is_prohibit,
 773                          u8 is_local,
 774                          u8 is_classify,
 775                          u32 classify_table_index,
 776                          u8 is_resolve_host,
 777                          u8 is_resolve_attached,
 778                          u32 fib_index,
 779                          const fib_prefix_t * prefix,
 780                          u8 next_hop_proto_is_ip4,
 781                          const ip46_address_t * next_hop,
 782                          u32 next_hop_sw_if_index,
 783                          u8 next_hop_fib_index,
 784                          u32 next_hop_weight,
 785                          mpls_label_t next_hop_via_label,
 786                          mpls_label_t * next_hop_out_label_stack)
 787 {
 788   vnet_classify_main_t *cm = &vnet_classify_main;
 789   fib_route_path_flags_t path_flags = FIB_ROUTE_PATH_FLAG_NONE;
 790   fib_route_path_t path = {
 791     .frp_proto = (next_hop_proto_is_ip4 ?
 792                   FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6),
 793     .frp_addr = (NULL == next_hop ? zero_addr : *next_hop),
 794     .frp_sw_if_index = next_hop_sw_if_index,
 795     .frp_fib_index = next_hop_fib_index,
 796     .frp_weight = next_hop_weight,
 797     .frp_label_stack = next_hop_out_label_stack,
 798   };
 799   fib_route_path_t *paths = NULL;
 800
 801   if (MPLS_LABEL_INVALID != next_hop_via_label)
 802     {
 803       path.frp_proto = FIB_PROTOCOL_MPLS;
 804       path.frp_local_label = next_hop_via_label;
 805     }
 806   if (is_resolve_host)
 807     path_flags |= FIB_ROUTE_PATH_RESOLVE_VIA_HOST;
 808   if (is_resolve_attached)
 809     path_flags |= FIB_ROUTE_PATH_RESOLVE_VIA_ATTACHED;
 810
 811   path.frp_flags = path_flags;
 812
 813   if (is_multipath)
 814     {
 815       stats_dslock_with_hint (1 /* release hint */ , 10 /* tag */ );
 816
 817
 818       vec_add1 (paths, path);
 819
 820       if (is_add)
 821         fib_table_entry_path_add2 (fib_index,
 822                                    prefix,
 823                                    FIB_SOURCE_API,
 824                                    FIB_ENTRY_FLAG_NONE, paths);
 825       else
 826         fib_table_entry_path_remove2 (fib_index,
 827                                       prefix, FIB_SOURCE_API, paths);
 828
 829       vec_free (paths);
 830       stats_dsunlock ();
 831       return 0;
 832     }
 833
 834   stats_dslock_with_hint (1 /* release hint */ , 2 /* tag */ );
 835
 836   if (is_drop || is_local || is_classify || is_unreach || is_prohibit)
 837     {
 838       /*
 839        * special route types that link directly to the adj
 840        */
 841       if (is_add)
 842         {
 843           dpo_id_t dpo = DPO_INVALID;
 844           dpo_proto_t dproto;
 845
 846           dproto = fib_proto_to_dpo (prefix->fp_proto);
 847
 848           if (is_drop)
 849             ip_null_dpo_add_and_lock (dproto, IP_NULL_ACTION_NONE, &dpo);
 850           else if (is_local)
 851             receive_dpo_add_or_lock (dproto, ~0, NULL, &dpo);
 852           else if (is_unreach)
 853             ip_null_dpo_add_and_lock (dproto,
 854                                       IP_NULL_ACTION_SEND_ICMP_UNREACH, &dpo);
 855           else if (is_prohibit)
 856             ip_null_dpo_add_and_lock (dproto,
 857                                       IP_NULL_ACTION_SEND_ICMP_PROHIBIT,
 858                                       &dpo);
 859           else if (is_classify)
 860             {
 861               if (pool_is_free_index (cm->tables,
 862                                       ntohl (classify_table_index)))
 863                 {
 864                   stats_dsunlock ();
 865                   return VNET_API_ERROR_NO_SUCH_TABLE;
 866                 }
 867
 868               dpo_set (&dpo, DPO_CLASSIFY, dproto,
 869                        classify_dpo_create (dproto,
 870                                             ntohl (classify_table_index)));
 871             }
 872           else
 873             {
 874               stats_dsunlock ();
 875               return VNET_API_ERROR_NO_SUCH_TABLE;
 876             }
 877
 878           fib_table_entry_special_dpo_update (fib_index,
 879                                               prefix,
 880                                               FIB_SOURCE_API,
 881                                               FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
 882           dpo_reset (&dpo);
 883         }
 884       else
 885         {
 886           fib_table_entry_special_remove (fib_index, prefix, FIB_SOURCE_API);
 887         }
 888     }
 889   else
 890     {
 891       if (is_add)
 892         {
 893           vec_add1 (paths, path);
 894           fib_table_entry_update (fib_index,
 895                                   prefix,
 896                                   FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE, paths);
 897           vec_free (paths);
 898         }
 899       else
 900         {
 901           fib_table_entry_delete (fib_index, prefix, FIB_SOURCE_API);
 902         }
 903     }
 904
 905   stats_dsunlock ();
 906   return (0);
 907 }
 908
 909 int
 910 add_del_route_check (fib_protocol_t table_proto,
 911                      u32 table_id,
 912                      u32 next_hop_sw_if_index,
 913                      fib_protocol_t next_hop_table_proto,
 914                      u32 next_hop_table_id,
 915                      u8 create_missing_tables,
 916                      u32 * fib_index, u32 * next_hop_fib_index)
 917 {
 918   vnet_main_t *vnm = vnet_get_main ();
 919
 920   *fib_index = fib_table_find (table_proto, ntohl (table_id));
 921   if (~0 == *fib_index)
 922     {
 923       if (create_missing_tables)
 924         {
 925           *fib_index = fib_table_find_or_create_and_lock (table_proto,
 926                                                           ntohl (table_id));
 927         }
 928       else
 929         {
 930           /* No such VRF, and we weren't asked to create one */
 931           return VNET_API_ERROR_NO_SUCH_FIB;
 932         }
 933     }
 934
 935   if (~0 != ntohl (next_hop_sw_if_index))
 936     {
 937       if (pool_is_free_index (vnm->interface_main.sw_interfaces,
 938                               ntohl (next_hop_sw_if_index)))
 939         {
 940           return VNET_API_ERROR_NO_MATCHING_INTERFACE;
 941         }
 942     }
 943   else
 944     {
 945       *next_hop_fib_index = fib_table_find (next_hop_table_proto,
 946                                             ntohl (next_hop_table_id));
 947
 948       if (~0 == *next_hop_fib_index)
 949         {
 950           if (create_missing_tables)
 951             {
 952               *next_hop_fib_index =
 953                 fib_table_find_or_create_and_lock (next_hop_table_proto,
 954                                                    ntohl (next_hop_table_id));
 955             }
 956           else
 957             {
 958               /* No such VRF, and we weren't asked to create one */
 959               return VNET_API_ERROR_NO_SUCH_FIB;
 960             }
 961         }
 962     }
 963
 964   return (0);
 965 }
 966
 967 static int
 968 ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
 969 {
 970   u32 fib_index, next_hop_fib_index;
 971   mpls_label_t *label_stack = NULL;
 972   int rv, ii, n_labels;;
 973
 974   rv = add_del_route_check (FIB_PROTOCOL_IP4,
 975                             mp->table_id,
 976                             mp->next_hop_sw_if_index,
 977                             FIB_PROTOCOL_IP4,
 978                             mp->next_hop_table_id,
 979                             mp->create_vrf_if_needed,
 980                             &fib_index, &next_hop_fib_index);
 981
 982   if (0 != rv)
 983     return (rv);
 984
 985   fib_prefix_t pfx = {
 986     .fp_len = mp->dst_address_length,
 987     .fp_proto = FIB_PROTOCOL_IP4,
 988   };
 989   clib_memcpy (&pfx.fp_addr.ip4, mp->dst_address, sizeof (pfx.fp_addr.ip4));
 990
 991   ip46_address_t nh;
 992   memset (&nh, 0, sizeof (nh));
 993   memcpy (&nh.ip4, mp->next_hop_address, sizeof (nh.ip4));
 994
 995   n_labels = mp->next_hop_n_out_labels;
 996   if (n_labels == 0)
 997     ;
 998   else if (1 == n_labels)
 999     vec_add1 (label_stack, ntohl (mp->next_hop_out_label_stack[0]));
1000   else
1001     {
1002       vec_validate (label_stack, n_labels - 1);
1003       for (ii = 0; ii < n_labels; ii++)
1004         label_stack[ii] = ntohl (mp->next_hop_out_label_stack[ii]);
1005     }
1006
1007   return (add_del_route_t_handler (mp->is_multipath,
1008                                    mp->is_add,
1009                                    mp->is_drop,
1010                                    mp->is_unreach,
1011                                    mp->is_prohibit,
1012                                    mp->is_local,
1013                                    mp->is_classify,
1014                                    mp->classify_table_index,
1015                                    mp->is_resolve_host,
1016                                    mp->is_resolve_attached,
1017                                    fib_index, &pfx, 1,
1018                                    &nh,
1019                                    ntohl (mp->next_hop_sw_if_index),
1020                                    next_hop_fib_index,
1021                                    mp->next_hop_weight,
1022                                    ntohl (mp->next_hop_via_label),
1023                                    label_stack));
1024 }
1025
1026 static int
1027 ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
1028 {
1029   u32 fib_index, next_hop_fib_index;
1030   mpls_label_t *label_stack = NULL;
1031   int rv, ii, n_labels;;
1032
1033   rv = add_del_route_check (FIB_PROTOCOL_IP6,
1034                             mp->table_id,
1035                             mp->next_hop_sw_if_index,
1036                             FIB_PROTOCOL_IP6,
1037                             mp->next_hop_table_id,
1038                             mp->create_vrf_if_needed,
1039                             &fib_index, &next_hop_fib_index);
1040
1041   if (0 != rv)
1042     return (rv);
1043
1044   fib_prefix_t pfx = {
1045     .fp_len = mp->dst_address_length,
1046     .fp_proto = FIB_PROTOCOL_IP6,
1047   };
1048   clib_memcpy (&pfx.fp_addr.ip6, mp->dst_address, sizeof (pfx.fp_addr.ip6));
1049
1050   ip46_address_t nh;
1051   memset (&nh, 0, sizeof (nh));
1052   memcpy (&nh.ip6, mp->next_hop_address, sizeof (nh.ip6));
1053
1054   n_labels = mp->next_hop_n_out_labels;
1055   if (n_labels == 0)
1056     ;
1057   else if (1 == n_labels)
1058     vec_add1 (label_stack, ntohl (mp->next_hop_out_label_stack[0]));
1059   else
1060     {
1061       vec_validate (label_stack, n_labels - 1);
1062       for (ii = 0; ii < n_labels; ii++)
1063         label_stack[ii] = ntohl (mp->next_hop_out_label_stack[ii]);
1064     }
1065
1066   return (add_del_route_t_handler (mp->is_multipath,
1067                                    mp->is_add,
1068                                    mp->is_drop,
1069                                    mp->is_unreach,
1070                                    mp->is_prohibit,
1071                                    mp->is_local,
1072                                    mp->is_classify,
1073                                    mp->classify_table_index,
1074                                    mp->is_resolve_host,
1075                                    mp->is_resolve_attached,
1076                                    fib_index, &pfx, 0,
1077                                    &nh, ntohl (mp->next_hop_sw_if_index),
1078                                    next_hop_fib_index,
1079                                    mp->next_hop_weight,
1080                                    ntohl (mp->next_hop_via_label),
1081                                    label_stack));
1082 }
1083
1084 void
1085 vl_api_ip_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
1086 {
1087   vl_api_ip_add_del_route_reply_t *rmp;
1088   int rv;
1089   vnet_main_t *vnm = vnet_get_main ();
1090
1091   vnm->api_errno = 0;
1092
1093   if (mp->is_ipv6)
1094     rv = ip6_add_del_route_t_handler (mp);
1095   else
1096     rv = ip4_add_del_route_t_handler (mp);
1097
1098   rv = (rv == 0) ? vnm->api_errno : rv;
1099
1100   REPLY_MACRO (VL_API_IP_ADD_DEL_ROUTE_REPLY);
1101 }
1102
1103 static int
1104 add_del_mroute_check (fib_protocol_t table_proto,
1105                       u32 table_id,
1106                       u32 next_hop_sw_if_index,
1107                       u8 is_local, u8 create_missing_tables, u32 * fib_index)
1108 {
1109   vnet_main_t *vnm = vnet_get_main ();
1110
1111   *fib_index = mfib_table_find (table_proto, ntohl (table_id));
1112   if (~0 == *fib_index)
1113     {
1114       if (create_missing_tables)
1115         {
1116           *fib_index = mfib_table_find_or_create_and_lock (table_proto,
1117                                                            ntohl (table_id));
1118         }
1119       else
1120         {
1121           /* No such VRF, and we weren't asked to create one */
1122           return VNET_API_ERROR_NO_SUCH_FIB;
1123         }
1124     }
1125
1126   if (~0 != ntohl (next_hop_sw_if_index))
1127     {
1128       if (pool_is_free_index (vnm->interface_main.sw_interfaces,
1129                               ntohl (next_hop_sw_if_index)))
1130         {
1131           return VNET_API_ERROR_NO_MATCHING_INTERFACE;
1132         }
1133     }
1134
1135   return (0);
1136 }
1137
1138 static int
1139 mroute_add_del_handler (u8 is_add,
1140                         u8 is_local,
1141                         u32 fib_index,
1142                         const mfib_prefix_t * prefix,
1143                         u32 entry_flags,
1144                         u32 next_hop_sw_if_index, u32 itf_flags)
1145 {
1146   stats_dslock_with_hint (1 /* release hint */ , 2 /* tag */ );
1147
1148   fib_route_path_t path = {
1149     .frp_sw_if_index = next_hop_sw_if_index,
1150     .frp_proto = prefix->fp_proto,
1151   };
1152
1153   if (is_local)
1154     path.frp_flags |= FIB_ROUTE_PATH_LOCAL;
1155
1156
1157   if (!is_local && ~0 == next_hop_sw_if_index)
1158     {
1159       mfib_table_entry_update (fib_index, prefix,
1160                                MFIB_SOURCE_API, entry_flags);
1161     }
1162   else
1163     {
1164       if (is_add)
1165         {
1166           mfib_table_entry_path_update (fib_index, prefix,
1167                                         MFIB_SOURCE_API, &path, itf_flags);
1168         }
1169       else
1170         {
1171           mfib_table_entry_path_remove (fib_index, prefix,
1172                                         MFIB_SOURCE_API, &path);
1173         }
1174     }
1175
1176   stats_dsunlock ();
1177   return (0);
1178 }
1179
1180 static int
1181 api_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp)
1182 {
1183   fib_protocol_t fproto;
1184   u32 fib_index;
1185   int rv;
1186
1187   fproto = (mp->is_ipv6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
1188   rv = add_del_mroute_check (fproto,
1189                              mp->table_id,
1190                              mp->next_hop_sw_if_index,
1191                              mp->is_local,
1192                              mp->create_vrf_if_needed, &fib_index);
1193
1194   if (0 != rv)
1195     return (rv);
1196
1197   mfib_prefix_t pfx = {
1198     .fp_len = ntohs (mp->grp_address_length),
1199     .fp_proto = fproto,
1200   };
1201
1202   if (FIB_PROTOCOL_IP4 == fproto)
1203     {
1204       clib_memcpy (&pfx.fp_grp_addr.ip4, mp->grp_address,
1205                    sizeof (pfx.fp_grp_addr.ip4));
1206       clib_memcpy (&pfx.fp_src_addr.ip4, mp->src_address,
1207                    sizeof (pfx.fp_src_addr.ip4));
1208     }
1209   else
1210     {
1211       clib_memcpy (&pfx.fp_grp_addr.ip6, mp->grp_address,
1212                    sizeof (pfx.fp_grp_addr.ip6));
1213       clib_memcpy (&pfx.fp_src_addr.ip6, mp->src_address,
1214                    sizeof (pfx.fp_src_addr.ip6));
1215     }
1216
1217   return (mroute_add_del_handler (mp->is_add,
1218                                   mp->is_local,
1219                                   fib_index, &pfx,
1220                                   ntohl (mp->entry_flags),
1221                                   ntohl (mp->next_hop_sw_if_index),
1222                                   ntohl (mp->itf_flags)));
1223 }
1224
1225 void
1226 vl_api_ip_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp)
1227 {
1228   vl_api_ip_mroute_add_del_reply_t *rmp;
1229   int rv;
1230   vnet_main_t *vnm = vnet_get_main ();
1231
1232   vnm->api_errno = 0;
1233
1234   rv = api_mroute_add_del_t_handler (mp);
1235
1236   rv = (rv == 0) ? vnm->api_errno : rv;
1237
1238   REPLY_MACRO (VL_API_IP_MROUTE_ADD_DEL_REPLY);
1239 }
1240
1241 static void
1242 send_ip_details (vpe_api_main_t * am,
1243                  unix_shared_memory_queue_t * q, u32 sw_if_index,
1244                  u8 is_ipv6, u32 context)
1245 {
1246   vl_api_ip_details_t *mp;
1247
1248   mp = vl_msg_api_alloc (sizeof (*mp));
1249   memset (mp, 0, sizeof (*mp));
1250   mp->_vl_msg_id = ntohs (VL_API_IP_DETAILS);
1251
1252   mp->sw_if_index = ntohl (sw_if_index);
1253   mp->is_ipv6 = is_ipv6;
1254   mp->context = context;
1255
1256   vl_msg_api_send_shmem (q, (u8 *) & mp);
1257 }
1258
1259 static void
1260 send_ip_address_details (vpe_api_main_t * am,
1261                          unix_shared_memory_queue_t * q,
1262                          u8 * ip, u16 prefix_length,
1263                          u32 sw_if_index, u8 is_ipv6, u32 context)
1264 {
1265   vl_api_ip_address_details_t *mp;
1266
1267   mp = vl_msg_api_alloc (sizeof (*mp));
1268   memset (mp, 0, sizeof (*mp));
1269   mp->_vl_msg_id = ntohs (VL_API_IP_ADDRESS_DETAILS);
1270
1271   if (is_ipv6)
1272     {
1273       clib_memcpy (&mp->ip, ip, sizeof (mp->ip));
1274     }
1275   else
1276     {
1277       u32 *tp = (u32 *) mp->ip;
1278       *tp = *(u32 *) ip;
1279     }
1280   mp->prefix_length = prefix_length;
1281   mp->context = context;
1282   mp->sw_if_index = htonl (sw_if_index);
1283   mp->is_ipv6 = is_ipv6;
1284
1285   vl_msg_api_send_shmem (q, (u8 *) & mp);
1286 }
1287
1288 static void
1289 vl_api_ip_address_dump_t_handler (vl_api_ip_address_dump_t * mp)
1290 {
1291   vpe_api_main_t *am = &vpe_api_main;
1292   unix_shared_memory_queue_t *q;
1293   ip6_address_t *r6;
1294   ip4_address_t *r4;
1295   ip6_main_t *im6 = &ip6_main;
1296   ip4_main_t *im4 = &ip4_main;
1297   ip_lookup_main_t *lm6 = &im6->lookup_main;
1298   ip_lookup_main_t *lm4 = &im4->lookup_main;
1299   ip_interface_address_t *ia = 0;
1300   u32 sw_if_index = ~0;
1301   int rv __attribute__ ((unused)) = 0;
1302
1303   VALIDATE_SW_IF_INDEX (mp);
1304
1305   sw_if_index = ntohl (mp->sw_if_index);
1306
1307   q = vl_api_client_index_to_input_queue (mp->client_index);
1308   if (q == 0)
1309     return;
1310
1311   if (mp->is_ipv6)
1312     {
1313       /* *INDENT-OFF* */
1314       foreach_ip_interface_address (lm6, ia, sw_if_index,
1315                                     1 /* honor unnumbered */,
1316       ({
1317         r6 = ip_interface_address_get_address (lm6, ia);
1318         u16 prefix_length = ia->address_length;
1319         send_ip_address_details(am, q, (u8*)r6, prefix_length,
1320                                 sw_if_index, 1, mp->context);
1321       }));
1322       /* *INDENT-ON* */
1323     }
1324   else
1325     {
1326       /* *INDENT-OFF* */
1327       foreach_ip_interface_address (lm4, ia, sw_if_index,
1328                                     1 /* honor unnumbered */,
1329       ({
1330         r4 = ip_interface_address_get_address (lm4, ia);
1331         u16 prefix_length = ia->address_length;
1332         send_ip_address_details(am, q, (u8*)r4, prefix_length,
1333                                 sw_if_index, 0, mp->context);
1334       }));
1335       /* *INDENT-ON* */
1336     }
1337   BAD_SW_IF_INDEX_LABEL;
1338 }
1339
1340 static void
1341 vl_api_ip_dump_t_handler (vl_api_ip_dump_t * mp)
1342 {
1343   vpe_api_main_t *am = &vpe_api_main;
1344   vnet_main_t *vnm = vnet_get_main ();
1345   vlib_main_t *vm = vlib_get_main ();
1346   vnet_interface_main_t *im = &vnm->interface_main;
1347   unix_shared_memory_queue_t *q;
1348   vnet_sw_interface_t *si, *sorted_sis;
1349   u32 sw_if_index = ~0;
1350
1351   q = vl_api_client_index_to_input_queue (mp->client_index);
1352   if (q == 0)
1353     {
1354       return;
1355     }
1356
1357   /* Gather interfaces. */
1358   sorted_sis = vec_new (vnet_sw_interface_t, pool_elts (im->sw_interfaces));
1359   _vec_len (sorted_sis) = 0;
1360   /* *INDENT-OFF* */
1361   pool_foreach (si, im->sw_interfaces,
1362   ({
1363     vec_add1 (sorted_sis, si[0]);
1364   }));
1365   /* *INDENT-ON* */
1366
1367   vec_foreach (si, sorted_sis)
1368   {
1369     if (!(si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
1370       {
1371         if (mp->is_ipv6 && !ip6_interface_enabled (vm, si->sw_if_index))
1372           {
1373             continue;
1374           }
1375         sw_if_index = si->sw_if_index;
1376         send_ip_details (am, q, sw_if_index, mp->is_ipv6, mp->context);
1377       }
1378   }
1379 }
1380
1381 static void
1382 set_ip6_flow_hash (vl_api_set_ip_flow_hash_t * mp)
1383 {
1384   vl_api_set_ip_flow_hash_reply_t *rmp;
1385   int rv = VNET_API_ERROR_UNIMPLEMENTED;
1386
1387   clib_warning ("unimplemented...");
1388
1389   REPLY_MACRO (VL_API_SET_IP_FLOW_HASH_REPLY);
1390 }
1391
1392 static void
1393 set_ip4_flow_hash (vl_api_set_ip_flow_hash_t * mp)
1394 {
1395   vl_api_set_ip_flow_hash_reply_t *rmp;
1396   int rv;
1397   u32 table_id;
1398   flow_hash_config_t flow_hash_config = 0;
1399
1400   table_id = ntohl (mp->vrf_id);
1401
1402 #define _(a,b) if (mp->a) flow_hash_config |= b;
1403   foreach_flow_hash_bit;
1404 #undef _
1405
1406   rv = vnet_set_ip4_flow_hash (table_id, flow_hash_config);
1407
1408   REPLY_MACRO (VL_API_SET_IP_FLOW_HASH_REPLY);
1409 }
1410
1411
1412 static void
1413 vl_api_set_ip_flow_hash_t_handler (vl_api_set_ip_flow_hash_t * mp)
1414 {
1415   if (mp->is_ipv6 == 0)
1416     set_ip4_flow_hash (mp);
1417   else
1418     set_ip6_flow_hash (mp);
1419 }
1420
1421 static void
1422   vl_api_sw_interface_ip6nd_ra_config_t_handler
1423   (vl_api_sw_interface_ip6nd_ra_config_t * mp)
1424 {
1425   vl_api_sw_interface_ip6nd_ra_config_reply_t *rmp;
1426   vlib_main_t *vm = vlib_get_main ();
1427   int rv = 0;
1428   u8 is_no, suppress, managed, other, ll_option, send_unicast, cease,
1429     default_router;
1430
1431   is_no = mp->is_no == 1;
1432   suppress = mp->suppress == 1;
1433   managed = mp->managed == 1;
1434   other = mp->other == 1;
1435   ll_option = mp->ll_option == 1;
1436   send_unicast = mp->send_unicast == 1;
1437   cease = mp->cease == 1;
1438   default_router = mp->default_router == 1;
1439
1440   VALIDATE_SW_IF_INDEX (mp);
1441
1442   rv = ip6_neighbor_ra_config (vm, ntohl (mp->sw_if_index),
1443                                suppress, managed, other,
1444                                ll_option, send_unicast, cease,
1445                                default_router, ntohl (mp->lifetime),
1446                                ntohl (mp->initial_count),
1447                                ntohl (mp->initial_interval),
1448                                ntohl (mp->max_interval),
1449                                ntohl (mp->min_interval), is_no);
1450
1451   BAD_SW_IF_INDEX_LABEL;
1452
1453   REPLY_MACRO (VL_API_SW_INTERFACE_IP6ND_RA_CONFIG_REPLY);
1454 }
1455
1456 static void
1457   vl_api_sw_interface_ip6nd_ra_prefix_t_handler
1458   (vl_api_sw_interface_ip6nd_ra_prefix_t * mp)
1459 {
1460   vlib_main_t *vm = vlib_get_main ();
1461   vl_api_sw_interface_ip6nd_ra_prefix_reply_t *rmp;
1462   int rv = 0;
1463   u8 is_no, use_default, no_advertise, off_link, no_autoconfig, no_onlink;
1464
1465   VALIDATE_SW_IF_INDEX (mp);
1466
1467   is_no = mp->is_no == 1;
1468   use_default = mp->use_default == 1;
1469   no_advertise = mp->no_advertise == 1;
1470   off_link = mp->off_link == 1;
1471   no_autoconfig = mp->no_autoconfig == 1;
1472   no_onlink = mp->no_onlink == 1;
1473
1474   rv = ip6_neighbor_ra_prefix (vm, ntohl (mp->sw_if_index),
1475                                (ip6_address_t *) mp->address,
1476                                mp->address_length, use_default,
1477                                ntohl (mp->val_lifetime),
1478                                ntohl (mp->pref_lifetime), no_advertise,
1479                                off_link, no_autoconfig, no_onlink, is_no);
1480
1481   BAD_SW_IF_INDEX_LABEL;
1482   REPLY_MACRO (VL_API_SW_INTERFACE_IP6ND_RA_PREFIX_REPLY);
1483 }
1484
1485 static void
1486   vl_api_sw_interface_ip6_enable_disable_t_handler
1487   (vl_api_sw_interface_ip6_enable_disable_t * mp)
1488 {
1489   vlib_main_t *vm = vlib_get_main ();
1490   vl_api_sw_interface_ip6_enable_disable_reply_t *rmp;
1491   vnet_main_t *vnm = vnet_get_main ();
1492   int rv = 0;
1493   clib_error_t *error;
1494
1495   vnm->api_errno = 0;
1496
1497   VALIDATE_SW_IF_INDEX (mp);
1498
1499   error =
1500     (mp->enable == 1) ? enable_ip6_interface (vm,
1501                                               ntohl (mp->sw_if_index)) :
1502     disable_ip6_interface (vm, ntohl (mp->sw_if_index));
1503
1504   if (error)
1505     {
1506       clib_error_report (error);
1507       rv = VNET_API_ERROR_UNSPECIFIED;
1508     }
1509   else
1510     {
1511       rv = vnm->api_errno;
1512     }
1513
1514   BAD_SW_IF_INDEX_LABEL;
1515
1516   REPLY_MACRO (VL_API_SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY);
1517 }
1518
1519 static void
1520   vl_api_sw_interface_ip6_set_link_local_address_t_handler
1521   (vl_api_sw_interface_ip6_set_link_local_address_t * mp)
1522 {
1523   vlib_main_t *vm = vlib_get_main ();
1524   vl_api_sw_interface_ip6_set_link_local_address_reply_t *rmp;
1525   int rv = 0;
1526   clib_error_t *error;
1527   vnet_main_t *vnm = vnet_get_main ();
1528
1529   vnm->api_errno = 0;
1530
1531   VALIDATE_SW_IF_INDEX (mp);
1532
1533   error = set_ip6_link_local_address (vm,
1534                                       ntohl (mp->sw_if_index),
1535                                       (ip6_address_t *) mp->address);
1536   if (error)
1537     {
1538       clib_error_report (error);
1539       rv = VNET_API_ERROR_UNSPECIFIED;
1540     }
1541   else
1542     {
1543       rv = vnm->api_errno;
1544     }
1545
1546   BAD_SW_IF_INDEX_LABEL;
1547
1548   REPLY_MACRO (VL_API_SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY);
1549 }
1550
1551 void
1552 vl_mfib_signal_send_one (unix_shared_memory_queue_t * q,
1553                          u32 context, const mfib_signal_t * mfs)
1554 {
1555   vl_api_mfib_signal_details_t *mp;
1556   mfib_prefix_t prefix;
1557   mfib_table_t *mfib;
1558   mfib_itf_t *mfi;
1559
1560   mp = vl_msg_api_alloc (sizeof (*mp));
1561
1562   memset (mp, 0, sizeof (*mp));
1563   mp->_vl_msg_id = ntohs (VL_API_MFIB_SIGNAL_DETAILS);
1564   mp->context = context;
1565
1566   mfi = mfib_itf_get (mfs->mfs_itf);
1567   mfib_entry_get_prefix (mfs->mfs_entry, &prefix);
1568   mfib = mfib_table_get (mfib_entry_get_fib_index (mfs->mfs_entry),
1569                          prefix.fp_proto);
1570   mp->table_id = ntohl (mfib->mft_table_id);
1571   mp->sw_if_index = ntohl (mfi->mfi_sw_if_index);
1572
1573   if (FIB_PROTOCOL_IP4 == prefix.fp_proto)
1574     {
1575       mp->grp_address_len = ntohs (prefix.fp_len);
1576
1577       memcpy (mp->grp_address, &prefix.fp_grp_addr.ip4, 4);
1578       if (prefix.fp_len > 32)
1579         {
1580           memcpy (mp->src_address, &prefix.fp_src_addr.ip4, 4);
1581         }
1582     }
1583   else
1584     {
1585       mp->grp_address_len = ntohs (prefix.fp_len);
1586
1587       ASSERT (0);
1588     }
1589
1590   if (0 != mfs->mfs_buffer_len)
1591     {
1592       mp->ip_packet_len = ntohs (mfs->mfs_buffer_len);
1593
1594       memcpy (mp->ip_packet_data, mfs->mfs_buffer, mfs->mfs_buffer_len);
1595     }
1596   else
1597     {
1598       mp->ip_packet_len = 0;
1599     }
1600
1601   vl_msg_api_send_shmem (q, (u8 *) & mp);
1602 }
1603
1604 static void
1605 vl_api_mfib_signal_dump_t_handler (vl_api_mfib_signal_dump_t * mp)
1606 {
1607   unix_shared_memory_queue_t *q;
1608
1609   q = vl_api_client_index_to_input_queue (mp->client_index);
1610   if (q == 0)
1611     {
1612       return;
1613     }
1614
1615   while (q->cursize < q->maxsize && mfib_signal_send_one (q, mp->context))
1616     ;
1617 }
1618
1619 #define vl_msg_name_crc_list
1620 #include <vnet/ip/ip.api.h>
1621 #undef vl_msg_name_crc_list
1622
1623 static void
1624 setup_message_id_table (api_main_t * am)
1625 {
1626 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1627   foreach_vl_msg_name_crc_ip;
1628 #undef _
1629 }
1630
1631 static clib_error_t *
1632 ip_api_hookup (vlib_main_t * vm)
1633 {
1634   api_main_t *am = &api_main;
1635
1636 #define _(N,n)                                                  \
1637     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1638                            vl_api_##n##_t_handler,              \
1639                            vl_noop_handler,                     \
1640                            vl_api_##n##_t_endian,               \
1641                            vl_api_##n##_t_print,                \
1642                            sizeof(vl_api_##n##_t), 1);
1643   foreach_ip_api_msg;
1644 #undef _
1645
1646   /*
1647    * Set up the (msg_name, crc, message-id) table
1648    */
1649   setup_message_id_table (am);
1650
1651   return 0;
1652 }
1653
1654 VLIB_API_INIT_FUNCTION (ip_api_hookup);
1655
1656 /*
1657  * fd.io coding-style-patch-verification: ON
1658  *
1659  * Local Variables:
1660  * eval: (c-set-style "gnu")
1661  * End:
1662  */