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/nat66.h>
  25 #include <nat/nat_inlines.h>
  26 #include <nat/nat44/inlines.h>
  27 #include <nat/nat_ha.h>
  28 #include <vlibapi/api.h>
  29 #include <vlibmemory/api.h>
  30
  31 #include <nat/nat_msg_enum.h>
  32 #include <vnet/fib/fib_table.h>
  33 #include <vnet/ip/ip_types_api.h>
  34
  35 #define vl_api_nat44_add_del_lb_static_mapping_t_endian vl_noop_handler
  36 #define vl_api_nat44_nat44_lb_static_mapping_details_t_endian vl_noop_handler
  37
  38 /* define message structures */
  39 #define vl_typedefs
  40 #include <nat/nat_all_api_h.h>
  41 #undef vl_typedefs
  42
  43 /* define generated endian-swappers */
  44 #define vl_endianfun
  45 #include <nat/nat_all_api_h.h>
  46 #undef vl_endianfun
  47
  48 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  49
  50 #define REPLY_MSG_ID_BASE sm->msg_id_base
  51 #include <vlibapi/api_helper_macros.h>
  52
  53 /* Get the API version number */
  54 #define vl_api_version(n,v) static u32 api_version=(v);
  55 #include <nat/nat_all_api_h.h>
  56 #undef vl_api_version
  57
  58 /* Macro to finish up custom dump fns */
  59 #define FINISH                                  \
  60     vec_add1 (s, 0);                            \
  61     vl_print (handle, (char *)s);               \
  62     vec_free (s);                               \
  63     return handle;
  64
  65 /******************************/
  66 /*** Common NAT plugin APIs ***/
  67 /******************************/
  68
  69 static void
  70 vl_api_nat_control_ping_t_handler (vl_api_nat_control_ping_t * mp)
  71 {
  72   vl_api_nat_control_ping_reply_t *rmp;
  73   snat_main_t *sm = &snat_main;
  74   int rv = 0;
  75
  76   /* *INDENT-OFF* */
  77   REPLY_MACRO2 (VL_API_NAT_CONTROL_PING_REPLY,
  78   ({
  79     rmp->vpe_pid = ntohl (getpid ());
  80   }));
  81   /* *INDENT-ON* */
  82 }
  83
  84 static void *
  85 vl_api_nat_control_ping_t_print (vl_api_nat_control_ping_t * mp, void *handle)
  86 {
  87   u8 *s;
  88
  89   s = format (0, "SCRIPT: nat_control_ping ");
  90
  91   FINISH;
  92 }
  93
  94 static void
  95 vl_api_nat_show_config_t_handler (vl_api_nat_show_config_t * mp)
  96 {
  97   vl_api_nat_show_config_reply_t *rmp;
  98   snat_main_t *sm = &snat_main;
  99   //dslite_main_t *dm = &dslite_main;
 100   nat64_main_t *n64m = &nat64_main;
 101   int rv = 0;
 102
 103   /* *INDENT-OFF* */
 104   REPLY_MACRO2 (VL_API_NAT_SHOW_CONFIG_REPLY,
 105   ({
 106     rmp->translation_buckets = htonl (sm->translation_buckets);
 107     rmp->translation_memory_size = htonl (sm->translation_memory_size);
 108     rmp->user_buckets = htonl (sm->user_buckets);
 109     rmp->user_memory_size = htonl (sm->user_memory_size);
 110     rmp->max_translations_per_user = htonl (sm->max_translations_per_user);
 111     rmp->outside_vrf_id = htonl (sm->outside_vrf_id);
 112     rmp->inside_vrf_id = htonl (sm->inside_vrf_id);
 113     rmp->static_mapping_only = sm->static_mapping_only;
 114     rmp->static_mapping_connection_tracking =
 115       sm->static_mapping_connection_tracking;
 116     rmp->deterministic = sm->deterministic;
 117     rmp->endpoint_dependent = sm->endpoint_dependent;
 118     rmp->out2in_dpo = sm->out2in_dpo;
 119     //rmp->dslite_ce = dm->is_ce;
 120     rmp->nat64_bib_buckets = n64m->bib_buckets;
 121     rmp->nat64_bib_memory_size = n64m->bib_memory_size;
 122     rmp->nat64_st_buckets = n64m->st_buckets;
 123     rmp->nat64_st_memory_size = n64m->st_memory_size;
 124   }));
 125   /* *INDENT-ON* */
 126 }
 127
 128 static void *
 129 vl_api_nat_show_config_t_print (vl_api_nat_show_config_t * mp, void *handle)
 130 {
 131   u8 *s;
 132
 133   s = format (0, "SCRIPT: nat_show_config ");
 134
 135   FINISH;
 136 }
 137
 138 static void
 139 vl_api_nat_set_workers_t_handler (vl_api_nat_set_workers_t * mp)
 140 {
 141   snat_main_t *sm = &snat_main;
 142   vl_api_nat_set_workers_reply_t *rmp;
 143   int rv = 0;
 144   uword *bitmap = 0;
 145   u64 mask;
 146
 147   if (sm->deterministic)
 148     {
 149       rv = VNET_API_ERROR_UNSUPPORTED;
 150       goto send_reply;
 151     }
 152
 153   mask = clib_net_to_host_u64 (mp->worker_mask);
 154
 155   if (sm->num_workers < 2)
 156     {
 157       rv = VNET_API_ERROR_FEATURE_DISABLED;
 158       goto send_reply;
 159     }
 160
 161   bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
 162   rv = snat_set_workers (bitmap);
 163   clib_bitmap_free (bitmap);
 164
 165 send_reply:
 166   REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
 167 }
 168
 169 static void *
 170 vl_api_nat_set_workers_t_print (vl_api_nat_set_workers_t * mp, void *handle)
 171 {
 172   u8 *s;
 173   uword *bitmap = 0;
 174   u8 first = 1;
 175   int i;
 176   u64 mask = clib_net_to_host_u64 (mp->worker_mask);
 177
 178   s = format (0, "SCRIPT: nat_set_workers ");
 179   bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
 180   /* *INDENT-OFF* */
 181   clib_bitmap_foreach (i, bitmap,
 182     ({
 183       if (first)
 184         s = format (s, "%d", i);
 185       else
 186         s = format (s, ",%d", i);
 187       first = 0;
 188     }));
 189   /* *INDENT-ON* */
 190   clib_bitmap_free (bitmap);
 191   FINISH;
 192 }
 193
 194 static void
 195 send_nat_worker_details (u32 worker_index, vl_api_registration_t * reg,
 196                          u32 context)
 197 {
 198   vl_api_nat_worker_details_t *rmp;
 199   snat_main_t *sm = &snat_main;
 200   vlib_worker_thread_t *w =
 201     vlib_worker_threads + worker_index + sm->first_worker_index;
 202
 203   rmp = vl_msg_api_alloc (sizeof (*rmp));
 204   clib_memset (rmp, 0, sizeof (*rmp));
 205   rmp->_vl_msg_id = ntohs (VL_API_NAT_WORKER_DETAILS + sm->msg_id_base);
 206   rmp->context = context;
 207   rmp->worker_index = htonl (worker_index);
 208   rmp->lcore_id = htonl (w->cpu_id);
 209   strncpy ((char *) rmp->name, (char *) w->name, ARRAY_LEN (rmp->name) - 1);
 210
 211   vl_api_send_msg (reg, (u8 *) rmp);
 212 }
 213
 214 static void
 215 vl_api_nat_worker_dump_t_handler (vl_api_nat_worker_dump_t * mp)
 216 {
 217   vl_api_registration_t *reg;
 218   snat_main_t *sm = &snat_main;
 219   u32 *worker_index;
 220
 221   if (sm->deterministic)
 222     return;
 223
 224   reg = vl_api_client_index_to_registration (mp->client_index);
 225   if (!reg)
 226     return;
 227
 228   /* *INDENT-OFF* */
 229   vec_foreach (worker_index, sm->workers)
 230     send_nat_worker_details(*worker_index, reg, mp->context);
 231   /* *INDENT-ON* */
 232 }
 233
 234 static void *
 235 vl_api_nat_worker_dump_t_print (vl_api_nat_worker_dump_t * mp, void *handle)
 236 {
 237   u8 *s;
 238
 239   s = format (0, "SCRIPT: nat_worker_dump ");
 240
 241   FINISH;
 242 }
 243
 244 static void
 245 vl_api_nat44_session_cleanup_t_handler (vl_api_nat44_session_cleanup_t * mp)
 246 {
 247   snat_main_t *sm = &snat_main;
 248   vl_api_nat44_session_cleanup_reply_t *rmp;
 249   int rv = 0;
 250
 251   nat44_force_session_cleanup ();
 252
 253   REPLY_MACRO (VL_API_NAT44_SESSION_CLEANUP_REPLY);
 254 }
 255
 256 static void *
 257 vl_api_nat44_session_cleanup_t_print (vl_api_nat44_session_cleanup_t * mp,
 258                                       void *handle)
 259 {
 260   u8 *s;
 261
 262   s = format (0, "SCRIPT: nat44_session_cleanup");
 263
 264   FINISH;
 265 }
 266
 267
 268 static void
 269 vl_api_nat_set_log_level_t_handler (vl_api_nat_set_log_level_t * mp)
 270 {
 271   snat_main_t *sm = &snat_main;
 272   vl_api_nat_set_log_level_reply_t *rmp;
 273   int rv = 0;
 274
 275   if (sm->log_level > NAT_LOG_DEBUG)
 276     rv = VNET_API_ERROR_UNSUPPORTED;
 277   else
 278     sm->log_level = mp->log_level;
 279
 280   REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
 281 }
 282
 283 static void *
 284 vl_api_nat_set_log_level_t_print (vl_api_nat_set_log_level_t *
 285                                   mp, void *handle)
 286 {
 287   u8 *s;
 288
 289   s = format (0, "SCRIPT: nat_set_log_level ");
 290   s = format (s, "log_level %d", mp->log_level);
 291
 292   FINISH;
 293 }
 294
 295 static void
 296 vl_api_nat_ipfix_enable_disable_t_handler (vl_api_nat_ipfix_enable_disable_t *
 297                                            mp)
 298 {
 299   snat_main_t *sm = &snat_main;
 300   vl_api_nat_ipfix_enable_disable_reply_t *rmp;
 301   int rv = 0;
 302
 303   rv = snat_ipfix_logging_enable_disable (mp->enable,
 304                                           clib_host_to_net_u32
 305                                           (mp->domain_id),
 306                                           clib_host_to_net_u16
 307                                           (mp->src_port));
 308
 309   REPLY_MACRO (VL_API_NAT_IPFIX_ENABLE_DISABLE_REPLY);
 310 }
 311
 312 static void *
 313 vl_api_nat_ipfix_enable_disable_t_print (vl_api_nat_ipfix_enable_disable_t *
 314                                          mp, void *handle)
 315 {
 316   u8 *s;
 317
 318   s = format (0, "SCRIPT: nat_ipfix_enable_disable ");
 319   if (mp->domain_id)
 320     s = format (s, "domain %d ", clib_net_to_host_u32 (mp->domain_id));
 321   if (mp->src_port)
 322     s = format (s, "src_port %d ", clib_net_to_host_u16 (mp->src_port));
 323   if (!mp->enable)
 324     s = format (s, "disable ");
 325
 326   FINISH;
 327 }
 328
 329 static void
 330 vl_api_nat_set_timeouts_t_handler (vl_api_nat_set_timeouts_t * mp)
 331 {
 332   snat_main_t *sm = &snat_main;
 333   vl_api_nat_set_timeouts_reply_t *rmp;
 334   int rv = 0;
 335
 336   sm->udp_timeout = ntohl (mp->udp);
 337   sm->tcp_established_timeout = ntohl (mp->tcp_established);
 338   sm->tcp_transitory_timeout = ntohl (mp->tcp_transitory);
 339   sm->icmp_timeout = ntohl (mp->icmp);
 340
 341   rv = nat64_set_icmp_timeout (ntohl (mp->icmp));
 342   if (rv)
 343     goto send_reply;
 344   rv = nat64_set_udp_timeout (ntohl (mp->udp));
 345   if (rv)
 346     goto send_reply;
 347   rv =
 348     nat64_set_tcp_timeouts (ntohl (mp->tcp_transitory),
 349                             ntohl (mp->tcp_established));
 350
 351 send_reply:
 352   REPLY_MACRO (VL_API_NAT_SET_TIMEOUTS_REPLY);
 353 }
 354
 355 static void *
 356 vl_api_nat_set_timeouts_t_print (vl_api_nat_set_timeouts_t * mp, void *handle)
 357 {
 358   u8 *s;
 359
 360   s = format (0, "SCRIPT: nat_set_timeouts ");
 361   s = format (s, "udp %d tcp_established %d tcp_transitory %d icmp %d\n",
 362               ntohl (mp->udp),
 363               ntohl (mp->tcp_established),
 364               ntohl (mp->tcp_transitory), ntohl (mp->icmp));
 365
 366   FINISH;
 367 }
 368
 369 static void
 370 vl_api_nat_get_timeouts_t_handler (vl_api_nat_get_timeouts_t * mp)
 371 {
 372   snat_main_t *sm = &snat_main;
 373   vl_api_nat_get_timeouts_reply_t *rmp;
 374   int rv = 0;
 375
 376   /* *INDENT-OFF* */
 377   REPLY_MACRO2 (VL_API_NAT_GET_TIMEOUTS_REPLY,
 378   ({
 379     rmp->udp = htonl (sm->udp_timeout);
 380     rmp->tcp_established = htonl (sm->tcp_established_timeout);
 381     rmp->tcp_transitory = htonl (sm->tcp_transitory_timeout);
 382     rmp->icmp = htonl (sm->icmp_timeout);
 383   }))
 384   /* *INDENT-ON* */
 385 }
 386
 387 static void *
 388 vl_api_nat_get_timeouts_t_print (vl_api_nat_get_timeouts_t * mp, void *handle)
 389 {
 390   u8 *s;
 391
 392   s = format (0, "SCRIPT: nat_get_timeouts");
 393
 394   FINISH;
 395 }
 396
 397 static void
 398   vl_api_nat_set_addr_and_port_alloc_alg_t_handler
 399   (vl_api_nat_set_addr_and_port_alloc_alg_t * mp)
 400 {
 401   snat_main_t *sm = &snat_main;
 402   vl_api_nat_set_addr_and_port_alloc_alg_reply_t *rmp;
 403   int rv = 0;
 404   u16 port_start, port_end;
 405
 406   if (sm->deterministic)
 407     {
 408       rv = VNET_API_ERROR_UNSUPPORTED;
 409       goto send_reply;
 410     }
 411
 412   switch (mp->alg)
 413     {
 414     case NAT_ADDR_AND_PORT_ALLOC_ALG_DEFAULT:
 415       nat_set_alloc_addr_and_port_default ();
 416       break;
 417     case NAT_ADDR_AND_PORT_ALLOC_ALG_MAPE:
 418       nat_set_alloc_addr_and_port_mape (ntohs (mp->psid), mp->psid_offset,
 419                                         mp->psid_length);
 420       break;
 421     case NAT_ADDR_AND_PORT_ALLOC_ALG_RANGE:
 422       port_start = ntohs (mp->start_port);
 423       port_end = ntohs (mp->end_port);
 424       if (port_end <= port_start)
 425         {
 426           rv = VNET_API_ERROR_INVALID_VALUE;
 427           goto send_reply;
 428         }
 429       nat_set_alloc_addr_and_port_range (port_start, port_end);
 430       break;
 431     default:
 432       rv = VNET_API_ERROR_INVALID_VALUE;
 433       break;
 434     }
 435
 436 send_reply:
 437   REPLY_MACRO (VL_API_NAT_SET_ADDR_AND_PORT_ALLOC_ALG_REPLY);
 438 }
 439
 440 static void *vl_api_nat_set_addr_and_port_alloc_alg_t_print
 441   (vl_api_nat_set_addr_and_port_alloc_alg_t * mp, void *handle)
 442 {
 443   u8 *s;
 444
 445   s = format (0, "SCRIPT: nat_set_addr_and_port_alloc_alg ");
 446   s = format (s, "alg %d psid_offset %d psid_length %d psid %d start_port %d "
 447               "end_port %d\n",
 448               ntohl (mp->alg), ntohl (mp->psid_offset),
 449               ntohl (mp->psid_length), ntohs (mp->psid),
 450               ntohs (mp->start_port), ntohs (mp->end_port));
 451
 452   FINISH;
 453 }
 454
 455 static void
 456   vl_api_nat_get_addr_and_port_alloc_alg_t_handler
 457   (vl_api_nat_get_addr_and_port_alloc_alg_t * mp)
 458 {
 459   snat_main_t *sm = &snat_main;
 460   vl_api_nat_get_addr_and_port_alloc_alg_reply_t *rmp;
 461   int rv = 0;
 462
 463   /* *INDENT-OFF* */
 464   REPLY_MACRO2 (VL_API_NAT_GET_ADDR_AND_PORT_ALLOC_ALG_REPLY,
 465   ({
 466     rmp->alg = sm->addr_and_port_alloc_alg;
 467     rmp->psid_offset = sm->psid_offset;
 468     rmp->psid_length = sm->psid_length;
 469     rmp->psid = htons (sm->psid);
 470     rmp->start_port = htons (sm->start_port);
 471     rmp->end_port = htons (sm->end_port);
 472   }))
 473   /* *INDENT-ON* */
 474 }
 475
 476 static void *vl_api_nat_get_addr_and_port_alloc_alg_t_print
 477   (vl_api_nat_get_addr_and_port_alloc_alg_t * mp, void *handle)
 478 {
 479   u8 *s;
 480
 481   s = format (0, "SCRIPT: nat_get_addr_and_port_alloc_alg");
 482
 483   FINISH;
 484 }
 485
 486 static void
 487 vl_api_nat_set_mss_clamping_t_handler (vl_api_nat_set_mss_clamping_t * mp)
 488 {
 489   snat_main_t *sm = &snat_main;
 490   vl_api_nat_set_mss_clamping_reply_t *rmp;
 491   int rv = 0;
 492
 493   if (mp->enable)
 494     {
 495       sm->mss_clamping = ntohs (mp->mss_value);
 496       sm->mss_value_net = mp->mss_value;
 497     }
 498   else
 499     sm->mss_clamping = 0;
 500
 501   REPLY_MACRO (VL_API_NAT_SET_MSS_CLAMPING_REPLY);
 502 }
 503
 504 static void *
 505 vl_api_nat_set_mss_clamping_t_print (vl_api_nat_set_mss_clamping_t * mp,
 506                                      void *handle)
 507 {
 508   u8 *s;
 509
 510   s = format (0, "SCRIPT: nat_set_mss_clamping enable %d mss_value %d\n",
 511               mp->enable, ntohs (mp->mss_value));
 512
 513   FINISH;
 514 }
 515
 516 static void
 517 vl_api_nat_get_mss_clamping_t_handler (vl_api_nat_get_mss_clamping_t * mp)
 518 {
 519   snat_main_t *sm = &snat_main;
 520   vl_api_nat_get_mss_clamping_reply_t *rmp;
 521   int rv = 0;
 522
 523   /* *INDENT-OFF* */
 524   REPLY_MACRO2 (VL_API_NAT_GET_MSS_CLAMPING_REPLY,
 525   ({
 526     rmp->enable = sm->mss_clamping ? 1 : 0;
 527     rmp->mss_value = htons (sm->mss_clamping);
 528   }))
 529   /* *INDENT-ON* */
 530 }
 531
 532 static void *
 533 vl_api_nat_get_mss_clamping_t_print (vl_api_nat_get_mss_clamping_t * mp,
 534                                      void *handle)
 535 {
 536   u8 *s;
 537
 538   s = format (0, "SCRIPT: nat_get_mss_clamping");
 539
 540   FINISH;
 541 }
 542
 543 static void
 544 vl_api_nat_ha_set_listener_t_handler (vl_api_nat_ha_set_listener_t * mp)
 545 {
 546   snat_main_t *sm = &snat_main;
 547   vl_api_nat_ha_set_listener_reply_t *rmp;
 548   ip4_address_t addr;
 549   int rv;
 550
 551   memcpy (&addr, &mp->ip_address, sizeof (addr));
 552   rv =
 553     nat_ha_set_listener (&addr, clib_net_to_host_u16 (mp->port),
 554                          clib_net_to_host_u32 (mp->path_mtu));
 555
 556   REPLY_MACRO (VL_API_NAT_HA_SET_LISTENER_REPLY);
 557 }
 558
 559 static void *
 560 vl_api_nat_ha_set_listener_t_print (vl_api_nat_ha_set_listener_t * mp,
 561                                     void *handle)
 562 {
 563   u8 *s;
 564
 565   s = format (0, "SCRIPT: nat_ha_set_listener ");
 566   s = format (s, "ip_address %U ", format_ip4_address, mp->ip_address);
 567   s = format (s, "port %d ", clib_net_to_host_u16 (mp->port));
 568   s = format (s, "path_mtu %d", clib_net_to_host_u32 (mp->path_mtu));
 569
 570   FINISH;
 571 }
 572
 573 static void
 574 vl_api_nat_ha_get_listener_t_handler (vl_api_nat_ha_get_listener_t * mp)
 575 {
 576   snat_main_t *sm = &snat_main;
 577   vl_api_nat_ha_get_listener_reply_t *rmp;
 578   int rv = 0;
 579   ip4_address_t addr;
 580   u16 port;
 581   u32 path_mtu;
 582
 583   nat_ha_get_listener (&addr, &port, &path_mtu);
 584
 585   /* *INDENT-OFF* */
 586   REPLY_MACRO2 (VL_API_NAT_HA_GET_LISTENER_REPLY,
 587   ({
 588     clib_memcpy (rmp->ip_address, &addr, sizeof (ip4_address_t));
 589     rmp->port = clib_host_to_net_u16 (port);
 590     rmp->path_mtu = clib_host_to_net_u32 (path_mtu);
 591   }))
 592   /* *INDENT-ON* */
 593 }
 594
 595 static void *
 596 vl_api_nat_ha_get_listener_t_print (vl_api_nat_ha_get_listener_t * mp,
 597                                     void *handle)
 598 {
 599   u8 *s;
 600
 601   s = format (0, "SCRIPT: nat_ha_get_listener");
 602
 603   FINISH;
 604 }
 605
 606 static void
 607 vl_api_nat_ha_set_failover_t_handler (vl_api_nat_ha_set_failover_t * mp)
 608 {
 609   snat_main_t *sm = &snat_main;
 610   vl_api_nat_ha_set_failover_reply_t *rmp;
 611   ip4_address_t addr;
 612   int rv;
 613
 614   memcpy (&addr, &mp->ip_address, sizeof (addr));
 615   rv =
 616     nat_ha_set_failover (&addr, clib_net_to_host_u16 (mp->port),
 617                          clib_net_to_host_u32 (mp->session_refresh_interval));
 618
 619   REPLY_MACRO (VL_API_NAT_HA_SET_FAILOVER_REPLY);
 620 }
 621
 622 static void *
 623 vl_api_nat_ha_set_failover_t_print (vl_api_nat_ha_set_failover_t * mp,
 624                                     void *handle)
 625 {
 626   u8 *s;
 627
 628   s = format (0, "SCRIPT: nat_ha_set_failover ");
 629   s = format (s, "ip_address %U ", format_ip4_address, mp->ip_address);
 630   s = format (s, "port %d ", clib_net_to_host_u16 (mp->port));
 631
 632   FINISH;
 633 }
 634
 635 static void
 636 vl_api_nat_ha_get_failover_t_handler (vl_api_nat_ha_get_failover_t * mp)
 637 {
 638   snat_main_t *sm = &snat_main;
 639   vl_api_nat_ha_get_failover_reply_t *rmp;
 640   int rv = 0;
 641   ip4_address_t addr;
 642   u16 port;
 643   u32 session_refresh_interval;
 644
 645   nat_ha_get_failover (&addr, &port, &session_refresh_interval);
 646
 647   /* *INDENT-OFF* */
 648   REPLY_MACRO2 (VL_API_NAT_HA_GET_FAILOVER_REPLY,
 649   ({
 650     clib_memcpy (rmp->ip_address, &addr, sizeof (ip4_address_t));
 651     rmp->port = clib_host_to_net_u16 (port);
 652     rmp->session_refresh_interval = clib_host_to_net_u32 (session_refresh_interval);
 653   }))
 654   /* *INDENT-ON* */
 655 }
 656
 657 static void *
 658 vl_api_nat_ha_get_failover_t_print (vl_api_nat_ha_get_failover_t * mp,
 659                                     void *handle)
 660 {
 661   u8 *s;
 662
 663   s = format (0, "SCRIPT: nat_ha_get_failover");
 664
 665   FINISH;
 666 }
 667
 668 static void
 669 vl_api_nat_ha_flush_t_handler (vl_api_nat_ha_flush_t * mp)
 670 {
 671   snat_main_t *sm = &snat_main;
 672   vl_api_nat_ha_flush_reply_t *rmp;
 673   int rv = 0;
 674
 675   nat_ha_flush (0);
 676
 677   REPLY_MACRO (VL_API_NAT_HA_FLUSH_REPLY);
 678 }
 679
 680 static void *
 681 vl_api_nat_ha_flush_t_print (vl_api_nat_ha_flush_t * mp, void *handle)
 682 {
 683   u8 *s;
 684
 685   s = format (0, "SCRIPT: nat_ha_flush ");
 686
 687   FINISH;
 688 }
 689
 690 static void
 691 nat_ha_resync_completed_event_cb (u32 client_index, u32 pid, u32 missed_count)
 692 {
 693   snat_main_t *sm = &snat_main;
 694   vl_api_registration_t *reg;
 695   vl_api_nat_ha_resync_completed_event_t *mp;
 696
 697   reg = vl_api_client_index_to_registration (client_index);
 698   if (!reg)
 699     return;
 700
 701   mp = vl_msg_api_alloc (sizeof (*mp));
 702   clib_memset (mp, 0, sizeof (*mp));
 703   mp->client_index = client_index;
 704   mp->pid = pid;
 705   mp->missed_count = clib_host_to_net_u32 (missed_count);
 706   mp->_vl_msg_id =
 707     ntohs (VL_API_NAT_HA_RESYNC_COMPLETED_EVENT + sm->msg_id_base);
 708
 709   vl_api_send_msg (reg, (u8 *) mp);
 710 }
 711
 712 static void
 713 vl_api_nat_ha_resync_t_handler (vl_api_nat_ha_resync_t * mp)
 714 {
 715   snat_main_t *sm = &snat_main;
 716   vl_api_nat_ha_resync_reply_t *rmp;
 717   int rv;
 718
 719   rv =
 720     nat_ha_resync (mp->client_index, mp->pid,
 721                    mp->want_resync_event ? nat_ha_resync_completed_event_cb :
 722                    NULL);
 723
 724   REPLY_MACRO (VL_API_NAT_HA_RESYNC_REPLY);
 725 }
 726
 727 static void *
 728 vl_api_nat_ha_resync_t_print (vl_api_nat_ha_resync_t * mp, void *handle)
 729 {
 730   u8 *s;
 731
 732   s = format (0, "SCRIPT: nat_ha_resync ");
 733   s =
 734     format (s, "want_resync_event %d pid %d", mp->want_resync_event,
 735             clib_host_to_net_u32 (mp->pid));
 736
 737   FINISH;
 738 }
 739
 740 /*************/
 741 /*** NAT44 ***/
 742 /*************/
 743 static void
 744   vl_api_nat44_add_del_address_range_t_handler
 745   (vl_api_nat44_add_del_address_range_t * mp)
 746 {
 747   snat_main_t *sm = &snat_main;
 748   vl_api_nat44_add_del_address_range_reply_t *rmp;
 749   ip4_address_t this_addr;
 750   u8 is_add, twice_nat;
 751   u32 start_host_order, end_host_order;
 752   u32 vrf_id;
 753   int i, count;
 754   int rv = 0;
 755   u32 *tmp;
 756
 757   if (sm->deterministic)
 758     {
 759       rv = VNET_API_ERROR_UNSUPPORTED;
 760       goto send_reply;
 761     }
 762
 763   if (sm->static_mapping_only)
 764     {
 765       rv = VNET_API_ERROR_FEATURE_DISABLED;
 766       goto send_reply;
 767     }
 768
 769   is_add = mp->is_add;
 770   twice_nat = mp->flags & NAT_API_IS_TWICE_NAT;
 771
 772   tmp = (u32 *) mp->first_ip_address;
 773   start_host_order = clib_host_to_net_u32 (tmp[0]);
 774   tmp = (u32 *) mp->last_ip_address;
 775   end_host_order = clib_host_to_net_u32 (tmp[0]);
 776
 777   count = (end_host_order - start_host_order) + 1;
 778
 779   vrf_id = clib_host_to_net_u32 (mp->vrf_id);
 780
 781   if (count > 1024)
 782     nat_log_info ("%U - %U, %d addresses...",
 783                   format_ip4_address, mp->first_ip_address,
 784                   format_ip4_address, mp->last_ip_address, count);
 785
 786   memcpy (&this_addr.as_u8, mp->first_ip_address, 4);
 787
 788   for (i = 0; i < count; i++)
 789     {
 790       if (is_add)
 791         rv = snat_add_address (sm, &this_addr, vrf_id, twice_nat);
 792       else
 793         rv = snat_del_address (sm, this_addr, 0, twice_nat);
 794
 795       if (rv)
 796         goto send_reply;
 797
 798       if (sm->out2in_dpo)
 799         nat44_add_del_address_dpo (this_addr, is_add);
 800
 801       increment_v4_address (&this_addr);
 802     }
 803
 804 send_reply:
 805   REPLY_MACRO (VL_API_NAT44_ADD_DEL_ADDRESS_RANGE_REPLY);
 806 }
 807
 808 static void *vl_api_nat44_add_del_address_range_t_print
 809   (vl_api_nat44_add_del_address_range_t * mp, void *handle)
 810 {
 811   u8 *s;
 812
 813   s = format (0, "SCRIPT: nat44_add_address_range ");
 814   s = format (s, "%U ", format_ip4_address, mp->first_ip_address);
 815   if (memcmp (mp->first_ip_address, mp->last_ip_address, 4))
 816     {
 817       s = format (s, " - %U ", format_ip4_address, mp->last_ip_address);
 818     }
 819   s = format (s, "twice_nat %d ", mp->flags & NAT_API_IS_TWICE_NAT);
 820   FINISH;
 821 }
 822
 823 static void
 824 send_nat44_address_details (snat_address_t * a,
 825                             vl_api_registration_t * reg, u32 context,
 826                             u8 twice_nat)
 827 {
 828   vl_api_nat44_address_details_t *rmp;
 829   snat_main_t *sm = &snat_main;
 830
 831   rmp = vl_msg_api_alloc (sizeof (*rmp));
 832   clib_memset (rmp, 0, sizeof (*rmp));
 833   rmp->_vl_msg_id = ntohs (VL_API_NAT44_ADDRESS_DETAILS + sm->msg_id_base);
 834   clib_memcpy (rmp->ip_address, &(a->addr), 4);
 835   if (a->fib_index != ~0)
 836     {
 837       fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP4);
 838       rmp->vrf_id = ntohl (fib->ft_table_id);
 839     }
 840   else
 841     rmp->vrf_id = ~0;
 842   if (twice_nat)
 843     rmp->flags |= NAT_API_IS_TWICE_NAT;
 844   rmp->context = context;
 845
 846   vl_api_send_msg (reg, (u8 *) rmp);
 847 }
 848
 849 static void
 850 vl_api_nat44_address_dump_t_handler (vl_api_nat44_address_dump_t * mp)
 851 {
 852   vl_api_registration_t *reg;
 853   snat_main_t *sm = &snat_main;
 854   snat_address_t *a;
 855
 856   if (sm->deterministic)
 857     return;
 858
 859   reg = vl_api_client_index_to_registration (mp->client_index);
 860   if (!reg)
 861     return;
 862
 863   /* *INDENT-OFF* */
 864   vec_foreach (a, sm->addresses)
 865     send_nat44_address_details (a, reg, mp->context, 0);
 866   vec_foreach (a, sm->twice_nat_addresses)
 867     send_nat44_address_details (a, reg, mp->context, 1);
 868   /* *INDENT-ON* */
 869 }
 870
 871 static void *
 872 vl_api_nat44_address_dump_t_print (vl_api_nat44_address_dump_t * mp,
 873                                    void *handle)
 874 {
 875   u8 *s;
 876
 877   s = format (0, "SCRIPT: nat44_address_dump ");
 878
 879   FINISH;
 880 }
 881
 882 static void
 883   vl_api_nat44_interface_add_del_feature_t_handler
 884   (vl_api_nat44_interface_add_del_feature_t * mp)
 885 {
 886   snat_main_t *sm = &snat_main;
 887   vl_api_nat44_interface_add_del_feature_reply_t *rmp;
 888   u32 sw_if_index = ntohl (mp->sw_if_index);
 889   u8 is_del;
 890   int rv = 0;
 891
 892   is_del = !mp->is_add;
 893
 894   VALIDATE_SW_IF_INDEX (mp);
 895
 896   rv =
 897     snat_interface_add_del (sw_if_index, mp->flags & NAT_API_IS_INSIDE,
 898                             is_del);
 899
 900   BAD_SW_IF_INDEX_LABEL;
 901
 902   REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_FEATURE_REPLY);
 903 }
 904
 905 static void *vl_api_nat44_interface_add_del_feature_t_print
 906   (vl_api_nat44_interface_add_del_feature_t * mp, void *handle)
 907 {
 908   u8 *s;
 909
 910   s = format (0, "SCRIPT: nat44_interface_add_del_feature ");
 911   s = format (s, "sw_if_index %d %s %s",
 912               clib_host_to_net_u32 (mp->sw_if_index),
 913               mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
 914               mp->is_add ? "" : "del");
 915
 916   FINISH;
 917 }
 918
 919 static void
 920 send_nat44_interface_details (snat_interface_t * i,
 921                               vl_api_registration_t * reg, u32 context)
 922 {
 923   vl_api_nat44_interface_details_t *rmp;
 924   snat_main_t *sm = &snat_main;
 925
 926   rmp = vl_msg_api_alloc (sizeof (*rmp));
 927   clib_memset (rmp, 0, sizeof (*rmp));
 928   rmp->_vl_msg_id = ntohs (VL_API_NAT44_INTERFACE_DETAILS + sm->msg_id_base);
 929   rmp->sw_if_index = ntohl (i->sw_if_index);
 930
 931   if (nat_interface_is_inside (i))
 932     rmp->flags |= NAT_API_IS_INSIDE;
 933   if (nat_interface_is_outside (i))
 934     rmp->flags |= NAT_API_IS_OUTSIDE;
 935
 936   rmp->context = context;
 937
 938   vl_api_send_msg (reg, (u8 *) rmp);
 939 }
 940
 941 static void
 942 vl_api_nat44_interface_dump_t_handler (vl_api_nat44_interface_dump_t * mp)
 943 {
 944   vl_api_registration_t *reg;
 945   snat_main_t *sm = &snat_main;
 946   snat_interface_t *i;
 947
 948   reg = vl_api_client_index_to_registration (mp->client_index);
 949   if (!reg)
 950     return;
 951
 952   /* *INDENT-OFF* */
 953   pool_foreach (i, sm->interfaces,
 954   ({
 955     send_nat44_interface_details(i, reg, mp->context);
 956   }));
 957   /* *INDENT-ON* */
 958 }
 959
 960 static void *
 961 vl_api_nat44_interface_dump_t_print (vl_api_nat44_interface_dump_t * mp,
 962                                      void *handle)
 963 {
 964   u8 *s;
 965
 966   s = format (0, "SCRIPT: nat44_interface_dump ");
 967
 968   FINISH;
 969 }
 970
 971 static void
 972   vl_api_nat44_interface_add_del_output_feature_t_handler
 973   (vl_api_nat44_interface_add_del_output_feature_t * mp)
 974 {
 975   snat_main_t *sm = &snat_main;
 976   vl_api_nat44_interface_add_del_output_feature_reply_t *rmp;
 977   u32 sw_if_index = ntohl (mp->sw_if_index);
 978   int rv = 0;
 979
 980   if (sm->deterministic)
 981     {
 982       rv = VNET_API_ERROR_UNSUPPORTED;
 983       goto send_reply;
 984     }
 985
 986   VALIDATE_SW_IF_INDEX (mp);
 987
 988   rv = snat_interface_add_del_output_feature (sw_if_index,
 989                                               mp->flags & NAT_API_IS_INSIDE,
 990                                               !mp->is_add);
 991
 992   BAD_SW_IF_INDEX_LABEL;
 993 send_reply:
 994   REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE_REPLY);
 995 }
 996
 997 static void *vl_api_nat44_interface_add_del_output_feature_t_print
 998   (vl_api_nat44_interface_add_del_output_feature_t * mp, void *handle)
 999 {
1000   u8 *s;
1001
1002   s = format (0, "SCRIPT: nat44_interface_add_del_output_feature ");
1003   s = format (s, "sw_if_index %d %s %s",
1004               clib_host_to_net_u32 (mp->sw_if_index),
1005               mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
1006               mp->is_add ? "" : "del");
1007
1008   FINISH;
1009 }
1010
1011 static void
1012 send_nat44_interface_output_feature_details (snat_interface_t * i,
1013                                              vl_api_registration_t * reg,
1014                                              u32 context)
1015 {
1016   vl_api_nat44_interface_output_feature_details_t *rmp;
1017   snat_main_t *sm = &snat_main;
1018
1019   rmp = vl_msg_api_alloc (sizeof (*rmp));
1020   clib_memset (rmp, 0, sizeof (*rmp));
1021   rmp->_vl_msg_id =
1022     ntohs (VL_API_NAT44_INTERFACE_OUTPUT_FEATURE_DETAILS + sm->msg_id_base);
1023   rmp->sw_if_index = ntohl (i->sw_if_index);
1024   rmp->context = context;
1025
1026   if (nat_interface_is_inside (i))
1027     rmp->flags |= NAT_API_IS_INSIDE;
1028
1029   vl_api_send_msg (reg, (u8 *) rmp);
1030 }
1031
1032 static void
1033   vl_api_nat44_interface_output_feature_dump_t_handler
1034   (vl_api_nat44_interface_output_feature_dump_t * mp)
1035 {
1036   vl_api_registration_t *reg;
1037   snat_main_t *sm = &snat_main;
1038   snat_interface_t *i;
1039
1040   if (sm->deterministic)
1041     return;
1042
1043   reg = vl_api_client_index_to_registration (mp->client_index);
1044   if (!reg)
1045     return;
1046
1047   /* *INDENT-OFF* */
1048   pool_foreach (i, sm->output_feature_interfaces,
1049   ({
1050     send_nat44_interface_output_feature_details(i, reg, mp->context);
1051   }));
1052   /* *INDENT-ON* */
1053 }
1054
1055 static void *vl_api_nat44_interface_output_feature_dump_t_print
1056   (vl_api_nat44_interface_output_feature_dump_t * mp, void *handle)
1057 {
1058   u8 *s;
1059
1060   s = format (0, "SCRIPT: nat44_interface_output_feature_dump ");
1061
1062   FINISH;
1063 }
1064
1065 static void
1066   vl_api_nat44_add_del_static_mapping_t_handler
1067   (vl_api_nat44_add_del_static_mapping_t * mp)
1068 {
1069   snat_main_t *sm = &snat_main;
1070   vl_api_nat44_add_del_static_mapping_reply_t *rmp;
1071   ip4_address_t local_addr, external_addr;
1072   u16 local_port = 0, external_port = 0;
1073   u32 vrf_id, external_sw_if_index;
1074   twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1075   int rv = 0;
1076   snat_protocol_t proto;
1077   u8 *tag = 0;
1078
1079   if (sm->deterministic)
1080     {
1081       rv = VNET_API_ERROR_UNSUPPORTED;
1082       goto send_reply;
1083     }
1084
1085   memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
1086   memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
1087
1088   if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1089     {
1090       local_port = clib_net_to_host_u16 (mp->local_port);
1091       external_port = clib_net_to_host_u16 (mp->external_port);
1092     }
1093
1094   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1095   external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
1096   proto = ip_proto_to_snat_proto (mp->protocol);
1097
1098   if (mp->flags & NAT_API_IS_TWICE_NAT)
1099     twice_nat = TWICE_NAT;
1100   else if (mp->flags & NAT_API_IS_SELF_TWICE_NAT)
1101     twice_nat = TWICE_NAT_SELF;
1102   mp->tag[sizeof (mp->tag) - 1] = 0;
1103   tag = format (0, "%s", mp->tag);
1104   vec_terminate_c_string (tag);
1105
1106   rv = snat_add_static_mapping (local_addr, external_addr, local_port,
1107                                 external_port, vrf_id,
1108                                 mp->flags & NAT_API_IS_ADDR_ONLY,
1109                                 external_sw_if_index, proto,
1110                                 mp->is_add, twice_nat,
1111                                 mp->flags & NAT_API_IS_OUT2IN_ONLY, tag, 0);
1112   vec_free (tag);
1113
1114 send_reply:
1115   REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_REPLY);
1116 }
1117
1118 static void *vl_api_nat44_add_del_static_mapping_t_print
1119   (vl_api_nat44_add_del_static_mapping_t * mp, void *handle)
1120 {
1121   u8 *s;
1122
1123   s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
1124   s = format (s, "protocol %d local_addr %U external_addr %U ",
1125               mp->protocol,
1126               format_ip4_address, mp->local_ip_address,
1127               format_ip4_address, mp->external_ip_address);
1128
1129   if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1130     s = format (s, "local_port %d external_port %d ",
1131                 clib_net_to_host_u16 (mp->local_port),
1132                 clib_net_to_host_u16 (mp->external_port));
1133
1134   s = format (s, "twice_nat %d out2in_only %d ",
1135               mp->flags & NAT_API_IS_TWICE_NAT,
1136               mp->flags & NAT_API_IS_OUT2IN_ONLY);
1137
1138   if (mp->vrf_id != ~0)
1139     s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
1140
1141   if (mp->external_sw_if_index != ~0)
1142     s = format (s, "external_sw_if_index %d",
1143                 clib_net_to_host_u32 (mp->external_sw_if_index));
1144   FINISH;
1145 }
1146
1147 static void
1148 send_nat44_static_mapping_details (snat_static_mapping_t * m,
1149                                    vl_api_registration_t * reg, u32 context)
1150 {
1151   vl_api_nat44_static_mapping_details_t *rmp;
1152   snat_main_t *sm = &snat_main;
1153   u32 len = sizeof (*rmp);
1154
1155   rmp = vl_msg_api_alloc (len);
1156   clib_memset (rmp, 0, len);
1157   rmp->_vl_msg_id =
1158     ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1159
1160   clib_memcpy (rmp->local_ip_address, &(m->local_addr), 4);
1161   clib_memcpy (rmp->external_ip_address, &(m->external_addr), 4);
1162   rmp->external_sw_if_index = ~0;
1163   rmp->vrf_id = htonl (m->vrf_id);
1164   rmp->context = context;
1165
1166   if (m->twice_nat == TWICE_NAT)
1167     rmp->flags |= NAT_API_IS_TWICE_NAT;
1168   else if (m->twice_nat == TWICE_NAT_SELF)
1169     rmp->flags |= NAT_API_IS_SELF_TWICE_NAT;
1170
1171   if (is_out2in_only_static_mapping (m))
1172     rmp->flags |= NAT_API_IS_OUT2IN_ONLY;
1173
1174   if (is_addr_only_static_mapping (m))
1175     {
1176       rmp->flags |= NAT_API_IS_ADDR_ONLY;
1177     }
1178   else
1179     {
1180       rmp->protocol = snat_proto_to_ip_proto (m->proto);
1181       rmp->external_port = htons (m->external_port);
1182       rmp->local_port = htons (m->local_port);
1183     }
1184
1185   if (m->tag)
1186     strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1187
1188   vl_api_send_msg (reg, (u8 *) rmp);
1189 }
1190
1191 static void
1192 send_nat44_static_map_resolve_details (snat_static_map_resolve_t * m,
1193                                        vl_api_registration_t * reg,
1194                                        u32 context)
1195 {
1196   vl_api_nat44_static_mapping_details_t *rmp;
1197   snat_main_t *sm = &snat_main;
1198
1199   rmp = vl_msg_api_alloc (sizeof (*rmp));
1200   clib_memset (rmp, 0, sizeof (*rmp));
1201   rmp->_vl_msg_id =
1202     ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1203   clib_memcpy (rmp->local_ip_address, &(m->l_addr), 4);
1204   rmp->external_sw_if_index = htonl (m->sw_if_index);
1205   rmp->vrf_id = htonl (m->vrf_id);
1206   rmp->context = context;
1207
1208   if (m->twice_nat)
1209     rmp->flags |= NAT_API_IS_TWICE_NAT;
1210
1211   if (m->addr_only)
1212     {
1213       rmp->flags |= NAT_API_IS_ADDR_ONLY;
1214     }
1215   else
1216     {
1217       rmp->protocol = snat_proto_to_ip_proto (m->proto);
1218       rmp->external_port = htons (m->e_port);
1219       rmp->local_port = htons (m->l_port);
1220     }
1221   if (m->tag)
1222     strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1223
1224   vl_api_send_msg (reg, (u8 *) rmp);
1225 }
1226
1227 static void
1228 vl_api_nat44_static_mapping_dump_t_handler (vl_api_nat44_static_mapping_dump_t
1229                                             * mp)
1230 {
1231   vl_api_registration_t *reg;
1232   snat_main_t *sm = &snat_main;
1233   snat_static_mapping_t *m;
1234   snat_static_map_resolve_t *rp;
1235   int j;
1236
1237   if (sm->deterministic)
1238     return;
1239
1240   reg = vl_api_client_index_to_registration (mp->client_index);
1241   if (!reg)
1242     return;
1243
1244   /* *INDENT-OFF* */
1245   pool_foreach (m, sm->static_mappings,
1246   ({
1247       if (!is_identity_static_mapping(m) && !is_lb_static_mapping (m))
1248         send_nat44_static_mapping_details (m, reg, mp->context);
1249   }));
1250   /* *INDENT-ON* */
1251
1252   for (j = 0; j < vec_len (sm->to_resolve); j++)
1253     {
1254       rp = sm->to_resolve + j;
1255       if (!rp->identity_nat)
1256         send_nat44_static_map_resolve_details (rp, reg, mp->context);
1257     }
1258 }
1259
1260 static void *
1261 vl_api_nat44_static_mapping_dump_t_print (vl_api_nat44_static_mapping_dump_t *
1262                                           mp, void *handle)
1263 {
1264   u8 *s;
1265
1266   s = format (0, "SCRIPT: nat44_static_mapping_dump ");
1267
1268   FINISH;
1269 }
1270
1271 static void
1272   vl_api_nat44_add_del_identity_mapping_t_handler
1273   (vl_api_nat44_add_del_identity_mapping_t * mp)
1274 {
1275   snat_main_t *sm = &snat_main;
1276   vl_api_nat44_add_del_identity_mapping_reply_t *rmp;
1277   ip4_address_t addr;
1278   u16 port = 0;
1279   u32 vrf_id, sw_if_index;
1280   int rv = 0;
1281   snat_protocol_t proto = ~0;
1282   u8 *tag = 0;
1283
1284   if (sm->deterministic)
1285     {
1286       rv = VNET_API_ERROR_UNSUPPORTED;
1287       goto send_reply;
1288     }
1289
1290   if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1291     {
1292       port = clib_net_to_host_u16 (mp->port);
1293       proto = ip_proto_to_snat_proto (mp->protocol);
1294     }
1295   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1296   sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
1297   if (sw_if_index != ~0)
1298     addr.as_u32 = 0;
1299   else
1300     memcpy (&addr.as_u8, mp->ip_address, 4);
1301   mp->tag[sizeof (mp->tag) - 1] = 0;
1302   tag = format (0, "%s", mp->tag);
1303   vec_terminate_c_string (tag);
1304
1305   rv =
1306     snat_add_static_mapping (addr, addr, port, port, vrf_id,
1307                              mp->flags & NAT_API_IS_ADDR_ONLY, sw_if_index,
1308                              proto, mp->is_add, 0, 0, tag, 1);
1309   vec_free (tag);
1310
1311 send_reply:
1312   REPLY_MACRO (VL_API_NAT44_ADD_DEL_IDENTITY_MAPPING_REPLY);
1313 }
1314
1315 static void *vl_api_nat44_add_del_identity_mapping_t_print
1316   (vl_api_nat44_add_del_identity_mapping_t * mp, void *handle)
1317 {
1318   u8 *s;
1319
1320   s = format (0, "SCRIPT: nat44_add_del_identity_mapping ");
1321   if (mp->sw_if_index != ~0)
1322     s = format (s, "sw_if_index %d", clib_net_to_host_u32 (mp->sw_if_index));
1323   else
1324     s = format (s, "addr %U", format_ip4_address, mp->ip_address);
1325
1326   if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1327     s =
1328       format (s, " protocol %d port %d", mp->protocol,
1329               clib_net_to_host_u16 (mp->port));
1330
1331   if (mp->vrf_id != ~0)
1332     s = format (s, " vrf %d", clib_net_to_host_u32 (mp->vrf_id));
1333
1334   FINISH;
1335 }
1336
1337 static void
1338 send_nat44_identity_mapping_details (snat_static_mapping_t * m, int index,
1339                                      vl_api_registration_t * reg, u32 context)
1340 {
1341   vl_api_nat44_identity_mapping_details_t *rmp;
1342   snat_main_t *sm = &snat_main;
1343   nat44_lb_addr_port_t *local = pool_elt_at_index (m->locals, index);
1344
1345   rmp = vl_msg_api_alloc (sizeof (*rmp));
1346   clib_memset (rmp, 0, sizeof (*rmp));
1347   rmp->_vl_msg_id =
1348     ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
1349
1350   if (is_addr_only_static_mapping (m))
1351     rmp->flags |= NAT_API_IS_ADDR_ONLY;
1352
1353   clib_memcpy (rmp->ip_address, &(m->local_addr), 4);
1354   rmp->port = htons (m->local_port);
1355   rmp->sw_if_index = ~0;
1356   rmp->vrf_id = htonl (local->vrf_id);
1357   rmp->protocol = snat_proto_to_ip_proto (m->proto);
1358   rmp->context = context;
1359   if (m->tag)
1360     strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1361
1362   vl_api_send_msg (reg, (u8 *) rmp);
1363 }
1364
1365 static void
1366 send_nat44_identity_map_resolve_details (snat_static_map_resolve_t * m,
1367                                          vl_api_registration_t * reg,
1368                                          u32 context)
1369 {
1370   vl_api_nat44_identity_mapping_details_t *rmp;
1371   snat_main_t *sm = &snat_main;
1372
1373   rmp = vl_msg_api_alloc (sizeof (*rmp));
1374   clib_memset (rmp, 0, sizeof (*rmp));
1375   rmp->_vl_msg_id =
1376     ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
1377
1378   if (m->addr_only)
1379     rmp->flags = (vl_api_nat_config_flags_t) NAT_API_IS_ADDR_ONLY;
1380
1381   rmp->port = htons (m->l_port);
1382   rmp->sw_if_index = htonl (m->sw_if_index);
1383   rmp->vrf_id = htonl (m->vrf_id);
1384   rmp->protocol = snat_proto_to_ip_proto (m->proto);
1385   rmp->context = context;
1386   if (m->tag)
1387     strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1388
1389   vl_api_send_msg (reg, (u8 *) rmp);
1390 }
1391
1392 static void
1393   vl_api_nat44_identity_mapping_dump_t_handler
1394   (vl_api_nat44_identity_mapping_dump_t * mp)
1395 {
1396   vl_api_registration_t *reg;
1397   snat_main_t *sm = &snat_main;
1398   snat_static_mapping_t *m;
1399   snat_static_map_resolve_t *rp;
1400   int j;
1401
1402   if (sm->deterministic)
1403     return;
1404
1405   reg = vl_api_client_index_to_registration (mp->client_index);
1406   if (!reg)
1407     return;
1408
1409   /* *INDENT-OFF* */
1410   pool_foreach (m, sm->static_mappings,
1411   ({
1412       if (is_identity_static_mapping(m) && !is_lb_static_mapping (m))
1413         {
1414           pool_foreach_index (j, m->locals,
1415           ({
1416             send_nat44_identity_mapping_details (m, j, reg, mp->context);
1417           }));
1418         }
1419   }));
1420   /* *INDENT-ON* */
1421
1422   for (j = 0; j < vec_len (sm->to_resolve); j++)
1423     {
1424       rp = sm->to_resolve + j;
1425       if (rp->identity_nat)
1426         send_nat44_identity_map_resolve_details (rp, reg, mp->context);
1427     }
1428 }
1429
1430 static void *vl_api_nat44_identity_mapping_dump_t_print
1431   (vl_api_nat44_identity_mapping_dump_t * mp, void *handle)
1432 {
1433   u8 *s;
1434
1435   s = format (0, "SCRIPT: nat44_identity_mapping_dump ");
1436
1437   FINISH;
1438 }
1439
1440 static void
1441   vl_api_nat44_add_del_interface_addr_t_handler
1442   (vl_api_nat44_add_del_interface_addr_t * mp)
1443 {
1444   snat_main_t *sm = &snat_main;
1445   vl_api_nat44_add_del_interface_addr_reply_t *rmp;
1446   u32 sw_if_index = ntohl (mp->sw_if_index);
1447   int rv = 0;
1448   u8 is_del;
1449
1450   if (sm->deterministic)
1451     {
1452       rv = VNET_API_ERROR_UNSUPPORTED;
1453       goto send_reply;
1454     }
1455
1456   is_del = !mp->is_add;
1457
1458   VALIDATE_SW_IF_INDEX (mp);
1459
1460   rv = snat_add_interface_address (sm, sw_if_index, is_del,
1461                                    mp->flags & NAT_API_IS_TWICE_NAT);
1462
1463   BAD_SW_IF_INDEX_LABEL;
1464 send_reply:
1465   REPLY_MACRO (VL_API_NAT44_ADD_DEL_INTERFACE_ADDR_REPLY);
1466 }
1467
1468 static void *vl_api_nat44_add_del_interface_addr_t_print
1469   (vl_api_nat44_add_del_interface_addr_t * mp, void *handle)
1470 {
1471   u8 *s;
1472
1473   s = format (0, "SCRIPT: nat44_add_del_interface_addr ");
1474   s = format (s, "sw_if_index %d twice_nat %d %s",
1475               clib_host_to_net_u32 (mp->sw_if_index),
1476               mp->flags & NAT_API_IS_TWICE_NAT, mp->is_add ? "" : "del");
1477
1478   FINISH;
1479 }
1480
1481 static void
1482 send_nat44_interface_addr_details (u32 sw_if_index,
1483                                    vl_api_registration_t * reg, u32 context,
1484                                    u8 twice_nat)
1485 {
1486   vl_api_nat44_interface_addr_details_t *rmp;
1487   snat_main_t *sm = &snat_main;
1488
1489   rmp = vl_msg_api_alloc (sizeof (*rmp));
1490   clib_memset (rmp, 0, sizeof (*rmp));
1491   rmp->_vl_msg_id =
1492     ntohs (VL_API_NAT44_INTERFACE_ADDR_DETAILS + sm->msg_id_base);
1493   rmp->sw_if_index = ntohl (sw_if_index);
1494
1495   if (twice_nat)
1496     rmp->flags = (vl_api_nat_config_flags_t) NAT_API_IS_TWICE_NAT;
1497   rmp->context = context;
1498
1499   vl_api_send_msg (reg, (u8 *) rmp);
1500 }
1501
1502 static void
1503 vl_api_nat44_interface_addr_dump_t_handler (vl_api_nat44_interface_addr_dump_t
1504                                             * mp)
1505 {
1506   vl_api_registration_t *reg;
1507   snat_main_t *sm = &snat_main;
1508   u32 *i;
1509
1510   if (sm->deterministic)
1511     return;
1512
1513   reg = vl_api_client_index_to_registration (mp->client_index);
1514   if (!reg)
1515     return;
1516
1517   /* *INDENT-OFF* */
1518   vec_foreach (i, sm->auto_add_sw_if_indices)
1519     send_nat44_interface_addr_details(*i, reg, mp->context, 0);
1520   vec_foreach (i, sm->auto_add_sw_if_indices_twice_nat)
1521     send_nat44_interface_addr_details(*i, reg, mp->context, 1);
1522   /* *INDENT-ON* */
1523 }
1524
1525 static void *
1526 vl_api_nat44_interface_addr_dump_t_print (vl_api_nat44_interface_addr_dump_t *
1527                                           mp, void *handle)
1528 {
1529   u8 *s;
1530
1531   s = format (0, "SCRIPT: nat44_interface_addr_dump ");
1532
1533   FINISH;
1534 }
1535
1536 static void
1537 send_nat44_user_details (snat_user_t * u, vl_api_registration_t * reg,
1538                          u32 context)
1539 {
1540   vl_api_nat44_user_details_t *rmp;
1541   snat_main_t *sm = &snat_main;
1542   ip4_main_t *im = &ip4_main;
1543
1544   rmp = vl_msg_api_alloc (sizeof (*rmp));
1545   clib_memset (rmp, 0, sizeof (*rmp));
1546   rmp->_vl_msg_id = ntohs (VL_API_NAT44_USER_DETAILS + sm->msg_id_base);
1547
1548   if (!pool_is_free_index (im->fibs, u->fib_index))
1549     {
1550       fib_table_t *fib = fib_table_get (u->fib_index, FIB_PROTOCOL_IP4);
1551       rmp->vrf_id = ntohl (fib->ft_table_id);
1552     }
1553
1554   clib_memcpy (rmp->ip_address, &(u->addr), 4);
1555   rmp->nsessions = ntohl (u->nsessions);
1556   rmp->nstaticsessions = ntohl (u->nstaticsessions);
1557   rmp->context = context;
1558
1559   vl_api_send_msg (reg, (u8 *) rmp);
1560 }
1561
1562 static void
1563 vl_api_nat44_user_dump_t_handler (vl_api_nat44_user_dump_t * mp)
1564 {
1565   vl_api_registration_t *reg;
1566   snat_main_t *sm = &snat_main;
1567   snat_main_per_thread_data_t *tsm;
1568   snat_user_t *u;
1569
1570   if (sm->deterministic)
1571     return;
1572
1573   reg = vl_api_client_index_to_registration (mp->client_index);
1574   if (!reg)
1575     return;
1576
1577   /* *INDENT-OFF* */
1578   vec_foreach (tsm, sm->per_thread_data)
1579     {
1580       pool_foreach (u, tsm->users,
1581       ({
1582         send_nat44_user_details (u, reg, mp->context);
1583       }));
1584     }
1585   /* *INDENT-ON* */
1586 }
1587
1588 static void *
1589 vl_api_nat44_user_dump_t_print (vl_api_nat44_user_dump_t * mp, void *handle)
1590 {
1591   u8 *s;
1592
1593   s = format (0, "SCRIPT: nat44_user_dump ");
1594
1595   FINISH;
1596 }
1597
1598 static void
1599 send_nat44_user_session_details (snat_session_t * s,
1600                                  vl_api_registration_t * reg, u32 context)
1601 {
1602   vl_api_nat44_user_session_details_t *rmp;
1603   snat_main_t *sm = &snat_main;
1604
1605   rmp = vl_msg_api_alloc (sizeof (*rmp));
1606   clib_memset (rmp, 0, sizeof (*rmp));
1607   rmp->_vl_msg_id =
1608     ntohs (VL_API_NAT44_USER_SESSION_DETAILS + sm->msg_id_base);
1609   clib_memcpy (rmp->outside_ip_address, (&s->out2in.addr), 4);
1610   clib_memcpy (rmp->inside_ip_address, (&s->in2out.addr), 4);
1611
1612   if (snat_is_session_static (s))
1613     rmp->flags |= NAT_API_IS_STATIC;
1614
1615   if (is_twice_nat_session (s))
1616     rmp->flags |= NAT_API_IS_TWICE_NAT;
1617
1618   if (is_ed_session (s) || is_fwd_bypass_session (s))
1619     rmp->flags |= NAT_API_IS_EXT_HOST_VALID;
1620
1621   rmp->last_heard = clib_host_to_net_u64 ((u64) s->last_heard);
1622   rmp->total_bytes = clib_host_to_net_u64 (s->total_bytes);
1623   rmp->total_pkts = ntohl (s->total_pkts);
1624   rmp->context = context;
1625   if (snat_is_unk_proto_session (s))
1626     {
1627       rmp->outside_port = 0;
1628       rmp->inside_port = 0;
1629       rmp->protocol = ntohs (s->in2out.port);
1630     }
1631   else
1632     {
1633       rmp->outside_port = s->out2in.port;
1634       rmp->inside_port = s->in2out.port;
1635       rmp->protocol = ntohs (snat_proto_to_ip_proto (s->in2out.protocol));
1636     }
1637   if (is_ed_session (s) || is_fwd_bypass_session (s))
1638     {
1639       clib_memcpy (rmp->ext_host_address, &s->ext_host_addr, 4);
1640       rmp->ext_host_port = s->ext_host_port;
1641       if (is_twice_nat_session (s))
1642         {
1643           clib_memcpy (rmp->ext_host_nat_address, &s->ext_host_nat_addr, 4);
1644           rmp->ext_host_nat_port = s->ext_host_nat_port;
1645         }
1646     }
1647
1648   vl_api_send_msg (reg, (u8 *) rmp);
1649 }
1650
1651 static void
1652 vl_api_nat44_user_session_dump_t_handler (vl_api_nat44_user_session_dump_t *
1653                                           mp)
1654 {
1655   vl_api_registration_t *reg;
1656   snat_main_t *sm = &snat_main;
1657   snat_main_per_thread_data_t *tsm;
1658   snat_session_t *s;
1659   clib_bihash_kv_8_8_t key, value;
1660   snat_user_key_t ukey;
1661   snat_user_t *u;
1662   u32 session_index, head_index, elt_index;
1663   dlist_elt_t *head, *elt;
1664   ip4_header_t ip;
1665
1666   if (sm->deterministic)
1667     return;
1668
1669   reg = vl_api_client_index_to_registration (mp->client_index);
1670   if (!reg)
1671     return;
1672
1673   clib_memcpy (&ukey.addr, mp->ip_address, 4);
1674   ip.src_address.as_u32 = ukey.addr.as_u32;
1675   ukey.fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->vrf_id));
1676   key.key = ukey.as_u64;
1677   if (sm->num_workers > 1)
1678     tsm =
1679       vec_elt_at_index (sm->per_thread_data,
1680                         sm->worker_in2out_cb (&ip, ukey.fib_index, 0));
1681   else
1682     tsm = vec_elt_at_index (sm->per_thread_data, sm->num_workers);
1683   if (clib_bihash_search_8_8 (&tsm->user_hash, &key, &value))
1684     return;
1685   u = pool_elt_at_index (tsm->users, value.value);
1686   if (!u->nsessions && !u->nstaticsessions)
1687     return;
1688
1689   head_index = u->sessions_per_user_list_head_index;
1690   head = pool_elt_at_index (tsm->list_pool, head_index);
1691   elt_index = head->next;
1692   elt = pool_elt_at_index (tsm->list_pool, elt_index);
1693   session_index = elt->value;
1694   while (session_index != ~0)
1695     {
1696       s = pool_elt_at_index (tsm->sessions, session_index);
1697
1698       send_nat44_user_session_details (s, reg, mp->context);
1699
1700       elt_index = elt->next;
1701       elt = pool_elt_at_index (tsm->list_pool, elt_index);
1702       session_index = elt->value;
1703     }
1704 }
1705
1706 static void *
1707 vl_api_nat44_user_session_dump_t_print (vl_api_nat44_user_session_dump_t * mp,
1708                                         void *handle)
1709 {
1710   u8 *s;
1711
1712   s = format (0, "SCRIPT: nat44_user_session_dump ");
1713   s = format (s, "ip_address %U vrf_id %d\n",
1714               format_ip4_address, mp->ip_address,
1715               clib_net_to_host_u32 (mp->vrf_id));
1716
1717   FINISH;
1718 }
1719
1720 static nat44_lb_addr_port_t *
1721 unformat_nat44_lb_addr_port (vl_api_nat44_lb_addr_port_t * addr_port_pairs,
1722                              u32 addr_port_pair_num)
1723 {
1724   u8 i;
1725   nat44_lb_addr_port_t *lb_addr_port_pairs = 0, lb_addr_port;
1726   vl_api_nat44_lb_addr_port_t *ap;
1727
1728   for (i = 0; i < addr_port_pair_num; i++)
1729     {
1730       ap = &addr_port_pairs[i];
1731       clib_memset (&lb_addr_port, 0, sizeof (lb_addr_port));
1732       clib_memcpy (&lb_addr_port.addr, ap->addr, 4);
1733       lb_addr_port.port = clib_net_to_host_u16 (ap->port);
1734       lb_addr_port.probability = ap->probability;
1735       lb_addr_port.vrf_id = clib_net_to_host_u32 (ap->vrf_id);
1736       vec_add1 (lb_addr_port_pairs, lb_addr_port);
1737     }
1738
1739   return lb_addr_port_pairs;
1740 }
1741
1742 static void
1743   vl_api_nat44_add_del_lb_static_mapping_t_handler
1744   (vl_api_nat44_add_del_lb_static_mapping_t * mp)
1745 {
1746   snat_main_t *sm = &snat_main;
1747   vl_api_nat44_add_del_lb_static_mapping_reply_t *rmp;
1748   twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1749   int rv = 0;
1750   nat44_lb_addr_port_t *locals = 0;
1751   ip4_address_t e_addr;
1752   snat_protocol_t proto;
1753   u8 *tag = 0;
1754
1755   if (!sm->endpoint_dependent)
1756     {
1757       rv = VNET_API_ERROR_UNSUPPORTED;
1758       goto send_reply;
1759     }
1760
1761   locals =
1762     unformat_nat44_lb_addr_port (mp->locals,
1763                                  clib_net_to_host_u32 (mp->local_num));
1764   clib_memcpy (&e_addr, mp->external_addr, 4);
1765   proto = ip_proto_to_snat_proto (mp->protocol);
1766
1767   if (mp->flags & NAT_API_IS_TWICE_NAT)
1768     twice_nat = TWICE_NAT;
1769   else if (mp->flags & NAT_API_IS_SELF_TWICE_NAT)
1770     twice_nat = TWICE_NAT_SELF;
1771   mp->tag[sizeof (mp->tag) - 1] = 0;
1772   tag = format (0, "%s", mp->tag);
1773   vec_terminate_c_string (tag);
1774
1775   rv =
1776     nat44_add_del_lb_static_mapping (e_addr,
1777                                      clib_net_to_host_u16 (mp->external_port),
1778                                      proto, locals, mp->is_add,
1779                                      twice_nat,
1780                                      mp->flags & NAT_API_IS_OUT2IN_ONLY, tag,
1781                                      clib_net_to_host_u32 (mp->affinity));
1782
1783   vec_free (locals);
1784   vec_free (tag);
1785
1786 send_reply:
1787   REPLY_MACRO (VL_API_NAT44_ADD_DEL_LB_STATIC_MAPPING_REPLY);
1788 }
1789
1790 static void *vl_api_nat44_add_del_lb_static_mapping_t_print
1791   (vl_api_nat44_add_del_lb_static_mapping_t * mp, void *handle)
1792 {
1793   u8 *s;
1794
1795   s = format (0, "SCRIPT: nat44_add_del_lb_static_mapping ");
1796   s = format (s, "is_add %d twice_nat %d out2in_only %d ",
1797               mp->is_add,
1798               mp->flags & NAT_API_IS_TWICE_NAT,
1799               mp->flags & NAT_API_IS_OUT2IN_ONLY);
1800
1801   FINISH;
1802 }
1803
1804 static void
1805   vl_api_nat44_lb_static_mapping_add_del_local_t_handler
1806   (vl_api_nat44_lb_static_mapping_add_del_local_t * mp)
1807 {
1808   snat_main_t *sm = &snat_main;
1809   vl_api_nat44_lb_static_mapping_add_del_local_reply_t *rmp;
1810   int rv = 0;
1811   ip4_address_t e_addr, l_addr;
1812   snat_protocol_t proto;
1813
1814   if (!sm->endpoint_dependent)
1815     {
1816       rv = VNET_API_ERROR_UNSUPPORTED;
1817       goto send_reply;
1818     }
1819
1820   clib_memcpy (&e_addr, mp->external_addr, 4);
1821   clib_memcpy (&l_addr, mp->local.addr, 4);
1822   proto = ip_proto_to_snat_proto (mp->protocol);
1823
1824   rv =
1825     nat44_lb_static_mapping_add_del_local (e_addr,
1826                                            clib_net_to_host_u16
1827                                            (mp->external_port), l_addr,
1828                                            clib_net_to_host_u16 (mp->
1829                                                                  local.port),
1830                                            proto,
1831                                            clib_net_to_host_u32 (mp->
1832                                                                  local.vrf_id),
1833                                            mp->local.probability, mp->is_add);
1834
1835 send_reply:
1836   REPLY_MACRO (VL_API_NAT44_LB_STATIC_MAPPING_ADD_DEL_LOCAL_REPLY);
1837 }
1838
1839 static void *vl_api_nat44_lb_static_mapping_add_del_local_t_print
1840   (vl_api_nat44_lb_static_mapping_add_del_local_t * mp, void *handle)
1841 {
1842   u8 *s;
1843
1844   s = format (0, "SCRIPT: nat44_lb_static_mapping_add_del_local ");
1845   s = format (s, "is_add %d", mp->is_add);
1846
1847   FINISH;
1848 }
1849
1850 static void
1851 send_nat44_lb_static_mapping_details (snat_static_mapping_t * m,
1852                                       vl_api_registration_t * reg,
1853                                       u32 context)
1854 {
1855   vl_api_nat44_lb_static_mapping_details_t *rmp;
1856   snat_main_t *sm = &snat_main;
1857   nat44_lb_addr_port_t *ap;
1858   vl_api_nat44_lb_addr_port_t *locals;
1859   u32 local_num = 0;
1860
1861   rmp =
1862     vl_msg_api_alloc (sizeof (*rmp) +
1863                       (pool_elts (m->locals) *
1864                        sizeof (nat44_lb_addr_port_t)));
1865   clib_memset (rmp, 0, sizeof (*rmp));
1866   rmp->_vl_msg_id =
1867     ntohs (VL_API_NAT44_LB_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1868
1869   clib_memcpy (rmp->external_addr, &(m->external_addr), 4);
1870   rmp->external_port = ntohs (m->external_port);
1871   rmp->protocol = snat_proto_to_ip_proto (m->proto);
1872   rmp->context = context;
1873
1874   if (m->twice_nat == TWICE_NAT)
1875     rmp->flags |= NAT_API_IS_TWICE_NAT;
1876   else if (m->twice_nat == TWICE_NAT_SELF)
1877     rmp->flags |= NAT_API_IS_SELF_TWICE_NAT;
1878   if (is_out2in_only_static_mapping (m))
1879     rmp->flags |= NAT_API_IS_OUT2IN_ONLY;
1880   if (m->tag)
1881     strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1882
1883   locals = (vl_api_nat44_lb_addr_port_t *) rmp->locals;
1884   /* *INDENT-OFF* */
1885   pool_foreach (ap, m->locals,
1886   ({
1887     clib_memcpy (locals->addr, &(ap->addr), 4);
1888     locals->port = htons (ap->port);
1889     locals->probability = ap->probability;
1890     locals->vrf_id = ntohl (ap->vrf_id);
1891     locals++;
1892     local_num++;
1893   }));
1894   /* *INDENT-ON* */
1895   rmp->local_num = ntohl (local_num);
1896
1897   vl_api_send_msg (reg, (u8 *) rmp);
1898 }
1899
1900 static void
1901   vl_api_nat44_lb_static_mapping_dump_t_handler
1902   (vl_api_nat44_lb_static_mapping_dump_t * mp)
1903 {
1904   vl_api_registration_t *reg;
1905   snat_main_t *sm = &snat_main;
1906   snat_static_mapping_t *m;
1907
1908   if (!sm->endpoint_dependent)
1909     return;
1910
1911   reg = vl_api_client_index_to_registration (mp->client_index);
1912   if (!reg)
1913     return;
1914
1915   /* *INDENT-OFF* */
1916   pool_foreach (m, sm->static_mappings,
1917   ({
1918       if (is_lb_static_mapping(m))
1919         send_nat44_lb_static_mapping_details (m, reg, mp->context);
1920   }));
1921   /* *INDENT-ON* */
1922 }
1923
1924 static void *vl_api_nat44_lb_static_mapping_dump_t_print
1925   (vl_api_nat44_lb_static_mapping_dump_t * mp, void *handle)
1926 {
1927   u8 *s;
1928
1929   s = format (0, "SCRIPT: nat44_lb_static_mapping_dump ");
1930
1931   FINISH;
1932 }
1933
1934 static void
1935 vl_api_nat44_del_session_t_handler (vl_api_nat44_del_session_t * mp)
1936 {
1937   snat_main_t *sm = &snat_main;
1938   vl_api_nat44_del_session_reply_t *rmp;
1939   ip4_address_t addr, eh_addr;
1940   u16 port, eh_port;
1941   u32 vrf_id;
1942   int rv = 0;
1943   u8 is_in;
1944   snat_protocol_t proto;
1945
1946   if (sm->deterministic)
1947     {
1948       rv = VNET_API_ERROR_UNSUPPORTED;
1949       goto send_reply;
1950     }
1951
1952   memcpy (&addr.as_u8, mp->address, 4);
1953   port = clib_net_to_host_u16 (mp->port);
1954   vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1955   proto = ip_proto_to_snat_proto (mp->protocol);
1956   memcpy (&eh_addr.as_u8, mp->ext_host_address, 4);
1957   eh_port = clib_net_to_host_u16 (mp->ext_host_port);
1958
1959   is_in = mp->flags & NAT_API_IS_INSIDE;
1960
1961   if (mp->flags & NAT_API_IS_EXT_HOST_VALID)
1962     rv =
1963       nat44_del_ed_session (sm, &addr, port, &eh_addr, eh_port, mp->protocol,
1964                             vrf_id, is_in);
1965   else
1966     rv = nat44_del_session (sm, &addr, port, proto, vrf_id, is_in);
1967
1968 send_reply:
1969   REPLY_MACRO (VL_API_NAT44_DEL_SESSION_REPLY);
1970 }
1971
1972 static void *
1973 vl_api_nat44_del_session_t_print (vl_api_nat44_del_session_t * mp,
1974                                   void *handle)
1975 {
1976   u8 *s;
1977
1978   s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
1979   s = format (s, "addr %U port %d protocol %d vrf_id %d is_in %d",
1980               format_ip4_address, mp->address,
1981               clib_net_to_host_u16 (mp->port),
1982               mp->protocol, clib_net_to_host_u32 (mp->vrf_id),
1983               mp->flags & NAT_API_IS_INSIDE);
1984   if (mp->flags & NAT_API_IS_EXT_HOST_VALID)
1985     s = format (s, "ext_host_address %U ext_host_port %d",
1986                 format_ip4_address, mp->ext_host_address,
1987                 clib_net_to_host_u16 (mp->ext_host_port));
1988
1989   FINISH;
1990 }
1991
1992 static void
1993   vl_api_nat44_forwarding_enable_disable_t_handler
1994   (vl_api_nat44_forwarding_enable_disable_t * mp)
1995 {
1996   snat_main_t *sm = &snat_main;
1997   vl_api_nat44_forwarding_enable_disable_reply_t *rmp;
1998   int rv = 0;
1999   u32 *ses_to_be_removed = 0, *ses_index;
2000   snat_main_per_thread_data_t *tsm;
2001   snat_session_t *s;
2002
2003   sm->forwarding_enabled = mp->enable != 0;
2004
2005   if (mp->enable == 0)
2006     {
2007       /* *INDENT-OFF* */
2008       vec_foreach (tsm, sm->per_thread_data)
2009       {
2010         pool_foreach (s, tsm->sessions,
2011         ({
2012           if (is_fwd_bypass_session(s))
2013             {
2014               vec_add1 (ses_to_be_removed, s - tsm->sessions);
2015             }
2016         }));
2017         vec_foreach (ses_index, ses_to_be_removed)
2018         {
2019           s = pool_elt_at_index(tsm->sessions, ses_index[0]);
2020           nat_free_session_data (sm, s, tsm - sm->per_thread_data, 0);
2021           nat44_delete_session (sm, s, tsm - sm->per_thread_data);
2022         }
2023         vec_free (ses_to_be_removed);
2024       }
2025       /* *INDENT-ON* */
2026     }
2027
2028   REPLY_MACRO (VL_API_NAT44_FORWARDING_ENABLE_DISABLE_REPLY);
2029 }
2030
2031 static void *vl_api_nat44_forwarding_enable_disable_t_print
2032   (vl_api_nat44_forwarding_enable_disable_t * mp, void *handle)
2033 {
2034   u8 *s;
2035
2036   s = format (0, "SCRIPT: nat44_forwarding_enable_disable ");
2037   s = format (s, "enable %d", mp->enable != 0);
2038
2039   FINISH;
2040 }
2041
2042 static void
2043   vl_api_nat44_forwarding_is_enabled_t_handler
2044   (vl_api_nat44_forwarding_is_enabled_t * mp)
2045 {
2046   vl_api_registration_t *reg;
2047   snat_main_t *sm = &snat_main;
2048   vl_api_nat44_forwarding_is_enabled_reply_t *rmp;
2049
2050   reg = vl_api_client_index_to_registration (mp->client_index);
2051   if (!reg)
2052     return;
2053
2054   rmp = vl_msg_api_alloc (sizeof (*rmp));
2055   clib_memset (rmp, 0, sizeof (*rmp));
2056   rmp->_vl_msg_id =
2057     ntohs (VL_API_NAT44_FORWARDING_IS_ENABLED_REPLY + sm->msg_id_base);
2058   rmp->context = mp->context;
2059
2060   rmp->enabled = sm->forwarding_enabled;
2061
2062   vl_api_send_msg (reg, (u8 *) rmp);
2063 }
2064
2065 static void *vl_api_nat44_forwarding_is_enabled_t_print
2066   (vl_api_nat44_forwarding_is_enabled_t * mp, void *handle)
2067 {
2068   u8 *s;
2069
2070   s = format (0, "SCRIPT: nat44_forwarding_is_enabled ");
2071
2072   FINISH;
2073 }
2074
2075 /*******************************/
2076 /*** Deterministic NAT (CGN) ***/
2077 /*******************************/
2078
2079 static void
2080 vl_api_nat_det_add_del_map_t_handler (vl_api_nat_det_add_del_map_t * mp)
2081 {
2082   snat_main_t *sm = &snat_main;
2083   vl_api_nat_det_add_del_map_reply_t *rmp;
2084   int rv = 0;
2085   ip4_address_t in_addr, out_addr;
2086
2087   if (!sm->deterministic)
2088     {
2089       rv = VNET_API_ERROR_UNSUPPORTED;
2090       goto send_reply;
2091     }
2092
2093   clib_memcpy (&in_addr, mp->in_addr, 4);
2094   clib_memcpy (&out_addr, mp->out_addr, 4);
2095   rv = snat_det_add_map (sm, &in_addr, mp->in_plen, &out_addr,
2096                          mp->out_plen, mp->is_add);
2097
2098 send_reply:
2099   REPLY_MACRO (VL_API_NAT_DET_ADD_DEL_MAP_REPLY);
2100 }
2101
2102 static void *
2103 vl_api_nat_det_add_del_map_t_print (vl_api_nat_det_add_del_map_t * mp,
2104                                     void *handle)
2105 {
2106   u8 *s;
2107
2108   s = format (0, "SCRIPT: nat_det_add_del_map ");
2109   s = format (s, "inside address %U/%d outside address %U/%d\n",
2110               format_ip4_address, mp->in_addr, mp->in_plen,
2111               format_ip4_address, mp->out_addr, mp->out_plen);
2112
2113   FINISH;
2114 }
2115
2116 static void
2117 vl_api_nat_det_forward_t_handler (vl_api_nat_det_forward_t * mp)
2118 {
2119   snat_main_t *sm = &snat_main;
2120   vl_api_nat_det_forward_reply_t *rmp;
2121   int rv = 0;
2122   u16 lo_port = 0, hi_port = 0;
2123   snat_det_map_t *dm;
2124   ip4_address_t in_addr, out_addr;
2125
2126   if (!sm->deterministic)
2127     {
2128       rv = VNET_API_ERROR_UNSUPPORTED;
2129       REPLY_MACRO (VL_API_NAT_DET_FORWARD_REPLY);
2130       return;
2131     }
2132
2133   out_addr.as_u32 = 0;
2134   clib_memcpy (&in_addr, mp->in_addr, 4);
2135   dm = snat_det_map_by_user (sm, &in_addr);
2136   if (!dm)
2137     {
2138       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2139       goto send_reply;
2140     }
2141
2142   snat_det_forward (dm, &in_addr, &out_addr, &lo_port);
2143   hi_port = lo_port + dm->ports_per_host - 1;
2144
2145 send_reply:
2146   /* *INDENT-OFF* */
2147   REPLY_MACRO2 (VL_API_NAT_DET_FORWARD_REPLY,
2148   ({
2149     rmp->out_port_lo = ntohs (lo_port);
2150     rmp->out_port_hi = ntohs (hi_port);
2151     clib_memcpy (rmp->out_addr, &out_addr, 4);
2152   }))
2153   /* *INDENT-ON* */
2154 }
2155
2156 static void *
2157 vl_api_nat_det_forward_t_print (vl_api_nat_det_forward_t * mp, void *handle)
2158 {
2159   u8 *s;
2160
2161   s = format (0, "SCRIPT: nat_det_forward");
2162   s = format (s, "inside ip address %U\n", format_ip4_address, mp->in_addr);
2163
2164   FINISH;
2165 }
2166
2167 static void
2168 vl_api_nat_det_reverse_t_handler (vl_api_nat_det_reverse_t * mp)
2169 {
2170   snat_main_t *sm = &snat_main;
2171   vl_api_nat_det_reverse_reply_t *rmp;
2172   int rv = 0;
2173   ip4_address_t out_addr, in_addr;
2174   snat_det_map_t *dm;
2175
2176   if (!sm->deterministic)
2177     {
2178       rv = VNET_API_ERROR_UNSUPPORTED;
2179       REPLY_MACRO (VL_API_NAT_DET_REVERSE_REPLY);
2180       return;
2181     }
2182
2183   in_addr.as_u32 = 0;
2184   clib_memcpy (&out_addr, mp->out_addr, 4);
2185   dm = snat_det_map_by_out (sm, &out_addr);
2186   if (!dm)
2187     {
2188       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2189       goto send_reply;
2190     }
2191
2192   snat_det_reverse (dm, &out_addr, htons (mp->out_port), &in_addr);
2193
2194 send_reply:
2195   /* *INDENT-OFF* */
2196   REPLY_MACRO2 (VL_API_NAT_DET_REVERSE_REPLY,
2197   ({
2198     clib_memcpy (rmp->in_addr, &in_addr, 4);
2199   }))
2200   /* *INDENT-ON* */
2201 }
2202
2203 static void *
2204 vl_api_nat_det_reverse_t_print (vl_api_nat_det_reverse_t * mp, void *handle)
2205 {
2206   u8 *s;
2207
2208   s = format (0, "SCRIPT: nat_det_reverse");
2209   s = format (s, "outside ip address %U outside port %d",
2210               format_ip4_address, mp->out_addr, ntohs (mp->out_port));
2211
2212   FINISH;
2213 }
2214
2215 static void
2216 sent_nat_det_map_details (snat_det_map_t * m, vl_api_registration_t * reg,
2217                           u32 context)
2218 {
2219   vl_api_nat_det_map_details_t *rmp;
2220   snat_main_t *sm = &snat_main;
2221
2222   rmp = vl_msg_api_alloc (sizeof (*rmp));
2223   clib_memset (rmp, 0, sizeof (*rmp));
2224   rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_MAP_DETAILS + sm->msg_id_base);
2225   clib_memcpy (rmp->in_addr, &m->in_addr, 4);
2226   rmp->in_plen = m->in_plen;
2227   clib_memcpy (rmp->out_addr, &m->out_addr, 4);
2228   rmp->out_plen = m->out_plen;
2229   rmp->sharing_ratio = htonl (m->sharing_ratio);
2230   rmp->ports_per_host = htons (m->ports_per_host);
2231   rmp->ses_num = htonl (m->ses_num);
2232   rmp->context = context;
2233
2234   vl_api_send_msg (reg, (u8 *) rmp);
2235 }
2236
2237 static void
2238 vl_api_nat_det_map_dump_t_handler (vl_api_nat_det_map_dump_t * mp)
2239 {
2240   vl_api_registration_t *reg;
2241   snat_main_t *sm = &snat_main;
2242   snat_det_map_t *m;
2243
2244   if (!sm->deterministic)
2245     return;
2246
2247   reg = vl_api_client_index_to_registration (mp->client_index);
2248   if (!reg)
2249     return;
2250
2251   /* *INDENT-OFF* */
2252   vec_foreach(m, sm->det_maps)
2253     sent_nat_det_map_details(m, reg, mp->context);
2254   /* *INDENT-ON* */
2255 }
2256
2257 static void *
2258 vl_api_nat_det_map_dump_t_print (vl_api_nat_det_map_dump_t * mp, void *handle)
2259 {
2260   u8 *s;
2261
2262   s = format (0, "SCRIPT: nat_det_map_dump ");
2263
2264   FINISH;
2265 }
2266
2267 static void
2268 vl_api_nat_det_close_session_out_t_handler (vl_api_nat_det_close_session_out_t
2269                                             * mp)
2270 {
2271   snat_main_t *sm = &snat_main;
2272   vl_api_nat_det_close_session_out_reply_t *rmp;
2273   ip4_address_t out_addr, ext_addr, in_addr;
2274   snat_det_out_key_t key;
2275   snat_det_map_t *dm;
2276   snat_det_session_t *ses;
2277   int rv = 0;
2278
2279   if (!sm->deterministic)
2280     {
2281       rv = VNET_API_ERROR_UNSUPPORTED;
2282       goto send_reply;
2283     }
2284
2285   clib_memcpy (&out_addr, mp->out_addr, 4);
2286   clib_memcpy (&ext_addr, mp->ext_addr, 4);
2287
2288   dm = snat_det_map_by_out (sm, &out_addr);
2289   if (!dm)
2290     {
2291       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2292       goto send_reply;
2293     }
2294   snat_det_reverse (dm, &ext_addr, ntohs (mp->out_port), &in_addr);
2295   key.ext_host_addr = ext_addr;
2296   key.ext_host_port = mp->ext_port;
2297   key.out_port = mp->out_port;
2298   ses = snat_det_get_ses_by_out (dm, &in_addr, key.as_u64);
2299   if (!ses)
2300     {
2301       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2302       goto send_reply;
2303     }
2304   snat_det_ses_close (dm, ses);
2305
2306 send_reply:
2307   REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
2308 }
2309
2310 static void *
2311 vl_api_nat_det_close_session_out_t_print (vl_api_nat_det_close_session_out_t *
2312                                           mp, void *handle)
2313 {
2314   u8 *s;
2315
2316   s = format (0, "SCRIPT: nat_det_close_session_out ");
2317   s = format (s, "out_addr %U out_port %d "
2318               "ext_addr %U ext_port %d\n",
2319               format_ip4_address, mp->out_addr, ntohs (mp->out_port),
2320               format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
2321
2322   FINISH;
2323 }
2324
2325 static void
2326 vl_api_nat_det_close_session_in_t_handler (vl_api_nat_det_close_session_in_t *
2327                                            mp)
2328 {
2329   snat_main_t *sm = &snat_main;
2330   vl_api_nat_det_close_session_in_reply_t *rmp;
2331   ip4_address_t in_addr, ext_addr;
2332   snat_det_out_key_t key;
2333   snat_det_map_t *dm;
2334   snat_det_session_t *ses;
2335   int rv = 0;
2336
2337   if (!sm->deterministic)
2338     {
2339       rv = VNET_API_ERROR_UNSUPPORTED;
2340       goto send_reply;
2341     }
2342
2343   clib_memcpy (&in_addr, mp->in_addr, 4);
2344   clib_memcpy (&ext_addr, mp->ext_addr, 4);
2345
2346   dm = snat_det_map_by_user (sm, &in_addr);
2347   if (!dm)
2348     {
2349       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2350       goto send_reply;
2351     }
2352   key.ext_host_addr = ext_addr;
2353   key.ext_host_port = mp->ext_port;
2354   ses = snat_det_find_ses_by_in (dm, &in_addr, mp->in_port, key);
2355   if (!ses)
2356     {
2357       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2358       goto send_reply;
2359     }
2360   snat_det_ses_close (dm, ses);
2361
2362 send_reply:
2363   REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
2364 }
2365
2366 static void *
2367 vl_api_nat_det_close_session_in_t_print (vl_api_nat_det_close_session_in_t *
2368                                          mp, void *handle)
2369 {
2370   u8 *s;
2371   s = format (0, "SCRIPT: nat_det_close_session_in ");
2372   s = format (s, "in_addr %U in_port %d ext_addr %U ext_port %d\n",
2373               format_ip4_address, mp->in_addr, ntohs (mp->in_port),
2374               format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
2375
2376   FINISH;
2377 }
2378
2379 static void
2380 send_nat_det_session_details (snat_det_session_t * s,
2381                               vl_api_registration_t * reg, u32 context)
2382 {
2383   vl_api_nat_det_session_details_t *rmp;
2384   snat_main_t *sm = &snat_main;
2385
2386   rmp = vl_msg_api_alloc (sizeof (*rmp));
2387   clib_memset (rmp, 0, sizeof (*rmp));
2388   rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_SESSION_DETAILS + sm->msg_id_base);
2389   rmp->in_port = s->in_port;
2390   clib_memcpy (rmp->ext_addr, &s->out.ext_host_addr, 4);
2391   rmp->ext_port = s->out.ext_host_port;
2392   rmp->out_port = s->out.out_port;
2393   rmp->state = s->state;
2394   rmp->expire = ntohl (s->expire);
2395   rmp->context = context;
2396
2397   vl_api_send_msg (reg, (u8 *) rmp);
2398 }
2399
2400 static void
2401 vl_api_nat_det_session_dump_t_handler (vl_api_nat_det_session_dump_t * mp)
2402 {
2403   vl_api_registration_t *reg;
2404   snat_main_t *sm = &snat_main;
2405   ip4_address_t user_addr;
2406   snat_det_map_t *dm;
2407   snat_det_session_t *s, empty_ses;
2408   u16 i;
2409
2410   if (!sm->deterministic)
2411     return;
2412
2413   reg = vl_api_client_index_to_registration (mp->client_index);
2414   if (!reg)
2415     return;
2416
2417   clib_memset (&empty_ses, 0, sizeof (empty_ses));
2418   clib_memcpy (&user_addr, mp->user_addr, 4);
2419   dm = snat_det_map_by_user (sm, &user_addr);
2420   if (!dm)
2421     return;
2422
2423   s = dm->sessions + snat_det_user_ses_offset (&user_addr, dm->in_plen);
2424   for (i = 0; i < SNAT_DET_SES_PER_USER; i++)
2425     {
2426       if (s->out.as_u64)
2427         send_nat_det_session_details (s, reg, mp->context);
2428       s++;
2429     }
2430 }
2431
2432 static void *
2433 vl_api_nat_det_session_dump_t_print (vl_api_nat_det_session_dump_t * mp,
2434                                      void *handle)
2435 {
2436   u8 *s;
2437
2438   s = format (0, "SCRIPT: nat_det_session_dump ");
2439   s = format (s, "user_addr %U\n", format_ip4_address, mp->user_addr);
2440
2441   FINISH;
2442 }
2443
2444 /*************/
2445 /*** NAT64 ***/
2446 /*************/
2447
2448 static void
2449   vl_api_nat64_add_del_pool_addr_range_t_handler
2450   (vl_api_nat64_add_del_pool_addr_range_t * mp)
2451 {
2452   vl_api_nat64_add_del_pool_addr_range_reply_t *rmp;
2453   snat_main_t *sm = &snat_main;
2454   int rv = 0;
2455   ip4_address_t this_addr;
2456   u32 start_host_order, end_host_order;
2457   u32 vrf_id;
2458   int i, count;
2459   u32 *tmp;
2460
2461   tmp = (u32 *) mp->start_addr;
2462   start_host_order = clib_host_to_net_u32 (tmp[0]);
2463   tmp = (u32 *) mp->end_addr;
2464   end_host_order = clib_host_to_net_u32 (tmp[0]);
2465
2466   count = (end_host_order - start_host_order) + 1;
2467
2468   vrf_id = clib_host_to_net_u32 (mp->vrf_id);
2469
2470   memcpy (&this_addr.as_u8, mp->start_addr, 4);
2471
2472   for (i = 0; i < count; i++)
2473     {
2474       if ((rv = nat64_add_del_pool_addr (0, &this_addr, vrf_id, mp->is_add)))
2475         goto send_reply;
2476
2477       increment_v4_address (&this_addr);
2478     }
2479
2480 send_reply:
2481   REPLY_MACRO (VL_API_NAT64_ADD_DEL_POOL_ADDR_RANGE_REPLY);
2482 }
2483
2484 static void *vl_api_nat64_add_del_pool_addr_range_t_print
2485   (vl_api_nat64_add_del_pool_addr_range_t * mp, void *handle)
2486 {
2487   u8 *s;
2488
2489   s = format (0, "SCRIPT: nat64_add_del_pool_addr_range ");
2490   s = format (s, "%U - %U vrf_id %u %s\n",
2491               format_ip4_address, mp->start_addr,
2492               format_ip4_address, mp->end_addr,
2493               ntohl (mp->vrf_id), mp->is_add ? "" : "del");
2494
2495   FINISH;
2496 }
2497
2498 typedef struct nat64_api_walk_ctx_t_
2499 {
2500   vl_api_registration_t *reg;
2501   u32 context;
2502   nat64_db_t *db;
2503 } nat64_api_walk_ctx_t;
2504
2505 static int
2506 nat64_api_pool_walk (snat_address_t * a, void *arg)
2507 {
2508   vl_api_nat64_pool_addr_details_t *rmp;
2509   snat_main_t *sm = &snat_main;
2510   nat64_api_walk_ctx_t *ctx = arg;
2511
2512   rmp = vl_msg_api_alloc (sizeof (*rmp));
2513   clib_memset (rmp, 0, sizeof (*rmp));
2514   rmp->_vl_msg_id = ntohs (VL_API_NAT64_POOL_ADDR_DETAILS + sm->msg_id_base);
2515   clib_memcpy (rmp->address, &(a->addr), 4);
2516   if (a->fib_index != ~0)
2517     {
2518       fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP6);
2519       if (!fib)
2520         return -1;
2521       rmp->vrf_id = ntohl (fib->ft_table_id);
2522     }
2523   else
2524     rmp->vrf_id = ~0;
2525   rmp->context = ctx->context;
2526
2527   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2528
2529   return 0;
2530 }
2531
2532 static void
2533 vl_api_nat64_pool_addr_dump_t_handler (vl_api_nat64_pool_addr_dump_t * mp)
2534 {
2535   vl_api_registration_t *reg;
2536
2537   reg = vl_api_client_index_to_registration (mp->client_index);
2538   if (!reg)
2539     return;
2540
2541   nat64_api_walk_ctx_t ctx = {
2542     .reg = reg,
2543     .context = mp->context,
2544   };
2545
2546   nat64_pool_addr_walk (nat64_api_pool_walk, &ctx);
2547 }
2548
2549 static void *
2550 vl_api_nat64_pool_addr_dump_t_print (vl_api_nat64_pool_addr_dump_t * mp,
2551                                      void *handle)
2552 {
2553   u8 *s;
2554
2555   s = format (0, "SCRIPT: nat64_pool_addr_dump\n");
2556
2557   FINISH;
2558 }
2559
2560 static void
2561 vl_api_nat64_add_del_interface_t_handler (vl_api_nat64_add_del_interface_t *
2562                                           mp)
2563 {
2564   snat_main_t *sm = &snat_main;
2565   vl_api_nat64_add_del_interface_reply_t *rmp;
2566   int rv = 0;
2567
2568   VALIDATE_SW_IF_INDEX (mp);
2569
2570   rv =
2571     nat64_add_del_interface (ntohl (mp->sw_if_index),
2572                              mp->flags & NAT_API_IS_INSIDE, mp->is_add);
2573
2574   BAD_SW_IF_INDEX_LABEL;
2575
2576   REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_REPLY);
2577 }
2578
2579 static void *
2580 vl_api_nat64_add_del_interface_t_print (vl_api_nat64_add_del_interface_t * mp,
2581                                         void *handle)
2582 {
2583   u8 *s;
2584
2585   s = format (0, "SCRIPT: nat64_add_del_interface ");
2586   s = format (s, "sw_if_index %d %s %s",
2587               clib_host_to_net_u32 (mp->sw_if_index),
2588               mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
2589               mp->is_add ? "" : "del");
2590
2591   FINISH;
2592 }
2593
2594 static int
2595 nat64_api_interface_walk (snat_interface_t * i, void *arg)
2596 {
2597   vl_api_nat64_interface_details_t *rmp;
2598   snat_main_t *sm = &snat_main;
2599   nat64_api_walk_ctx_t *ctx = arg;
2600
2601   rmp = vl_msg_api_alloc (sizeof (*rmp));
2602   clib_memset (rmp, 0, sizeof (*rmp));
2603   rmp->_vl_msg_id = ntohs (VL_API_NAT64_INTERFACE_DETAILS + sm->msg_id_base);
2604   rmp->sw_if_index = ntohl (i->sw_if_index);
2605
2606   if (nat_interface_is_inside (i))
2607     rmp->flags |= NAT_API_IS_INSIDE;
2608   if (nat_interface_is_outside (i))
2609     rmp->flags |= NAT_API_IS_OUTSIDE;
2610
2611   rmp->context = ctx->context;
2612
2613   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2614
2615   return 0;
2616 }
2617
2618 static void
2619 vl_api_nat64_interface_dump_t_handler (vl_api_nat64_interface_dump_t * mp)
2620 {
2621   vl_api_registration_t *reg;
2622
2623   reg = vl_api_client_index_to_registration (mp->client_index);
2624   if (!reg)
2625     return;
2626
2627   nat64_api_walk_ctx_t ctx = {
2628     .reg = reg,
2629     .context = mp->context,
2630   };
2631
2632   nat64_interfaces_walk (nat64_api_interface_walk, &ctx);
2633 }
2634
2635 static void *
2636 vl_api_nat64_interface_dump_t_print (vl_api_nat64_interface_dump_t * mp,
2637                                      void *handle)
2638 {
2639   u8 *s;
2640
2641   s = format (0, "SCRIPT: snat_interface_dump ");
2642
2643   FINISH;
2644 }
2645
2646 static void
2647   vl_api_nat64_add_del_static_bib_t_handler
2648   (vl_api_nat64_add_del_static_bib_t * mp)
2649 {
2650   snat_main_t *sm = &snat_main;
2651   vl_api_nat64_add_del_static_bib_reply_t *rmp;
2652   ip6_address_t in_addr;
2653   ip4_address_t out_addr;
2654   int rv = 0;
2655
2656   memcpy (&in_addr.as_u8, mp->i_addr, 16);
2657   memcpy (&out_addr.as_u8, mp->o_addr, 4);
2658
2659   rv =
2660     nat64_add_del_static_bib_entry (&in_addr, &out_addr,
2661                                     clib_net_to_host_u16 (mp->i_port),
2662                                     clib_net_to_host_u16 (mp->o_port),
2663                                     mp->proto,
2664                                     clib_net_to_host_u32 (mp->vrf_id),
2665                                     mp->is_add);
2666
2667   REPLY_MACRO (VL_API_NAT64_ADD_DEL_STATIC_BIB_REPLY);
2668 }
2669
2670 static void *vl_api_nat64_add_del_static_bib_t_print
2671   (vl_api_nat64_add_del_static_bib_t * mp, void *handle)
2672 {
2673   u8 *s;
2674
2675   s = format (0, "SCRIPT: nat64_add_del_static_bib ");
2676   s = format (s, "protocol %d i_addr %U o_addr %U ",
2677               mp->proto,
2678               format_ip6_address, mp->i_addr, format_ip4_address, mp->o_addr);
2679
2680   if (mp->vrf_id != ~0)
2681     s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
2682
2683   FINISH;
2684 }
2685
2686 static int
2687 nat64_api_bib_walk (nat64_db_bib_entry_t * bibe, void *arg)
2688 {
2689   vl_api_nat64_bib_details_t *rmp;
2690   snat_main_t *sm = &snat_main;
2691   nat64_api_walk_ctx_t *ctx = arg;
2692   fib_table_t *fib;
2693
2694   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2695   if (!fib)
2696     return -1;
2697
2698   rmp = vl_msg_api_alloc (sizeof (*rmp));
2699   clib_memset (rmp, 0, sizeof (*rmp));
2700   rmp->_vl_msg_id = ntohs (VL_API_NAT64_BIB_DETAILS + sm->msg_id_base);
2701   rmp->context = ctx->context;
2702   clib_memcpy (rmp->i_addr, &(bibe->in_addr), 16);
2703   clib_memcpy (rmp->o_addr, &(bibe->out_addr), 4);
2704   rmp->i_port = bibe->in_port;
2705   rmp->o_port = bibe->out_port;
2706   rmp->vrf_id = ntohl (fib->ft_table_id);
2707   rmp->proto = bibe->proto;
2708   if (bibe->is_static)
2709     rmp->flags |= NAT_API_IS_STATIC;
2710   rmp->ses_num = ntohl (bibe->ses_num);
2711
2712   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2713
2714   return 0;
2715 }
2716
2717 static void
2718 vl_api_nat64_bib_dump_t_handler (vl_api_nat64_bib_dump_t * mp)
2719 {
2720   vl_api_registration_t *reg;
2721   nat64_main_t *nm = &nat64_main;
2722   nat64_db_t *db;
2723
2724   reg = vl_api_client_index_to_registration (mp->client_index);
2725   if (!reg)
2726     return;
2727
2728   nat64_api_walk_ctx_t ctx = {
2729     .reg = reg,
2730     .context = mp->context,
2731   };
2732
2733   /* *INDENT-OFF* */
2734   vec_foreach (db, nm->db)
2735     nat64_db_bib_walk (db, mp->proto, nat64_api_bib_walk, &ctx);
2736   /* *INDENT-ON* */
2737 }
2738
2739 static void *
2740 vl_api_nat64_bib_dump_t_print (vl_api_nat64_bib_dump_t * mp, void *handle)
2741 {
2742   u8 *s;
2743
2744   s = format (0, "SCRIPT: snat_bib_dump protocol %d", mp->proto);
2745
2746   FINISH;
2747 }
2748
2749 static int
2750 nat64_api_st_walk (nat64_db_st_entry_t * ste, void *arg)
2751 {
2752   vl_api_nat64_st_details_t *rmp;
2753   snat_main_t *sm = &snat_main;
2754   nat64_api_walk_ctx_t *ctx = arg;
2755   nat64_db_bib_entry_t *bibe;
2756   fib_table_t *fib;
2757
2758   bibe = nat64_db_bib_entry_by_index (ctx->db, ste->proto, ste->bibe_index);
2759   if (!bibe)
2760     return -1;
2761
2762   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2763   if (!fib)
2764     return -1;
2765
2766   rmp = vl_msg_api_alloc (sizeof (*rmp));
2767   clib_memset (rmp, 0, sizeof (*rmp));
2768   rmp->_vl_msg_id = ntohs (VL_API_NAT64_ST_DETAILS + sm->msg_id_base);
2769   rmp->context = ctx->context;
2770   clib_memcpy (rmp->il_addr, &(bibe->in_addr), 16);
2771   clib_memcpy (rmp->ol_addr, &(bibe->out_addr), 4);
2772   rmp->il_port = bibe->in_port;
2773   rmp->ol_port = bibe->out_port;
2774   clib_memcpy (rmp->ir_addr, &(ste->in_r_addr), 16);
2775   clib_memcpy (rmp->or_addr, &(ste->out_r_addr), 4);
2776   rmp->il_port = ste->r_port;
2777   rmp->vrf_id = ntohl (fib->ft_table_id);
2778   rmp->proto = ste->proto;
2779
2780   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2781
2782   return 0;
2783 }
2784
2785 static void
2786 vl_api_nat64_st_dump_t_handler (vl_api_nat64_st_dump_t * mp)
2787 {
2788   vl_api_registration_t *reg;
2789   nat64_main_t *nm = &nat64_main;
2790   nat64_db_t *db;
2791
2792   reg = vl_api_client_index_to_registration (mp->client_index);
2793   if (!reg)
2794     return;
2795
2796   nat64_api_walk_ctx_t ctx = {
2797     .reg = reg,
2798     .context = mp->context,
2799   };
2800
2801   /* *INDENT-OFF* */
2802   vec_foreach (db, nm->db)
2803     {
2804       ctx.db = db;
2805       nat64_db_st_walk (db, mp->proto, nat64_api_st_walk, &ctx);
2806     }
2807   /* *INDENT-ON* */
2808 }
2809
2810 static void *
2811 vl_api_nat64_st_dump_t_print (vl_api_nat64_st_dump_t * mp, void *handle)
2812 {
2813   u8 *s;
2814
2815   s = format (0, "SCRIPT: snat_st_dump protocol %d", mp->proto);
2816
2817   FINISH;
2818 }
2819
2820 static void
2821 vl_api_nat64_add_del_prefix_t_handler (vl_api_nat64_add_del_prefix_t * mp)
2822 {
2823   vl_api_nat64_add_del_prefix_reply_t *rmp;
2824   snat_main_t *sm = &snat_main;
2825   ip6_address_t prefix;
2826   int rv = 0;
2827
2828   memcpy (&prefix.as_u8, mp->prefix.address, 16);
2829
2830   rv =
2831     nat64_add_del_prefix (&prefix, mp->prefix.len,
2832                           clib_net_to_host_u32 (mp->vrf_id), mp->is_add);
2833   REPLY_MACRO (VL_API_NAT64_ADD_DEL_PREFIX_REPLY);
2834 }
2835
2836 static void *
2837 vl_api_nat64_add_del_prefix_t_print (vl_api_nat64_add_del_prefix_t * mp,
2838                                      void *handle)
2839 {
2840   u8 *s;
2841
2842   s = format (0, "SCRIPT: nat64_add_del_prefix %U/%u vrf_id %u %s\n",
2843               format_ip6_address, mp->prefix.address, mp->prefix.len,
2844               ntohl (mp->vrf_id), mp->is_add ? "" : "del");
2845
2846   FINISH;
2847 }
2848
2849 static int
2850 nat64_api_prefix_walk (nat64_prefix_t * p, void *arg)
2851 {
2852   vl_api_nat64_prefix_details_t *rmp;
2853   snat_main_t *sm = &snat_main;
2854   nat64_api_walk_ctx_t *ctx = arg;
2855
2856   rmp = vl_msg_api_alloc (sizeof (*rmp));
2857   clib_memset (rmp, 0, sizeof (*rmp));
2858   rmp->_vl_msg_id = ntohs (VL_API_NAT64_PREFIX_DETAILS + sm->msg_id_base);
2859   clib_memcpy (rmp->prefix.address, &(p->prefix), 16);
2860   rmp->prefix.len = p->plen;
2861   rmp->vrf_id = ntohl (p->vrf_id);
2862   rmp->context = ctx->context;
2863
2864   vl_api_send_msg (ctx->reg, (u8 *) rmp);
2865
2866   return 0;
2867 }
2868
2869 static void
2870 vl_api_nat64_prefix_dump_t_handler (vl_api_nat64_prefix_dump_t * mp)
2871 {
2872   vl_api_registration_t *reg;
2873
2874   reg = vl_api_client_index_to_registration (mp->client_index);
2875   if (!reg)
2876     return;
2877
2878   nat64_api_walk_ctx_t ctx = {
2879     .reg = reg,
2880     .context = mp->context,
2881   };
2882
2883   nat64_prefix_walk (nat64_api_prefix_walk, &ctx);
2884 }
2885
2886 static void *
2887 vl_api_nat64_prefix_dump_t_print (vl_api_nat64_prefix_dump_t * mp,
2888                                   void *handle)
2889 {
2890   u8 *s;
2891
2892   s = format (0, "SCRIPT: nat64_prefix_dump\n");
2893
2894   FINISH;
2895 }
2896
2897 static void
2898   vl_api_nat64_add_del_interface_addr_t_handler
2899   (vl_api_nat64_add_del_interface_addr_t * mp)
2900 {
2901   snat_main_t *sm = &snat_main;
2902   vl_api_nat64_add_del_interface_addr_reply_t *rmp;
2903   u32 sw_if_index = ntohl (mp->sw_if_index);
2904   int rv = 0;
2905
2906   VALIDATE_SW_IF_INDEX (mp);
2907
2908   rv = nat64_add_interface_address (sw_if_index, mp->is_add);
2909
2910   BAD_SW_IF_INDEX_LABEL;
2911
2912   REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_ADDR_REPLY);
2913 }
2914
2915 static void *vl_api_nat64_add_del_interface_addr_t_print
2916   (vl_api_nat64_add_del_interface_addr_t * mp, void *handle)
2917 {
2918   u8 *s;
2919
2920   s = format (0, "SCRIPT: nat64_add_del_interface_addr ");
2921   s = format (s, "sw_if_index %d %s",
2922               clib_host_to_net_u32 (mp->sw_if_index),
2923               mp->is_add ? "" : "del");
2924
2925   FINISH;
2926 }
2927
2928 /*************/
2929 /*** NAT66 ***/
2930 /*************/
2931
2932 static void
2933 vl_api_nat66_add_del_interface_t_handler (vl_api_nat66_add_del_interface_t *
2934                                           mp)
2935 {
2936   snat_main_t *sm = &snat_main;
2937   vl_api_nat66_add_del_interface_reply_t *rmp;
2938   int rv = 0;
2939
2940   VALIDATE_SW_IF_INDEX (mp);
2941
2942   rv =
2943     nat66_interface_add_del (ntohl (mp->sw_if_index),
2944                              mp->flags & NAT_API_IS_INSIDE, mp->is_add);
2945
2946   BAD_SW_IF_INDEX_LABEL;
2947
2948   REPLY_MACRO (VL_API_NAT66_ADD_DEL_INTERFACE_REPLY);
2949 }
2950
2951 static void *
2952 vl_api_nat66_add_del_interface_t_print (vl_api_nat66_add_del_interface_t * mp,
2953                                         void *handle)
2954 {
2955   u8 *s;
2956
2957   s = format (0, "SCRIPT: nat66_add_del_interface ");
2958   s = format (s, "sw_if_index %d %s %s",
2959               clib_host_to_net_u32 (mp->sw_if_index),
2960               mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
2961               mp->is_add ? "" : "del");
2962
2963   FINISH;
2964 }
2965
2966 static void
2967   vl_api_nat66_add_del_static_mapping_t_handler
2968   (vl_api_nat66_add_del_static_mapping_t * mp)
2969 {
2970   snat_main_t *sm = &snat_main;
2971   vl_api_nat66_add_del_static_mapping_reply_t *rmp;
2972   ip6_address_t l_addr, e_addr;
2973   int rv = 0;
2974
2975   memcpy (&l_addr.as_u8, mp->local_ip_address, 16);
2976   memcpy (&e_addr.as_u8, mp->external_ip_address, 16);
2977
2978   rv =
2979     nat66_static_mapping_add_del (&l_addr, &e_addr,
2980                                   clib_net_to_host_u32 (mp->vrf_id),
2981                                   mp->is_add);
2982
2983   REPLY_MACRO (VL_API_NAT66_ADD_DEL_STATIC_MAPPING_REPLY);
2984 }
2985
2986 static void *vl_api_nat66_add_del_static_mapping_t_print
2987   (vl_api_nat66_add_del_static_mapping_t * mp, void *handle)
2988 {
2989   u8 *s;
2990
2991   s = format (0, "SCRIPT: nat66_add_del_static_mapping ");
2992   s = format (s, "local_ip_address %U external_ip_address %U vrf_id %d %s",
2993               format_ip6_address, mp->local_ip_address,
2994               format_ip6_address, mp->external_ip_address,
2995               clib_net_to_host_u32 (mp->vrf_id), mp->is_add ? "" : "del");
2996
2997   FINISH;
2998 }
2999
3000 typedef struct nat66_api_walk_ctx_t_
3001 {
3002   vl_api_registration_t *rp;
3003   u32 context;
3004 } nat66_api_walk_ctx_t;
3005
3006 static int
3007 nat66_api_interface_walk (snat_interface_t * i, void *arg)
3008 {
3009   vl_api_nat66_interface_details_t *rmp;
3010   snat_main_t *sm = &snat_main;
3011   nat66_api_walk_ctx_t *ctx = arg;
3012
3013   rmp = vl_msg_api_alloc (sizeof (*rmp));
3014   clib_memset (rmp, 0, sizeof (*rmp));
3015   rmp->_vl_msg_id = ntohs (VL_API_NAT66_INTERFACE_DETAILS + sm->msg_id_base);
3016   rmp->sw_if_index = ntohl (i->sw_if_index);
3017   if (nat_interface_is_inside (i))
3018     rmp->flags |= NAT_API_IS_INSIDE;
3019   rmp->context = ctx->context;
3020
3021   vl_api_send_msg (ctx->rp, (u8 *) rmp);
3022
3023   return 0;
3024 }
3025
3026 static void
3027 vl_api_nat66_interface_dump_t_handler (vl_api_nat66_interface_dump_t * mp)
3028 {
3029   vl_api_registration_t *rp;
3030
3031   rp = vl_api_client_index_to_registration (mp->client_index);
3032   if (rp == 0)
3033     return;
3034
3035   nat66_api_walk_ctx_t ctx = {
3036     .rp = rp,
3037     .context = mp->context,
3038   };
3039
3040   nat66_interfaces_walk (nat66_api_interface_walk, &ctx);
3041 }
3042
3043 static void *
3044 vl_api_nat66_interface_dump_t_print (vl_api_nat66_interface_dump_t * mp,
3045                                      void *handle)
3046 {
3047   u8 *s;
3048
3049   s = format (0, "SCRIPT: nat66_interface_dump ");
3050
3051   FINISH;
3052 }
3053
3054 static int
3055 nat66_api_static_mapping_walk (nat66_static_mapping_t * m, void *arg)
3056 {
3057   vl_api_nat66_static_mapping_details_t *rmp;
3058   nat66_main_t *nm = &nat66_main;
3059   snat_main_t *sm = &snat_main;
3060   nat66_api_walk_ctx_t *ctx = arg;
3061   fib_table_t *fib;
3062   vlib_counter_t vc;
3063
3064   fib = fib_table_get (m->fib_index, FIB_PROTOCOL_IP6);
3065   if (!fib)
3066     return -1;
3067
3068   vlib_get_combined_counter (&nm->session_counters, m - nm->sm, &vc);
3069
3070   rmp = vl_msg_api_alloc (sizeof (*rmp));
3071   clib_memset (rmp, 0, sizeof (*rmp));
3072   rmp->_vl_msg_id =
3073     ntohs (VL_API_NAT66_STATIC_MAPPING_DETAILS + sm->msg_id_base);
3074   clib_memcpy (rmp->local_ip_address, &m->l_addr, 16);
3075   clib_memcpy (rmp->external_ip_address, &m->e_addr, 16);
3076   rmp->vrf_id = ntohl (fib->ft_table_id);
3077   rmp->total_bytes = clib_host_to_net_u64 (vc.bytes);
3078   rmp->total_pkts = clib_host_to_net_u64 (vc.packets);
3079   rmp->context = ctx->context;
3080
3081   vl_api_send_msg (ctx->rp, (u8 *) rmp);
3082
3083   return 0;
3084 }
3085
3086 static void
3087 vl_api_nat66_static_mapping_dump_t_handler (vl_api_nat66_static_mapping_dump_t
3088                                             * mp)
3089 {
3090   vl_api_registration_t *rp;
3091
3092   rp = vl_api_client_index_to_registration (mp->client_index);
3093   if (rp == 0)
3094     return;
3095
3096   nat66_api_walk_ctx_t ctx = {
3097     .rp = rp,
3098     .context = mp->context,
3099   };
3100
3101   nat66_static_mappings_walk (nat66_api_static_mapping_walk, &ctx);
3102 }
3103
3104 static void *
3105 vl_api_nat66_static_mapping_dump_t_print (vl_api_nat66_static_mapping_dump_t *
3106                                           mp, void *handle)
3107 {
3108   u8 *s;
3109
3110   s = format (0, "SCRIPT: nat66_static_mapping_dump ");
3111
3112   FINISH;
3113 }
3114
3115
3116 /* List of message types that this plugin understands */
3117 #define foreach_snat_plugin_api_msg                                     \
3118 _(NAT_CONTROL_PING, nat_control_ping)                                   \
3119 _(NAT_SHOW_CONFIG, nat_show_config)                                     \
3120 _(NAT_SET_WORKERS, nat_set_workers)                                     \
3121 _(NAT_WORKER_DUMP, nat_worker_dump)                                     \
3122 _(NAT44_SESSION_CLEANUP, nat44_session_cleanup)                         \
3123 _(NAT_SET_LOG_LEVEL, nat_set_log_level)                                 \
3124 _(NAT_IPFIX_ENABLE_DISABLE, nat_ipfix_enable_disable)                   \
3125 _(NAT_SET_TIMEOUTS, nat_set_timeouts)                                   \
3126 _(NAT_GET_TIMEOUTS, nat_get_timeouts)                                   \
3127 _(NAT_SET_ADDR_AND_PORT_ALLOC_ALG, nat_set_addr_and_port_alloc_alg)     \
3128 _(NAT_GET_ADDR_AND_PORT_ALLOC_ALG, nat_get_addr_and_port_alloc_alg)     \
3129 _(NAT_SET_MSS_CLAMPING, nat_set_mss_clamping)                           \
3130 _(NAT_GET_MSS_CLAMPING, nat_get_mss_clamping)                           \
3131 _(NAT_HA_SET_LISTENER, nat_ha_set_listener)                             \
3132 _(NAT_HA_SET_FAILOVER, nat_ha_set_failover)                             \
3133 _(NAT_HA_GET_LISTENER, nat_ha_get_listener)                             \
3134 _(NAT_HA_GET_FAILOVER, nat_ha_get_failover)                             \
3135 _(NAT_HA_FLUSH, nat_ha_flush)                                           \
3136 _(NAT_HA_RESYNC, nat_ha_resync)                                         \
3137 _(NAT44_ADD_DEL_ADDRESS_RANGE, nat44_add_del_address_range)             \
3138 _(NAT44_INTERFACE_ADD_DEL_FEATURE, nat44_interface_add_del_feature)     \
3139 _(NAT44_ADD_DEL_STATIC_MAPPING, nat44_add_del_static_mapping)           \
3140 _(NAT44_ADD_DEL_IDENTITY_MAPPING, nat44_add_del_identity_mapping)       \
3141 _(NAT44_STATIC_MAPPING_DUMP, nat44_static_mapping_dump)                 \
3142 _(NAT44_IDENTITY_MAPPING_DUMP, nat44_identity_mapping_dump)             \
3143 _(NAT44_ADDRESS_DUMP, nat44_address_dump)                               \
3144 _(NAT44_INTERFACE_DUMP, nat44_interface_dump)                           \
3145 _(NAT44_ADD_DEL_INTERFACE_ADDR, nat44_add_del_interface_addr)           \
3146 _(NAT44_INTERFACE_ADDR_DUMP, nat44_interface_addr_dump)                 \
3147 _(NAT44_USER_DUMP, nat44_user_dump)                                     \
3148 _(NAT44_USER_SESSION_DUMP, nat44_user_session_dump)                     \
3149 _(NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE,                               \
3150   nat44_interface_add_del_output_feature)                               \
3151 _(NAT44_INTERFACE_OUTPUT_FEATURE_DUMP,                                  \
3152   nat44_interface_output_feature_dump)                                  \
3153 _(NAT44_ADD_DEL_LB_STATIC_MAPPING, nat44_add_del_lb_static_mapping)     \
3154 _(NAT44_LB_STATIC_MAPPING_ADD_DEL_LOCAL,                                \
3155   nat44_lb_static_mapping_add_del_local)                                \
3156 _(NAT44_LB_STATIC_MAPPING_DUMP, nat44_lb_static_mapping_dump)           \
3157 _(NAT44_DEL_SESSION, nat44_del_session)                                 \
3158 _(NAT44_FORWARDING_ENABLE_DISABLE, nat44_forwarding_enable_disable)     \
3159 _(NAT44_FORWARDING_IS_ENABLED, nat44_forwarding_is_enabled)             \
3160 _(NAT_DET_ADD_DEL_MAP, nat_det_add_del_map)                             \
3161 _(NAT_DET_FORWARD, nat_det_forward)                                     \
3162 _(NAT_DET_REVERSE, nat_det_reverse)                                     \
3163 _(NAT_DET_MAP_DUMP, nat_det_map_dump)                                   \
3164 _(NAT_DET_CLOSE_SESSION_OUT, nat_det_close_session_out)                 \
3165 _(NAT_DET_CLOSE_SESSION_IN, nat_det_close_session_in)                   \
3166 _(NAT_DET_SESSION_DUMP, nat_det_session_dump)                           \
3167 _(NAT64_ADD_DEL_POOL_ADDR_RANGE, nat64_add_del_pool_addr_range)         \
3168 _(NAT64_POOL_ADDR_DUMP, nat64_pool_addr_dump)                           \
3169 _(NAT64_ADD_DEL_INTERFACE, nat64_add_del_interface)                     \
3170 _(NAT64_INTERFACE_DUMP, nat64_interface_dump)                           \
3171 _(NAT64_ADD_DEL_STATIC_BIB, nat64_add_del_static_bib)                   \
3172 _(NAT64_BIB_DUMP, nat64_bib_dump)                                       \
3173 _(NAT64_ST_DUMP, nat64_st_dump)                                         \
3174 _(NAT64_ADD_DEL_PREFIX, nat64_add_del_prefix)                           \
3175 _(NAT64_PREFIX_DUMP, nat64_prefix_dump)                                 \
3176 _(NAT64_ADD_DEL_INTERFACE_ADDR, nat64_add_del_interface_addr)           \
3177 _(NAT66_ADD_DEL_INTERFACE, nat66_add_del_interface)                     \
3178 _(NAT66_INTERFACE_DUMP, nat66_interface_dump)                           \
3179 _(NAT66_ADD_DEL_STATIC_MAPPING, nat66_add_del_static_mapping)           \
3180 _(NAT66_STATIC_MAPPING_DUMP, nat66_static_mapping_dump)
3181
3182 /* Set up the API message handling tables */
3183 static clib_error_t *
3184 snat_plugin_api_hookup (vlib_main_t * vm)
3185 {
3186   snat_main_t *sm __attribute__ ((unused)) = &snat_main;
3187 #define _(N,n)                                                  \
3188     vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base),     \
3189                            #n,                                  \
3190                            vl_api_##n##_t_handler,              \
3191                            vl_noop_handler,                     \
3192                            vl_api_##n##_t_endian,               \
3193                            vl_api_##n##_t_print,                \
3194                            sizeof(vl_api_##n##_t), 1);
3195   foreach_snat_plugin_api_msg;
3196 #undef _
3197
3198   return 0;
3199 }
3200
3201 #define vl_msg_name_crc_list
3202 #include <nat/nat_all_api_h.h>
3203 #undef vl_msg_name_crc_list
3204
3205 static void
3206 setup_message_id_table (snat_main_t * sm, api_main_t * am)
3207 {
3208 #define _(id,n,crc) \
3209   vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + sm->msg_id_base);
3210   foreach_vl_msg_name_crc_nat;
3211 #undef _
3212 }
3213
3214 static void
3215 plugin_custom_dump_configure (snat_main_t * sm)
3216 {
3217 #define _(n,f) sm->api_main->msg_print_handlers \
3218   [VL_API_##n + sm->msg_id_base]                \
3219     = (void *) vl_api_##f##_t_print;
3220   foreach_snat_plugin_api_msg;
3221 #undef _
3222 }
3223
3224 clib_error_t *
3225 snat_api_init (vlib_main_t * vm, snat_main_t * sm)
3226 {
3227   u8 *name;
3228   clib_error_t *error = 0;
3229
3230   name = format (0, "nat_%08x%c", api_version, 0);
3231
3232   /* Ask for a correctly-sized block of API message decode slots */
3233   sm->msg_id_base =
3234     vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE);
3235
3236   error = snat_plugin_api_hookup (vm);
3237
3238   /* Add our API messages to the global name_crc hash table */
3239   setup_message_id_table (sm, sm->api_main);
3240
3241   plugin_custom_dump_configure (sm);
3242
3243   vec_free (name);
3244
3245   return error;
3246 }
3247
3248 /*
3249  * fd.io coding-style-patch-verification: ON
3250  *
3251  * Local Variables:
3252  * eval: (c-set-style "gnu")
3253  * End:
3254  */