src/plugins/nat/nat_api.c

   1 /*
   2  * Copyright (c) 2017 Cisco and/or its affiliates.
   3  *
   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  * @file
  18  * @brief NAT plugin API implementation
  19  */
  20
  21 #include <nat/nat.h>
  22 #include <nat/nat_det.h>
  23 #include <nat/nat64.h>
  24 #include <nat/dslite.h>
  25 #include <nat/nat_reass.h>
  26 #include <vlibapi/api.h>
  27 #include <vlibmemory/api.h>
  28
  29 #include <nat/nat_msg_enum.h>
  30 #include <vnet/fib/fib_table.h>
  31
  32 #define vl_api_nat44_lb_addr_port_t_endian vl_noop_handler
  33 #define vl_api_nat44_add_del_lb_static_mapping_t_endian vl_noop_handler
  34 #define vl_api_nat44_nat44_lb_static_mapping_details_t_endian vl_noop_handler
  35
  36 /* define message structures */
  37 #define vl_typedefs
  38 #include <nat/nat_all_api_h.h>
  39 #undef vl_typedefs
  40
  41 /* define generated endian-swappers */
  42 #define vl_endianfun
  43 #include <nat/nat_all_api_h.h>
  44 #undef vl_endianfun
  45
  46 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  47
  48 #define REPLY_MSG_ID_BASE sm->msg_id_base
  49 #include <vlibapi/api_helper_macros.h>
  50
  51 /* Get the API version number */
  52 #define vl_api_version(n,v) static u32 api_version=(v);
  53 #include <nat/nat_all_api_h.h>
  54 #undef vl_api_version
  55
  56 /* Macro to finish up custom dump fns */
  57 #define FINISH                                  \
  58     vec_add1 (s, 0);                            \
  59     vl_print (handle, (char *)s);               \
  60     vec_free (s);                               \
  61     return handle;
  62
  63
  64 /******************************/
  65 /*** Common NAT plugin APIs ***/
  66 /******************************/
  67
  68 static void
  69 vl_api_nat_control_ping_t_handler (vl_api_nat_control_ping_t * mp)
  70 {
  71   vl_api_nat_control_ping_reply_t *rmp;
  72   snat_main_t *sm = &snat_main;
  73   int rv = 0;
  74
  75   /* *INDENT-OFF* */
  76   REPLY_MACRO2 (VL_API_NAT_CONTROL_PING_REPLY,
  77   ({
  78     rmp->vpe_pid = ntohl (getpid ());
  79   }));
  80   /* *INDENT-ON* */
  81 }
  82
  83 static void *
  84 vl_api_nat_control_ping_t_print (vl_api_nat_control_ping_t * mp, void *handle)
  85 {
  86   u8 *s;
  87
  88   s = format (0, "SCRIPT: nat_control_ping ");
  89
  90   FINISH;
  91 }
  92
  93 static void
  94 vl_api_nat_show_config_t_handler (vl_api_nat_show_config_t * mp)
  95 {
  96   vl_api_nat_show_config_reply_t *rmp;
  97   snat_main_t *sm = &snat_main;
  98   int rv = 0;
  99
 100   /* *INDENT-OFF* */
 101   REPLY_MACRO2 (VL_API_NAT_SHOW_CONFIG_REPLY,
 102   ({
 103     rmp->translation_buckets = htonl (sm->translation_buckets);
 104     rmp->translation_memory_size = htonl (sm->translation_memory_size);
 105     rmp->user_buckets = htonl (sm->user_buckets);
 106     rmp->user_memory_size = htonl (sm->user_memory_size);
 107     rmp->max_translations_per_user = htonl (sm->max_translations_per_user);
 108     rmp->outside_vrf_id = htonl (sm->outside_vrf_id);
 109     rmp->inside_vrf_id = htonl (sm->inside_vrf_id);
 110     rmp->static_mapping_only = sm->static_mapping_only;
 111     rmp->static_mapping_connection_tracking =
 112       sm->static_mapping_connection_tracking;
 113     rmp->deterministic = sm->deterministic;
 114   }));
 115   /* *INDENT-ON* */
 116 }
 117
 118 static void *
 119 vl_api_nat_show_config_t_print (vl_api_nat_show_config_t * mp, void *handle)
 120 {
 121   u8 *s;
 122
 123   s = format (0, "SCRIPT: nat_show_config ");
 124
 125   FINISH;
 126 }
 127
 128 static void
 129 vl_api_nat_set_workers_t_handler (vl_api_nat_set_workers_t * mp)
 130 {
 131   snat_main_t *sm = &snat_main;
 132   vl_api_nat_set_workers_reply_t *rmp;
 133   int rv = 0;
 134   uword *bitmap = 0;
 135   u64 mask = clib_net_to_host_u64 (mp->worker_mask);
 136
 137   if (sm->num_workers < 2)
 138     {
 139       rv = VNET_API_ERROR_FEATURE_DISABLED;
 140       goto send_reply;
 141     }
 142
 143   bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
 144   rv = snat_set_workers (bitmap);
 145   clib_bitmap_free (bitmap);
 146
 147 send_reply:
 148   REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
 149 }
 150
 151 static void *
 152 vl_api_nat_set_workers_t_print (vl_api_nat_set_workers_t * mp, void *handle)
 153 {
 154   u8 *s;
 155   uword *bitmap = 0;
 156   u8 first = 1;
 157   int i;
 158   u64 mask = clib_net_to_host_u64 (mp->worker_mask);
 159
 160   s = format (0, "SCRIPT: nat_set_workers ");
 161   bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
 162   /* *INDENT-OFF* */
 163   clib_bitmap_foreach (i, bitmap,
 164     ({
 165       if (first)
 166         s = format (s, "%d", i);
 167       else
 168         s = format (s, ",%d", i);
 169       first = 0;
 170     }));
 171   /* *INDENT-ON* */
 172   clib_bitmap_free (bitmap);
 173   FINISH;
 174 }
 175
 176 static void
 177 send_nat_worker_details (u32 worker_index, vl_api_registration_t * reg,
 178                          u32 context)
 179 {
 180   vl_api_nat_worker_details_t *rmp;
 181   snat_main_t *sm = &snat_main;
 182   vlib_worker_thread_t *w =
 183     vlib_worker_threads + worker_index + sm->first_worker_index;
 184
 185   rmp = vl_msg_api_alloc (sizeof (*rmp));
 186   memset (rmp, 0, sizeof (*rmp));
 187   rmp->_vl_msg_id = ntohs (VL_API_NAT_WORKER_DETAILS + sm->msg_id_base);
 188   rmp->context = context;
 189   rmp->worker_index = htonl (worker_index);
 190   rmp->lcore_id = htonl (w->lcore_id);
 191   strncpy ((char *) rmp->name, (char *) w->name, ARRAY_LEN (rmp->name) - 1);
 192
 193   vl_api_send_msg (reg, (u8 *) rmp);
 194 }
 195
 196 static void
 197 vl_api_nat_worker_dump_t_handler (vl_api_nat_worker_dump_t * mp)
 198 {
 199   vl_api_registration_t *reg;
 200   snat_main_t *sm = &snat_main;
 201   u32 *worker_index;
 202
 203   reg = vl_api_client_index_to_registration (mp->client_index);
 204   if (!reg)
 205     return;
 206
 207   /* *INDENT-OFF* */
 208   vec_foreach (worker_index, sm->workers)
 209     send_nat_worker_details(*worker_index, reg, mp->context);
 210   /* *INDENT-ON* */
 211 }
 212
 213 static void *
 214 vl_api_nat_worker_dump_t_print (vl_api_nat_worker_dump_t * mp, void *handle)
 215 {
 216   u8 *s;
 217
 218   s = format (0, "SCRIPT: nat_worker_dump ");
 219
 220   FINISH;
 221 }
 222
 223 static void
 224 vl_api_nat_ipfix_enable_disable_t_handler (vl_api_nat_ipfix_enable_disable_t *
 225                                            mp)
 226 {
 227   snat_main_t *sm = &snat_main;
 228   vl_api_nat_ipfix_enable_disable_reply_t *rmp;
 229   int rv = 0;
 230
 231   rv = snat_ipfix_logging_enable_disable (mp->enable,
 232                                           clib_host_to_net_u32
 233                                           (mp->domain_id),
 234                                           clib_host_to_net_u16
 235                                           (mp->src_port));
 236
 237   REPLY_MACRO (VL_API_NAT_IPFIX_ENABLE_DISABLE_REPLY);
 238 }
 239
 240 static void *
 241 vl_api_nat_ipfix_enable_disable_t_print (vl_api_nat_ipfix_enable_disable_t *
 242                                          mp, void *handle)
 243 {
 244   u8 *s;
 245
 246   s = format (0, "SCRIPT: nat_ipfix_enable_disable ");
 247   if (mp->domain_id)
 248     s = format (s, "domain %d ", clib_net_to_host_u32 (mp->domain_id));
 249   if (mp->src_port)
 250     s = format (s, "src_port %d ", clib_net_to_host_u16 (mp->src_port));
 251   if (!mp->enable)
 252     s = format (s, "disable ");
 253
 254   FINISH;
 255 }
 256
 257 static void
 258 vl_api_nat_set_reass_t_handler (vl_api_nat_set_reass_t * mp)
 259 {
 260   snat_main_t *sm = &snat_main;
 261   vl_api_nat_set_reass_reply_t *rmp;
 262   int rv = 0;
 263
 264   rv =
 265     nat_reass_set (ntohl (mp->timeout), ntohs (mp->max_reass), mp->max_frag,
 266                    mp->drop_frag, mp->is_ip6);
 267
 268   REPLY_MACRO (VL_API_NAT_SET_REASS_REPLY);
 269 }
 270
 271 static void *
 272 vl_api_nat_set_reass_t_print (vl_api_nat_set_reass_t * mp, void *handle)
 273 {
 274   u8 *s;
 275
 276   s = format (0, "SCRIPT: nat_set_reass ");
 277   s = format (s, "timeout %d max_reass %d max_frag %d drop_frag %d is_ip6 %d",
 278               clib_host_to_net_u32 (mp->timeout),
 279               clib_host_to_net_u16 (mp->max_reass),
 280               mp->max_frag, mp->drop_frag, mp->is_ip6);
 281
 282   FINISH;
 283 }
 284
 285 static void
 286 vl_api_nat_get_reass_t_handler (vl_api_nat_get_reass_t * mp)
 287 {
 288   snat_main_t *sm = &snat_main;
 289   vl_api_nat_get_reass_reply_t *rmp;
 290   int rv = 0;
 291
 292   /* *INDENT-OFF* */
 293   REPLY_MACRO2 (VL_API_NAT_GET_REASS_REPLY,
 294   ({
 295     rmp->ip4_timeout = htonl (nat_reass_get_timeout(0));
 296     rmp->ip4_max_reass = htons (nat_reass_get_max_reass(0));
 297     rmp->ip4_max_frag = nat_reass_get_max_frag(0);
 298     rmp->ip4_drop_frag = nat_reass_is_drop_frag(0);
 299     rmp->ip6_timeout = htonl (nat_reass_get_timeout(1));
 300     rmp->ip6_max_reass = htons (nat_reass_get_max_reass(1));
 301     rmp->ip6_max_frag = nat_reass_get_max_frag(1);
 302     rmp->ip6_drop_frag = nat_reass_is_drop_frag(1);
 303   }))
 304   /* *INDENT-ON* */
 305 }
 306
 307 static void *
 308 vl_api_nat_get_reass_t_print (vl_api_nat_get_reass_t * mp, void *handle)
 309 {
 310   u8 *s;
 311
 312   s = format (0, "SCRIPT: nat_get_reass");
 313
 314   FINISH;
 315 }
 316
 317 typedef struct nat_api_walk_ctx_t_
 318 {
 319   vl_api_registration_t *reg;
 320   u32 context;
 321 } nat_api_walk_ctx_t;
 322
 323 static int
 324 nat_ip4_reass_walk_api (nat_reass_ip4_t * reass, void *arg)
 325 {
 326   vl_api_nat_reass_details_t *rmp;
 327   snat_main_t *sm = &snat_main;
 328   nat_api_walk_ctx_t *ctx = arg;
 329
 330   rmp = vl_msg_api_alloc (sizeof (*rmp));
 331   memset (rmp, 0, sizeof (*rmp));
 332   rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
 333   rmp->context = ctx->context;
 334   clib_memcpy (rmp->src_addr, &(reass->key.src), 4);
 335   clib_memcpy (rmp->dst_addr, &(reass->key.dst), 4);
 336   rmp->proto = reass->key.proto;
 337   rmp->frag_id = ntohl (reass->key.frag_id);
 338   rmp->frag_n = reass->frag_n;
 339   rmp->is_ip4 = 1;
 340
 341   vl_api_send_msg (ctx->reg, (u8 *) rmp);
 342
 343   return 0;
 344 }
 345
 346 static int
 347 nat_ip6_reass_walk_api (nat_reass_ip6_t * reass, void *arg)
 348 {
 349   vl_api_nat_reass_details_t *rmp;
 350   snat_main_t *sm = &snat_main;
 351   nat_api_walk_ctx_t *ctx = arg;
 352
 353   rmp = vl_msg_api_alloc (sizeof (*rmp));
 354   memset (rmp, 0, sizeof (*rmp));
 355   rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
 356   rmp->context = ctx->context;
 357   clib_memcpy (rmp->src_addr, &(reass->key.src), 16);
 358   clib_memcpy (rmp->dst_addr, &(reass->key.dst), 16);
 359   rmp->proto = reass->key.proto;
 360   rmp->frag_id = ntohl (reass->key.frag_id);
 361   rmp->frag_n = reass->frag_n;
 362   rmp->is_ip4 = 0;
 363
 364   vl_api_send_msg (ctx->reg, (u8 *) rmp);
 365
 366   return 0;
 367 }
 368
 369 static void
 370 vl_api_nat_reass_dump_t_handler (vl_api_nat_reass_dump_t * mp)
 371 {
 372   vl_api_registration_t *reg;
 373
 374   reg = vl_api_client_index_to_registration (mp->client_index);
 375   if (!reg)
 376     return;
 377
 378   nat_api_walk_ctx_t ctx = {
 379     .reg = reg,
 380     .context = mp->context,
 381   };
 382
 383   nat_ip4_reass_walk (nat_ip4_reass_walk_api, &ctx);
 384   nat_ip6_reass_walk (nat_ip6_reass_walk_api, &ctx);
 385 }
 386
 387 static void *
 388 vl_api_nat_reass_dump_t_print (vl_api_nat_reass_dump_t * mp, void *handle)
 389 {
 390   u8 *s;
 391
 392   s = format (0, "SCRIPT: nat_reass_dump");
 393
 394   FINISH;
 395 }
 396
 397 /*************/
 398 /*** NAT44 ***/
 399 /*************/
 400 static void
 401   vl_api_nat44_add_del_address_range_t_handler
 402   (vl_api_nat44_add_del_address_range_t * mp)
 403 {
 404   snat_main_t *sm = &snat_main;
 405   vl_api_nat44_add_del_address_range_reply_t *rmp;
 406   ip4_address_t this_addr;
 407   u32 start_host_order, end_host_order;
 408   u32 vrf_id;
 409   int i, count;
 410   int rv = 0;
 411   u32 *tmp;
 412
 413   if (sm->static_mapping_only)
 414     {
 415       rv = VNET_API_ERROR_FEATURE_DISABLED;
 416       goto send_reply;
 417     }
 418
 419   tmp = (u32 *) mp->first_ip_address;
 420   start_host_order = clib_host_to_net_u32 (tmp[0]);
 421   tmp = (u32 *) mp->last_ip_address;
 422   end_host_order = clib_host_to_net_u32 (tmp[0]);
 423
 424   count = (end_host_order - start_host_order) + 1;
 425
 426   vrf_id = clib_host_to_net_u32 (mp->vrf_id);
 427
 428   if (count > 1024)
 429     clib_warning ("%U - %U, %d addresses...",
 430                   format_ip4_address, mp->first_ip_address,
 431                   format_ip4_address, mp->last_ip_address, count);
 432
 433   memcpy (&this_addr.as_u8, mp->first_ip_address, 4);
 434
 435   for (i = 0; i < count; i++)
 436     {
 437       if (mp->is_add)
 438         snat_add_address (sm, &this_addr, vrf_id, mp->twice_nat);
 439       else
 440         rv = snat_del_address (sm, this_addr, 0, mp->twice_nat);
 441
 442       if (rv)
 443         goto send_reply;
 444
 445       if (sm->out2in_dpo)
 446         nat44_add_del_address_dpo (this_addr, mp->is_add);
 447
 448       increment_v4_address (&this_addr);
 449     }
 450
 451 send_reply:
 452   REPLY_MACRO (VL_API_NAT44_ADD_DEL_ADDRESS_RANGE_REPLY);
 453 }
 454
 455 static void *vl_api_nat44_add_del_address_range_t_print
 456   (vl_api_nat44_add_del_address_range_t * mp, void *handle)
 457 {
 458   u8 *s;
 459
 460   s = format (0, "SCRIPT: nat44_add_address_range ");
 461   s = format (s, "%U ", format_ip4_address, mp->first_ip_address);
 462   if (memcmp (mp->first_ip_address, mp->last_ip_address, 4))
 463     {
 464       s = format (s, " - %U ", format_ip4_address, mp->last_ip_address);
 465     }
 466   s = format (s, "twice_nat %d ", mp->twice_nat);
 467   FINISH;
 468 }
 469
 470 static void
 471 send_nat44_address_details (snat_address_t * a,
 472                             vl_api_registration_t * reg, u32 context,
 473                             u8 twice_nat)
 474 {
 475   vl_api_nat44_address_details_t *rmp;
 476   snat_main_t *sm = &snat_main;
 477
 478   rmp = vl_msg_api_alloc (sizeof (*rmp));
 479   memset (rmp, 0, sizeof (*rmp));
 480   rmp->_vl_msg_id = ntohs (VL_API_NAT44_ADDRESS_DETAILS + sm->msg_id_base);
 481   clib_memcpy (rmp->ip_address, &(a->addr), 4);
 482   if (a->fib_index != ~0)
 483     {
 484       fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP4);
 485       rmp->vrf_id = ntohl (fib->ft_table_id);
 486     }
 487   else
 488     rmp->vrf_id = ~0;
 489   rmp->twice_nat = twice_nat;
 490   rmp->context = context;
 491
 492   vl_api_send_msg (reg, (u8 *) rmp);
 493 }
 494
 495 static void
 496 vl_api_nat44_address_dump_t_handler (vl_api_nat44_address_dump_t * mp)
 497 {
 498   vl_api_registration_t *reg;
 499   snat_main_t *sm = &snat_main;
 500   snat_address_t *a;
 501
 502   reg = vl_api_client_index_to_registration (mp->client_index);
 503   if (!reg)
 504     return;
 505
 506   /* *INDENT-OFF* */
 507   vec_foreach (a, sm->addresses)
 508     send_nat44_address_details (a, reg, mp->context, 0);
 509   vec_foreach (a, sm->twice_nat_addresses)
 510     send_nat44_address_details (a, reg, mp->context, 1);
 511   /* *INDENT-ON* */
 512 }
 513
 514 static void *
 515 vl_api_nat44_address_dump_t_print (vl_api_nat44_address_dump_t * mp,
 516                                    void *handle)
 517 {
 518   u8 *s;
 519
 520   s = format (0, "SCRIPT: nat44_address_dump ");
 521
 522   FINISH;
 523 }
 524
 525 static void
 526   vl_api_nat44_interface_add_del_feature_t_handler
 527   (vl_api_nat44_interface_add_del_feature_t * mp)
 528 {
 529   snat_main_t *sm = &snat_main;
 530   vl_api_nat44_interface_add_del_feature_reply_t *rmp;
 531   u8 is_del = mp->is_add == 0;
 532   u32 sw_if_index = ntohl (mp->sw_if_index);
 533   int rv = 0;
 534
 535   VALIDATE_SW_IF_INDEX (mp);
 536
 537   rv = snat_interface_add_del (sw_if_index, mp->is_inside, is_del);
 538
 539   BAD_SW_IF_INDEX_LABEL;
 540
 541   REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_FEATURE_REPLY);
 542 }
 543
 544 static void *vl_api_nat44_interface_add_del_feature_t_print
 545   (vl_api_nat44_interface_add_del_feature_t * mp, void *handle)
 546 {
 547   u8 *s;
 548
 549   s = format (0, "SCRIPT: nat44_interface_add_del_feature ");
 550   s = format (s, "sw_if_index %d %s %s",
 551               clib_host_to_net_u32 (mp->sw_if_index),
 552               mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
 553
 554   FINISH;
 555 }
 556
 557 static void
 558 send_nat44_interface_details (snat_interface_t * i,
 559                               vl_api_registration_t * reg, u32 context)
 560 {
 561   vl_api_nat44_interface_details_t *rmp;
 562   snat_main_t *sm = &snat_main;
 563
 564   rmp = vl_msg_api_alloc (sizeof (*rmp));
 565   memset (rmp, 0, sizeof (*rmp));
 566   rmp->_vl_msg_id = ntohs (VL_API_NAT44_INTERFACE_DETAILS + sm->msg_id_base);
 567   rmp->sw_if_index = ntohl (i->sw_if_index);
 568   rmp->is_inside = (nat_interface_is_inside (i)
 569                     && nat_interface_is_outside (i)) ? 2 :
 570     nat_interface_is_inside (i);
 571   rmp->context = context;
 572
 573   vl_api_send_msg (reg, (u8 *) rmp);
 574 }
 575
 576 static void
 577 vl_api_nat44_interface_dump_t_handler (vl_api_nat44_interface_dump_t * mp)
 578 {
 579   vl_api_registration_t *reg;
 580   snat_main_t *sm = &snat_main;
 581   snat_interface_t *i;
 582
 583   reg = vl_api_client_index_to_registration (mp->client_index);
 584   if (!reg)
 585     return;
 586
 587   /* *INDENT-OFF* */
 588   pool_foreach (i, sm->interfaces,
 589   ({
 590     send_nat44_interface_details(i, reg, mp->context);
 591   }));
 592   /* *INDENT-ON* */
 593 }
 594
 595 static void *
 596 vl_api_nat44_interface_dump_t_print (vl_api_nat44_interface_dump_t * mp,
 597                                      void *handle)
 598 {
 599   u8 *s;
 600
 601   s = format (0, "SCRIPT: nat44_interface_dump ");
 602
 603   FINISH;
 604 }
 605
 606 static void
 607   vl_api_nat44_interface_add_del_output_feature_t_handler
 608   (vl_api_nat44_interface_add_del_output_feature_t * mp)
 609 {
 610   snat_main_t *sm = &snat_main;
 611   vl_api_nat44_interface_add_del_output_feature_reply_t *rmp;
 612   u8 is_del = mp->is_add == 0;
 613   u32 sw_if_index = ntohl (mp->sw_if_index);
 614   int rv = 0;
 615
 616   VALIDATE_SW_IF_INDEX (mp);
 617
 618   rv = snat_interface_add_del_output_feature (sw_if_index, mp->is_inside,
 619                                               is_del);
 620
 621   BAD_SW_IF_INDEX_LABEL;
 622
 623   REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE_REPLY);
 624 }
 625
 626 static void *vl_api_nat44_interface_add_del_output_feature_t_print
 627   (vl_api_nat44_interface_add_del_output_feature_t * mp, void *handle)
 628 {
 629   u8 *s;
 630
 631   s = format (0, "SCRIPT: nat44_interface_add_del_output_feature ");
 632   s = format (s, "sw_if_index %d %s %s",
 633               clib_host_to_net_u32 (mp->sw_if_index),
 634               mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
 635
 636   FINISH;
 637 }
 638
 639 static void
 640 send_nat44_interface_output_feature_details (snat_interface_t * i,
 641                                              vl_api_registration_t * reg,
 642                                              u32 context)
 643 {
 644   vl_api_nat44_interface_output_feature_details_t *rmp;
 645   snat_main_t *sm = &snat_main;
 646
 647   rmp = vl_msg_api_alloc (sizeof (*rmp));
 648   memset (rmp, 0, sizeof (*rmp));
 649   rmp->_vl_msg_id =
 650     ntohs (VL_API_NAT44_INTERFACE_OUTPUT_FEATURE_DETAILS + sm->msg_id_base);
 651   rmp->sw_if_index = ntohl (i->sw_if_index);
 652   rmp->context = context;
 653   rmp->is_inside = nat_interface_is_inside (i);
 654
 655   vl_api_send_msg (reg, (u8 *) rmp);
 656 }
 657
 658 static void
 659   vl_api_nat44_interface_output_feature_dump_t_handler
 660   (vl_api_nat44_interface_output_feature_dump_t * mp)
 661 {
 662   vl_api_registration_t *reg;
 663   snat_main_t *sm = &snat_main;
 664   snat_interface_t *i;
 665
 666   reg = vl_api_client_index_to_registration (mp->client_index);
 667   if (!reg)
 668     return;
 669
 670   /* *INDENT-OFF* */
 671   pool_foreach (i, sm->output_feature_interfaces,
 672   ({
 673     send_nat44_interface_output_feature_details(i, reg, mp->context);
 674   }));
 675   /* *INDENT-ON* */
 676 }
 677
 678 static void *vl_api_nat44_interface_output_feature_dump_t_print
 679   (vl_api_nat44_interface_output_feature_dump_t * mp, void *handle)
 680 {
 681   u8 *s;
 682
 683   s = format (0, "SCRIPT: nat44_interface_output_feature_dump ");
 684
 685   FINISH;
 686 }
 687
 688 static void
 689   vl_api_nat44_add_del_static_mapping_t_handler
 690   (vl_api_nat44_add_del_static_mapping_t * mp)
 691 {
 692   snat_main_t *sm = &snat_main;
 693   vl_api_nat44_add_del_static_mapping_reply_t *rmp;
 694   ip4_address_t local_addr, external_addr;
 695   u16 local_port = 0, external_port = 0;
 696   u32 vrf_id, external_sw_if_index;
 697   int rv = 0;
 698   snat_protocol_t proto;
 699
 700   memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
 701   memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
 702   if (mp->addr_only == 0)
 703     {
 704       local_port = clib_net_to_host_u16 (mp->local_port);
 705       external_port = clib_net_to_host_u16 (mp->external_port);
 706     }
 707   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
 708   external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
 709   proto = ip_proto_to_snat_proto (mp->protocol);
 710
 711   rv = snat_add_static_mapping (local_addr, external_addr, local_port,
 712                                 external_port, vrf_id, mp->addr_only,
 713                                 external_sw_if_index, proto, mp->is_add,
 714                                 mp->twice_nat, mp->out2in_only);
 715
 716   REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_REPLY);
 717 }
 718
 719 static void *vl_api_nat44_add_del_static_mapping_t_print
 720   (vl_api_nat44_add_del_static_mapping_t * mp, void *handle)
 721 {
 722   u8 *s;
 723
 724   s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
 725   s = format (s, "protocol %d local_addr %U external_addr %U ",
 726               mp->protocol,
 727               format_ip4_address, mp->local_ip_address,
 728               format_ip4_address, mp->external_ip_address);
 729
 730   if (mp->addr_only == 0)
 731     s = format (s, "local_port %d external_port %d ",
 732                 clib_net_to_host_u16 (mp->local_port),
 733                 clib_net_to_host_u16 (mp->external_port));
 734
 735   s = format (s, "twice_nat %d out2in_only %d ",
 736               mp->twice_nat, mp->out2in_only);
 737
 738   if (mp->vrf_id != ~0)
 739     s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
 740
 741   if (mp->external_sw_if_index != ~0)
 742     s = format (s, "external_sw_if_index %d",
 743                 clib_net_to_host_u32 (mp->external_sw_if_index));
 744   FINISH;
 745 }
 746
 747 static void
 748 send_nat44_static_mapping_details (snat_static_mapping_t * m,
 749                                    vl_api_registration_t * reg, u32 context)
 750 {
 751   vl_api_nat44_static_mapping_details_t *rmp;
 752   snat_main_t *sm = &snat_main;
 753
 754   rmp = vl_msg_api_alloc (sizeof (*rmp));
 755   memset (rmp, 0, sizeof (*rmp));
 756   rmp->_vl_msg_id =
 757     ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
 758   rmp->addr_only = m->addr_only;
 759   clib_memcpy (rmp->local_ip_address, &(m->local_addr), 4);
 760   clib_memcpy (rmp->external_ip_address, &(m->external_addr), 4);
 761   rmp->local_port = htons (m->local_port);
 762   rmp->external_port = htons (m->external_port);
 763   rmp->external_sw_if_index = ~0;
 764   rmp->vrf_id = htonl (m->vrf_id);
 765   rmp->protocol = snat_proto_to_ip_proto (m->proto);
 766   rmp->context = context;
 767   rmp->twice_nat = m->twice_nat;
 768   rmp->out2in_only = m->out2in_only;
 769
 770   vl_api_send_msg (reg, (u8 *) rmp);
 771 }
 772
 773 static void
 774 send_nat44_static_map_resolve_details (snat_static_map_resolve_t * m,
 775                                        vl_api_registration_t * reg,
 776                                        u32 context)
 777 {
 778   vl_api_nat44_static_mapping_details_t *rmp;
 779   snat_main_t *sm = &snat_main;
 780
 781   rmp = vl_msg_api_alloc (sizeof (*rmp));
 782   memset (rmp, 0, sizeof (*rmp));
 783   rmp->_vl_msg_id =
 784     ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
 785   rmp->addr_only = m->addr_only;
 786   clib_memcpy (rmp->local_ip_address, &(m->l_addr), 4);
 787   rmp->local_port = htons (m->l_port);
 788   rmp->external_port = htons (m->e_port);
 789   rmp->external_sw_if_index = htonl (m->sw_if_index);
 790   rmp->vrf_id = htonl (m->vrf_id);
 791   rmp->protocol = snat_proto_to_ip_proto (m->proto);
 792   rmp->context = context;
 793   rmp->twice_nat = m->twice_nat;
 794
 795   vl_api_send_msg (reg, (u8 *) rmp);
 796 }
 797
 798 static void
 799 vl_api_nat44_static_mapping_dump_t_handler (vl_api_nat44_static_mapping_dump_t
 800                                             * mp)
 801 {
 802   vl_api_registration_t *reg;
 803   snat_main_t *sm = &snat_main;
 804   snat_static_mapping_t *m;
 805   snat_static_map_resolve_t *rp;
 806   int j;
 807
 808   reg = vl_api_client_index_to_registration (mp->client_index);
 809   if (!reg)
 810     return;
 811
 812   /* *INDENT-OFF* */
 813   pool_foreach (m, sm->static_mappings,
 814   ({
 815       if (!vec_len(m->locals) && (m->local_addr.as_u32 != m->external_addr.as_u32))
 816         send_nat44_static_mapping_details (m, reg, mp->context);
 817   }));
 818   /* *INDENT-ON* */
 819
 820   for (j = 0; j < vec_len (sm->to_resolve); j++)
 821     {
 822       rp = sm->to_resolve + j;
 823       if (rp->l_addr.as_u32 != 0)
 824         send_nat44_static_map_resolve_details (rp, reg, mp->context);
 825     }
 826 }
 827
 828 static void *
 829 vl_api_nat44_static_mapping_dump_t_print (vl_api_nat44_static_mapping_dump_t *
 830                                           mp, void *handle)
 831 {
 832   u8 *s;
 833
 834   s = format (0, "SCRIPT: nat44_static_mapping_dump ");
 835
 836   FINISH;
 837 }
 838
 839 static void
 840   vl_api_nat44_add_del_identity_mapping_t_handler
 841   (vl_api_nat44_add_del_identity_mapping_t * mp)
 842 {
 843   snat_main_t *sm = &snat_main;
 844   vl_api_nat44_add_del_identity_mapping_reply_t *rmp;
 845   ip4_address_t addr;
 846   u16 port = 0;
 847   u32 vrf_id, sw_if_index;
 848   int rv = 0;
 849   snat_protocol_t proto = ~0;
 850
 851   if (mp->addr_only == 0)
 852     {
 853       port = clib_net_to_host_u16 (mp->port);
 854       proto = ip_proto_to_snat_proto (mp->protocol);
 855     }
 856   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
 857   sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
 858   if (sw_if_index != ~0)
 859     addr.as_u32 = 0;
 860   else
 861     memcpy (&addr.as_u8, mp->ip_address, 4);
 862
 863
 864   rv =
 865     snat_add_static_mapping (addr, addr, port, port, vrf_id, mp->addr_only,
 866                              sw_if_index, proto, mp->is_add, 0, 0);
 867
 868   REPLY_MACRO (VL_API_NAT44_ADD_DEL_IDENTITY_MAPPING_REPLY);
 869 }
 870
 871 static void *vl_api_nat44_add_del_identity_mapping_t_print
 872   (vl_api_nat44_add_del_identity_mapping_t * mp, void *handle)
 873 {
 874   u8 *s;
 875
 876   s = format (0, "SCRIPT: nat44_add_del_identity_mapping ");
 877   if (mp->sw_if_index != ~0)
 878     s = format (s, "sw_if_index %d", clib_net_to_host_u32 (mp->sw_if_index));
 879   else
 880     s = format (s, "addr %U", format_ip4_address, mp->ip_address);
 881
 882   if (mp->addr_only == 0)
 883     s =
 884       format (s, "protocol %d port %d", mp->protocol,
 885               clib_net_to_host_u16 (mp->port));
 886
 887   if (mp->vrf_id != ~0)
 888     s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
 889
 890   FINISH;
 891 }
 892
 893 static void
 894 send_nat44_identity_mapping_details (snat_static_mapping_t * m,
 895                                      vl_api_registration_t * reg, u32 context)
 896 {
 897   vl_api_nat44_identity_mapping_details_t *rmp;
 898   snat_main_t *sm = &snat_main;
 899
 900   rmp = vl_msg_api_alloc (sizeof (*rmp));
 901   memset (rmp, 0, sizeof (*rmp));
 902   rmp->_vl_msg_id =
 903     ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
 904   rmp->addr_only = m->addr_only;
 905   clib_memcpy (rmp->ip_address, &(m->local_addr), 4);
 906   rmp->port = htons (m->local_port);
 907   rmp->sw_if_index = ~0;
 908   rmp->vrf_id = htonl (m->vrf_id);
 909   rmp->protocol = snat_proto_to_ip_proto (m->proto);
 910   rmp->context = context;
 911
 912   vl_api_send_msg (reg, (u8 *) rmp);
 913 }
 914
 915 static void
 916 send_nat44_identity_map_resolve_details (snat_static_map_resolve_t * m,
 917                                          vl_api_registration_t * reg,
 918                                          u32 context)
 919 {
 920   vl_api_nat44_identity_mapping_details_t *rmp;
 921   snat_main_t *sm = &snat_main;
 922
 923   rmp = vl_msg_api_alloc (sizeof (*rmp));
 924   memset (rmp, 0, sizeof (*rmp));
 925   rmp->_vl_msg_id =
 926     ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
 927   rmp->addr_only = m->addr_only;
 928   rmp->port = htons (m->l_port);
 929   rmp->sw_if_index = htonl (m->sw_if_index);
 930   rmp->vrf_id = htonl (m->vrf_id);
 931   rmp->protocol = snat_proto_to_ip_proto (m->proto);
 932   rmp->context = context;
 933
 934   vl_api_send_msg (reg, (u8 *) rmp);
 935 }
 936
 937 static void
 938   vl_api_nat44_identity_mapping_dump_t_handler
 939   (vl_api_nat44_identity_mapping_dump_t * mp)
 940 {
 941   vl_api_registration_t *reg;
 942   snat_main_t *sm = &snat_main;
 943   snat_static_mapping_t *m;
 944   snat_static_map_resolve_t *rp;
 945   int j;
 946
 947   reg = vl_api_client_index_to_registration (mp->client_index);
 948   if (!reg)
 949     return;
 950
 951   /* *INDENT-OFF* */
 952   pool_foreach (m, sm->static_mappings,
 953   ({
 954       if (!vec_len(m->locals) && (m->local_addr.as_u32 == m->external_addr.as_u32))
 955         send_nat44_identity_mapping_details (m, reg, mp->context);
 956   }));
 957   /* *INDENT-ON* */
 958
 959   for (j = 0; j < vec_len (sm->to_resolve); j++)
 960     {
 961       rp = sm->to_resolve + j;
 962       if (rp->l_addr.as_u32 == 0)
 963         send_nat44_identity_map_resolve_details (rp, reg, mp->context);
 964     }
 965 }
 966
 967 static void *vl_api_nat44_identity_mapping_dump_t_print
 968   (vl_api_nat44_identity_mapping_dump_t * mp, void *handle)
 969 {
 970   u8 *s;
 971
 972   s = format (0, "SCRIPT: nat44_identity_mapping_dump ");
 973
 974   FINISH;
 975 }
 976
 977 static void
 978   vl_api_nat44_add_del_interface_addr_t_handler
 979   (vl_api_nat44_add_del_interface_addr_t * mp)
 980 {
 981   snat_main_t *sm = &snat_main;
 982   vl_api_nat44_add_del_interface_addr_reply_t *rmp;
 983   u8 is_del = mp->is_add == 0;
 984   u32 sw_if_index = ntohl (mp->sw_if_index);
 985   int rv = 0;
 986
 987   VALIDATE_SW_IF_INDEX (mp);
 988
 989   rv = snat_add_interface_address (sm, sw_if_index, is_del, mp->twice_nat);
 990
 991   BAD_SW_IF_INDEX_LABEL;
 992
 993   REPLY_MACRO (VL_API_NAT44_ADD_DEL_INTERFACE_ADDR_REPLY);
 994 }
 995
 996 static void *vl_api_nat44_add_del_interface_addr_t_print
 997   (vl_api_nat44_add_del_interface_addr_t * mp, void *handle)
 998 {
 999   u8 *s;
1000
1001   s = format (0, "SCRIPT: nat44_add_del_interface_addr ");
1002   s = format (s, "sw_if_index %d twice_nat %d %s",
1003               clib_host_to_net_u32 (mp->sw_if_index),
1004               mp->twice_nat, mp->is_add ? "" : "del");
1005
1006   FINISH;
1007 }
1008
1009 static void
1010 send_nat44_interface_addr_details (u32 sw_if_index,
1011                                    vl_api_registration_t * reg, u32 context,
1012                                    u8 twice_nat)
1013 {
1014   vl_api_nat44_interface_addr_details_t *rmp;
1015   snat_main_t *sm = &snat_main;
1016
1017   rmp = vl_msg_api_alloc (sizeof (*rmp));
1018   memset (rmp, 0, sizeof (*rmp));
1019   rmp->_vl_msg_id =
1020     ntohs (VL_API_NAT44_INTERFACE_ADDR_DETAILS + sm->msg_id_base);
1021   rmp->sw_if_index = ntohl (sw_if_index);
1022   rmp->twice_nat = twice_nat;
1023   rmp->context = context;
1024
1025   vl_api_send_msg (reg, (u8 *) rmp);
1026 }
1027
1028 static void
1029 vl_api_nat44_interface_addr_dump_t_handler (vl_api_nat44_interface_addr_dump_t
1030                                             * mp)
1031 {
1032   vl_api_registration_t *reg;
1033   snat_main_t *sm = &snat_main;
1034   u32 *i;
1035
1036   reg = vl_api_client_index_to_registration (mp->client_index);
1037   if (!reg)
1038     return;
1039
1040   /* *INDENT-OFF* */
1041   vec_foreach (i, sm->auto_add_sw_if_indices)
1042     send_nat44_interface_addr_details(*i, reg, mp->context, 0);
1043   vec_foreach (i, sm->auto_add_sw_if_indices_twice_nat)
1044     send_nat44_interface_addr_details(*i, reg, mp->context, 1);
1045   /* *INDENT-ON* */
1046 }
1047
1048 static void *
1049 vl_api_nat44_interface_addr_dump_t_print (vl_api_nat44_interface_addr_dump_t *
1050                                           mp, void *handle)
1051 {
1052   u8 *s;
1053
1054   s = format (0, "SCRIPT: nat44_interface_addr_dump ");
1055
1056   FINISH;
1057 }
1058
1059 static void
1060 send_nat44_user_details (snat_user_t * u, vl_api_registration_t * reg,
1061                          u32 context)
1062 {
1063   vl_api_nat44_user_details_t *rmp;
1064   snat_main_t *sm = &snat_main;
1065   fib_table_t *fib = fib_table_get (u->fib_index, FIB_PROTOCOL_IP4);
1066
1067   rmp = vl_msg_api_alloc (sizeof (*rmp));
1068   memset (rmp, 0, sizeof (*rmp));
1069   rmp->_vl_msg_id = ntohs (VL_API_NAT44_USER_DETAILS + sm->msg_id_base);
1070
1071   rmp->vrf_id = ntohl (fib->ft_table_id);
1072
1073   clib_memcpy (rmp->ip_address, &(u->addr), 4);
1074   rmp->nsessions = ntohl (u->nsessions);
1075   rmp->nstaticsessions = ntohl (u->nstaticsessions);
1076   rmp->context = context;
1077
1078   vl_api_send_msg (reg, (u8 *) rmp);
1079 }
1080
1081 static void
1082 vl_api_nat44_user_dump_t_handler (vl_api_nat44_user_dump_t * mp)
1083 {
1084   vl_api_registration_t *reg;
1085   snat_main_t *sm = &snat_main;
1086   snat_main_per_thread_data_t *tsm;
1087   snat_user_t *u;
1088
1089   reg = vl_api_client_index_to_registration (mp->client_index);
1090   if (!reg)
1091     return;
1092
1093   /* *INDENT-OFF* */
1094   vec_foreach (tsm, sm->per_thread_data)
1095     vec_foreach (u, tsm->users)
1096       send_nat44_user_details (u, reg, mp->context);
1097   /* *INDENT-ON* */
1098 }
1099
1100 static void *
1101 vl_api_nat44_user_dump_t_print (vl_api_nat44_user_dump_t * mp, void *handle)
1102 {
1103   u8 *s;
1104
1105   s = format (0, "SCRIPT: nat44_user_dump ");
1106
1107   FINISH;
1108 }
1109
1110 static void
1111 send_nat44_user_session_details (snat_session_t * s,
1112                                  vl_api_registration_t * reg, u32 context)
1113 {
1114   vl_api_nat44_user_session_details_t *rmp;
1115   snat_main_t *sm = &snat_main;
1116
1117   rmp = vl_msg_api_alloc (sizeof (*rmp));
1118   memset (rmp, 0, sizeof (*rmp));
1119   rmp->_vl_msg_id =
1120     ntohs (VL_API_NAT44_USER_SESSION_DETAILS + sm->msg_id_base);
1121   clib_memcpy (rmp->outside_ip_address, (&s->out2in.addr), 4);
1122   clib_memcpy (rmp->inside_ip_address, (&s->in2out.addr), 4);
1123   rmp->is_static = s->flags & SNAT_SESSION_FLAG_STATIC_MAPPING ? 1 : 0;
1124   rmp->last_heard = clib_host_to_net_u64 ((u64) s->last_heard);
1125   rmp->total_bytes = clib_host_to_net_u64 (s->total_bytes);
1126   rmp->total_pkts = ntohl (s->total_pkts);
1127   rmp->context = context;
1128   if (snat_is_unk_proto_session (s))
1129     {
1130       rmp->outside_port = 0;
1131       rmp->inside_port = 0;
1132       rmp->protocol = ntohs (s->in2out.port);
1133     }
1134   else
1135     {
1136       rmp->outside_port = s->out2in.port;
1137       rmp->inside_port = s->in2out.port;
1138       rmp->protocol = ntohs (snat_proto_to_ip_proto (s->in2out.protocol));
1139     }
1140
1141   vl_api_send_msg (reg, (u8 *) rmp);
1142 }
1143
1144 static void
1145 vl_api_nat44_user_session_dump_t_handler (vl_api_nat44_user_session_dump_t *
1146                                           mp)
1147 {
1148   vl_api_registration_t *reg;
1149   snat_main_t *sm = &snat_main;
1150   snat_main_per_thread_data_t *tsm;
1151   snat_session_t *s;
1152   clib_bihash_kv_8_8_t key, value;
1153   snat_user_key_t ukey;
1154   snat_user_t *u;
1155   u32 session_index, head_index, elt_index;
1156   dlist_elt_t *head, *elt;
1157   ip4_header_t ip;
1158
1159   reg = vl_api_client_index_to_registration (mp->client_index);
1160   if (!reg)
1161     return;
1162
1163   clib_memcpy (&ukey.addr, mp->ip_address, 4);
1164   ip.src_address.as_u32 = ukey.addr.as_u32;
1165   ukey.fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->vrf_id));
1166   key.key = ukey.as_u64;
1167   if (sm->num_workers)
1168     tsm =
1169       vec_elt_at_index (sm->per_thread_data,
1170                         sm->worker_in2out_cb (&ip, ukey.fib_index));
1171   else
1172     tsm = vec_elt_at_index (sm->per_thread_data, sm->num_workers);
1173   if (clib_bihash_search_8_8 (&tsm->user_hash, &key, &value))
1174     return;
1175   u = pool_elt_at_index (tsm->users, value.value);
1176   if (!u->nsessions && !u->nstaticsessions)
1177     return;
1178
1179   head_index = u->sessions_per_user_list_head_index;
1180   head = pool_elt_at_index (tsm->list_pool, head_index);
1181   elt_index = head->next;
1182   elt = pool_elt_at_index (tsm->list_pool, elt_index);
1183   session_index = elt->value;
1184   while (session_index != ~0)
1185     {
1186       s = pool_elt_at_index (tsm->sessions, session_index);
1187
1188       send_nat44_user_session_details (s, reg, mp->context);
1189
1190       elt_index = elt->next;
1191       elt = pool_elt_at_index (tsm->list_pool, elt_index);
1192       session_index = elt->value;
1193     }
1194 }
1195
1196 static void *
1197 vl_api_nat44_user_session_dump_t_print (vl_api_nat44_user_session_dump_t * mp,
1198                                         void *handle)
1199 {
1200   u8 *s;
1201
1202   s = format (0, "SCRIPT: nat44_user_session_dump ");
1203   s = format (s, "ip_address %U vrf_id %d\n",
1204               format_ip4_address, mp->ip_address,
1205               clib_net_to_host_u32 (mp->vrf_id));
1206
1207   FINISH;
1208 }
1209
1210 static nat44_lb_addr_port_t *
1211 unformat_nat44_lb_addr_port (vl_api_nat44_lb_addr_port_t * addr_port_pairs,
1212                              u8 addr_port_pair_num)
1213 {
1214   u8 i;
1215   nat44_lb_addr_port_t *lb_addr_port_pairs = 0, lb_addr_port;
1216   vl_api_nat44_lb_addr_port_t *ap;
1217
1218   for (i = 0; i < addr_port_pair_num; i++)
1219     {
1220       ap = &addr_port_pairs[i];
1221       memset (&lb_addr_port, 0, sizeof (lb_addr_port));
1222       clib_memcpy (&lb_addr_port.addr, ap->addr, 4);
1223       lb_addr_port.port = clib_net_to_host_u16 (ap->port);
1224       lb_addr_port.probability = ap->probability;
1225       vec_add1 (lb_addr_port_pairs, lb_addr_port);
1226     }
1227
1228   return lb_addr_port_pairs;
1229 }
1230
1231 static void
1232   vl_api_nat44_add_del_lb_static_mapping_t_handler
1233   (vl_api_nat44_add_del_lb_static_mapping_t * mp)
1234 {
1235   snat_main_t *sm = &snat_main;
1236   vl_api_nat44_add_del_lb_static_mapping_reply_t *rmp;
1237   int rv = 0;
1238   nat44_lb_addr_port_t *locals = 0;
1239   ip4_address_t e_addr;
1240   snat_protocol_t proto;
1241
1242   locals = unformat_nat44_lb_addr_port (mp->locals, mp->local_num);
1243   clib_memcpy (&e_addr, mp->external_addr, 4);
1244   proto = ip_proto_to_snat_proto (mp->protocol);
1245
1246   rv =
1247     nat44_add_del_lb_static_mapping (e_addr,
1248                                      clib_net_to_host_u16 (mp->external_port),
1249                                      proto, clib_net_to_host_u32 (mp->vrf_id),
1250                                      locals, mp->is_add, mp->twice_nat,
1251                                      mp->out2in_only);
1252
1253   vec_free (locals);
1254
1255   REPLY_MACRO (VL_API_NAT44_ADD_DEL_LB_STATIC_MAPPING_REPLY);
1256 }
1257
1258 static void *vl_api_nat44_add_del_lb_static_mapping_t_print
1259   (vl_api_nat44_add_del_lb_static_mapping_t * mp, void *handle)
1260 {
1261   u8 *s;
1262
1263   s = format (0, "SCRIPT: nat44_add_del_lb_static_mapping ");
1264   s = format (s, "is_add %d twice_nat %d out2in_only %d ",
1265               mp->is_add, mp->twice_nat, mp->out2in_only);
1266
1267   FINISH;
1268 }
1269
1270 static void
1271 send_nat44_lb_static_mapping_details (snat_static_mapping_t * m,
1272                                       vl_api_registration_t * reg,
1273                                       u32 context)
1274 {
1275   vl_api_nat44_lb_static_mapping_details_t *rmp;
1276   snat_main_t *sm = &snat_main;
1277   nat44_lb_addr_port_t *ap;
1278   vl_api_nat44_lb_addr_port_t *locals;
1279
1280   rmp =
1281     vl_msg_api_alloc (sizeof (*rmp) +
1282                       (vec_len (m->locals) * sizeof (nat44_lb_addr_port_t)));
1283   memset (rmp, 0, sizeof (*rmp));
1284   rmp->_vl_msg_id =
1285     ntohs (VL_API_NAT44_LB_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1286
1287   clib_memcpy (rmp->external_addr, &(m->external_addr), 4);
1288   rmp->external_port = ntohs (m->external_port);
1289   rmp->protocol = snat_proto_to_ip_proto (m->proto);
1290   rmp->vrf_id = ntohl (m->vrf_id);
1291   rmp->context = context;
1292   rmp->twice_nat = m->twice_nat;
1293   rmp->out2in_only = m->out2in_only;
1294
1295   locals = (vl_api_nat44_lb_addr_port_t *) rmp->locals;
1296   vec_foreach (ap, m->locals)
1297   {
1298     clib_memcpy (locals->addr, &(ap->addr), 4);
1299     locals->port = htons (ap->port);
1300     locals->probability = ap->probability;
1301     locals++;
1302     rmp->local_num++;
1303   }
1304
1305   vl_api_send_msg (reg, (u8 *) rmp);
1306 }
1307
1308 static void
1309   vl_api_nat44_lb_static_mapping_dump_t_handler
1310   (vl_api_nat44_lb_static_mapping_dump_t * mp)
1311 {
1312   vl_api_registration_t *reg;
1313   snat_main_t *sm = &snat_main;
1314   snat_static_mapping_t *m;
1315
1316   reg = vl_api_client_index_to_registration (mp->client_index);
1317   if (!reg)
1318     return;
1319
1320   /* *INDENT-OFF* */
1321   pool_foreach (m, sm->static_mappings,
1322   ({
1323       if (vec_len(m->locals))
1324         send_nat44_lb_static_mapping_details (m, reg, mp->context);
1325   }));
1326   /* *INDENT-ON* */
1327 }
1328
1329 static void *vl_api_nat44_lb_static_mapping_dump_t_print
1330   (vl_api_nat44_lb_static_mapping_dump_t * mp, void *handle)
1331 {
1332   u8 *s;
1333
1334   s = format (0, "SCRIPT: nat44_lb_static_mapping_dump ");
1335
1336   FINISH;
1337 }
1338
1339 static void
1340 vl_api_nat44_del_session_t_handler (vl_api_nat44_del_session_t * mp)
1341 {
1342   snat_main_t *sm = &snat_main;
1343   vl_api_nat44_del_session_reply_t *rmp;
1344   ip4_address_t addr;
1345   u16 port;
1346   u32 vrf_id;
1347   int rv = 0;
1348   snat_protocol_t proto;
1349
1350   memcpy (&addr.as_u8, mp->address, 4);
1351   port = clib_net_to_host_u16 (mp->port);
1352   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1353   proto = ip_proto_to_snat_proto (mp->protocol);
1354
1355   rv = nat44_del_session (sm, &addr, port, proto, vrf_id, mp->is_in);
1356
1357   REPLY_MACRO (VL_API_NAT44_DEL_SESSION_REPLY);
1358 }
1359
1360 static void *
1361 vl_api_nat44_del_session_t_print (vl_api_nat44_del_session_t * mp,
1362                                   void *handle)
1363 {
1364   u8 *s;
1365
1366   s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
1367   s = format (s, "addr %U port %d protocol %d vrf_id %d is_in %d",
1368               format_ip4_address, mp->address,
1369               clib_net_to_host_u16 (mp->port),
1370               mp->protocol, clib_net_to_host_u32 (mp->vrf_id), mp->is_in);
1371
1372   FINISH;
1373 }
1374
1375 static void
1376   vl_api_nat44_forwarding_enable_disable_t_handler
1377   (vl_api_nat44_forwarding_enable_disable_t * mp)
1378 {
1379   snat_main_t *sm = &snat_main;
1380   vl_api_nat44_forwarding_enable_disable_reply_t *rmp;
1381   int rv = 0;
1382
1383   sm->forwarding_enabled = mp->enable != 0;
1384
1385   REPLY_MACRO (VL_API_NAT44_FORWARDING_ENABLE_DISABLE_REPLY);
1386 }
1387
1388 static void *vl_api_nat44_forwarding_enable_disable_t_print
1389   (vl_api_nat44_forwarding_enable_disable_t * mp, void *handle)
1390 {
1391   u8 *s;
1392
1393   s = format (0, "SCRIPT: nat44_forwarding_enable_disable ");
1394   s = format (s, "enable %d", mp->enable != 0);
1395
1396   FINISH;
1397 }
1398
1399 static void
1400   vl_api_nat44_forwarding_is_enabled_t_handler
1401   (vl_api_nat44_forwarding_is_enabled_t * mp)
1402 {
1403   vl_api_registration_t *reg;
1404   snat_main_t *sm = &snat_main;
1405   vl_api_nat44_forwarding_is_enabled_reply_t *rmp;
1406
1407   reg = vl_api_client_index_to_registration (mp->client_index);
1408   if (!reg)
1409     return;
1410
1411   rmp = vl_msg_api_alloc (sizeof (*rmp));
1412   memset (rmp, 0, sizeof (*rmp));
1413   rmp->_vl_msg_id =
1414     ntohs (VL_API_NAT44_FORWARDING_IS_ENABLED_REPLY + sm->msg_id_base);
1415   rmp->context = mp->context;
1416
1417   rmp->enabled = sm->forwarding_enabled;
1418
1419   vl_api_send_msg (reg, (u8 *) rmp);
1420 }
1421
1422 static void *vl_api_nat44_forwarding_is_enabled_t_print
1423   (vl_api_nat44_forwarding_is_enabled_t * mp, void *handle)
1424 {
1425   u8 *s;
1426
1427   s = format (0, "SCRIPT: nat44_forwarding_is_enabled ");
1428
1429   FINISH;
1430 }
1431
1432 /*******************************/
1433 /*** Deterministic NAT (CGN) ***/
1434 /*******************************/
1435
1436 static void
1437 vl_api_nat_det_add_del_map_t_handler (vl_api_nat_det_add_del_map_t * mp)
1438 {
1439   snat_main_t *sm = &snat_main;
1440   vl_api_nat_det_add_del_map_reply_t *rmp;
1441   int rv = 0;
1442   ip4_address_t in_addr, out_addr;
1443
1444   if (!mp->is_nat44)
1445     {
1446       rv = VNET_API_ERROR_UNIMPLEMENTED;
1447       goto send_reply;
1448     }
1449
1450   clib_memcpy (&in_addr, mp->in_addr, 4);
1451   clib_memcpy (&out_addr, mp->out_addr, 4);
1452   rv = snat_det_add_map (sm, &in_addr, mp->in_plen, &out_addr,
1453                          mp->out_plen, mp->is_add);
1454
1455 send_reply:
1456   REPLY_MACRO (VL_API_NAT_DET_ADD_DEL_MAP_REPLY);
1457 }
1458
1459 static void *
1460 vl_api_nat_det_add_del_map_t_print (vl_api_nat_det_add_del_map_t * mp,
1461                                     void *handle)
1462 {
1463   u8 *s;
1464
1465   s = format (0, "SCRIPT: nat_det_add_del_map ");
1466   s = format (s, "inside address %U/%d outside address %U/%d\n",
1467               format_ip4_address, mp->in_addr, mp->in_plen,
1468               format_ip4_address, mp->out_addr, mp->out_plen);
1469
1470   FINISH;
1471 }
1472
1473 static void
1474 vl_api_nat_det_forward_t_handler (vl_api_nat_det_forward_t * mp)
1475 {
1476   snat_main_t *sm = &snat_main;
1477   vl_api_nat_det_forward_reply_t *rmp;
1478   int rv = 0;
1479   u16 lo_port = 0, hi_port = 0;
1480   snat_det_map_t *dm;
1481   ip4_address_t in_addr, out_addr;
1482
1483   if (!mp->is_nat44)
1484     {
1485       out_addr.as_u32 = 0;
1486       rv = VNET_API_ERROR_UNIMPLEMENTED;
1487       goto send_reply;
1488     }
1489
1490   out_addr.as_u32 = 0;
1491   clib_memcpy (&in_addr, mp->in_addr, 4);
1492   dm = snat_det_map_by_user (sm, &in_addr);
1493   if (!dm)
1494     {
1495       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1496       goto send_reply;
1497     }
1498
1499   snat_det_forward (dm, &in_addr, &out_addr, &lo_port);
1500   hi_port = lo_port + dm->ports_per_host - 1;
1501
1502 send_reply:
1503   /* *INDENT-OFF* */
1504   REPLY_MACRO2 (VL_API_NAT_DET_FORWARD_REPLY,
1505   ({
1506     rmp->out_port_lo = ntohs (lo_port);
1507     rmp->out_port_hi = ntohs (hi_port);
1508     clib_memcpy (rmp->out_addr, &out_addr, 4);
1509   }))
1510   /* *INDENT-ON* */
1511 }
1512
1513 static void *
1514 vl_api_nat_det_forward_t_print (vl_api_nat_det_forward_t * mp, void *handle)
1515 {
1516   u8 *s;
1517
1518   s = format (0, "SCRIPT: nat_det_forward");
1519   s = format (s, "inside ip address %U\n", format_ip4_address, mp->in_addr);
1520
1521   FINISH;
1522 }
1523
1524 static void
1525 vl_api_nat_det_reverse_t_handler (vl_api_nat_det_reverse_t * mp)
1526 {
1527   snat_main_t *sm = &snat_main;
1528   vl_api_nat_det_reverse_reply_t *rmp;
1529   int rv = 0;
1530   ip4_address_t out_addr, in_addr;
1531   snat_det_map_t *dm;
1532
1533   in_addr.as_u32 = 0;
1534   clib_memcpy (&out_addr, mp->out_addr, 4);
1535   dm = snat_det_map_by_out (sm, &out_addr);
1536   if (!dm)
1537     {
1538       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1539       goto send_reply;
1540     }
1541
1542   snat_det_reverse (dm, &out_addr, htons (mp->out_port), &in_addr);
1543
1544 send_reply:
1545   /* *INDENT-OFF* */
1546   REPLY_MACRO2 (VL_API_NAT_DET_REVERSE_REPLY,
1547   ({
1548     rmp->is_nat44 = 1;
1549     memset (rmp->in_addr, 0, 16);
1550     clib_memcpy (rmp->in_addr, &in_addr, 4);
1551   }))
1552   /* *INDENT-ON* */
1553 }
1554
1555 static void *
1556 vl_api_nat_det_reverse_t_print (vl_api_nat_det_reverse_t * mp, void *handle)
1557 {
1558   u8 *s;
1559
1560   s = format (0, "SCRIPT: nat_det_reverse");
1561   s = format (s, "outside ip address %U outside port %d",
1562               format_ip4_address, mp->out_addr, ntohs (mp->out_port));
1563
1564   FINISH;
1565 }
1566
1567 static void
1568 sent_nat_det_map_details (snat_det_map_t * m, vl_api_registration_t * reg,
1569                           u32 context)
1570 {
1571   vl_api_nat_det_map_details_t *rmp;
1572   snat_main_t *sm = &snat_main;
1573
1574   rmp = vl_msg_api_alloc (sizeof (*rmp));
1575   memset (rmp, 0, sizeof (*rmp));
1576   rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_MAP_DETAILS + sm->msg_id_base);
1577   rmp->is_nat44 = 1;
1578   clib_memcpy (rmp->in_addr, &m->in_addr, 4);
1579   rmp->in_plen = m->in_plen;
1580   clib_memcpy (rmp->out_addr, &m->out_addr, 4);
1581   rmp->out_plen = m->out_plen;
1582   rmp->sharing_ratio = htonl (m->sharing_ratio);
1583   rmp->ports_per_host = htons (m->ports_per_host);
1584   rmp->ses_num = htonl (m->ses_num);
1585   rmp->context = context;
1586
1587   vl_api_send_msg (reg, (u8 *) rmp);
1588 }
1589
1590 static void
1591 vl_api_nat_det_map_dump_t_handler (vl_api_nat_det_map_dump_t * mp)
1592 {
1593   vl_api_registration_t *reg;
1594   snat_main_t *sm = &snat_main;
1595   snat_det_map_t *m;
1596
1597   reg = vl_api_client_index_to_registration (mp->client_index);
1598   if (!reg)
1599     return;
1600
1601   /* *INDENT-OFF* */
1602   vec_foreach(m, sm->det_maps)
1603     sent_nat_det_map_details(m, reg, mp->context);
1604   /* *INDENT-ON* */
1605 }
1606
1607 static void *
1608 vl_api_nat_det_map_dump_t_print (vl_api_nat_det_map_dump_t * mp, void *handle)
1609 {
1610   u8 *s;
1611
1612   s = format (0, "SCRIPT: nat_det_map_dump ");
1613
1614   FINISH;
1615 }
1616
1617 static void
1618 vl_api_nat_det_set_timeouts_t_handler (vl_api_nat_det_set_timeouts_t * mp)
1619 {
1620   snat_main_t *sm = &snat_main;
1621   vl_api_nat_det_set_timeouts_reply_t *rmp;
1622   int rv = 0;
1623
1624   sm->udp_timeout = ntohl (mp->udp);
1625   sm->tcp_established_timeout = ntohl (mp->tcp_established);
1626   sm->tcp_transitory_timeout = ntohl (mp->tcp_transitory);
1627   sm->icmp_timeout = ntohl (mp->icmp);
1628
1629   REPLY_MACRO (VL_API_NAT_DET_SET_TIMEOUTS_REPLY);
1630 }
1631
1632 static void *
1633 vl_api_nat_det_set_timeouts_t_print (vl_api_nat_det_set_timeouts_t * mp,
1634                                      void *handle)
1635 {
1636   u8 *s;
1637
1638   s = format (0, "SCRIPT: nat_det_set_timeouts ");
1639   s = format (s, "udp %d tcp_established %d tcp_transitory %d icmp %d\n",
1640               ntohl (mp->udp),
1641               ntohl (mp->tcp_established),
1642               ntohl (mp->tcp_transitory), ntohl (mp->icmp));
1643
1644   FINISH;
1645 }
1646
1647 static void
1648 vl_api_nat_det_get_timeouts_t_handler (vl_api_nat_det_get_timeouts_t * mp)
1649 {
1650   snat_main_t *sm = &snat_main;
1651   vl_api_nat_det_get_timeouts_reply_t *rmp;
1652   int rv = 0;
1653
1654   /* *INDENT-OFF* */
1655   REPLY_MACRO2 (VL_API_NAT_DET_GET_TIMEOUTS_REPLY,
1656   ({
1657     rmp->udp = htonl (sm->udp_timeout);
1658     rmp->tcp_established = htonl (sm->tcp_established_timeout);
1659     rmp->tcp_transitory = htonl (sm->tcp_transitory_timeout);
1660     rmp->icmp = htonl (sm->icmp_timeout);
1661   }))
1662   /* *INDENT-ON* */
1663 }
1664
1665 static void *
1666 vl_api_nat_det_get_timeouts_t_print (vl_api_nat_det_get_timeouts_t * mp,
1667                                      void *handle)
1668 {
1669   u8 *s;
1670
1671   s = format (0, "SCRIPT: nat_det_get_timeouts");
1672
1673   FINISH;
1674 }
1675
1676 static void
1677 vl_api_nat_det_close_session_out_t_handler (vl_api_nat_det_close_session_out_t
1678                                             * mp)
1679 {
1680   snat_main_t *sm = &snat_main;
1681   vl_api_nat_det_close_session_out_reply_t *rmp;
1682   ip4_address_t out_addr, ext_addr, in_addr;
1683   snat_det_out_key_t key;
1684   snat_det_map_t *dm;
1685   snat_det_session_t *ses;
1686   int rv = 0;
1687
1688   clib_memcpy (&out_addr, mp->out_addr, 4);
1689   clib_memcpy (&ext_addr, mp->ext_addr, 4);
1690
1691   dm = snat_det_map_by_out (sm, &out_addr);
1692   if (!dm)
1693     {
1694       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1695       goto send_reply;
1696     }
1697   snat_det_reverse (dm, &ext_addr, ntohs (mp->out_port), &in_addr);
1698   key.ext_host_addr = ext_addr;
1699   key.ext_host_port = mp->ext_port;
1700   key.out_port = mp->out_port;
1701   ses = snat_det_get_ses_by_out (dm, &in_addr, key.as_u64);
1702   if (!ses)
1703     {
1704       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1705       goto send_reply;
1706     }
1707   snat_det_ses_close (dm, ses);
1708
1709 send_reply:
1710   REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
1711 }
1712
1713 static void *
1714 vl_api_nat_det_close_session_out_t_print (vl_api_nat_det_close_session_out_t *
1715                                           mp, void *handle)
1716 {
1717   u8 *s;
1718
1719   s = format (0, "SCRIPT: nat_det_close_session_out ");
1720   s = format (s, "out_addr %U out_port %d "
1721               "ext_addr %U ext_port %d\n",
1722               format_ip4_address, mp->out_addr, ntohs (mp->out_port),
1723               format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
1724
1725   FINISH;
1726 }
1727
1728 static void
1729 vl_api_nat_det_close_session_in_t_handler (vl_api_nat_det_close_session_in_t *
1730                                            mp)
1731 {
1732   snat_main_t *sm = &snat_main;
1733   vl_api_nat_det_close_session_in_reply_t *rmp;
1734   ip4_address_t in_addr, ext_addr;
1735   snat_det_out_key_t key;
1736   snat_det_map_t *dm;
1737   snat_det_session_t *ses;
1738   int rv = 0;
1739
1740   if (!mp->is_nat44)
1741     {
1742       rv = VNET_API_ERROR_UNIMPLEMENTED;
1743       goto send_reply;
1744     }
1745
1746   clib_memcpy (&in_addr, mp->in_addr, 4);
1747   clib_memcpy (&ext_addr, mp->ext_addr, 4);
1748
1749   dm = snat_det_map_by_user (sm, &in_addr);
1750   if (!dm)
1751     {
1752       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1753       goto send_reply;
1754     }
1755   key.ext_host_addr = ext_addr;
1756   key.ext_host_port = mp->ext_port;
1757   ses = snat_det_find_ses_by_in (dm, &in_addr, mp->in_port, key);
1758   if (!ses)
1759     {
1760       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1761       goto send_reply;
1762     }
1763   snat_det_ses_close (dm, ses);
1764
1765 send_reply:
1766   REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
1767 }
1768
1769 static void *
1770 vl_api_nat_det_close_session_in_t_print (vl_api_nat_det_close_session_in_t *
1771                                          mp, void *handle)
1772 {
1773   u8 *s;
1774   s = format (0, "SCRIPT: nat_det_close_session_in ");
1775   s = format (s, "in_addr %U in_port %d ext_addr %U ext_port %d\n",
1776               format_ip4_address, mp->in_addr, ntohs (mp->in_port),
1777               format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
1778
1779   FINISH;
1780 }
1781
1782 static void
1783 send_nat_det_session_details (snat_det_session_t * s,
1784                               vl_api_registration_t * reg, u32 context)
1785 {
1786   vl_api_nat_det_session_details_t *rmp;
1787   snat_main_t *sm = &snat_main;
1788
1789   rmp = vl_msg_api_alloc (sizeof (*rmp));
1790   memset (rmp, 0, sizeof (*rmp));
1791   rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_SESSION_DETAILS + sm->msg_id_base);
1792   rmp->in_port = s->in_port;
1793   clib_memcpy (rmp->ext_addr, &s->out.ext_host_addr, 4);
1794   rmp->ext_port = s->out.ext_host_port;
1795   rmp->out_port = s->out.out_port;
1796   rmp->state = s->state;
1797   rmp->expire = ntohl (s->expire);
1798   rmp->context = context;
1799
1800   vl_api_send_msg (reg, (u8 *) rmp);
1801 }
1802
1803 static void
1804 vl_api_nat_det_session_dump_t_handler (vl_api_nat_det_session_dump_t * mp)
1805 {
1806   vl_api_registration_t *reg;
1807   snat_main_t *sm = &snat_main;
1808   ip4_address_t user_addr;
1809   snat_det_map_t *dm;
1810   snat_det_session_t *s, empty_ses;
1811   u16 i;
1812
1813   reg = vl_api_client_index_to_registration (mp->client_index);
1814   if (!reg)
1815     return;
1816   if (!mp->is_nat44)
1817     return;
1818
1819   memset (&empty_ses, 0, sizeof (empty_ses));
1820   clib_memcpy (&user_addr, mp->user_addr, 4);
1821   dm = snat_det_map_by_user (sm, &user_addr);
1822   if (!dm)
1823     return;
1824
1825   s = dm->sessions + snat_det_user_ses_offset (&user_addr, dm->in_plen);
1826   for (i = 0; i < SNAT_DET_SES_PER_USER; i++)
1827     {
1828       if (s->out.as_u64)
1829         send_nat_det_session_details (s, reg, mp->context);
1830       s++;
1831     }
1832 }
1833
1834 static void *
1835 vl_api_nat_det_session_dump_t_print (vl_api_nat_det_session_dump_t * mp,
1836                                      void *handle)
1837 {
1838   u8 *s;
1839
1840   s = format (0, "SCRIPT: nat_det_session_dump ");
1841   s = format (s, "user_addr %U\n", format_ip4_address, mp->user_addr);
1842
1843   FINISH;
1844 }
1845
1846 /*************/
1847 /*** NAT64 ***/
1848 /*************/
1849
1850 static void
1851   vl_api_nat64_add_del_pool_addr_range_t_handler
1852   (vl_api_nat64_add_del_pool_addr_range_t * mp)
1853 {
1854   vl_api_nat64_add_del_pool_addr_range_reply_t *rmp;
1855   snat_main_t *sm = &snat_main;
1856   int rv = 0;
1857   ip4_address_t this_addr;
1858   u32 start_host_order, end_host_order;
1859   u32 vrf_id;
1860   int i, count;
1861   u32 *tmp;
1862
1863   tmp = (u32 *) mp->start_addr;
1864   start_host_order = clib_host_to_net_u32 (tmp[0]);
1865   tmp = (u32 *) mp->end_addr;
1866   end_host_order = clib_host_to_net_u32 (tmp[0]);
1867
1868   count = (end_host_order - start_host_order) + 1;
1869
1870   vrf_id = clib_host_to_net_u32 (mp->vrf_id);
1871
1872   memcpy (&this_addr.as_u8, mp->start_addr, 4);
1873
1874   for (i = 0; i < count; i++)
1875     {
1876       if ((rv = nat64_add_del_pool_addr (&this_addr, vrf_id, mp->is_add)))
1877         goto send_reply;
1878
1879       increment_v4_address (&this_addr);
1880     }
1881
1882 send_reply:
1883   REPLY_MACRO (VL_API_NAT64_ADD_DEL_POOL_ADDR_RANGE_REPLY);
1884 }
1885
1886 static void *vl_api_nat64_add_del_pool_addr_range_t_print
1887   (vl_api_nat64_add_del_pool_addr_range_t * mp, void *handle)
1888 {
1889   u8 *s;
1890
1891   s = format (0, "SCRIPT: nat64_add_del_pool_addr_range ");
1892   s = format (s, "%U - %U vrf_id %u %s\n",
1893               format_ip4_address, mp->start_addr,
1894               format_ip4_address, mp->end_addr,
1895               ntohl (mp->vrf_id), mp->is_add ? "" : "del");
1896
1897   FINISH;
1898 }
1899
1900 typedef struct nat64_api_walk_ctx_t_
1901 {
1902   vl_api_registration_t *reg;
1903   u32 context;
1904   nat64_db_t *db;
1905 } nat64_api_walk_ctx_t;
1906
1907 static int
1908 nat64_api_pool_walk (snat_address_t * a, void *arg)
1909 {
1910   vl_api_nat64_pool_addr_details_t *rmp;
1911   snat_main_t *sm = &snat_main;
1912   nat64_api_walk_ctx_t *ctx = arg;
1913
1914   rmp = vl_msg_api_alloc (sizeof (*rmp));
1915   memset (rmp, 0, sizeof (*rmp));
1916   rmp->_vl_msg_id = ntohs (VL_API_NAT64_POOL_ADDR_DETAILS + sm->msg_id_base);
1917   clib_memcpy (rmp->address, &(a->addr), 4);
1918   if (a->fib_index != ~0)
1919     {
1920       fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP6);
1921       if (!fib)
1922         return -1;
1923       rmp->vrf_id = ntohl (fib->ft_table_id);
1924     }
1925   else
1926     rmp->vrf_id = ~0;
1927   rmp->context = ctx->context;
1928
1929   vl_api_send_msg (ctx->reg, (u8 *) rmp);
1930
1931   return 0;
1932 }
1933
1934 static void
1935 vl_api_nat64_pool_addr_dump_t_handler (vl_api_nat64_pool_addr_dump_t * mp)
1936 {
1937   vl_api_registration_t *reg;
1938
1939   reg = vl_api_client_index_to_registration (mp->client_index);
1940   if (!reg)
1941     return;
1942
1943   nat64_api_walk_ctx_t ctx = {
1944     .reg = reg,
1945     .context = mp->context,
1946   };
1947
1948   nat64_pool_addr_walk (nat64_api_pool_walk, &ctx);
1949 }
1950
1951 static void *
1952 vl_api_nat64_pool_addr_dump_t_print (vl_api_nat64_pool_addr_dump_t * mp,
1953                                      void *handle)
1954 {
1955   u8 *s;
1956
1957   s = format (0, "SCRIPT: nat64_pool_addr_dump\n");
1958
1959   FINISH;
1960 }
1961
1962 static void
1963 vl_api_nat64_add_del_interface_t_handler (vl_api_nat64_add_del_interface_t *
1964                                           mp)
1965 {
1966   snat_main_t *sm = &snat_main;
1967   vl_api_nat64_add_del_interface_reply_t *rmp;
1968   int rv = 0;
1969
1970   VALIDATE_SW_IF_INDEX (mp);
1971
1972   rv =
1973     nat64_add_del_interface (ntohl (mp->sw_if_index), mp->is_inside,
1974                              mp->is_add);
1975
1976   BAD_SW_IF_INDEX_LABEL;
1977
1978   REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_REPLY);
1979 }
1980
1981 static void *
1982 vl_api_nat64_add_del_interface_t_print (vl_api_nat64_add_del_interface_t * mp,
1983                                         void *handle)
1984 {
1985   u8 *s;
1986
1987   s = format (0, "SCRIPT: nat64_add_del_interface ");
1988   s = format (s, "sw_if_index %d %s %s",
1989               clib_host_to_net_u32 (mp->sw_if_index),
1990               mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
1991
1992   FINISH;
1993 }
1994
1995 static int
1996 nat64_api_interface_walk (snat_interface_t * i, void *arg)
1997 {
1998   vl_api_nat64_interface_details_t *rmp;
1999   snat_main_t *sm = &snat_main;
2000   nat64_api_walk_ctx_t *ctx = arg;
2001
2002   rmp = vl_msg_api_alloc (sizeof (*rmp));
2003   memset (rmp, 0, sizeof (*rmp));
2004   rmp->_vl_msg_id = ntohs (VL_API_NAT64_INTERFACE_DETAILS + sm->msg_id_base);
2005   rmp->sw_if_index = ntohl (i->sw_if_index);
2006   rmp->is_inside = (nat_interface_is_inside (i)
2007                     && nat_interface_is_outside (i)) ? 2 :
2008     nat_interface_is_inside (i);
2009   rmp->context = ctx->context;
2010
2011   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2012
2013   return 0;
2014 }
2015
2016 static void
2017 vl_api_nat64_interface_dump_t_handler (vl_api_nat64_interface_dump_t * mp)
2018 {
2019   vl_api_registration_t *reg;
2020
2021   reg = vl_api_client_index_to_registration (mp->client_index);
2022   if (!reg)
2023     return;
2024
2025   nat64_api_walk_ctx_t ctx = {
2026     .reg = reg,
2027     .context = mp->context,
2028   };
2029
2030   nat64_interfaces_walk (nat64_api_interface_walk, &ctx);
2031 }
2032
2033 static void *
2034 vl_api_nat64_interface_dump_t_print (vl_api_nat64_interface_dump_t * mp,
2035                                      void *handle)
2036 {
2037   u8 *s;
2038
2039   s = format (0, "SCRIPT: snat_interface_dump ");
2040
2041   FINISH;
2042 }
2043
2044 static void
2045   vl_api_nat64_add_del_static_bib_t_handler
2046   (vl_api_nat64_add_del_static_bib_t * mp)
2047 {
2048   snat_main_t *sm = &snat_main;
2049   vl_api_nat64_add_del_static_bib_reply_t *rmp;
2050   ip6_address_t in_addr;
2051   ip4_address_t out_addr;
2052   int rv = 0;
2053
2054   memcpy (&in_addr.as_u8, mp->i_addr, 16);
2055   memcpy (&out_addr.as_u8, mp->o_addr, 4);
2056
2057   rv =
2058     nat64_add_del_static_bib_entry (&in_addr, &out_addr,
2059                                     clib_net_to_host_u16 (mp->i_port),
2060                                     clib_net_to_host_u16 (mp->o_port),
2061                                     mp->proto,
2062                                     clib_net_to_host_u32 (mp->vrf_id),
2063                                     mp->is_add);
2064
2065   REPLY_MACRO (VL_API_NAT64_ADD_DEL_STATIC_BIB_REPLY);
2066 }
2067
2068 static void *vl_api_nat64_add_del_static_bib_t_print
2069   (vl_api_nat64_add_del_static_bib_t * mp, void *handle)
2070 {
2071   u8 *s;
2072
2073   s = format (0, "SCRIPT: nat64_add_del_static_bib ");
2074   s = format (s, "protocol %d i_addr %U o_addr %U ",
2075               mp->proto,
2076               format_ip6_address, mp->i_addr, format_ip4_address, mp->o_addr);
2077
2078   if (mp->vrf_id != ~0)
2079     s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
2080
2081   FINISH;
2082 }
2083
2084 static int
2085 nat64_api_bib_walk (nat64_db_bib_entry_t * bibe, void *arg)
2086 {
2087   vl_api_nat64_bib_details_t *rmp;
2088   snat_main_t *sm = &snat_main;
2089   nat64_api_walk_ctx_t *ctx = arg;
2090   fib_table_t *fib;
2091
2092   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2093   if (!fib)
2094     return -1;
2095
2096   rmp = vl_msg_api_alloc (sizeof (*rmp));
2097   memset (rmp, 0, sizeof (*rmp));
2098   rmp->_vl_msg_id = ntohs (VL_API_NAT64_BIB_DETAILS + sm->msg_id_base);
2099   rmp->context = ctx->context;
2100   clib_memcpy (rmp->i_addr, &(bibe->in_addr), 16);
2101   clib_memcpy (rmp->o_addr, &(bibe->out_addr), 4);
2102   rmp->i_port = bibe->in_port;
2103   rmp->o_port = bibe->out_port;
2104   rmp->vrf_id = ntohl (fib->ft_table_id);
2105   rmp->proto = bibe->proto;
2106   rmp->is_static = bibe->is_static;
2107   rmp->ses_num = ntohl (bibe->ses_num);
2108
2109   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2110
2111   return 0;
2112 }
2113
2114 static void
2115 vl_api_nat64_bib_dump_t_handler (vl_api_nat64_bib_dump_t * mp)
2116 {
2117   vl_api_registration_t *reg;
2118   nat64_main_t *nm = &nat64_main;
2119   nat64_db_t *db;
2120
2121   reg = vl_api_client_index_to_registration (mp->client_index);
2122   if (!reg)
2123     return;
2124
2125   nat64_api_walk_ctx_t ctx = {
2126     .reg = reg,
2127     .context = mp->context,
2128   };
2129
2130   /* *INDENT-OFF* */
2131   vec_foreach (db, nm->db)
2132     nat64_db_bib_walk (db, mp->proto, nat64_api_bib_walk, &ctx);
2133   /* *INDENT-ON* */
2134 }
2135
2136 static void *
2137 vl_api_nat64_bib_dump_t_print (vl_api_nat64_bib_dump_t * mp, void *handle)
2138 {
2139   u8 *s;
2140
2141   s = format (0, "SCRIPT: snat_bib_dump protocol %d", mp->proto);
2142
2143   FINISH;
2144 }
2145
2146 static void
2147 vl_api_nat64_set_timeouts_t_handler (vl_api_nat64_set_timeouts_t * mp)
2148 {
2149   snat_main_t *sm = &snat_main;
2150   vl_api_nat64_set_timeouts_reply_t *rmp;
2151   int rv = 0;
2152
2153   rv = nat64_set_icmp_timeout (ntohl (mp->icmp));
2154   if (rv)
2155     goto send_reply;
2156   rv = nat64_set_udp_timeout (ntohl (mp->udp));
2157   if (rv)
2158     goto send_reply;
2159   rv =
2160     nat64_set_tcp_timeouts (ntohl (mp->tcp_trans), ntohl (mp->tcp_est),
2161                             ntohl (mp->tcp_incoming_syn));
2162
2163 send_reply:
2164   REPLY_MACRO (VL_API_NAT64_SET_TIMEOUTS_REPLY);
2165 }
2166
2167 static void *vl_api_nat64_set_timeouts_t_print
2168   (vl_api_nat64_set_timeouts_t * mp, void *handle)
2169 {
2170   u8 *s;
2171
2172   s = format (0, "SCRIPT: nat64_set_timeouts ");
2173   s =
2174     format (s,
2175             "udp %d icmp %d, tcp_trans %d, tcp_est %d, tcp_incoming_syn %d\n",
2176             ntohl (mp->udp), ntohl (mp->icmp), ntohl (mp->tcp_trans),
2177             ntohl (mp->tcp_est), ntohl (mp->tcp_incoming_syn));
2178
2179   FINISH;
2180 }
2181
2182 static void
2183 vl_api_nat64_get_timeouts_t_handler (vl_api_nat64_get_timeouts_t * mp)
2184 {
2185   snat_main_t *sm = &snat_main;
2186   vl_api_nat64_get_timeouts_reply_t *rmp;
2187   int rv = 0;
2188
2189   /* *INDENT-OFF* */
2190   REPLY_MACRO2 (VL_API_NAT64_GET_TIMEOUTS_REPLY,
2191   ({
2192     rmp->udp = htonl (nat64_get_udp_timeout());
2193     rmp->icmp = htonl (nat64_get_icmp_timeout());
2194     rmp->tcp_trans = htonl (nat64_get_tcp_trans_timeout());
2195     rmp->tcp_est = htonl (nat64_get_tcp_est_timeout());
2196     rmp->tcp_incoming_syn = htonl (nat64_get_tcp_incoming_syn_timeout());
2197   }))
2198   /* *INDENT-ON* */
2199 }
2200
2201 static void *vl_api_nat64_get_timeouts_t_print
2202   (vl_api_nat64_get_timeouts_t * mp, void *handle)
2203 {
2204   u8 *s;
2205
2206   s = format (0, "SCRIPT: nat64_get_timeouts");
2207
2208   FINISH;
2209 }
2210
2211 static int
2212 nat64_api_st_walk (nat64_db_st_entry_t * ste, void *arg)
2213 {
2214   vl_api_nat64_st_details_t *rmp;
2215   snat_main_t *sm = &snat_main;
2216   nat64_api_walk_ctx_t *ctx = arg;
2217   nat64_db_bib_entry_t *bibe;
2218   fib_table_t *fib;
2219
2220   bibe = nat64_db_bib_entry_by_index (ctx->db, ste->proto, ste->bibe_index);
2221   if (!bibe)
2222     return -1;
2223
2224   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2225   if (!fib)
2226     return -1;
2227
2228   rmp = vl_msg_api_alloc (sizeof (*rmp));
2229   memset (rmp, 0, sizeof (*rmp));
2230   rmp->_vl_msg_id = ntohs (VL_API_NAT64_ST_DETAILS + sm->msg_id_base);
2231   rmp->context = ctx->context;
2232   clib_memcpy (rmp->il_addr, &(bibe->in_addr), 16);
2233   clib_memcpy (rmp->ol_addr, &(bibe->out_addr), 4);
2234   rmp->il_port = bibe->in_port;
2235   rmp->ol_port = bibe->out_port;
2236   clib_memcpy (rmp->ir_addr, &(ste->in_r_addr), 16);
2237   clib_memcpy (rmp->or_addr, &(ste->out_r_addr), 4);
2238   rmp->il_port = ste->r_port;
2239   rmp->vrf_id = ntohl (fib->ft_table_id);
2240   rmp->proto = ste->proto;
2241
2242   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2243
2244   return 0;
2245 }
2246
2247 static void
2248 vl_api_nat64_st_dump_t_handler (vl_api_nat64_st_dump_t * mp)
2249 {
2250   vl_api_registration_t *reg;
2251   nat64_main_t *nm = &nat64_main;
2252   nat64_db_t *db;
2253
2254   reg = vl_api_client_index_to_registration (mp->client_index);
2255   if (!reg)
2256     return;
2257
2258   nat64_api_walk_ctx_t ctx = {
2259     .reg = reg,
2260     .context = mp->context,
2261   };
2262
2263   /* *INDENT-OFF* */
2264   vec_foreach (db, nm->db)
2265     {
2266       ctx.db = db;
2267       nat64_db_st_walk (db, mp->proto, nat64_api_st_walk, &ctx);
2268     }
2269   /* *INDENT-ON* */
2270 }
2271
2272 static void *
2273 vl_api_nat64_st_dump_t_print (vl_api_nat64_st_dump_t * mp, void *handle)
2274 {
2275   u8 *s;
2276
2277   s = format (0, "SCRIPT: snat_st_dump protocol %d", mp->proto);
2278
2279   FINISH;
2280 }
2281
2282 static void
2283 vl_api_nat64_add_del_prefix_t_handler (vl_api_nat64_add_del_prefix_t * mp)
2284 {
2285   vl_api_nat64_add_del_prefix_reply_t *rmp;
2286   snat_main_t *sm = &snat_main;
2287   ip6_address_t prefix;
2288   int rv = 0;
2289
2290   memcpy (&prefix.as_u8, mp->prefix, 16);
2291
2292   rv =
2293     nat64_add_del_prefix (&prefix, mp->prefix_len,
2294                           clib_net_to_host_u32 (mp->vrf_id), mp->is_add);
2295   REPLY_MACRO (VL_API_NAT64_ADD_DEL_PREFIX_REPLY);
2296 }
2297
2298 static void *
2299 vl_api_nat64_add_del_prefix_t_print (vl_api_nat64_add_del_prefix_t * mp,
2300                                      void *handle)
2301 {
2302   u8 *s;
2303
2304   s = format (0, "SCRIPT: nat64_add_del_prefix %U/%u vrf_id %u %s\n",
2305               format_ip6_address, mp->prefix, mp->prefix_len,
2306               ntohl (mp->vrf_id), mp->is_add ? "" : "del");
2307
2308   FINISH;
2309 }
2310
2311 static int
2312 nat64_api_prefix_walk (nat64_prefix_t * p, void *arg)
2313 {
2314   vl_api_nat64_prefix_details_t *rmp;
2315   snat_main_t *sm = &snat_main;
2316   nat64_api_walk_ctx_t *ctx = arg;
2317
2318   rmp = vl_msg_api_alloc (sizeof (*rmp));
2319   memset (rmp, 0, sizeof (*rmp));
2320   rmp->_vl_msg_id = ntohs (VL_API_NAT64_PREFIX_DETAILS + sm->msg_id_base);
2321   clib_memcpy (rmp->prefix, &(p->prefix), 16);
2322   rmp->prefix_len = p->plen;
2323   rmp->vrf_id = ntohl (p->vrf_id);
2324   rmp->context = ctx->context;
2325
2326   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2327
2328   return 0;
2329 }
2330
2331 static void
2332 vl_api_nat64_prefix_dump_t_handler (vl_api_nat64_prefix_dump_t * mp)
2333 {
2334   vl_api_registration_t *reg;
2335
2336   reg = vl_api_client_index_to_registration (mp->client_index);
2337   if (!reg)
2338     return;
2339
2340   nat64_api_walk_ctx_t ctx = {
2341     .reg = reg,
2342     .context = mp->context,
2343   };
2344
2345   nat64_prefix_walk (nat64_api_prefix_walk, &ctx);
2346 }
2347
2348 static void *
2349 vl_api_nat64_prefix_dump_t_print (vl_api_nat64_prefix_dump_t * mp,
2350                                   void *handle)
2351 {
2352   u8 *s;
2353
2354   s = format (0, "SCRIPT: nat64_prefix_dump\n");
2355
2356   FINISH;
2357 }
2358
2359 static void
2360   vl_api_nat64_add_del_interface_addr_t_handler
2361   (vl_api_nat64_add_del_interface_addr_t * mp)
2362 {
2363   snat_main_t *sm = &snat_main;
2364   vl_api_nat64_add_del_interface_addr_reply_t *rmp;
2365   u32 sw_if_index = ntohl (mp->sw_if_index);
2366   int rv = 0;
2367
2368   VALIDATE_SW_IF_INDEX (mp);
2369
2370   rv = nat64_add_interface_address (sw_if_index, mp->is_add);
2371
2372   BAD_SW_IF_INDEX_LABEL;
2373
2374   REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_ADDR_REPLY);
2375 }
2376
2377 static void *vl_api_nat64_add_del_interface_addr_t_print
2378   (vl_api_nat64_add_del_interface_addr_t * mp, void *handle)
2379 {
2380   u8 *s;
2381
2382   s = format (0, "SCRIPT: nat64_add_del_interface_addr ");
2383   s = format (s, "sw_if_index %d %s",
2384               clib_host_to_net_u32 (mp->sw_if_index),
2385               mp->is_add ? "" : "del");
2386
2387   FINISH;
2388 }
2389
2390 /***************/
2391 /*** DS-Lite ***/
2392 /***************/
2393
2394 static void
2395 vl_api_dslite_set_aftr_addr_t_handler (vl_api_dslite_set_aftr_addr_t * mp)
2396 {
2397   vl_api_dslite_set_aftr_addr_reply_t *rmp;
2398   snat_main_t *sm = &snat_main;
2399   dslite_main_t *dm = &dslite_main;
2400   int rv = 0;
2401   ip6_address_t ip6_addr;
2402   ip4_address_t ip4_addr;
2403
2404   memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
2405   memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
2406
2407   rv = dslite_set_aftr_ip6_addr (dm, &ip6_addr);
2408   if (rv == 0)
2409     rv = dslite_set_aftr_ip4_addr (dm, &ip4_addr);
2410
2411   REPLY_MACRO (VL_API_DSLITE_SET_AFTR_ADDR_REPLY);
2412 }
2413
2414 static void *
2415 vl_api_dslite_set_aftr_addr_t_print (vl_api_dslite_set_aftr_addr_t * mp,
2416                                      void *handle)
2417 {
2418   u8 *s;
2419
2420   s = format (0, "SCRIPT: dslite_set_aftr_addr ");
2421   s = format (s, "ip6_addr %U ip4_addr %U\n",
2422               format_ip6_address, mp->ip6_addr,
2423               format_ip4_address, mp->ip4_addr);
2424
2425   FINISH;
2426 }
2427
2428 static void
2429 vl_api_dslite_get_aftr_addr_t_handler (vl_api_dslite_get_aftr_addr_t * mp)
2430 {
2431   snat_main_t *sm = &snat_main;
2432   vl_api_dslite_get_aftr_addr_reply_t *rmp;
2433   dslite_main_t *dm = &dslite_main;
2434   int rv = 0;
2435
2436   /* *INDENT-OFF* */
2437   REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
2438   ({
2439     memcpy (rmp->ip4_addr, &dm->aftr_ip4_addr.as_u8, 4);
2440     memcpy (rmp->ip6_addr, &dm->aftr_ip6_addr.as_u8, 16);
2441   }))
2442   /* *INDENT-ON* */
2443 }
2444
2445 static void *
2446 vl_api_dslite_get_aftr_addr_t_print (vl_api_dslite_get_aftr_addr_t * mp,
2447                                      void *handle)
2448 {
2449   u8 *s;
2450
2451   s = format (0, "SCRIPT: dslite_get_aftr_addr");
2452
2453   FINISH;
2454 }
2455
2456 static void
2457 vl_api_dslite_set_b4_addr_t_handler (vl_api_dslite_set_b4_addr_t * mp)
2458 {
2459   vl_api_dslite_set_b4_addr_reply_t *rmp;
2460   snat_main_t *sm = &snat_main;
2461   dslite_main_t *dm = &dslite_main;
2462   int rv = 0;
2463   ip6_address_t ip6_addr;
2464   ip4_address_t ip4_addr;
2465
2466   memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
2467   memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
2468
2469   rv = dslite_set_b4_ip6_addr (dm, &ip6_addr);
2470   if (rv == 0)
2471     rv = dslite_set_b4_ip4_addr (dm, &ip4_addr);
2472
2473   REPLY_MACRO (VL_API_DSLITE_SET_B4_ADDR_REPLY);
2474 }
2475
2476 static void *
2477 vl_api_dslite_set_b4_addr_t_print (vl_api_dslite_set_b4_addr_t * mp,
2478                                    void *handle)
2479 {
2480   u8 *s;
2481
2482   s = format (0, "SCRIPT: dslite_set_b4_addr ");
2483   s = format (s, "ip6_addr %U ip4_addr %U\n",
2484               format_ip6_address, mp->ip6_addr,
2485               format_ip6_address, mp->ip4_addr);
2486
2487   FINISH;
2488 }
2489
2490 static void
2491 vl_api_dslite_get_b4_addr_t_handler (vl_api_dslite_get_b4_addr_t * mp)
2492 {
2493   snat_main_t *sm = &snat_main;
2494   vl_api_dslite_get_b4_addr_reply_t *rmp;
2495   dslite_main_t *dm = &dslite_main;
2496   int rv = 0;
2497
2498   /* *INDENT-OFF* */
2499   REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
2500   ({
2501     memcpy (rmp->ip4_addr, &dm->b4_ip4_addr.as_u8, 4);
2502     memcpy (rmp->ip6_addr, &dm->b4_ip6_addr.as_u8, 16);
2503   }))
2504   /* *INDENT-ON* */
2505 }
2506
2507 static void *
2508 vl_api_dslite_get_b4_addr_t_print (vl_api_dslite_get_b4_addr_t * mp,
2509                                    void *handle)
2510 {
2511   u8 *s;
2512
2513   s = format (0, "SCRIPT: dslite_get_b4_addr");
2514
2515   FINISH;
2516 }
2517
2518 static void
2519   vl_api_dslite_add_del_pool_addr_range_t_handler
2520   (vl_api_dslite_add_del_pool_addr_range_t * mp)
2521 {
2522   vl_api_dslite_add_del_pool_addr_range_reply_t *rmp;
2523   snat_main_t *sm = &snat_main;
2524   dslite_main_t *dm = &dslite_main;
2525   int rv = 0;
2526   ip4_address_t this_addr;
2527   u32 start_host_order, end_host_order;
2528   int i, count;
2529   u32 *tmp;
2530
2531   tmp = (u32 *) mp->start_addr;
2532   start_host_order = clib_host_to_net_u32 (tmp[0]);
2533   tmp = (u32 *) mp->end_addr;
2534   end_host_order = clib_host_to_net_u32 (tmp[0]);
2535
2536   count = (end_host_order - start_host_order) + 1;
2537   memcpy (&this_addr.as_u8, mp->start_addr, 4);
2538
2539   for (i = 0; i < count; i++)
2540     {
2541       if ((rv = dslite_add_del_pool_addr (dm, &this_addr, mp->is_add)))
2542         goto send_reply;
2543
2544       increment_v4_address (&this_addr);
2545     }
2546
2547 send_reply:
2548   REPLY_MACRO (VL_API_DSLITE_ADD_DEL_POOL_ADDR_RANGE_REPLY);
2549 }
2550
2551 static void *vl_api_dslite_add_del_pool_addr_range_t_print
2552   (vl_api_dslite_add_del_pool_addr_range_t * mp, void *handle)
2553 {
2554   u8 *s;
2555
2556   s = format (0, "SCRIPT: dslite_add_del_pool_addr_range ");
2557   s = format (s, "%U - %U\n",
2558               format_ip4_address, mp->start_addr,
2559               format_ip4_address, mp->end_addr);
2560
2561   FINISH;
2562 }
2563
2564
2565 /* List of message types that this plugin understands */
2566 #define foreach_snat_plugin_api_msg                                     \
2567 _(NAT_CONTROL_PING, nat_control_ping)                                   \
2568 _(NAT_SHOW_CONFIG, nat_show_config)                                     \
2569 _(NAT_SET_WORKERS, nat_set_workers)                                     \
2570 _(NAT_WORKER_DUMP, nat_worker_dump)                                     \
2571 _(NAT_IPFIX_ENABLE_DISABLE, nat_ipfix_enable_disable)                   \
2572 _(NAT_SET_REASS, nat_set_reass)                                         \
2573 _(NAT_GET_REASS, nat_get_reass)                                         \
2574 _(NAT_REASS_DUMP, nat_reass_dump)                                       \
2575 _(NAT44_ADD_DEL_ADDRESS_RANGE, nat44_add_del_address_range)             \
2576 _(NAT44_INTERFACE_ADD_DEL_FEATURE, nat44_interface_add_del_feature)     \
2577 _(NAT44_ADD_DEL_STATIC_MAPPING, nat44_add_del_static_mapping)           \
2578 _(NAT44_ADD_DEL_IDENTITY_MAPPING, nat44_add_del_identity_mapping)       \
2579 _(NAT44_STATIC_MAPPING_DUMP, nat44_static_mapping_dump)                 \
2580 _(NAT44_IDENTITY_MAPPING_DUMP, nat44_identity_mapping_dump)             \
2581 _(NAT44_ADDRESS_DUMP, nat44_address_dump)                               \
2582 _(NAT44_INTERFACE_DUMP, nat44_interface_dump)                           \
2583 _(NAT44_ADD_DEL_INTERFACE_ADDR, nat44_add_del_interface_addr)           \
2584 _(NAT44_INTERFACE_ADDR_DUMP, nat44_interface_addr_dump)                 \
2585 _(NAT44_USER_DUMP, nat44_user_dump)                                     \
2586 _(NAT44_USER_SESSION_DUMP, nat44_user_session_dump)                     \
2587 _(NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE,                               \
2588   nat44_interface_add_del_output_feature)                               \
2589 _(NAT44_INTERFACE_OUTPUT_FEATURE_DUMP,                                  \
2590   nat44_interface_output_feature_dump)                                  \
2591 _(NAT44_ADD_DEL_LB_STATIC_MAPPING, nat44_add_del_lb_static_mapping)     \
2592 _(NAT44_LB_STATIC_MAPPING_DUMP, nat44_lb_static_mapping_dump)           \
2593 _(NAT44_DEL_SESSION, nat44_del_session)                                 \
2594 _(NAT44_FORWARDING_ENABLE_DISABLE, nat44_forwarding_enable_disable)     \
2595 _(NAT44_FORWARDING_IS_ENABLED, nat44_forwarding_is_enabled)             \
2596 _(NAT_DET_ADD_DEL_MAP, nat_det_add_del_map)                             \
2597 _(NAT_DET_FORWARD, nat_det_forward)                                     \
2598 _(NAT_DET_REVERSE, nat_det_reverse)                                     \
2599 _(NAT_DET_MAP_DUMP, nat_det_map_dump)                                   \
2600 _(NAT_DET_SET_TIMEOUTS, nat_det_set_timeouts)                           \
2601 _(NAT_DET_GET_TIMEOUTS, nat_det_get_timeouts)                           \
2602 _(NAT_DET_CLOSE_SESSION_OUT, nat_det_close_session_out)                 \
2603 _(NAT_DET_CLOSE_SESSION_IN, nat_det_close_session_in)                   \
2604 _(NAT_DET_SESSION_DUMP, nat_det_session_dump)                           \
2605 _(NAT64_ADD_DEL_POOL_ADDR_RANGE, nat64_add_del_pool_addr_range)         \
2606 _(NAT64_POOL_ADDR_DUMP, nat64_pool_addr_dump)                           \
2607 _(NAT64_ADD_DEL_INTERFACE, nat64_add_del_interface)                     \
2608 _(NAT64_INTERFACE_DUMP, nat64_interface_dump)                           \
2609 _(NAT64_ADD_DEL_STATIC_BIB, nat64_add_del_static_bib)                   \
2610 _(NAT64_BIB_DUMP, nat64_bib_dump)                                       \
2611 _(NAT64_SET_TIMEOUTS, nat64_set_timeouts)                               \
2612 _(NAT64_GET_TIMEOUTS, nat64_get_timeouts)                               \
2613 _(NAT64_ST_DUMP, nat64_st_dump)                                         \
2614 _(NAT64_ADD_DEL_PREFIX, nat64_add_del_prefix)                           \
2615 _(NAT64_PREFIX_DUMP, nat64_prefix_dump)                                 \
2616 _(NAT64_ADD_DEL_INTERFACE_ADDR, nat64_add_del_interface_addr)           \
2617 _(DSLITE_ADD_DEL_POOL_ADDR_RANGE, dslite_add_del_pool_addr_range)       \
2618 _(DSLITE_SET_AFTR_ADDR, dslite_set_aftr_addr)                           \
2619 _(DSLITE_GET_AFTR_ADDR, dslite_get_aftr_addr)                           \
2620 _(DSLITE_SET_B4_ADDR, dslite_set_b4_addr)                               \
2621 _(DSLITE_GET_B4_ADDR, dslite_get_b4_addr)
2622
2623 /* Set up the API message handling tables */
2624 static clib_error_t *
2625 snat_plugin_api_hookup (vlib_main_t * vm)
2626 {
2627   snat_main_t *sm __attribute__ ((unused)) = &snat_main;
2628 #define _(N,n)                                                  \
2629     vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base),     \
2630                            #n,                                  \
2631                            vl_api_##n##_t_handler,              \
2632                            vl_noop_handler,                     \
2633                            vl_api_##n##_t_endian,               \
2634                            vl_api_##n##_t_print,                \
2635                            sizeof(vl_api_##n##_t), 1);
2636   foreach_snat_plugin_api_msg;
2637 #undef _
2638
2639   return 0;
2640 }
2641
2642 #define vl_msg_name_crc_list
2643 #include <nat/nat_all_api_h.h>
2644 #undef vl_msg_name_crc_list
2645
2646 static void
2647 setup_message_id_table (snat_main_t * sm, api_main_t * am)
2648 {
2649 #define _(id,n,crc) \
2650   vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + sm->msg_id_base);
2651   foreach_vl_msg_name_crc_nat;
2652 #undef _
2653 }
2654
2655 static void
2656 plugin_custom_dump_configure (snat_main_t * sm)
2657 {
2658 #define _(n,f) sm->api_main->msg_print_handlers \
2659   [VL_API_##n + sm->msg_id_base]                \
2660     = (void *) vl_api_##f##_t_print;
2661   foreach_snat_plugin_api_msg;
2662 #undef _
2663 }
2664
2665 clib_error_t *
2666 snat_api_init (vlib_main_t * vm, snat_main_t * sm)
2667 {
2668   u8 *name;
2669   clib_error_t *error = 0;
2670
2671   name = format (0, "nat_%08x%c", api_version, 0);
2672
2673   /* Ask for a correctly-sized block of API message decode slots */
2674   sm->msg_id_base =
2675     vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE);
2676
2677   error = snat_plugin_api_hookup (vm);
2678
2679   /* Add our API messages to the global name_crc hash table */
2680   setup_message_id_table (sm, sm->api_main);
2681
2682   plugin_custom_dump_configure (sm);
2683
2684   vec_free (name);
2685
2686   return error;
2687 }
2688
2689 /*
2690  * fd.io coding-style-patch-verification: ON
2691  *
2692  * Local Variables:
2693  * eval: (c-set-style "gnu")
2694  * End:
2695  */