src/plugins/gbp/gbp_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/plugin/plugin.h>
  20
  21 #include <vnet/interface.h>
  22 #include <vnet/api_errno.h>
  23 #include <vnet/ip/ip_types_api.h>
  24 #include <vnet/ethernet/ethernet_types_api.h>
  25 #include <vpp/app/version.h>
  26
  27 #include <gbp/gbp.h>
  28 #include <gbp/gbp_learn.h>
  29 #include <gbp/gbp_itf.h>
  30 #include <gbp/gbp_vxlan.h>
  31 #include <gbp/gbp_bridge_domain.h>
  32 #include <gbp/gbp_route_domain.h>
  33 #include <gbp/gbp_ext_itf.h>
  34
  35 #include <vlibapi/api.h>
  36 #include <vlibmemory/api.h>
  37
  38 /* define message IDs */
  39 #include <gbp/gbp_msg_enum.h>
  40
  41 #define vl_typedefs             /* define message structures */
  42 #include <gbp/gbp_all_api_h.h>
  43 #undef vl_typedefs
  44
  45 #define vl_endianfun            /* define message structures */
  46 #include <gbp/gbp_all_api_h.h>
  47 #undef vl_endianfun
  48
  49 /* instantiate all the print functions we know about */
  50 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  51 #define vl_printfun
  52 #include <gbp/gbp_all_api_h.h>
  53 #undef vl_printfun
  54
  55 /* Get the API version number */
  56 #define vl_api_version(n,v) static u32 api_version=(v);
  57 #include <gbp/gbp_all_api_h.h>
  58 #undef vl_api_version
  59
  60 #include <vlibapi/api_helper_macros.h>
  61
  62 #define foreach_gbp_api_msg                                 \
  63   _(GBP_ENDPOINT_ADD, gbp_endpoint_add)                     \
  64   _(GBP_ENDPOINT_DEL, gbp_endpoint_del)                     \
  65   _(GBP_ENDPOINT_DUMP, gbp_endpoint_dump)                   \
  66   _(GBP_SUBNET_ADD_DEL, gbp_subnet_add_del)                 \
  67   _(GBP_SUBNET_DUMP, gbp_subnet_dump)                       \
  68   _(GBP_ENDPOINT_GROUP_ADD, gbp_endpoint_group_add)         \
  69   _(GBP_ENDPOINT_GROUP_DEL, gbp_endpoint_group_del)         \
  70   _(GBP_ENDPOINT_GROUP_DUMP, gbp_endpoint_group_dump)       \
  71   _(GBP_BRIDGE_DOMAIN_ADD, gbp_bridge_domain_add)           \
  72   _(GBP_BRIDGE_DOMAIN_DEL, gbp_bridge_domain_del)           \
  73   _(GBP_BRIDGE_DOMAIN_DUMP, gbp_bridge_domain_dump)         \
  74   _(GBP_ROUTE_DOMAIN_ADD, gbp_route_domain_add)             \
  75   _(GBP_ROUTE_DOMAIN_DEL, gbp_route_domain_del)             \
  76   _(GBP_ROUTE_DOMAIN_DUMP, gbp_route_domain_dump)           \
  77   _(GBP_RECIRC_ADD_DEL, gbp_recirc_add_del)                 \
  78   _(GBP_RECIRC_DUMP, gbp_recirc_dump)                       \
  79   _(GBP_EXT_ITF_ADD_DEL, gbp_ext_itf_add_del)               \
  80   _(GBP_EXT_ITF_DUMP, gbp_ext_itf_dump)                     \
  81   _(GBP_CONTRACT_ADD_DEL, gbp_contract_add_del)             \
  82   _(GBP_CONTRACT_DUMP, gbp_contract_dump)                   \
  83   _(GBP_VXLAN_TUNNEL_ADD, gbp_vxlan_tunnel_add)             \
  84   _(GBP_VXLAN_TUNNEL_DEL, gbp_vxlan_tunnel_del)             \
  85   _(GBP_VXLAN_TUNNEL_DUMP, gbp_vxlan_tunnel_dump)           \
  86   _(GBP_EXT_ITF_ANON_ADD_DEL, gbp_ext_itf_anon_add_del)
  87
  88 gbp_main_t gbp_main;
  89
  90 static u16 msg_id_base;
  91
  92 #define GBP_MSG_BASE msg_id_base
  93
  94 static gbp_endpoint_flags_t
  95 gbp_endpoint_flags_decode (vl_api_gbp_endpoint_flags_t v)
  96 {
  97   gbp_endpoint_flags_t f = GBP_ENDPOINT_FLAG_NONE;
  98
  99   v = ntohl (v);
 100
 101   if (v & GBP_API_ENDPOINT_FLAG_BOUNCE)
 102     f |= GBP_ENDPOINT_FLAG_BOUNCE;
 103   if (v & GBP_API_ENDPOINT_FLAG_REMOTE)
 104     f |= GBP_ENDPOINT_FLAG_REMOTE;
 105   if (v & GBP_API_ENDPOINT_FLAG_LEARNT)
 106     f |= GBP_ENDPOINT_FLAG_LEARNT;
 107   if (v & GBP_API_ENDPOINT_FLAG_EXTERNAL)
 108     f |= GBP_ENDPOINT_FLAG_EXTERNAL;
 109
 110   return (f);
 111 }
 112
 113 static vl_api_gbp_endpoint_flags_t
 114 gbp_endpoint_flags_encode (gbp_endpoint_flags_t f)
 115 {
 116   vl_api_gbp_endpoint_flags_t v = 0;
 117
 118
 119   if (f & GBP_ENDPOINT_FLAG_BOUNCE)
 120     v |= GBP_API_ENDPOINT_FLAG_BOUNCE;
 121   if (f & GBP_ENDPOINT_FLAG_REMOTE)
 122     v |= GBP_API_ENDPOINT_FLAG_REMOTE;
 123   if (f & GBP_ENDPOINT_FLAG_LEARNT)
 124     v |= GBP_API_ENDPOINT_FLAG_LEARNT;
 125   if (f & GBP_ENDPOINT_FLAG_EXTERNAL)
 126     v |= GBP_API_ENDPOINT_FLAG_EXTERNAL;
 127
 128   v = htonl (v);
 129
 130   return (v);
 131 }
 132
 133 static void
 134 vl_api_gbp_endpoint_add_t_handler (vl_api_gbp_endpoint_add_t * mp)
 135 {
 136   vl_api_gbp_endpoint_add_reply_t *rmp;
 137   gbp_endpoint_flags_t gef;
 138   u32 sw_if_index, handle;
 139   ip46_address_t *ips;
 140   mac_address_t mac;
 141   int rv = 0, ii;
 142
 143   VALIDATE_SW_IF_INDEX (&(mp->endpoint));
 144
 145   gef = gbp_endpoint_flags_decode (mp->endpoint.flags), ips = NULL;
 146   sw_if_index = ntohl (mp->endpoint.sw_if_index);
 147
 148   if (mp->endpoint.n_ips)
 149     {
 150       vec_validate (ips, mp->endpoint.n_ips - 1);
 151
 152       vec_foreach_index (ii, ips)
 153       {
 154         ip_address_decode (&mp->endpoint.ips[ii], &ips[ii]);
 155       }
 156     }
 157   mac_address_decode (mp->endpoint.mac, &mac);
 158
 159   if (GBP_ENDPOINT_FLAG_REMOTE & gef)
 160     {
 161       ip46_address_t tun_src, tun_dst;
 162
 163       ip_address_decode (&mp->endpoint.tun.src, &tun_src);
 164       ip_address_decode (&mp->endpoint.tun.dst, &tun_dst);
 165
 166       rv = gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
 167                                          sw_if_index, ips, &mac,
 168                                          INDEX_INVALID, INDEX_INVALID,
 169                                          ntohs (mp->endpoint.sclass),
 170                                          gef, &tun_src, &tun_dst, &handle);
 171     }
 172   else
 173     {
 174       rv = gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
 175                                          sw_if_index, ips, &mac,
 176                                          INDEX_INVALID, INDEX_INVALID,
 177                                          ntohs (mp->endpoint.sclass),
 178                                          gef, NULL, NULL, &handle);
 179     }
 180   vec_free (ips);
 181   BAD_SW_IF_INDEX_LABEL;
 182
 183   /* *INDENT-OFF* */
 184   REPLY_MACRO2 (VL_API_GBP_ENDPOINT_ADD_REPLY + GBP_MSG_BASE,
 185   ({
 186     rmp->handle = htonl (handle);
 187   }));
 188   /* *INDENT-ON* */
 189 }
 190
 191 static void
 192 vl_api_gbp_endpoint_del_t_handler (vl_api_gbp_endpoint_del_t * mp)
 193 {
 194   vl_api_gbp_endpoint_del_reply_t *rmp;
 195   int rv = 0;
 196
 197   gbp_endpoint_unlock (GBP_ENDPOINT_SRC_CP, ntohl (mp->handle));
 198
 199   REPLY_MACRO (VL_API_GBP_ENDPOINT_DEL_REPLY + GBP_MSG_BASE);
 200 }
 201
 202 typedef struct gbp_walk_ctx_t_
 203 {
 204   vl_api_registration_t *reg;
 205   u32 context;
 206 } gbp_walk_ctx_t;
 207
 208 static walk_rc_t
 209 gbp_endpoint_send_details (index_t gei, void *args)
 210 {
 211   vl_api_gbp_endpoint_details_t *mp;
 212   gbp_endpoint_loc_t *gel;
 213   gbp_endpoint_fwd_t *gef;
 214   gbp_endpoint_t *ge;
 215   gbp_walk_ctx_t *ctx;
 216   u8 n_ips, ii;
 217
 218   ctx = args;
 219   ge = gbp_endpoint_get (gei);
 220
 221   n_ips = vec_len (ge->ge_key.gek_ips);
 222   mp = vl_msg_api_alloc (sizeof (*mp) + (sizeof (*mp->endpoint.ips) * n_ips));
 223   if (!mp)
 224     return 1;
 225
 226   clib_memset (mp, 0, sizeof (*mp));
 227   mp->_vl_msg_id = ntohs (VL_API_GBP_ENDPOINT_DETAILS + GBP_MSG_BASE);
 228   mp->context = ctx->context;
 229
 230   gel = &ge->ge_locs[0];
 231   gef = &ge->ge_fwd;
 232
 233   if (gbp_endpoint_is_remote (ge))
 234     {
 235       mp->endpoint.sw_if_index = ntohl (gel->tun.gel_parent_sw_if_index);
 236       ip_address_encode (&gel->tun.gel_src, IP46_TYPE_ANY,
 237                          &mp->endpoint.tun.src);
 238       ip_address_encode (&gel->tun.gel_dst, IP46_TYPE_ANY,
 239                          &mp->endpoint.tun.dst);
 240     }
 241   else
 242     {
 243       mp->endpoint.sw_if_index = ntohl (gef->gef_itf);
 244     }
 245   mp->endpoint.sclass = ntohs (ge->ge_fwd.gef_sclass);
 246   mp->endpoint.n_ips = n_ips;
 247   mp->endpoint.flags = gbp_endpoint_flags_encode (gef->gef_flags);
 248   mp->handle = htonl (gei);
 249   mp->age = vlib_time_now (vlib_get_main ()) - ge->ge_last_time;
 250   mac_address_encode (&ge->ge_key.gek_mac, mp->endpoint.mac);
 251
 252   vec_foreach_index (ii, ge->ge_key.gek_ips)
 253   {
 254     ip_address_encode (&ge->ge_key.gek_ips[ii].fp_addr,
 255                        IP46_TYPE_ANY, &mp->endpoint.ips[ii]);
 256   }
 257
 258   vl_api_send_msg (ctx->reg, (u8 *) mp);
 259
 260   return (WALK_CONTINUE);
 261 }
 262
 263 static void
 264 vl_api_gbp_endpoint_dump_t_handler (vl_api_gbp_endpoint_dump_t * mp)
 265 {
 266   vl_api_registration_t *reg;
 267
 268   reg = vl_api_client_index_to_registration (mp->client_index);
 269   if (!reg)
 270     return;
 271
 272   gbp_walk_ctx_t ctx = {
 273     .reg = reg,
 274     .context = mp->context,
 275   };
 276
 277   gbp_endpoint_walk (gbp_endpoint_send_details, &ctx);
 278 }
 279
 280 static void
 281 gbp_retention_decode (const vl_api_gbp_endpoint_retention_t * in,
 282                       gbp_endpoint_retention_t * out)
 283 {
 284   out->remote_ep_timeout = ntohl (in->remote_ep_timeout);
 285 }
 286
 287 static void
 288   vl_api_gbp_endpoint_group_add_t_handler
 289   (vl_api_gbp_endpoint_group_add_t * mp)
 290 {
 291   vl_api_gbp_endpoint_group_add_reply_t *rmp;
 292   gbp_endpoint_retention_t retention;
 293   int rv = 0;
 294
 295   gbp_retention_decode (&mp->epg.retention, &retention);
 296
 297   rv = gbp_endpoint_group_add_and_lock (ntohl (mp->epg.vnid),
 298                                         ntohs (mp->epg.sclass),
 299                                         ntohl (mp->epg.bd_id),
 300                                         ntohl (mp->epg.rd_id),
 301                                         ntohl (mp->epg.uplink_sw_if_index),
 302                                         &retention);
 303
 304   REPLY_MACRO (VL_API_GBP_ENDPOINT_GROUP_ADD_REPLY + GBP_MSG_BASE);
 305 }
 306
 307 static void
 308   vl_api_gbp_endpoint_group_del_t_handler
 309   (vl_api_gbp_endpoint_group_del_t * mp)
 310 {
 311   vl_api_gbp_endpoint_group_del_reply_t *rmp;
 312   int rv = 0;
 313
 314   rv = gbp_endpoint_group_delete (ntohs (mp->sclass));
 315
 316   REPLY_MACRO (VL_API_GBP_ENDPOINT_GROUP_DEL_REPLY + GBP_MSG_BASE);
 317 }
 318
 319 static gbp_bridge_domain_flags_t
 320 gbp_bridge_domain_flags_from_api (vl_api_gbp_bridge_domain_flags_t a)
 321 {
 322   gbp_bridge_domain_flags_t g;
 323
 324   g = GBP_BD_FLAG_NONE;
 325   a = clib_net_to_host_u32 (a);
 326
 327   if (a & GBP_BD_API_FLAG_DO_NOT_LEARN)
 328     g |= GBP_BD_FLAG_DO_NOT_LEARN;
 329   if (a & GBP_BD_API_FLAG_UU_FWD_DROP)
 330     g |= GBP_BD_FLAG_UU_FWD_DROP;
 331   if (a & GBP_BD_API_FLAG_MCAST_DROP)
 332     g |= GBP_BD_FLAG_MCAST_DROP;
 333   if (a & GBP_BD_API_FLAG_UCAST_ARP)
 334     g |= GBP_BD_FLAG_UCAST_ARP;
 335
 336   return (g);
 337 }
 338
 339 static void
 340 vl_api_gbp_bridge_domain_add_t_handler (vl_api_gbp_bridge_domain_add_t * mp)
 341 {
 342   vl_api_gbp_bridge_domain_add_reply_t *rmp;
 343   int rv = 0;
 344
 345   rv = gbp_bridge_domain_add_and_lock (ntohl (mp->bd.bd_id),
 346                                        ntohl (mp->bd.rd_id),
 347                                        gbp_bridge_domain_flags_from_api
 348                                        (mp->bd.flags),
 349                                        ntohl (mp->bd.bvi_sw_if_index),
 350                                        ntohl (mp->bd.uu_fwd_sw_if_index),
 351                                        ntohl (mp->bd.bm_flood_sw_if_index));
 352
 353   REPLY_MACRO (VL_API_GBP_BRIDGE_DOMAIN_ADD_REPLY + GBP_MSG_BASE);
 354 }
 355
 356 static void
 357 vl_api_gbp_bridge_domain_del_t_handler (vl_api_gbp_bridge_domain_del_t * mp)
 358 {
 359   vl_api_gbp_bridge_domain_del_reply_t *rmp;
 360   int rv = 0;
 361
 362   rv = gbp_bridge_domain_delete (ntohl (mp->bd_id));
 363
 364   REPLY_MACRO (VL_API_GBP_BRIDGE_DOMAIN_DEL_REPLY + GBP_MSG_BASE);
 365 }
 366
 367 static void
 368 vl_api_gbp_route_domain_add_t_handler (vl_api_gbp_route_domain_add_t * mp)
 369 {
 370   vl_api_gbp_route_domain_add_reply_t *rmp;
 371   int rv = 0;
 372
 373   rv = gbp_route_domain_add_and_lock (ntohl (mp->rd.rd_id),
 374                                       ntohs (mp->rd.scope),
 375                                       ntohl (mp->rd.ip4_table_id),
 376                                       ntohl (mp->rd.ip6_table_id),
 377                                       ntohl (mp->rd.ip4_uu_sw_if_index),
 378                                       ntohl (mp->rd.ip6_uu_sw_if_index));
 379
 380   REPLY_MACRO (VL_API_GBP_ROUTE_DOMAIN_ADD_REPLY + GBP_MSG_BASE);
 381 }
 382
 383 static void
 384 vl_api_gbp_route_domain_del_t_handler (vl_api_gbp_route_domain_del_t * mp)
 385 {
 386   vl_api_gbp_route_domain_del_reply_t *rmp;
 387   int rv = 0;
 388
 389   rv = gbp_route_domain_delete (ntohl (mp->rd_id));
 390
 391   REPLY_MACRO (VL_API_GBP_ROUTE_DOMAIN_DEL_REPLY + GBP_MSG_BASE);
 392 }
 393
 394 static int
 395 gub_subnet_type_from_api (vl_api_gbp_subnet_type_t a, gbp_subnet_type_t * t)
 396 {
 397   a = clib_net_to_host_u32 (a);
 398
 399   switch (a)
 400     {
 401     case GBP_API_SUBNET_TRANSPORT:
 402       *t = GBP_SUBNET_TRANSPORT;
 403       return (0);
 404     case GBP_API_SUBNET_L3_OUT:
 405       *t = GBP_SUBNET_L3_OUT;
 406       return (0);
 407     case GBP_API_SUBNET_STITCHED_INTERNAL:
 408       *t = GBP_SUBNET_STITCHED_INTERNAL;
 409       return (0);
 410     case GBP_API_SUBNET_STITCHED_EXTERNAL:
 411       *t = GBP_SUBNET_STITCHED_EXTERNAL;
 412       return (0);
 413     }
 414
 415   return (-1);
 416 }
 417
 418 static void
 419 vl_api_gbp_subnet_add_del_t_handler (vl_api_gbp_subnet_add_del_t * mp)
 420 {
 421   vl_api_gbp_subnet_add_del_reply_t *rmp;
 422   gbp_subnet_type_t type;
 423   fib_prefix_t pfx;
 424   int rv = 0;
 425
 426   ip_prefix_decode (&mp->subnet.prefix, &pfx);
 427
 428   rv = gub_subnet_type_from_api (mp->subnet.type, &type);
 429
 430   if (0 != rv)
 431     goto out;
 432
 433   if (mp->is_add)
 434     rv = gbp_subnet_add (ntohl (mp->subnet.rd_id),
 435                          &pfx, type,
 436                          ntohl (mp->subnet.sw_if_index),
 437                          ntohs (mp->subnet.sclass));
 438   else
 439     rv = gbp_subnet_del (ntohl (mp->subnet.rd_id), &pfx);
 440
 441 out:
 442   REPLY_MACRO (VL_API_GBP_SUBNET_ADD_DEL_REPLY + GBP_MSG_BASE);
 443 }
 444
 445 static vl_api_gbp_subnet_type_t
 446 gub_subnet_type_to_api (gbp_subnet_type_t t)
 447 {
 448   vl_api_gbp_subnet_type_t a = 0;
 449
 450   switch (t)
 451     {
 452     case GBP_SUBNET_TRANSPORT:
 453       a = GBP_API_SUBNET_TRANSPORT;
 454       break;
 455     case GBP_SUBNET_STITCHED_INTERNAL:
 456       a = GBP_API_SUBNET_STITCHED_INTERNAL;
 457       break;
 458     case GBP_SUBNET_STITCHED_EXTERNAL:
 459       a = GBP_API_SUBNET_STITCHED_EXTERNAL;
 460       break;
 461     case GBP_SUBNET_L3_OUT:
 462       a = GBP_API_SUBNET_L3_OUT;
 463       break;
 464     }
 465
 466   a = clib_host_to_net_u32 (a);
 467
 468   return (a);
 469 }
 470
 471 static walk_rc_t
 472 gbp_subnet_send_details (u32 rd_id,
 473                          const fib_prefix_t * pfx,
 474                          gbp_subnet_type_t type,
 475                          u32 sw_if_index, sclass_t sclass, void *args)
 476 {
 477   vl_api_gbp_subnet_details_t *mp;
 478   gbp_walk_ctx_t *ctx;
 479
 480   ctx = args;
 481   mp = vl_msg_api_alloc (sizeof (*mp));
 482   if (!mp)
 483     return 1;
 484
 485   clib_memset (mp, 0, sizeof (*mp));
 486   mp->_vl_msg_id = ntohs (VL_API_GBP_SUBNET_DETAILS + GBP_MSG_BASE);
 487   mp->context = ctx->context;
 488
 489   mp->subnet.type = gub_subnet_type_to_api (type);
 490   mp->subnet.sw_if_index = ntohl (sw_if_index);
 491   mp->subnet.sclass = ntohs (sclass);
 492   mp->subnet.rd_id = ntohl (rd_id);
 493   ip_prefix_encode (pfx, &mp->subnet.prefix);
 494
 495   vl_api_send_msg (ctx->reg, (u8 *) mp);
 496
 497   return (WALK_CONTINUE);
 498 }
 499
 500 static void
 501 vl_api_gbp_subnet_dump_t_handler (vl_api_gbp_subnet_dump_t * mp)
 502 {
 503   vl_api_registration_t *reg;
 504
 505   reg = vl_api_client_index_to_registration (mp->client_index);
 506   if (!reg)
 507     return;
 508
 509   gbp_walk_ctx_t ctx = {
 510     .reg = reg,
 511     .context = mp->context,
 512   };
 513
 514   gbp_subnet_walk (gbp_subnet_send_details, &ctx);
 515 }
 516
 517 static int
 518 gbp_endpoint_group_send_details (gbp_endpoint_group_t * gg, void *args)
 519 {
 520   vl_api_gbp_endpoint_group_details_t *mp;
 521   gbp_walk_ctx_t *ctx;
 522
 523   ctx = args;
 524   mp = vl_msg_api_alloc (sizeof (*mp));
 525   if (!mp)
 526     return 1;
 527
 528   clib_memset (mp, 0, sizeof (*mp));
 529   mp->_vl_msg_id = ntohs (VL_API_GBP_ENDPOINT_GROUP_DETAILS + GBP_MSG_BASE);
 530   mp->context = ctx->context;
 531
 532   mp->epg.uplink_sw_if_index = ntohl (gg->gg_uplink_sw_if_index);
 533   mp->epg.vnid = ntohl (gg->gg_vnid);
 534   mp->epg.sclass = ntohs (gg->gg_sclass);
 535   mp->epg.bd_id = ntohl (gbp_endpoint_group_get_bd_id (gg));
 536   mp->epg.rd_id = ntohl (gbp_route_domain_get_rd_id (gg->gg_rd));
 537
 538   vl_api_send_msg (ctx->reg, (u8 *) mp);
 539
 540   return (1);
 541 }
 542
 543 static void
 544 vl_api_gbp_endpoint_group_dump_t_handler (vl_api_gbp_endpoint_group_dump_t *
 545                                           mp)
 546 {
 547   vl_api_registration_t *reg;
 548
 549   reg = vl_api_client_index_to_registration (mp->client_index);
 550   if (!reg)
 551     return;
 552
 553   gbp_walk_ctx_t ctx = {
 554     .reg = reg,
 555     .context = mp->context,
 556   };
 557
 558   gbp_endpoint_group_walk (gbp_endpoint_group_send_details, &ctx);
 559 }
 560
 561 static int
 562 gbp_bridge_domain_send_details (gbp_bridge_domain_t * gb, void *args)
 563 {
 564   vl_api_gbp_bridge_domain_details_t *mp;
 565   gbp_route_domain_t *gr;
 566   gbp_walk_ctx_t *ctx;
 567
 568   ctx = args;
 569   mp = vl_msg_api_alloc (sizeof (*mp));
 570   if (!mp)
 571     return 1;
 572
 573   memset (mp, 0, sizeof (*mp));
 574   mp->_vl_msg_id = ntohs (VL_API_GBP_BRIDGE_DOMAIN_DETAILS + GBP_MSG_BASE);
 575   mp->context = ctx->context;
 576
 577   gr = gbp_route_domain_get (gb->gb_rdi);
 578
 579   mp->bd.bd_id = ntohl (gb->gb_bd_id);
 580   mp->bd.rd_id = ntohl (gr->grd_id);
 581   mp->bd.bvi_sw_if_index = ntohl (gb->gb_bvi_sw_if_index);
 582   mp->bd.uu_fwd_sw_if_index = ntohl (gb->gb_uu_fwd_sw_if_index);
 583   mp->bd.bm_flood_sw_if_index = ntohl (gb->gb_bm_flood_sw_if_index);
 584
 585   vl_api_send_msg (ctx->reg, (u8 *) mp);
 586
 587   return (1);
 588 }
 589
 590 static void
 591 vl_api_gbp_bridge_domain_dump_t_handler (vl_api_gbp_bridge_domain_dump_t * mp)
 592 {
 593   vl_api_registration_t *reg;
 594
 595   reg = vl_api_client_index_to_registration (mp->client_index);
 596   if (!reg)
 597     return;
 598
 599   gbp_walk_ctx_t ctx = {
 600     .reg = reg,
 601     .context = mp->context,
 602   };
 603
 604   gbp_bridge_domain_walk (gbp_bridge_domain_send_details, &ctx);
 605 }
 606
 607 static int
 608 gbp_route_domain_send_details (gbp_route_domain_t * grd, void *args)
 609 {
 610   vl_api_gbp_route_domain_details_t *mp;
 611   gbp_walk_ctx_t *ctx;
 612
 613   ctx = args;
 614   mp = vl_msg_api_alloc (sizeof (*mp));
 615   if (!mp)
 616     return 1;
 617
 618   memset (mp, 0, sizeof (*mp));
 619   mp->_vl_msg_id = ntohs (VL_API_GBP_ROUTE_DOMAIN_DETAILS + GBP_MSG_BASE);
 620   mp->context = ctx->context;
 621
 622   mp->rd.rd_id = ntohl (grd->grd_id);
 623   mp->rd.ip4_uu_sw_if_index =
 624     ntohl (grd->grd_uu_sw_if_index[FIB_PROTOCOL_IP4]);
 625   mp->rd.ip6_uu_sw_if_index =
 626     ntohl (grd->grd_uu_sw_if_index[FIB_PROTOCOL_IP6]);
 627
 628   vl_api_send_msg (ctx->reg, (u8 *) mp);
 629
 630   return (1);
 631 }
 632
 633 static void
 634 vl_api_gbp_route_domain_dump_t_handler (vl_api_gbp_route_domain_dump_t * mp)
 635 {
 636   vl_api_registration_t *reg;
 637
 638   reg = vl_api_client_index_to_registration (mp->client_index);
 639   if (!reg)
 640     return;
 641
 642   gbp_walk_ctx_t ctx = {
 643     .reg = reg,
 644     .context = mp->context,
 645   };
 646
 647   gbp_route_domain_walk (gbp_route_domain_send_details, &ctx);
 648 }
 649
 650 static void
 651 vl_api_gbp_recirc_add_del_t_handler (vl_api_gbp_recirc_add_del_t * mp)
 652 {
 653   vl_api_gbp_recirc_add_del_reply_t *rmp;
 654   u32 sw_if_index;
 655   int rv = 0;
 656
 657   sw_if_index = ntohl (mp->recirc.sw_if_index);
 658   if (!vnet_sw_if_index_is_api_valid (sw_if_index))
 659     goto bad_sw_if_index;
 660
 661   if (mp->is_add)
 662     rv = gbp_recirc_add (sw_if_index,
 663                          ntohs (mp->recirc.sclass), mp->recirc.is_ext);
 664   else
 665     rv = gbp_recirc_delete (sw_if_index);
 666
 667   BAD_SW_IF_INDEX_LABEL;
 668
 669   REPLY_MACRO (VL_API_GBP_RECIRC_ADD_DEL_REPLY + GBP_MSG_BASE);
 670 }
 671
 672 static walk_rc_t
 673 gbp_recirc_send_details (gbp_recirc_t * gr, void *args)
 674 {
 675   vl_api_gbp_recirc_details_t *mp;
 676   gbp_walk_ctx_t *ctx;
 677
 678   ctx = args;
 679   mp = vl_msg_api_alloc (sizeof (*mp));
 680   if (!mp)
 681     return (WALK_STOP);
 682
 683   clib_memset (mp, 0, sizeof (*mp));
 684   mp->_vl_msg_id = ntohs (VL_API_GBP_RECIRC_DETAILS + GBP_MSG_BASE);
 685   mp->context = ctx->context;
 686
 687   mp->recirc.sclass = ntohs (gr->gr_sclass);
 688   mp->recirc.sw_if_index = ntohl (gr->gr_sw_if_index);
 689   mp->recirc.is_ext = gr->gr_is_ext;
 690
 691   vl_api_send_msg (ctx->reg, (u8 *) mp);
 692
 693   return (WALK_CONTINUE);
 694 }
 695
 696 static void
 697 vl_api_gbp_recirc_dump_t_handler (vl_api_gbp_recirc_dump_t * mp)
 698 {
 699   vl_api_registration_t *reg;
 700
 701   reg = vl_api_client_index_to_registration (mp->client_index);
 702   if (!reg)
 703     return;
 704
 705   gbp_walk_ctx_t ctx = {
 706     .reg = reg,
 707     .context = mp->context,
 708   };
 709
 710   gbp_recirc_walk (gbp_recirc_send_details, &ctx);
 711 }
 712
 713 static void
 714 vl_api_gbp_ext_itf_add_del_t_handler (vl_api_gbp_ext_itf_add_del_t * mp)
 715 {
 716   vl_api_gbp_ext_itf_add_del_reply_t *rmp;
 717   u32 sw_if_index = ~0;
 718   vl_api_gbp_ext_itf_t *ext_itf;
 719   int rv = 0;
 720
 721   ext_itf = &mp->ext_itf;
 722   if (ext_itf)
 723     sw_if_index = ntohl (ext_itf->sw_if_index);
 724
 725   if (!vnet_sw_if_index_is_api_valid (sw_if_index))
 726     goto bad_sw_if_index;
 727
 728   if (mp->is_add)
 729     rv = gbp_ext_itf_add (sw_if_index,
 730                           ntohl (ext_itf->bd_id), ntohl (ext_itf->rd_id));
 731   else
 732     rv = gbp_ext_itf_delete (sw_if_index);
 733
 734   BAD_SW_IF_INDEX_LABEL;
 735
 736   REPLY_MACRO (VL_API_GBP_EXT_ITF_ADD_DEL_REPLY + GBP_MSG_BASE);
 737 }
 738
 739 static walk_rc_t
 740 gbp_ext_itf_send_details (gbp_ext_itf_t * gx, void *args)
 741 {
 742   vl_api_gbp_ext_itf_details_t *mp;
 743   gbp_walk_ctx_t *ctx;
 744
 745   ctx = args;
 746   mp = vl_msg_api_alloc (sizeof (*mp));
 747   if (!mp)
 748     return (WALK_STOP);
 749
 750   clib_memset (mp, 0, sizeof (*mp));
 751   mp->_vl_msg_id = ntohs (VL_API_GBP_EXT_ITF_DETAILS + GBP_MSG_BASE);
 752   mp->context = ctx->context;
 753
 754   mp->ext_itf.bd_id = ntohl (gbp_bridge_domain_get_bd_id (gx->gx_bd));
 755   mp->ext_itf.rd_id = ntohl (gbp_route_domain_get_rd_id (gx->gx_rd));
 756   mp->ext_itf.sw_if_index = ntohl (gx->gx_itf);
 757
 758   vl_api_send_msg (ctx->reg, (u8 *) mp);
 759
 760   return (WALK_CONTINUE);
 761 }
 762
 763 static void
 764 vl_api_gbp_ext_itf_dump_t_handler (vl_api_gbp_ext_itf_dump_t * mp)
 765 {
 766   vl_api_registration_t *reg;
 767
 768   reg = vl_api_client_index_to_registration (mp->client_index);
 769   if (!reg)
 770     return;
 771
 772   gbp_walk_ctx_t ctx = {
 773     .reg = reg,
 774     .context = mp->context,
 775   };
 776
 777   gbp_ext_itf_walk (gbp_ext_itf_send_details, &ctx);
 778 }
 779
 780 static int
 781 gbp_contract_rule_action_deocde (vl_api_gbp_rule_action_t in,
 782                                  gbp_rule_action_t * out)
 783 {
 784   in = clib_net_to_host_u32 (in);
 785
 786   switch (in)
 787     {
 788     case GBP_API_RULE_PERMIT:
 789       *out = GBP_RULE_PERMIT;
 790       return (0);
 791     case GBP_API_RULE_DENY:
 792       *out = GBP_RULE_DENY;
 793       return (0);
 794     case GBP_API_RULE_REDIRECT:
 795       *out = GBP_RULE_REDIRECT;
 796       return (0);
 797     }
 798
 799   return (-1);
 800 }
 801
 802 static int
 803 gbp_hash_mode_decode (vl_api_gbp_hash_mode_t in, gbp_hash_mode_t * out)
 804 {
 805   in = clib_net_to_host_u32 (in);
 806
 807   switch (in)
 808     {
 809     case GBP_API_HASH_MODE_SRC_IP:
 810       *out = GBP_HASH_MODE_SRC_IP;
 811       return (0);
 812     case GBP_API_HASH_MODE_DST_IP:
 813       *out = GBP_HASH_MODE_DST_IP;
 814       return (0);
 815     case GBP_API_HASH_MODE_SYMMETRIC:
 816       *out = GBP_HASH_MODE_SYMMETRIC;
 817       return (0);
 818     }
 819
 820   return (-2);
 821 }
 822
 823 static int
 824 gbp_next_hop_decode (const vl_api_gbp_next_hop_t * in, index_t * gnhi)
 825 {
 826   ip46_address_t ip;
 827   mac_address_t mac;
 828   index_t grd, gbd;
 829
 830   gbd = gbp_bridge_domain_find_and_lock (ntohl (in->bd_id));
 831
 832   if (INDEX_INVALID == gbd)
 833     return (VNET_API_ERROR_BD_NOT_MODIFIABLE);
 834
 835   grd = gbp_route_domain_find_and_lock (ntohl (in->rd_id));
 836
 837   if (INDEX_INVALID == grd)
 838     return (VNET_API_ERROR_NO_SUCH_FIB);
 839
 840   ip_address_decode (&in->ip, &ip);
 841   mac_address_decode (in->mac, &mac);
 842
 843   *gnhi = gbp_next_hop_alloc (&ip, grd, &mac, gbd);
 844
 845   return (0);
 846 }
 847
 848 static int
 849 gbp_next_hop_set_decode (const vl_api_gbp_next_hop_set_t * in,
 850                          gbp_hash_mode_t * hash_mode, index_t ** out)
 851 {
 852
 853   index_t *gnhis = NULL;
 854   int rv;
 855   u8 ii;
 856
 857   rv = gbp_hash_mode_decode (in->hash_mode, hash_mode);
 858
 859   if (0 != rv)
 860     return rv;
 861
 862   vec_validate (gnhis, in->n_nhs - 1);
 863
 864   for (ii = 0; ii < in->n_nhs; ii++)
 865     {
 866       rv = gbp_next_hop_decode (&in->nhs[ii], &gnhis[ii]);
 867
 868       if (0 != rv)
 869         {
 870           vec_free (gnhis);
 871           break;
 872         }
 873     }
 874
 875   *out = gnhis;
 876   return (rv);
 877 }
 878
 879 static int
 880 gbp_contract_rule_decode (const vl_api_gbp_rule_t * in, index_t * gui)
 881 {
 882   gbp_hash_mode_t hash_mode;
 883   gbp_rule_action_t action;
 884   index_t *nhs = NULL;
 885   int rv;
 886
 887   rv = gbp_contract_rule_action_deocde (in->action, &action);
 888
 889   if (0 != rv)
 890     return rv;
 891
 892   if (GBP_RULE_REDIRECT == action)
 893     {
 894       rv = gbp_next_hop_set_decode (&in->nh_set, &hash_mode, &nhs);
 895
 896       if (0 != rv)
 897         return (rv);
 898     }
 899   else
 900     {
 901       hash_mode = GBP_HASH_MODE_SRC_IP;
 902     }
 903
 904   *gui = gbp_rule_alloc (action, hash_mode, nhs);
 905
 906   return (rv);
 907 }
 908
 909 static int
 910 gbp_contract_rules_decode (u8 n_rules,
 911                            const vl_api_gbp_rule_t * rules, index_t ** out)
 912 {
 913   index_t *guis = NULL;
 914   int rv;
 915   u8 ii;
 916
 917   if (0 == n_rules)
 918     {
 919       *out = NULL;
 920       return (0);
 921     }
 922
 923   vec_validate (guis, n_rules - 1);
 924
 925   for (ii = 0; ii < n_rules; ii++)
 926     {
 927       rv = gbp_contract_rule_decode (&rules[ii], &guis[ii]);
 928
 929       if (0 != rv)
 930         {
 931           vec_free (guis);
 932           return (rv);
 933         }
 934     }
 935
 936   *out = guis;
 937   return (rv);
 938 }
 939
 940 static void
 941 vl_api_gbp_contract_add_del_t_handler (vl_api_gbp_contract_add_del_t * mp)
 942 {
 943   vl_api_gbp_contract_add_del_reply_t *rmp;
 944   u16 *allowed_ethertypes;
 945   u32 stats_index = ~0;
 946   index_t *rules;
 947   int ii, rv = 0;
 948   u8 n_et;
 949
 950   if (mp->is_add)
 951     {
 952       rv = gbp_contract_rules_decode (mp->contract.n_rules,
 953                                       mp->contract.rules, &rules);
 954       if (0 != rv)
 955         goto out;
 956
 957       allowed_ethertypes = NULL;
 958
 959       /*
 960        * allowed ether types
 961        */
 962       n_et = mp->contract.n_ether_types;
 963       vec_validate (allowed_ethertypes, n_et - 1);
 964
 965       for (ii = 0; ii < n_et; ii++)
 966         {
 967           /* leave the ether types in network order */
 968           allowed_ethertypes[ii] = mp->contract.allowed_ethertypes[ii];
 969         }
 970
 971       rv = gbp_contract_update (ntohs (mp->contract.scope),
 972                                 ntohs (mp->contract.sclass),
 973                                 ntohs (mp->contract.dclass),
 974                                 ntohl (mp->contract.acl_index),
 975                                 rules, allowed_ethertypes, &stats_index);
 976     }
 977   else
 978     rv = gbp_contract_delete (ntohs (mp->contract.scope),
 979                               ntohs (mp->contract.sclass),
 980                               ntohs (mp->contract.dclass));
 981
 982 out:
 983   /* *INDENT-OFF* */
 984   REPLY_MACRO2 (VL_API_GBP_CONTRACT_ADD_DEL_REPLY + GBP_MSG_BASE,
 985   ({
 986     rmp->stats_index = htonl (stats_index);
 987   }));
 988   /* *INDENT-ON* */
 989 }
 990
 991 static int
 992 gbp_contract_send_details (gbp_contract_t * gbpc, void *args)
 993 {
 994   vl_api_gbp_contract_details_t *mp;
 995   gbp_walk_ctx_t *ctx;
 996
 997   ctx = args;
 998   mp = vl_msg_api_alloc (sizeof (*mp));
 999   if (!mp)
1000     return 1;
1001
1002   clib_memset (mp, 0, sizeof (*mp));
1003   mp->_vl_msg_id = ntohs (VL_API_GBP_CONTRACT_DETAILS + GBP_MSG_BASE);
1004   mp->context = ctx->context;
1005
1006   mp->contract.sclass = ntohs (gbpc->gc_key.gck_src);
1007   mp->contract.dclass = ntohs (gbpc->gc_key.gck_dst);
1008   mp->contract.acl_index = ntohl (gbpc->gc_acl_index);
1009   mp->contract.scope = ntohs (gbpc->gc_key.gck_scope);
1010
1011   vl_api_send_msg (ctx->reg, (u8 *) mp);
1012
1013   return (1);
1014 }
1015
1016 static void
1017 vl_api_gbp_contract_dump_t_handler (vl_api_gbp_contract_dump_t * mp)
1018 {
1019   vl_api_registration_t *reg;
1020
1021   reg = vl_api_client_index_to_registration (mp->client_index);
1022   if (!reg)
1023     return;
1024
1025   gbp_walk_ctx_t ctx = {
1026     .reg = reg,
1027     .context = mp->context,
1028   };
1029
1030   gbp_contract_walk (gbp_contract_send_details, &ctx);
1031 }
1032
1033 static int
1034 gbp_vxlan_tunnel_mode_2_layer (vl_api_gbp_vxlan_tunnel_mode_t mode,
1035                                gbp_vxlan_tunnel_layer_t * l)
1036 {
1037   mode = clib_net_to_host_u32 (mode);
1038
1039   switch (mode)
1040     {
1041     case GBP_VXLAN_TUNNEL_MODE_L2:
1042       *l = GBP_VXLAN_TUN_L2;
1043       return (0);
1044     case GBP_VXLAN_TUNNEL_MODE_L3:
1045       *l = GBP_VXLAN_TUN_L3;
1046       return (0);
1047     }
1048   return (-1);
1049 }
1050
1051 static void
1052 vl_api_gbp_vxlan_tunnel_add_t_handler (vl_api_gbp_vxlan_tunnel_add_t * mp)
1053 {
1054   vl_api_gbp_vxlan_tunnel_add_reply_t *rmp;
1055   gbp_vxlan_tunnel_layer_t layer;
1056   ip4_address_t src;
1057   u32 sw_if_index;
1058   int rv = 0;
1059
1060   ip4_address_decode (mp->tunnel.src, &src);
1061   rv = gbp_vxlan_tunnel_mode_2_layer (mp->tunnel.mode, &layer);
1062
1063   if (0 != rv)
1064     goto out;
1065
1066   rv = gbp_vxlan_tunnel_add (ntohl (mp->tunnel.vni),
1067                              layer,
1068                              ntohl (mp->tunnel.bd_rd_id), &src, &sw_if_index);
1069
1070 out:
1071   /* *INDENT-OFF* */
1072   REPLY_MACRO2 (VL_API_GBP_VXLAN_TUNNEL_ADD_REPLY + GBP_MSG_BASE,
1073   ({
1074     rmp->sw_if_index = htonl (sw_if_index);
1075   }));
1076   /* *INDENT-ON* */
1077 }
1078
1079 static void
1080 vl_api_gbp_vxlan_tunnel_del_t_handler (vl_api_gbp_vxlan_tunnel_add_t * mp)
1081 {
1082   vl_api_gbp_vxlan_tunnel_del_reply_t *rmp;
1083   int rv = 0;
1084
1085   rv = gbp_vxlan_tunnel_del (ntohl (mp->tunnel.vni));
1086
1087   REPLY_MACRO (VL_API_GBP_VXLAN_TUNNEL_DEL_REPLY + GBP_MSG_BASE);
1088 }
1089
1090 static vl_api_gbp_vxlan_tunnel_mode_t
1091 gbp_vxlan_tunnel_layer_2_mode (gbp_vxlan_tunnel_layer_t layer)
1092 {
1093   vl_api_gbp_vxlan_tunnel_mode_t mode = GBP_VXLAN_TUNNEL_MODE_L2;
1094
1095   switch (layer)
1096     {
1097     case GBP_VXLAN_TUN_L2:
1098       mode = GBP_VXLAN_TUNNEL_MODE_L2;
1099       break;
1100     case GBP_VXLAN_TUN_L3:
1101       mode = GBP_VXLAN_TUNNEL_MODE_L3;
1102       break;
1103     }
1104   mode = clib_host_to_net_u32 (mode);
1105
1106   return (mode);
1107 }
1108
1109 static walk_rc_t
1110 gbp_vxlan_tunnel_send_details (gbp_vxlan_tunnel_t * gt, void *args)
1111 {
1112   vl_api_gbp_vxlan_tunnel_details_t *mp;
1113   gbp_walk_ctx_t *ctx;
1114
1115   ctx = args;
1116   mp = vl_msg_api_alloc (sizeof (*mp));
1117   if (!mp)
1118     return 1;
1119
1120   memset (mp, 0, sizeof (*mp));
1121   mp->_vl_msg_id = htons (VL_API_GBP_VXLAN_TUNNEL_DETAILS + GBP_MSG_BASE);
1122   mp->context = ctx->context;
1123
1124   mp->tunnel.vni = htonl (gt->gt_vni);
1125   mp->tunnel.mode = gbp_vxlan_tunnel_layer_2_mode (gt->gt_layer);
1126   mp->tunnel.bd_rd_id = htonl (gt->gt_bd_rd_id);
1127
1128   vl_api_send_msg (ctx->reg, (u8 *) mp);
1129
1130   return (1);
1131 }
1132
1133 static void
1134 vl_api_gbp_vxlan_tunnel_dump_t_handler (vl_api_gbp_vxlan_tunnel_dump_t * mp)
1135 {
1136   vl_api_registration_t *reg;
1137
1138   reg = vl_api_client_index_to_registration (mp->client_index);
1139   if (!reg)
1140     return;
1141
1142   gbp_walk_ctx_t ctx = {
1143     .reg = reg,
1144     .context = mp->context,
1145   };
1146
1147   gbp_vxlan_walk (gbp_vxlan_tunnel_send_details, &ctx);
1148 }
1149
1150 static void
1151 vl_api_gbp_ext_itf_anon_add_del_t_handler (vl_api_gbp_ext_itf_anon_add_del_t *
1152                                            mp)
1153 {
1154   vl_api_gbp_ext_itf_anon_add_del_reply_t *rmp;
1155   u32 sw_if_index = ~0;
1156   vl_api_gbp_ext_itf_t *ext_itf;
1157   int rv = 0;
1158
1159   ext_itf = &mp->ext_itf;
1160   if (ext_itf)
1161     sw_if_index = ntohl (ext_itf->sw_if_index);
1162
1163   if (!vnet_sw_if_index_is_api_valid (sw_if_index))
1164     goto bad_sw_if_index;
1165
1166   if (mp->is_add)
1167     rv = gbp_ext_itf_anon_add (sw_if_index,
1168                                ntohl (ext_itf->bd_id),
1169                                ntohl (ext_itf->rd_id));
1170   else
1171     rv = gbp_ext_itf_anon_delete (sw_if_index);
1172
1173   BAD_SW_IF_INDEX_LABEL;
1174
1175   REPLY_MACRO (VL_API_GBP_EXT_ITF_ANON_ADD_DEL_REPLY + GBP_MSG_BASE);
1176 }
1177
1178 /*
1179  * gbp_api_hookup
1180  * Add vpe's API message handlers to the table.
1181  * vlib has already mapped shared memory and
1182  * added the client registration handlers.
1183  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1184  */
1185 #define vl_msg_name_crc_list
1186 #include <gbp/gbp_all_api_h.h>
1187 #undef vl_msg_name_crc_list
1188
1189 static void
1190 setup_message_id_table (api_main_t * am)
1191 {
1192 #define _(id,n,crc)                                     \
1193   vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + GBP_MSG_BASE);
1194   foreach_vl_msg_name_crc_gbp;
1195 #undef _
1196 }
1197
1198 static void
1199 gbp_api_hookup (vlib_main_t * vm)
1200 {
1201 #define _(N,n)                                                  \
1202     vl_msg_api_set_handlers(VL_API_##N + GBP_MSG_BASE,          \
1203                             #n,                                 \
1204                             vl_api_##n##_t_handler,             \
1205                             vl_noop_handler,                    \
1206                             vl_api_##n##_t_endian,              \
1207                             vl_api_##n##_t_print,               \
1208                             sizeof(vl_api_##n##_t), 1);
1209   foreach_gbp_api_msg;
1210 #undef _
1211 }
1212
1213 static clib_error_t *
1214 gbp_init (vlib_main_t * vm)
1215 {
1216   api_main_t *am = &api_main;
1217   gbp_main_t *gbpm = &gbp_main;
1218   u8 *name = format (0, "gbp_%08x%c", api_version, 0);
1219
1220   gbpm->gbp_acl_user_id = ~0;
1221
1222   /* Ask for a correctly-sized block of API message decode slots */
1223   msg_id_base = vl_msg_api_get_msg_ids ((char *) name,
1224                                         VL_MSG_FIRST_AVAILABLE);
1225   gbp_api_hookup (vm);
1226
1227   /* Add our API messages to the global name_crc hash table */
1228   setup_message_id_table (am);
1229
1230   vec_free (name);
1231   return (NULL);
1232 }
1233
1234 VLIB_API_INIT_FUNCTION (gbp_init);
1235
1236 /* *INDENT-OFF* */
1237 VLIB_PLUGIN_REGISTER () = {
1238     .version = VPP_BUILD_VER,
1239     .description = "Group Based Policy (GBP)",
1240 };
1241 /* *INDENT-ON* */
1242
1243
1244 /*
1245  * fd.io coding-style-patch-verification: ON
1246  *
1247  * Local Variables:
1248  * eval: (c-set-style "gnu")
1249  * End:
1250  */