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