2 * Copyright (c) 2017 Cisco and/or its affiliates.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * @brief NAT plugin API implementation
22 #include <nat/nat_inlines.h>
23 #include <nat/nat44/inlines.h>
24 #include <nat/lib/nat_inlines.h>
25 #include <nat/nat_ha.h>
26 #include <vlibapi/api.h>
27 #include <vlibmemory/api.h>
29 #include <nat/nat_msg_enum.h>
30 #include <vnet/fib/fib_table.h>
31 #include <vnet/ip/ip_types_api.h>
32 #include <nat/nat44/ed_inlines.h>
33 #include <nat/lib/ipfix_logging.h>
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
38 /* define message structures */
40 #include <nat/nat_all_api_h.h>
43 /* define generated endian-swappers */
45 #include <nat/nat_all_api_h.h>
48 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
50 #define REPLY_MSG_ID_BASE sm->msg_id_base
51 #include <vlibapi/api_helper_macros.h>
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>
58 /* Macro to finish up custom dump fns */
61 vl_print (handle, (char *)s); \
65 /******************************/
66 /*** Common NAT plugin APIs ***/
67 /******************************/
70 vl_api_nat_control_ping_t_handler (vl_api_nat_control_ping_t * mp)
72 vl_api_nat_control_ping_reply_t *rmp;
73 snat_main_t *sm = &snat_main;
77 REPLY_MACRO2 (VL_API_NAT_CONTROL_PING_REPLY,
79 rmp->vpe_pid = ntohl (getpid ());
85 vl_api_nat_control_ping_t_print (vl_api_nat_control_ping_t * mp, void *handle)
89 s = format (0, "SCRIPT: nat_control_ping ");
95 vl_api_nat_show_config_t_handler (vl_api_nat_show_config_t * mp)
97 vl_api_nat_show_config_reply_t *rmp;
98 snat_main_t *sm = &snat_main;
102 REPLY_MACRO2 (VL_API_NAT_SHOW_CONFIG_REPLY,
104 rmp->translation_buckets = htonl (sm->translation_buckets);
105 rmp->translation_memory_size = 0;
106 rmp->user_buckets = htonl (sm->user_buckets);
107 rmp->user_memory_size = 0;
108 rmp->max_translations_per_user = htonl (sm->max_translations_per_user);
109 rmp->outside_vrf_id = htonl (sm->outside_vrf_id);
110 rmp->inside_vrf_id = htonl (sm->inside_vrf_id);
111 rmp->static_mapping_only = sm->static_mapping_only;
112 rmp->static_mapping_connection_tracking =
113 sm->static_mapping_connection_tracking;
114 rmp->endpoint_dependent = sm->endpoint_dependent;
115 rmp->out2in_dpo = sm->out2in_dpo;
116 // these are obsolete
118 rmp->deterministic = 0;
119 rmp->nat64_bib_buckets = 0;
120 rmp->nat64_bib_memory_size = 0;
121 rmp->nat64_st_buckets = 0;
122 rmp->nat64_st_memory_size = 0;
128 vl_api_nat_show_config_t_print (vl_api_nat_show_config_t * mp, void *handle)
132 s = format (0, "SCRIPT: nat_show_config ");
138 vl_api_nat_show_config_2_t_handler (vl_api_nat_show_config_2_t * mp)
140 vl_api_nat_show_config_2_reply_t *rmp;
141 snat_main_t *sm = &snat_main;
145 REPLY_MACRO2 (VL_API_NAT_SHOW_CONFIG_2_REPLY,
147 rmp->translation_buckets = htonl (sm->translation_buckets);
148 rmp->translation_memory_size = 0;
149 rmp->user_buckets = htonl (sm->user_buckets);
150 rmp->user_memory_size = 0;
151 rmp->max_translations_per_user = htonl (sm->max_translations_per_user);
152 rmp->outside_vrf_id = htonl (sm->outside_vrf_id);
153 rmp->inside_vrf_id = htonl (sm->inside_vrf_id);
154 rmp->static_mapping_only = sm->static_mapping_only;
155 rmp->static_mapping_connection_tracking =
156 sm->static_mapping_connection_tracking;
157 rmp->endpoint_dependent = sm->endpoint_dependent;
158 rmp->out2in_dpo = sm->out2in_dpo;
159 rmp->max_translations_per_thread = clib_net_to_host_u32(sm->max_translations_per_thread);
160 rmp->max_users_per_thread = clib_net_to_host_u32(sm->max_users_per_thread);
161 // these are obsolete
163 rmp->deterministic = 0;
164 rmp->nat64_bib_buckets = 0;
165 rmp->nat64_bib_memory_size = 0;
166 rmp->nat64_st_buckets = 0;
167 rmp->nat64_st_memory_size = 0;
173 vl_api_nat_show_config_2_t_print (vl_api_nat_show_config_t * mp, void *handle)
177 s = format (0, "SCRIPT: nat_show_config_2 ");
183 vl_api_nat_set_workers_t_handler (vl_api_nat_set_workers_t * mp)
185 snat_main_t *sm = &snat_main;
186 vl_api_nat_set_workers_reply_t *rmp;
191 mask = clib_net_to_host_u64 (mp->worker_mask);
193 if (sm->num_workers < 2)
195 rv = VNET_API_ERROR_FEATURE_DISABLED;
199 bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
200 rv = snat_set_workers (bitmap);
201 clib_bitmap_free (bitmap);
204 REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
208 vl_api_nat_set_workers_t_print (vl_api_nat_set_workers_t * mp, void *handle)
214 u64 mask = clib_net_to_host_u64 (mp->worker_mask);
216 s = format (0, "SCRIPT: nat_set_workers ");
217 bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
219 clib_bitmap_foreach (i, bitmap,
222 s = format (s, "%d", i);
224 s = format (s, ",%d", i);
228 clib_bitmap_free (bitmap);
233 send_nat_worker_details (u32 worker_index, vl_api_registration_t * reg,
236 vl_api_nat_worker_details_t *rmp;
237 snat_main_t *sm = &snat_main;
238 vlib_worker_thread_t *w =
239 vlib_worker_threads + worker_index + sm->first_worker_index;
241 rmp = vl_msg_api_alloc (sizeof (*rmp));
242 clib_memset (rmp, 0, sizeof (*rmp));
243 rmp->_vl_msg_id = ntohs (VL_API_NAT_WORKER_DETAILS + sm->msg_id_base);
244 rmp->context = context;
245 rmp->worker_index = htonl (worker_index);
246 rmp->lcore_id = htonl (w->cpu_id);
247 strncpy ((char *) rmp->name, (char *) w->name, ARRAY_LEN (rmp->name) - 1);
249 vl_api_send_msg (reg, (u8 *) rmp);
253 vl_api_nat_worker_dump_t_handler (vl_api_nat_worker_dump_t * mp)
255 vl_api_registration_t *reg;
256 snat_main_t *sm = &snat_main;
259 reg = vl_api_client_index_to_registration (mp->client_index);
264 vec_foreach (worker_index, sm->workers)
265 send_nat_worker_details(*worker_index, reg, mp->context);
270 vl_api_nat_worker_dump_t_print (vl_api_nat_worker_dump_t * mp, void *handle)
274 s = format (0, "SCRIPT: nat_worker_dump ");
280 vl_api_nat44_set_session_limit_t_handler (vl_api_nat44_set_session_limit_t *
283 snat_main_t *sm = &snat_main;
284 vl_api_nat44_set_session_limit_reply_t *rmp;
287 rv = nat44_set_session_limit
288 (ntohl (mp->session_limit), ntohl (mp->vrf_id));
290 REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
294 vl_api_nat44_set_session_limit_t_print (vl_api_nat44_set_session_limit_t *
299 s = format (0, "SCRIPT: nat44_set_session_limit ");
300 s = format (s, "session_limit %d", ntohl (mp->session_limit));
301 s = format (s, "vrf_id %d", ntohl (mp->vrf_id));
307 vl_api_nat_set_log_level_t_handler (vl_api_nat_set_log_level_t * mp)
309 snat_main_t *sm = &snat_main;
310 vl_api_nat_set_log_level_reply_t *rmp;
313 if (sm->log_level > NAT_LOG_DEBUG)
314 rv = VNET_API_ERROR_UNSUPPORTED;
316 sm->log_level = mp->log_level;
318 REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
322 vl_api_nat_set_log_level_t_print (vl_api_nat_set_log_level_t *
327 s = format (0, "SCRIPT: nat_set_log_level ");
328 s = format (s, "log_level %d", mp->log_level);
334 vl_api_nat44_plugin_enable_disable_t_handler
335 (vl_api_nat44_plugin_enable_disable_t * mp)
337 snat_main_t *sm = &snat_main;
338 nat44_config_t c = { 0 };
339 vl_api_nat44_plugin_enable_disable_reply_t *rmp;
344 c.endpoint_dependent = mp->flags & NAT44_API_IS_ENDPOINT_DEPENDENT;
345 c.static_mapping_only = mp->flags & NAT44_API_IS_STATIC_MAPPING_ONLY;
346 c.connection_tracking = mp->flags & NAT44_API_IS_CONNECTION_TRACKING;
347 c.out2in_dpo = mp->flags & NAT44_API_IS_OUT2IN_DPO;
349 c.inside_vrf = ntohl (mp->inside_vrf);
350 c.outside_vrf = ntohl (mp->outside_vrf);
352 c.users = ntohl (mp->users);
354 c.sessions = ntohl (mp->sessions);
356 c.user_sessions = ntohl (mp->user_sessions);
358 rv = nat44_plugin_enable (c);
361 rv = nat44_plugin_disable ();
363 REPLY_MACRO (VL_API_NAT44_PLUGIN_ENABLE_DISABLE_REPLY);
366 static void *vl_api_nat44_plugin_enable_disable_t_print
367 (vl_api_nat44_plugin_enable_disable_t * mp, void *handle)
372 s = format (0, "SCRIPT: nat44_plugin_enable_disable ");
375 s = format (s, "enable ");
376 if (mp->flags & NAT44_API_IS_ENDPOINT_DEPENDENT)
377 s = format (s, "endpoint-dependent ");
379 s = format (s, "endpoint-indepenednet ");
380 if (mp->flags & NAT44_API_IS_STATIC_MAPPING_ONLY)
381 s = format (s, "static_mapping_only ");
382 if (mp->flags & NAT44_API_IS_CONNECTION_TRACKING)
383 s = format (s, "connection_tracking ");
384 if (mp->flags & NAT44_API_IS_OUT2IN_DPO)
385 s = format (s, "out2in_dpo ");
386 val = ntohl (mp->inside_vrf);
388 s = format (s, "inside_vrf %u ", val);
389 val = ntohl (mp->outside_vrf);
391 s = format (s, "outside_vrf %u ", val);
392 val = ntohl (mp->users);
394 s = format (s, "users %u ", val);
395 val = ntohl (mp->user_memory);
397 s = format (s, "user_memory %u ", val);
398 val = ntohl (mp->sessions);
400 s = format (s, "sessions %u ", val);
401 val = ntohl (mp->session_memory);
403 s = format (s, "session_memory %u ", val);
404 val = ntohl (mp->user_sessions);
406 s = format (s, "user_sessions %u ", val);
409 s = format (s, "disable ");
415 vl_api_nat_ipfix_enable_disable_t_handler (vl_api_nat_ipfix_enable_disable_t *
418 snat_main_t *sm = &snat_main;
419 vl_api_nat_ipfix_enable_disable_reply_t *rmp;
422 rv = nat_ipfix_logging_enable_disable (mp->enable,
425 clib_host_to_net_u16 (mp->src_port));
427 REPLY_MACRO (VL_API_NAT_IPFIX_ENABLE_DISABLE_REPLY);
431 vl_api_nat_ipfix_enable_disable_t_print (vl_api_nat_ipfix_enable_disable_t *
436 s = format (0, "SCRIPT: nat_ipfix_enable_disable ");
438 s = format (s, "domain %d ", clib_net_to_host_u32 (mp->domain_id));
440 s = format (s, "src_port %d ", clib_net_to_host_u16 (mp->src_port));
442 s = format (s, "disable ");
448 vl_api_nat_set_timeouts_t_handler (vl_api_nat_set_timeouts_t * mp)
450 snat_main_t *sm = &snat_main;
451 vl_api_nat_set_timeouts_reply_t *rmp;
454 sm->udp_timeout = ntohl (mp->udp);
455 sm->tcp_established_timeout = ntohl (mp->tcp_established);
456 sm->tcp_transitory_timeout = ntohl (mp->tcp_transitory);
457 sm->icmp_timeout = ntohl (mp->icmp);
459 REPLY_MACRO (VL_API_NAT_SET_TIMEOUTS_REPLY);
463 vl_api_nat_set_timeouts_t_print (vl_api_nat_set_timeouts_t * mp, void *handle)
467 s = format (0, "SCRIPT: nat_set_timeouts ");
468 s = format (s, "udp %d tcp_established %d tcp_transitory %d icmp %d\n",
470 ntohl (mp->tcp_established),
471 ntohl (mp->tcp_transitory), ntohl (mp->icmp));
477 vl_api_nat_get_timeouts_t_handler (vl_api_nat_get_timeouts_t * mp)
479 snat_main_t *sm = &snat_main;
480 vl_api_nat_get_timeouts_reply_t *rmp;
484 REPLY_MACRO2 (VL_API_NAT_GET_TIMEOUTS_REPLY,
486 rmp->udp = htonl (sm->udp_timeout);
487 rmp->tcp_established = htonl (sm->tcp_established_timeout);
488 rmp->tcp_transitory = htonl (sm->tcp_transitory_timeout);
489 rmp->icmp = htonl (sm->icmp_timeout);
495 vl_api_nat_get_timeouts_t_print (vl_api_nat_get_timeouts_t * mp, void *handle)
499 s = format (0, "SCRIPT: nat_get_timeouts");
505 vl_api_nat_set_addr_and_port_alloc_alg_t_handler
506 (vl_api_nat_set_addr_and_port_alloc_alg_t * mp)
508 snat_main_t *sm = &snat_main;
509 vl_api_nat_set_addr_and_port_alloc_alg_reply_t *rmp;
511 u16 port_start, port_end;
515 case NAT_ADDR_AND_PORT_ALLOC_ALG_DEFAULT:
516 nat_set_alloc_addr_and_port_default ();
518 case NAT_ADDR_AND_PORT_ALLOC_ALG_MAPE:
519 nat_set_alloc_addr_and_port_mape (ntohs (mp->psid), mp->psid_offset,
522 case NAT_ADDR_AND_PORT_ALLOC_ALG_RANGE:
523 port_start = ntohs (mp->start_port);
524 port_end = ntohs (mp->end_port);
525 if (port_end <= port_start)
527 rv = VNET_API_ERROR_INVALID_VALUE;
530 nat_set_alloc_addr_and_port_range (port_start, port_end);
533 rv = VNET_API_ERROR_INVALID_VALUE;
538 REPLY_MACRO (VL_API_NAT_SET_ADDR_AND_PORT_ALLOC_ALG_REPLY);
541 static void *vl_api_nat_set_addr_and_port_alloc_alg_t_print
542 (vl_api_nat_set_addr_and_port_alloc_alg_t * mp, void *handle)
546 s = format (0, "SCRIPT: nat_set_addr_and_port_alloc_alg ");
547 s = format (s, "alg %d psid_offset %d psid_length %d psid %d start_port %d "
549 ntohl (mp->alg), ntohl (mp->psid_offset),
550 ntohl (mp->psid_length), ntohs (mp->psid),
551 ntohs (mp->start_port), ntohs (mp->end_port));
557 vl_api_nat_get_addr_and_port_alloc_alg_t_handler
558 (vl_api_nat_get_addr_and_port_alloc_alg_t * mp)
560 snat_main_t *sm = &snat_main;
561 vl_api_nat_get_addr_and_port_alloc_alg_reply_t *rmp;
565 REPLY_MACRO2 (VL_API_NAT_GET_ADDR_AND_PORT_ALLOC_ALG_REPLY,
567 rmp->alg = sm->addr_and_port_alloc_alg;
568 rmp->psid_offset = sm->psid_offset;
569 rmp->psid_length = sm->psid_length;
570 rmp->psid = htons (sm->psid);
571 rmp->start_port = htons (sm->start_port);
572 rmp->end_port = htons (sm->end_port);
577 static void *vl_api_nat_get_addr_and_port_alloc_alg_t_print
578 (vl_api_nat_get_addr_and_port_alloc_alg_t * mp, void *handle)
582 s = format (0, "SCRIPT: nat_get_addr_and_port_alloc_alg");
588 vl_api_nat_set_mss_clamping_t_handler (vl_api_nat_set_mss_clamping_t * mp)
590 snat_main_t *sm = &snat_main;
591 vl_api_nat_set_mss_clamping_reply_t *rmp;
595 sm->mss_clamping = ntohs (mp->mss_value);
597 sm->mss_clamping = 0;
599 REPLY_MACRO (VL_API_NAT_SET_MSS_CLAMPING_REPLY);
603 vl_api_nat_set_mss_clamping_t_print (vl_api_nat_set_mss_clamping_t * mp,
608 s = format (0, "SCRIPT: nat_set_mss_clamping enable %d mss_value %d\n",
609 mp->enable, ntohs (mp->mss_value));
615 vl_api_nat_get_mss_clamping_t_handler (vl_api_nat_get_mss_clamping_t * mp)
617 snat_main_t *sm = &snat_main;
618 vl_api_nat_get_mss_clamping_reply_t *rmp;
622 REPLY_MACRO2 (VL_API_NAT_GET_MSS_CLAMPING_REPLY,
624 rmp->enable = sm->mss_clamping ? 1 : 0;
625 rmp->mss_value = htons (sm->mss_clamping);
631 vl_api_nat_get_mss_clamping_t_print (vl_api_nat_get_mss_clamping_t * mp,
636 s = format (0, "SCRIPT: nat_get_mss_clamping");
642 vl_api_nat_ha_set_listener_t_handler (vl_api_nat_ha_set_listener_t * mp)
644 snat_main_t *sm = &snat_main;
645 vl_api_nat_ha_set_listener_reply_t *rmp;
649 memcpy (&addr, &mp->ip_address, sizeof (addr));
651 nat_ha_set_listener (&addr, clib_net_to_host_u16 (mp->port),
652 clib_net_to_host_u32 (mp->path_mtu));
654 REPLY_MACRO (VL_API_NAT_HA_SET_LISTENER_REPLY);
658 vl_api_nat_ha_set_listener_t_print (vl_api_nat_ha_set_listener_t * mp,
663 s = format (0, "SCRIPT: nat_ha_set_listener ");
664 s = format (s, "ip_address %U ", format_ip4_address, mp->ip_address);
665 s = format (s, "port %d ", clib_net_to_host_u16 (mp->port));
666 s = format (s, "path_mtu %d", clib_net_to_host_u32 (mp->path_mtu));
672 vl_api_nat_ha_get_listener_t_handler (vl_api_nat_ha_get_listener_t * mp)
674 snat_main_t *sm = &snat_main;
675 vl_api_nat_ha_get_listener_reply_t *rmp;
681 nat_ha_get_listener (&addr, &port, &path_mtu);
684 REPLY_MACRO2 (VL_API_NAT_HA_GET_LISTENER_REPLY,
686 clib_memcpy (rmp->ip_address, &addr, sizeof (ip4_address_t));
687 rmp->port = clib_host_to_net_u16 (port);
688 rmp->path_mtu = clib_host_to_net_u32 (path_mtu);
694 vl_api_nat_ha_get_listener_t_print (vl_api_nat_ha_get_listener_t * mp,
699 s = format (0, "SCRIPT: nat_ha_get_listener");
705 vl_api_nat_ha_set_failover_t_handler (vl_api_nat_ha_set_failover_t * mp)
707 snat_main_t *sm = &snat_main;
708 vl_api_nat_ha_set_failover_reply_t *rmp;
712 memcpy (&addr, &mp->ip_address, sizeof (addr));
714 nat_ha_set_failover (&addr, clib_net_to_host_u16 (mp->port),
715 clib_net_to_host_u32 (mp->session_refresh_interval));
717 REPLY_MACRO (VL_API_NAT_HA_SET_FAILOVER_REPLY);
721 vl_api_nat_ha_set_failover_t_print (vl_api_nat_ha_set_failover_t * mp,
726 s = format (0, "SCRIPT: nat_ha_set_failover ");
727 s = format (s, "ip_address %U ", format_ip4_address, mp->ip_address);
728 s = format (s, "port %d ", clib_net_to_host_u16 (mp->port));
734 vl_api_nat_ha_get_failover_t_handler (vl_api_nat_ha_get_failover_t * mp)
736 snat_main_t *sm = &snat_main;
737 vl_api_nat_ha_get_failover_reply_t *rmp;
741 u32 session_refresh_interval;
743 nat_ha_get_failover (&addr, &port, &session_refresh_interval);
746 REPLY_MACRO2 (VL_API_NAT_HA_GET_FAILOVER_REPLY,
748 clib_memcpy (rmp->ip_address, &addr, sizeof (ip4_address_t));
749 rmp->port = clib_host_to_net_u16 (port);
750 rmp->session_refresh_interval = clib_host_to_net_u32 (session_refresh_interval);
756 vl_api_nat_ha_get_failover_t_print (vl_api_nat_ha_get_failover_t * mp,
761 s = format (0, "SCRIPT: nat_ha_get_failover");
767 vl_api_nat_ha_flush_t_handler (vl_api_nat_ha_flush_t * mp)
769 snat_main_t *sm = &snat_main;
770 vl_api_nat_ha_flush_reply_t *rmp;
775 REPLY_MACRO (VL_API_NAT_HA_FLUSH_REPLY);
779 vl_api_nat_ha_flush_t_print (vl_api_nat_ha_flush_t * mp, void *handle)
783 s = format (0, "SCRIPT: nat_ha_flush ");
789 nat_ha_resync_completed_event_cb (u32 client_index, u32 pid, u32 missed_count)
791 snat_main_t *sm = &snat_main;
792 vl_api_registration_t *reg;
793 vl_api_nat_ha_resync_completed_event_t *mp;
795 reg = vl_api_client_index_to_registration (client_index);
799 mp = vl_msg_api_alloc (sizeof (*mp));
800 clib_memset (mp, 0, sizeof (*mp));
801 mp->client_index = client_index;
803 mp->missed_count = clib_host_to_net_u32 (missed_count);
805 ntohs (VL_API_NAT_HA_RESYNC_COMPLETED_EVENT + sm->msg_id_base);
807 vl_api_send_msg (reg, (u8 *) mp);
811 vl_api_nat_ha_resync_t_handler (vl_api_nat_ha_resync_t * mp)
813 snat_main_t *sm = &snat_main;
814 vl_api_nat_ha_resync_reply_t *rmp;
818 nat_ha_resync (mp->client_index, mp->pid,
819 mp->want_resync_event ? nat_ha_resync_completed_event_cb :
822 REPLY_MACRO (VL_API_NAT_HA_RESYNC_REPLY);
826 vl_api_nat_ha_resync_t_print (vl_api_nat_ha_resync_t * mp, void *handle)
830 s = format (0, "SCRIPT: nat_ha_resync ");
832 format (s, "want_resync_event %d pid %d", mp->want_resync_event,
833 clib_host_to_net_u32 (mp->pid));
842 vl_api_nat44_del_user_t_handler (vl_api_nat44_del_user_t * mp)
844 snat_main_t *sm = &snat_main;
845 vl_api_nat44_del_user_reply_t *rmp;
848 memcpy (&addr.as_u8, mp->ip_address, 4);
849 rv = nat44_user_del (&addr, ntohl (mp->fib_index));
850 REPLY_MACRO (VL_API_NAT44_DEL_USER_REPLY);
853 static void *vl_api_nat44_del_user_t_print
854 (vl_api_nat44_del_user_t * mp, void *handle)
857 s = format (0, "SCRIPT: nat44_del_user ");
858 s = format (s, "ip_address %U fib_index %U ",
859 format_ip4_address, mp->ip_address, ntohl (mp->fib_index));
864 vl_api_nat44_add_del_address_range_t_handler
865 (vl_api_nat44_add_del_address_range_t * mp)
867 snat_main_t *sm = &snat_main;
868 vl_api_nat44_add_del_address_range_reply_t *rmp;
869 ip4_address_t this_addr;
870 u8 is_add, twice_nat;
871 u32 start_host_order, end_host_order;
877 if (sm->static_mapping_only)
879 rv = VNET_API_ERROR_FEATURE_DISABLED;
884 twice_nat = mp->flags & NAT_API_IS_TWICE_NAT;
886 tmp = (u32 *) mp->first_ip_address;
887 start_host_order = clib_host_to_net_u32 (tmp[0]);
888 tmp = (u32 *) mp->last_ip_address;
889 end_host_order = clib_host_to_net_u32 (tmp[0]);
891 count = (end_host_order - start_host_order) + 1;
893 vrf_id = clib_host_to_net_u32 (mp->vrf_id);
896 nat_log_info ("%U - %U, %d addresses...",
897 format_ip4_address, mp->first_ip_address,
898 format_ip4_address, mp->last_ip_address, count);
900 memcpy (&this_addr.as_u8, mp->first_ip_address, 4);
902 for (i = 0; i < count; i++)
905 rv = snat_add_address (sm, &this_addr, vrf_id, twice_nat);
907 rv = snat_del_address (sm, this_addr, 0, twice_nat);
913 nat44_add_del_address_dpo (this_addr, is_add);
915 increment_v4_address (&this_addr);
919 REPLY_MACRO (VL_API_NAT44_ADD_DEL_ADDRESS_RANGE_REPLY);
922 static void *vl_api_nat44_add_del_address_range_t_print
923 (vl_api_nat44_add_del_address_range_t * mp, void *handle)
927 s = format (0, "SCRIPT: nat44_add_address_range ");
928 s = format (s, "%U ", format_ip4_address, mp->first_ip_address);
929 if (memcmp (mp->first_ip_address, mp->last_ip_address, 4))
931 s = format (s, " - %U ", format_ip4_address, mp->last_ip_address);
933 s = format (s, "twice_nat %d ", mp->flags & NAT_API_IS_TWICE_NAT);
938 send_nat44_address_details (snat_address_t * a,
939 vl_api_registration_t * reg, u32 context,
942 vl_api_nat44_address_details_t *rmp;
943 snat_main_t *sm = &snat_main;
945 rmp = vl_msg_api_alloc (sizeof (*rmp));
946 clib_memset (rmp, 0, sizeof (*rmp));
947 rmp->_vl_msg_id = ntohs (VL_API_NAT44_ADDRESS_DETAILS + sm->msg_id_base);
948 clib_memcpy (rmp->ip_address, &(a->addr), 4);
949 if (a->fib_index != ~0)
951 fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP4);
952 rmp->vrf_id = ntohl (fib->ft_table_id);
957 rmp->flags |= NAT_API_IS_TWICE_NAT;
958 rmp->context = context;
960 vl_api_send_msg (reg, (u8 *) rmp);
964 vl_api_nat44_address_dump_t_handler (vl_api_nat44_address_dump_t * mp)
966 vl_api_registration_t *reg;
967 snat_main_t *sm = &snat_main;
970 reg = vl_api_client_index_to_registration (mp->client_index);
975 vec_foreach (a, sm->addresses)
976 send_nat44_address_details (a, reg, mp->context, 0);
977 vec_foreach (a, sm->twice_nat_addresses)
978 send_nat44_address_details (a, reg, mp->context, 1);
983 vl_api_nat44_address_dump_t_print (vl_api_nat44_address_dump_t * mp,
988 s = format (0, "SCRIPT: nat44_address_dump ");
994 vl_api_nat44_interface_add_del_feature_t_handler
995 (vl_api_nat44_interface_add_del_feature_t * mp)
997 snat_main_t *sm = &snat_main;
998 vl_api_nat44_interface_add_del_feature_reply_t *rmp;
999 u32 sw_if_index = ntohl (mp->sw_if_index);
1003 is_del = !mp->is_add;
1005 VALIDATE_SW_IF_INDEX (mp);
1008 snat_interface_add_del (sw_if_index, mp->flags & NAT_API_IS_INSIDE,
1011 BAD_SW_IF_INDEX_LABEL;
1013 REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_FEATURE_REPLY);
1016 static void *vl_api_nat44_interface_add_del_feature_t_print
1017 (vl_api_nat44_interface_add_del_feature_t * mp, void *handle)
1021 s = format (0, "SCRIPT: nat44_interface_add_del_feature ");
1022 s = format (s, "sw_if_index %d %s %s",
1023 clib_host_to_net_u32 (mp->sw_if_index),
1024 mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
1025 mp->is_add ? "" : "del");
1031 send_nat44_interface_details (snat_interface_t * i,
1032 vl_api_registration_t * reg, u32 context)
1034 vl_api_nat44_interface_details_t *rmp;
1035 snat_main_t *sm = &snat_main;
1037 rmp = vl_msg_api_alloc (sizeof (*rmp));
1038 clib_memset (rmp, 0, sizeof (*rmp));
1039 rmp->_vl_msg_id = ntohs (VL_API_NAT44_INTERFACE_DETAILS + sm->msg_id_base);
1040 rmp->sw_if_index = ntohl (i->sw_if_index);
1042 if (nat_interface_is_inside (i))
1043 rmp->flags |= NAT_API_IS_INSIDE;
1044 if (nat_interface_is_outside (i))
1045 rmp->flags |= NAT_API_IS_OUTSIDE;
1047 rmp->context = context;
1049 vl_api_send_msg (reg, (u8 *) rmp);
1053 vl_api_nat44_interface_dump_t_handler (vl_api_nat44_interface_dump_t * mp)
1055 vl_api_registration_t *reg;
1056 snat_main_t *sm = &snat_main;
1057 snat_interface_t *i;
1059 reg = vl_api_client_index_to_registration (mp->client_index);
1064 pool_foreach (i, sm->interfaces,
1066 send_nat44_interface_details(i, reg, mp->context);
1072 vl_api_nat44_interface_dump_t_print (vl_api_nat44_interface_dump_t * mp,
1077 s = format (0, "SCRIPT: nat44_interface_dump ");
1083 vl_api_nat44_interface_add_del_output_feature_t_handler
1084 (vl_api_nat44_interface_add_del_output_feature_t * mp)
1086 snat_main_t *sm = &snat_main;
1087 vl_api_nat44_interface_add_del_output_feature_reply_t *rmp;
1088 u32 sw_if_index = ntohl (mp->sw_if_index);
1091 VALIDATE_SW_IF_INDEX (mp);
1093 rv = snat_interface_add_del_output_feature (sw_if_index,
1094 mp->flags & NAT_API_IS_INSIDE,
1097 BAD_SW_IF_INDEX_LABEL;
1098 REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE_REPLY);
1101 static void *vl_api_nat44_interface_add_del_output_feature_t_print
1102 (vl_api_nat44_interface_add_del_output_feature_t * mp, void *handle)
1106 s = format (0, "SCRIPT: nat44_interface_add_del_output_feature ");
1107 s = format (s, "sw_if_index %d %s %s",
1108 clib_host_to_net_u32 (mp->sw_if_index),
1109 mp->flags & NAT_API_IS_INSIDE ? "in" : "out",
1110 mp->is_add ? "" : "del");
1116 send_nat44_interface_output_feature_details (snat_interface_t * i,
1117 vl_api_registration_t * reg,
1120 vl_api_nat44_interface_output_feature_details_t *rmp;
1121 snat_main_t *sm = &snat_main;
1123 rmp = vl_msg_api_alloc (sizeof (*rmp));
1124 clib_memset (rmp, 0, sizeof (*rmp));
1126 ntohs (VL_API_NAT44_INTERFACE_OUTPUT_FEATURE_DETAILS + sm->msg_id_base);
1127 rmp->sw_if_index = ntohl (i->sw_if_index);
1128 rmp->context = context;
1130 if (nat_interface_is_inside (i))
1131 rmp->flags |= NAT_API_IS_INSIDE;
1133 vl_api_send_msg (reg, (u8 *) rmp);
1137 vl_api_nat44_interface_output_feature_dump_t_handler
1138 (vl_api_nat44_interface_output_feature_dump_t * mp)
1140 vl_api_registration_t *reg;
1141 snat_main_t *sm = &snat_main;
1142 snat_interface_t *i;
1144 reg = vl_api_client_index_to_registration (mp->client_index);
1149 pool_foreach (i, sm->output_feature_interfaces,
1151 send_nat44_interface_output_feature_details(i, reg, mp->context);
1156 static void *vl_api_nat44_interface_output_feature_dump_t_print
1157 (vl_api_nat44_interface_output_feature_dump_t * mp, void *handle)
1161 s = format (0, "SCRIPT: nat44_interface_output_feature_dump ");
1167 vl_api_nat44_add_del_static_mapping_t_handler
1168 (vl_api_nat44_add_del_static_mapping_t * mp)
1170 snat_main_t *sm = &snat_main;
1171 vl_api_nat44_add_del_static_mapping_reply_t *rmp;
1172 ip4_address_t local_addr, external_addr, pool_addr = { 0 };
1173 u16 local_port = 0, external_port = 0;
1174 u32 vrf_id, external_sw_if_index;
1175 twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1177 nat_protocol_t proto;
1180 memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
1181 memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
1183 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1185 local_port = mp->local_port;
1186 external_port = mp->external_port;
1189 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1190 external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
1191 proto = ip_proto_to_nat_proto (mp->protocol);
1193 if (mp->flags & NAT_API_IS_TWICE_NAT)
1194 twice_nat = TWICE_NAT;
1195 else if (mp->flags & NAT_API_IS_SELF_TWICE_NAT)
1196 twice_nat = TWICE_NAT_SELF;
1197 mp->tag[sizeof (mp->tag) - 1] = 0;
1198 tag = format (0, "%s", mp->tag);
1199 vec_terminate_c_string (tag);
1201 rv = snat_add_static_mapping (local_addr, external_addr, local_port,
1202 external_port, vrf_id,
1203 mp->flags & NAT_API_IS_ADDR_ONLY,
1204 external_sw_if_index, proto,
1205 mp->is_add, twice_nat,
1206 mp->flags & NAT_API_IS_OUT2IN_ONLY, tag, 0,
1210 REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_REPLY);
1214 vl_api_nat44_add_del_static_mapping_v2_t_handler
1215 (vl_api_nat44_add_del_static_mapping_v2_t * mp)
1217 snat_main_t *sm = &snat_main;
1218 vl_api_nat44_add_del_static_mapping_v2_reply_t *rmp;
1219 ip4_address_t local_addr, external_addr, pool_addr;
1220 u16 local_port = 0, external_port = 0;
1221 u32 vrf_id, external_sw_if_index;
1222 twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1224 nat_protocol_t proto;
1227 memcpy (&pool_addr.as_u8, mp->pool_ip_address, 4);
1228 memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
1229 memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
1231 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1233 local_port = mp->local_port;
1234 external_port = mp->external_port;
1237 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1238 external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
1239 proto = ip_proto_to_nat_proto (mp->protocol);
1241 if (mp->flags & NAT_API_IS_TWICE_NAT)
1242 twice_nat = TWICE_NAT;
1243 else if (mp->flags & NAT_API_IS_SELF_TWICE_NAT)
1244 twice_nat = TWICE_NAT_SELF;
1245 mp->tag[sizeof (mp->tag) - 1] = 0;
1246 tag = format (0, "%s", mp->tag);
1247 vec_terminate_c_string (tag);
1249 rv = snat_add_static_mapping (local_addr, external_addr, local_port,
1250 external_port, vrf_id,
1251 mp->flags & NAT_API_IS_ADDR_ONLY,
1252 external_sw_if_index, proto,
1253 mp->is_add, twice_nat,
1254 mp->flags & NAT_API_IS_OUT2IN_ONLY, tag, 0,
1255 pool_addr, mp->match_pool);
1258 REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_V2_REPLY);
1261 static void *vl_api_nat44_add_del_static_mapping_t_print
1262 (vl_api_nat44_add_del_static_mapping_t * mp, void *handle)
1266 s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
1267 s = format (s, "protocol %d local_addr %U external_addr %U ",
1269 format_ip4_address, mp->local_ip_address,
1270 format_ip4_address, mp->external_ip_address);
1272 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1273 s = format (s, "local_port %d external_port %d ",
1274 clib_net_to_host_u16 (mp->local_port),
1275 clib_net_to_host_u16 (mp->external_port));
1277 s = format (s, "twice_nat %d out2in_only %d ",
1278 mp->flags & NAT_API_IS_TWICE_NAT,
1279 mp->flags & NAT_API_IS_OUT2IN_ONLY);
1281 if (mp->vrf_id != ~0)
1282 s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
1284 if (mp->external_sw_if_index != ~0)
1285 s = format (s, "external_sw_if_index %d",
1286 clib_net_to_host_u32 (mp->external_sw_if_index));
1290 static void *vl_api_nat44_add_del_static_mapping_v2_t_print
1291 (vl_api_nat44_add_del_static_mapping_v2_t * mp, void *handle)
1295 s = format (0, "SCRIPT: nat44_add_del_static_mapping_v2 ");
1296 s = format (s, "protocol %d local_addr %U external_addr %U ",
1298 format_ip4_address, mp->local_ip_address,
1299 format_ip4_address, mp->external_ip_address);
1301 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1302 s = format (s, "local_port %d external_port %d ",
1303 clib_net_to_host_u16 (mp->local_port),
1304 clib_net_to_host_u16 (mp->external_port));
1306 s = format (s, "twice_nat %d out2in_only %d ",
1307 mp->flags & NAT_API_IS_TWICE_NAT,
1308 mp->flags & NAT_API_IS_OUT2IN_ONLY);
1310 if (mp->vrf_id != ~0)
1311 s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
1313 if (mp->external_sw_if_index != ~0)
1314 s = format (s, "external_sw_if_index %d",
1315 clib_net_to_host_u32 (mp->external_sw_if_index));
1317 s = format (s, "match pool address %U",
1318 format_ip4_address, mp->pool_ip_address);
1324 send_nat44_static_mapping_details (snat_static_mapping_t * m,
1325 vl_api_registration_t * reg, u32 context)
1327 vl_api_nat44_static_mapping_details_t *rmp;
1328 snat_main_t *sm = &snat_main;
1329 u32 len = sizeof (*rmp);
1331 rmp = vl_msg_api_alloc (len);
1332 clib_memset (rmp, 0, len);
1334 ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1336 clib_memcpy (rmp->local_ip_address, &(m->local_addr), 4);
1337 clib_memcpy (rmp->external_ip_address, &(m->external_addr), 4);
1338 rmp->external_sw_if_index = ~0;
1339 rmp->vrf_id = htonl (m->vrf_id);
1340 rmp->context = context;
1342 if (m->twice_nat == TWICE_NAT)
1343 rmp->flags |= NAT_API_IS_TWICE_NAT;
1344 else if (m->twice_nat == TWICE_NAT_SELF)
1345 rmp->flags |= NAT_API_IS_SELF_TWICE_NAT;
1347 if (is_out2in_only_static_mapping (m))
1348 rmp->flags |= NAT_API_IS_OUT2IN_ONLY;
1350 if (is_addr_only_static_mapping (m))
1352 rmp->flags |= NAT_API_IS_ADDR_ONLY;
1356 rmp->protocol = nat_proto_to_ip_proto (m->proto);
1357 rmp->external_port = m->external_port;
1358 rmp->local_port = m->local_port;
1362 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1364 vl_api_send_msg (reg, (u8 *) rmp);
1368 send_nat44_static_map_resolve_details (snat_static_map_resolve_t * m,
1369 vl_api_registration_t * reg,
1372 vl_api_nat44_static_mapping_details_t *rmp;
1373 snat_main_t *sm = &snat_main;
1375 rmp = vl_msg_api_alloc (sizeof (*rmp));
1376 clib_memset (rmp, 0, sizeof (*rmp));
1378 ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1379 clib_memcpy (rmp->local_ip_address, &(m->l_addr), 4);
1380 rmp->external_sw_if_index = htonl (m->sw_if_index);
1381 rmp->vrf_id = htonl (m->vrf_id);
1382 rmp->context = context;
1385 rmp->flags |= NAT_API_IS_TWICE_NAT;
1389 rmp->flags |= NAT_API_IS_ADDR_ONLY;
1393 rmp->protocol = nat_proto_to_ip_proto (m->proto);
1394 rmp->external_port = m->e_port;
1395 rmp->local_port = m->l_port;
1398 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1400 vl_api_send_msg (reg, (u8 *) rmp);
1404 vl_api_nat44_static_mapping_dump_t_handler (vl_api_nat44_static_mapping_dump_t
1407 vl_api_registration_t *reg;
1408 snat_main_t *sm = &snat_main;
1409 snat_static_mapping_t *m;
1410 snat_static_map_resolve_t *rp;
1413 reg = vl_api_client_index_to_registration (mp->client_index);
1418 pool_foreach (m, sm->static_mappings,
1420 if (!is_identity_static_mapping(m) && !is_lb_static_mapping (m))
1421 send_nat44_static_mapping_details (m, reg, mp->context);
1425 for (j = 0; j < vec_len (sm->to_resolve); j++)
1427 rp = sm->to_resolve + j;
1428 if (!rp->identity_nat)
1429 send_nat44_static_map_resolve_details (rp, reg, mp->context);
1434 vl_api_nat44_static_mapping_dump_t_print (vl_api_nat44_static_mapping_dump_t *
1439 s = format (0, "SCRIPT: nat44_static_mapping_dump ");
1445 vl_api_nat44_add_del_identity_mapping_t_handler
1446 (vl_api_nat44_add_del_identity_mapping_t * mp)
1448 snat_main_t *sm = &snat_main;
1449 vl_api_nat44_add_del_identity_mapping_reply_t *rmp;
1450 ip4_address_t addr, pool_addr = { 0 };
1452 u32 vrf_id, sw_if_index;
1454 nat_protocol_t proto = NAT_PROTOCOL_OTHER;
1457 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1460 proto = ip_proto_to_nat_proto (mp->protocol);
1462 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1463 sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
1464 if (sw_if_index != ~0)
1467 memcpy (&addr.as_u8, mp->ip_address, 4);
1468 mp->tag[sizeof (mp->tag) - 1] = 0;
1469 tag = format (0, "%s", mp->tag);
1470 vec_terminate_c_string (tag);
1473 snat_add_static_mapping (addr, addr, port, port, vrf_id,
1474 mp->flags & NAT_API_IS_ADDR_ONLY, sw_if_index,
1475 proto, mp->is_add, 0, 0, tag, 1, pool_addr, 0);
1478 REPLY_MACRO (VL_API_NAT44_ADD_DEL_IDENTITY_MAPPING_REPLY);
1481 static void *vl_api_nat44_add_del_identity_mapping_t_print
1482 (vl_api_nat44_add_del_identity_mapping_t * mp, void *handle)
1486 s = format (0, "SCRIPT: nat44_add_del_identity_mapping ");
1487 if (mp->sw_if_index != ~0)
1488 s = format (s, "sw_if_index %d", clib_net_to_host_u32 (mp->sw_if_index));
1490 s = format (s, "addr %U", format_ip4_address, mp->ip_address);
1492 if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
1494 format (s, " protocol %d port %d", mp->protocol,
1495 clib_net_to_host_u16 (mp->port));
1497 if (mp->vrf_id != ~0)
1498 s = format (s, " vrf %d", clib_net_to_host_u32 (mp->vrf_id));
1504 send_nat44_identity_mapping_details (snat_static_mapping_t * m, int index,
1505 vl_api_registration_t * reg, u32 context)
1507 vl_api_nat44_identity_mapping_details_t *rmp;
1508 snat_main_t *sm = &snat_main;
1509 nat44_lb_addr_port_t *local = pool_elt_at_index (m->locals, index);
1511 rmp = vl_msg_api_alloc (sizeof (*rmp));
1512 clib_memset (rmp, 0, sizeof (*rmp));
1514 ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
1516 if (is_addr_only_static_mapping (m))
1517 rmp->flags |= NAT_API_IS_ADDR_ONLY;
1519 clib_memcpy (rmp->ip_address, &(m->local_addr), 4);
1520 rmp->port = m->local_port;
1521 rmp->sw_if_index = ~0;
1522 rmp->vrf_id = htonl (local->vrf_id);
1523 rmp->protocol = nat_proto_to_ip_proto (m->proto);
1524 rmp->context = context;
1526 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1528 vl_api_send_msg (reg, (u8 *) rmp);
1532 send_nat44_identity_map_resolve_details (snat_static_map_resolve_t * m,
1533 vl_api_registration_t * reg,
1536 vl_api_nat44_identity_mapping_details_t *rmp;
1537 snat_main_t *sm = &snat_main;
1539 rmp = vl_msg_api_alloc (sizeof (*rmp));
1540 clib_memset (rmp, 0, sizeof (*rmp));
1542 ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
1545 rmp->flags = (vl_api_nat_config_flags_t) NAT_API_IS_ADDR_ONLY;
1547 rmp->port = m->l_port;
1548 rmp->sw_if_index = htonl (m->sw_if_index);
1549 rmp->vrf_id = htonl (m->vrf_id);
1550 rmp->protocol = nat_proto_to_ip_proto (m->proto);
1551 rmp->context = context;
1553 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1555 vl_api_send_msg (reg, (u8 *) rmp);
1559 vl_api_nat44_identity_mapping_dump_t_handler
1560 (vl_api_nat44_identity_mapping_dump_t * mp)
1562 vl_api_registration_t *reg;
1563 snat_main_t *sm = &snat_main;
1564 snat_static_mapping_t *m;
1565 snat_static_map_resolve_t *rp;
1568 reg = vl_api_client_index_to_registration (mp->client_index);
1573 pool_foreach (m, sm->static_mappings,
1575 if (is_identity_static_mapping(m) && !is_lb_static_mapping (m))
1577 pool_foreach_index (j, m->locals,
1579 send_nat44_identity_mapping_details (m, j, reg, mp->context);
1585 for (j = 0; j < vec_len (sm->to_resolve); j++)
1587 rp = sm->to_resolve + j;
1588 if (rp->identity_nat)
1589 send_nat44_identity_map_resolve_details (rp, reg, mp->context);
1593 static void *vl_api_nat44_identity_mapping_dump_t_print
1594 (vl_api_nat44_identity_mapping_dump_t * mp, void *handle)
1598 s = format (0, "SCRIPT: nat44_identity_mapping_dump ");
1604 vl_api_nat44_add_del_interface_addr_t_handler
1605 (vl_api_nat44_add_del_interface_addr_t * mp)
1607 snat_main_t *sm = &snat_main;
1608 vl_api_nat44_add_del_interface_addr_reply_t *rmp;
1609 u32 sw_if_index = ntohl (mp->sw_if_index);
1613 is_del = !mp->is_add;
1615 VALIDATE_SW_IF_INDEX (mp);
1617 rv = snat_add_interface_address (sm, sw_if_index, is_del,
1618 mp->flags & NAT_API_IS_TWICE_NAT);
1620 BAD_SW_IF_INDEX_LABEL;
1621 REPLY_MACRO (VL_API_NAT44_ADD_DEL_INTERFACE_ADDR_REPLY);
1624 static void *vl_api_nat44_add_del_interface_addr_t_print
1625 (vl_api_nat44_add_del_interface_addr_t * mp, void *handle)
1629 s = format (0, "SCRIPT: nat44_add_del_interface_addr ");
1630 s = format (s, "sw_if_index %d twice_nat %d %s",
1631 clib_host_to_net_u32 (mp->sw_if_index),
1632 mp->flags & NAT_API_IS_TWICE_NAT, mp->is_add ? "" : "del");
1638 send_nat44_interface_addr_details (u32 sw_if_index,
1639 vl_api_registration_t * reg, u32 context,
1642 vl_api_nat44_interface_addr_details_t *rmp;
1643 snat_main_t *sm = &snat_main;
1645 rmp = vl_msg_api_alloc (sizeof (*rmp));
1646 clib_memset (rmp, 0, sizeof (*rmp));
1648 ntohs (VL_API_NAT44_INTERFACE_ADDR_DETAILS + sm->msg_id_base);
1649 rmp->sw_if_index = ntohl (sw_if_index);
1652 rmp->flags = (vl_api_nat_config_flags_t) NAT_API_IS_TWICE_NAT;
1653 rmp->context = context;
1655 vl_api_send_msg (reg, (u8 *) rmp);
1659 vl_api_nat44_interface_addr_dump_t_handler (vl_api_nat44_interface_addr_dump_t
1662 vl_api_registration_t *reg;
1663 snat_main_t *sm = &snat_main;
1666 reg = vl_api_client_index_to_registration (mp->client_index);
1671 vec_foreach (i, sm->auto_add_sw_if_indices)
1672 send_nat44_interface_addr_details(*i, reg, mp->context, 0);
1673 vec_foreach (i, sm->auto_add_sw_if_indices_twice_nat)
1674 send_nat44_interface_addr_details(*i, reg, mp->context, 1);
1679 vl_api_nat44_interface_addr_dump_t_print (vl_api_nat44_interface_addr_dump_t *
1684 s = format (0, "SCRIPT: nat44_interface_addr_dump ");
1690 send_nat44_user_details (snat_user_t * u, vl_api_registration_t * reg,
1693 vl_api_nat44_user_details_t *rmp;
1694 snat_main_t *sm = &snat_main;
1695 ip4_main_t *im = &ip4_main;
1697 rmp = vl_msg_api_alloc (sizeof (*rmp));
1698 clib_memset (rmp, 0, sizeof (*rmp));
1699 rmp->_vl_msg_id = ntohs (VL_API_NAT44_USER_DETAILS + sm->msg_id_base);
1701 if (!pool_is_free_index (im->fibs, u->fib_index))
1703 fib_table_t *fib = fib_table_get (u->fib_index, FIB_PROTOCOL_IP4);
1704 rmp->vrf_id = ntohl (fib->ft_table_id);
1707 clib_memcpy (rmp->ip_address, &(u->addr), 4);
1708 rmp->nsessions = ntohl (u->nsessions);
1709 rmp->nstaticsessions = ntohl (u->nstaticsessions);
1710 rmp->context = context;
1712 vl_api_send_msg (reg, (u8 *) rmp);
1716 nat_ed_user_create_helper (snat_main_per_thread_data_t * tsm,
1720 k.addr = s->in2out.addr;
1721 k.fib_index = s->in2out.fib_index;
1722 clib_bihash_kv_8_8_t key, value;
1725 if (clib_bihash_search_8_8 (&tsm->user_hash, &key, &value))
1727 pool_get (tsm->users, u);
1729 u->fib_index = k.fib_index;
1731 u->nstaticsessions = 0;
1732 key.value = u - tsm->users;
1733 clib_bihash_add_del_8_8 (&tsm->user_hash, &key, 1);
1737 u = pool_elt_at_index (tsm->users, value.value);
1739 if (snat_is_session_static (s))
1741 ++u->nstaticsessions;
1750 nat_ed_users_create (snat_main_per_thread_data_t * tsm)
1754 pool_foreach (s, tsm->sessions, { nat_ed_user_create_helper (tsm, s); });
1759 nat_ed_users_destroy (snat_main_per_thread_data_t * tsm)
1763 pool_flush (u, tsm->users, { });
1765 clib_bihash_free_8_8 (&tsm->user_hash);
1766 clib_bihash_init_8_8 (&tsm->user_hash, "users", snat_main.user_buckets, 0);
1767 clib_bihash_set_kvp_format_fn_8_8 (&tsm->user_hash, format_user_kvp);
1771 vl_api_nat44_user_dump_t_handler (vl_api_nat44_user_dump_t * mp)
1773 vl_api_registration_t *reg;
1774 snat_main_t *sm = &snat_main;
1775 snat_main_per_thread_data_t *tsm;
1778 reg = vl_api_client_index_to_registration (mp->client_index);
1783 vec_foreach (tsm, sm->per_thread_data)
1785 if (sm->endpoint_dependent)
1787 nat_ed_users_create (tsm);
1789 pool_foreach (u, tsm->users,
1791 send_nat44_user_details (u, reg, mp->context);
1793 if (sm->endpoint_dependent)
1795 nat_ed_users_destroy (tsm);
1802 vl_api_nat44_user_dump_t_print (vl_api_nat44_user_dump_t * mp, void *handle)
1806 s = format (0, "SCRIPT: nat44_user_dump ");
1812 send_nat44_user_session_details (snat_session_t * s,
1813 vl_api_registration_t * reg, u32 context)
1815 vl_api_nat44_user_session_details_t *rmp;
1816 snat_main_t *sm = &snat_main;
1818 rmp = vl_msg_api_alloc (sizeof (*rmp));
1819 clib_memset (rmp, 0, sizeof (*rmp));
1821 ntohs (VL_API_NAT44_USER_SESSION_DETAILS + sm->msg_id_base);
1822 clib_memcpy (rmp->outside_ip_address, (&s->out2in.addr), 4);
1823 clib_memcpy (rmp->inside_ip_address, (&s->in2out.addr), 4);
1825 if (snat_is_session_static (s))
1826 rmp->flags |= NAT_API_IS_STATIC;
1828 if (is_twice_nat_session (s))
1829 rmp->flags |= NAT_API_IS_TWICE_NAT;
1831 if (is_ed_session (s) || is_fwd_bypass_session (s))
1832 rmp->flags |= NAT_API_IS_EXT_HOST_VALID;
1834 rmp->last_heard = clib_host_to_net_u64 ((u64) s->last_heard);
1835 rmp->total_bytes = clib_host_to_net_u64 (s->total_bytes);
1836 rmp->total_pkts = ntohl (s->total_pkts);
1837 rmp->context = context;
1838 if (snat_is_unk_proto_session (s))
1840 rmp->outside_port = 0;
1841 rmp->inside_port = 0;
1842 rmp->protocol = ntohs (s->in2out.port);
1846 rmp->outside_port = s->out2in.port;
1847 rmp->inside_port = s->in2out.port;
1848 rmp->protocol = ntohs (nat_proto_to_ip_proto (s->nat_proto));
1850 if (is_ed_session (s) || is_fwd_bypass_session (s))
1852 clib_memcpy (rmp->ext_host_address, &s->ext_host_addr, 4);
1853 rmp->ext_host_port = s->ext_host_port;
1854 if (is_twice_nat_session (s))
1856 clib_memcpy (rmp->ext_host_nat_address, &s->ext_host_nat_addr, 4);
1857 rmp->ext_host_nat_port = s->ext_host_nat_port;
1861 vl_api_send_msg (reg, (u8 *) rmp);
1865 vl_api_nat44_user_session_dump_t_handler (vl_api_nat44_user_session_dump_t *
1868 vl_api_registration_t *reg;
1869 snat_main_t *sm = &snat_main;
1870 snat_main_per_thread_data_t *tsm;
1872 clib_bihash_kv_8_8_t key, value;
1873 snat_user_key_t ukey;
1875 u32 session_index, head_index, elt_index;
1876 dlist_elt_t *head, *elt;
1879 reg = vl_api_client_index_to_registration (mp->client_index);
1883 clib_memcpy (&ukey.addr, mp->ip_address, 4);
1884 ip.src_address.as_u32 = ukey.addr.as_u32;
1885 ukey.fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->vrf_id));
1886 key.key = ukey.as_u64;
1887 if (sm->num_workers > 1)
1889 vec_elt_at_index (sm->per_thread_data,
1890 sm->worker_in2out_cb (&ip, ukey.fib_index, 0));
1892 tsm = vec_elt_at_index (sm->per_thread_data, sm->num_workers);
1893 if (!sm->endpoint_dependent)
1895 if (clib_bihash_search_8_8 (&tsm->user_hash, &key, &value))
1897 u = pool_elt_at_index (tsm->users, value.value);
1898 if (!u->nsessions && !u->nstaticsessions)
1901 head_index = u->sessions_per_user_list_head_index;
1902 head = pool_elt_at_index (tsm->list_pool, head_index);
1903 elt_index = head->next;
1904 elt = pool_elt_at_index (tsm->list_pool, elt_index);
1905 session_index = elt->value;
1906 while (session_index != ~0)
1908 s = pool_elt_at_index (tsm->sessions, session_index);
1910 send_nat44_user_session_details (s, reg, mp->context);
1912 elt_index = elt->next;
1913 elt = pool_elt_at_index (tsm->list_pool, elt_index);
1914 session_index = elt->value;
1920 pool_foreach (s, tsm->sessions, {
1921 if (s->in2out.addr.as_u32 == ukey.addr.as_u32)
1923 send_nat44_user_session_details (s, reg, mp->context);
1931 vl_api_nat44_user_session_dump_t_print (vl_api_nat44_user_session_dump_t * mp,
1936 s = format (0, "SCRIPT: nat44_user_session_dump ");
1937 s = format (s, "ip_address %U vrf_id %d\n",
1938 format_ip4_address, mp->ip_address,
1939 clib_net_to_host_u32 (mp->vrf_id));
1944 static nat44_lb_addr_port_t *
1945 unformat_nat44_lb_addr_port (vl_api_nat44_lb_addr_port_t * addr_port_pairs,
1946 u32 addr_port_pair_num)
1949 nat44_lb_addr_port_t *lb_addr_port_pairs = 0, lb_addr_port;
1950 vl_api_nat44_lb_addr_port_t *ap;
1952 for (i = 0; i < addr_port_pair_num; i++)
1954 ap = &addr_port_pairs[i];
1955 clib_memset (&lb_addr_port, 0, sizeof (lb_addr_port));
1956 clib_memcpy (&lb_addr_port.addr, ap->addr, 4);
1957 lb_addr_port.port = ap->port;
1958 lb_addr_port.probability = ap->probability;
1959 lb_addr_port.vrf_id = clib_net_to_host_u32 (ap->vrf_id);
1960 vec_add1 (lb_addr_port_pairs, lb_addr_port);
1963 return lb_addr_port_pairs;
1967 vl_api_nat44_add_del_lb_static_mapping_t_handler
1968 (vl_api_nat44_add_del_lb_static_mapping_t * mp)
1970 snat_main_t *sm = &snat_main;
1971 vl_api_nat44_add_del_lb_static_mapping_reply_t *rmp;
1972 twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1974 nat44_lb_addr_port_t *locals = 0;
1975 ip4_address_t e_addr;
1976 nat_protocol_t proto;
1979 if (!sm->endpoint_dependent)
1981 rv = VNET_API_ERROR_UNSUPPORTED;
1986 unformat_nat44_lb_addr_port (mp->locals,
1987 clib_net_to_host_u32 (mp->local_num));
1988 clib_memcpy (&e_addr, mp->external_addr, 4);
1989 proto = ip_proto_to_nat_proto (mp->protocol);
1991 if (mp->flags & NAT_API_IS_TWICE_NAT)
1992 twice_nat = TWICE_NAT;
1993 else if (mp->flags & NAT_API_IS_SELF_TWICE_NAT)
1994 twice_nat = TWICE_NAT_SELF;
1995 mp->tag[sizeof (mp->tag) - 1] = 0;
1996 tag = format (0, "%s", mp->tag);
1997 vec_terminate_c_string (tag);
2000 nat44_add_del_lb_static_mapping (e_addr,
2002 proto, locals, mp->is_add,
2004 mp->flags & NAT_API_IS_OUT2IN_ONLY, tag,
2005 clib_net_to_host_u32 (mp->affinity));
2011 REPLY_MACRO (VL_API_NAT44_ADD_DEL_LB_STATIC_MAPPING_REPLY);
2014 static void *vl_api_nat44_add_del_lb_static_mapping_t_print
2015 (vl_api_nat44_add_del_lb_static_mapping_t * mp, void *handle)
2019 s = format (0, "SCRIPT: nat44_add_del_lb_static_mapping ");
2020 s = format (s, "is_add %d twice_nat %d out2in_only %d ",
2022 mp->flags & NAT_API_IS_TWICE_NAT,
2023 mp->flags & NAT_API_IS_OUT2IN_ONLY);
2029 vl_api_nat44_lb_static_mapping_add_del_local_t_handler
2030 (vl_api_nat44_lb_static_mapping_add_del_local_t * mp)
2032 snat_main_t *sm = &snat_main;
2033 vl_api_nat44_lb_static_mapping_add_del_local_reply_t *rmp;
2035 ip4_address_t e_addr, l_addr;
2036 nat_protocol_t proto;
2038 if (!sm->endpoint_dependent)
2040 rv = VNET_API_ERROR_UNSUPPORTED;
2044 clib_memcpy (&e_addr, mp->external_addr, 4);
2045 clib_memcpy (&l_addr, mp->local.addr, 4);
2046 proto = ip_proto_to_nat_proto (mp->protocol);
2049 nat44_lb_static_mapping_add_del_local (e_addr,
2050 clib_net_to_host_u16
2051 (mp->external_port), l_addr,
2052 clib_net_to_host_u16 (mp->
2055 clib_net_to_host_u32 (mp->
2057 mp->local.probability, mp->is_add);
2060 REPLY_MACRO (VL_API_NAT44_LB_STATIC_MAPPING_ADD_DEL_LOCAL_REPLY);
2063 static void *vl_api_nat44_lb_static_mapping_add_del_local_t_print
2064 (vl_api_nat44_lb_static_mapping_add_del_local_t * mp, void *handle)
2068 s = format (0, "SCRIPT: nat44_lb_static_mapping_add_del_local ");
2069 s = format (s, "is_add %d", mp->is_add);
2075 send_nat44_lb_static_mapping_details (snat_static_mapping_t * m,
2076 vl_api_registration_t * reg,
2079 vl_api_nat44_lb_static_mapping_details_t *rmp;
2080 snat_main_t *sm = &snat_main;
2081 nat44_lb_addr_port_t *ap;
2082 vl_api_nat44_lb_addr_port_t *locals;
2086 vl_msg_api_alloc (sizeof (*rmp) +
2087 (pool_elts (m->locals) *
2088 sizeof (nat44_lb_addr_port_t)));
2089 clib_memset (rmp, 0, sizeof (*rmp));
2091 ntohs (VL_API_NAT44_LB_STATIC_MAPPING_DETAILS + sm->msg_id_base);
2093 clib_memcpy (rmp->external_addr, &(m->external_addr), 4);
2094 rmp->external_port = m->external_port;
2095 rmp->protocol = nat_proto_to_ip_proto (m->proto);
2096 rmp->context = context;
2098 if (m->twice_nat == TWICE_NAT)
2099 rmp->flags |= NAT_API_IS_TWICE_NAT;
2100 else if (m->twice_nat == TWICE_NAT_SELF)
2101 rmp->flags |= NAT_API_IS_SELF_TWICE_NAT;
2102 if (is_out2in_only_static_mapping (m))
2103 rmp->flags |= NAT_API_IS_OUT2IN_ONLY;
2105 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
2107 locals = (vl_api_nat44_lb_addr_port_t *) rmp->locals;
2109 pool_foreach (ap, m->locals,
2111 clib_memcpy (locals->addr, &(ap->addr), 4);
2112 locals->port = ap->port;
2113 locals->probability = ap->probability;
2114 locals->vrf_id = ntohl (ap->vrf_id);
2119 rmp->local_num = ntohl (local_num);
2121 vl_api_send_msg (reg, (u8 *) rmp);
2125 vl_api_nat44_lb_static_mapping_dump_t_handler
2126 (vl_api_nat44_lb_static_mapping_dump_t * mp)
2128 vl_api_registration_t *reg;
2129 snat_main_t *sm = &snat_main;
2130 snat_static_mapping_t *m;
2132 if (!sm->endpoint_dependent)
2135 reg = vl_api_client_index_to_registration (mp->client_index);
2140 pool_foreach (m, sm->static_mappings,
2142 if (is_lb_static_mapping(m))
2143 send_nat44_lb_static_mapping_details (m, reg, mp->context);
2148 static void *vl_api_nat44_lb_static_mapping_dump_t_print
2149 (vl_api_nat44_lb_static_mapping_dump_t * mp, void *handle)
2153 s = format (0, "SCRIPT: nat44_lb_static_mapping_dump ");
2159 vl_api_nat44_del_session_t_handler (vl_api_nat44_del_session_t * mp)
2161 snat_main_t *sm = &snat_main;
2162 vl_api_nat44_del_session_reply_t *rmp;
2163 ip4_address_t addr, eh_addr;
2168 nat_protocol_t proto;
2170 memcpy (&addr.as_u8, mp->address, 4);
2172 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
2173 proto = ip_proto_to_nat_proto (mp->protocol);
2174 memcpy (&eh_addr.as_u8, mp->ext_host_address, 4);
2175 eh_port = mp->ext_host_port;
2177 is_in = mp->flags & NAT_API_IS_INSIDE;
2179 if (mp->flags & NAT_API_IS_EXT_HOST_VALID)
2181 nat44_del_ed_session (sm, &addr, port, &eh_addr, eh_port, mp->protocol,
2184 rv = nat44_del_session (sm, &addr, port, proto, vrf_id, is_in);
2186 REPLY_MACRO (VL_API_NAT44_DEL_SESSION_REPLY);
2190 vl_api_nat44_del_session_t_print (vl_api_nat44_del_session_t * mp,
2195 s = format (0, "SCRIPT: nat44_add_del_session ");
2196 s = format (s, "addr %U port %d protocol %d vrf_id %d is_in %d",
2197 format_ip4_address, mp->address,
2198 clib_net_to_host_u16 (mp->port),
2199 mp->protocol, clib_net_to_host_u32 (mp->vrf_id),
2200 mp->flags & NAT_API_IS_INSIDE);
2201 if (mp->flags & NAT_API_IS_EXT_HOST_VALID)
2202 s = format (s, "ext_host_address %U ext_host_port %d",
2203 format_ip4_address, mp->ext_host_address,
2204 clib_net_to_host_u16 (mp->ext_host_port));
2210 vl_api_nat44_forwarding_enable_disable_t_handler
2211 (vl_api_nat44_forwarding_enable_disable_t * mp)
2213 snat_main_t *sm = &snat_main;
2214 vl_api_nat44_forwarding_enable_disable_reply_t *rmp;
2216 u32 *ses_to_be_removed = 0, *ses_index;
2217 snat_main_per_thread_data_t *tsm;
2220 sm->forwarding_enabled = mp->enable != 0;
2222 if (mp->enable == 0)
2225 vec_foreach (tsm, sm->per_thread_data)
2227 pool_foreach (s, tsm->sessions,
2229 if (is_fwd_bypass_session(s))
2231 vec_add1 (ses_to_be_removed, s - tsm->sessions);
2234 if(sm->endpoint_dependent){
2235 vec_foreach (ses_index, ses_to_be_removed)
2237 s = pool_elt_at_index(tsm->sessions, ses_index[0]);
2238 nat_free_session_data (sm, s, tsm - sm->per_thread_data, 0);
2239 nat_ed_session_delete (sm, s, tsm - sm->per_thread_data, 1);
2242 vec_foreach (ses_index, ses_to_be_removed)
2244 s = pool_elt_at_index(tsm->sessions, ses_index[0]);
2245 nat_free_session_data (sm, s, tsm - sm->per_thread_data, 0);
2246 nat44_delete_session (sm, s, tsm - sm->per_thread_data);
2249 vec_free (ses_to_be_removed);
2254 REPLY_MACRO (VL_API_NAT44_FORWARDING_ENABLE_DISABLE_REPLY);
2257 static void *vl_api_nat44_forwarding_enable_disable_t_print
2258 (vl_api_nat44_forwarding_enable_disable_t * mp, void *handle)
2262 s = format (0, "SCRIPT: nat44_forwarding_enable_disable ");
2263 s = format (s, "enable %d", mp->enable != 0);
2269 vl_api_nat44_forwarding_is_enabled_t_handler
2270 (vl_api_nat44_forwarding_is_enabled_t * mp)
2272 vl_api_registration_t *reg;
2273 snat_main_t *sm = &snat_main;
2274 vl_api_nat44_forwarding_is_enabled_reply_t *rmp;
2276 reg = vl_api_client_index_to_registration (mp->client_index);
2280 rmp = vl_msg_api_alloc (sizeof (*rmp));
2281 clib_memset (rmp, 0, sizeof (*rmp));
2283 ntohs (VL_API_NAT44_FORWARDING_IS_ENABLED_REPLY + sm->msg_id_base);
2284 rmp->context = mp->context;
2286 rmp->enabled = sm->forwarding_enabled;
2288 vl_api_send_msg (reg, (u8 *) rmp);
2291 static void *vl_api_nat44_forwarding_is_enabled_t_print
2292 (vl_api_nat44_forwarding_is_enabled_t * mp, void *handle)
2296 s = format (0, "SCRIPT: nat44_forwarding_is_enabled ");
2301 /* List of message types that this plugin understands */
2302 #define foreach_snat_plugin_api_msg \
2303 _(NAT_CONTROL_PING, nat_control_ping) \
2304 _(NAT_SHOW_CONFIG, nat_show_config) \
2305 _(NAT_SHOW_CONFIG_2, nat_show_config_2) \
2306 _(NAT_SET_WORKERS, nat_set_workers) \
2307 _(NAT_WORKER_DUMP, nat_worker_dump) \
2308 _(NAT44_PLUGIN_ENABLE_DISABLE, nat44_plugin_enable_disable) \
2309 _(NAT44_DEL_USER, nat44_del_user) \
2310 _(NAT44_SET_SESSION_LIMIT, nat44_set_session_limit) \
2311 _(NAT_SET_LOG_LEVEL, nat_set_log_level) \
2312 _(NAT_IPFIX_ENABLE_DISABLE, nat_ipfix_enable_disable) \
2313 _(NAT_SET_TIMEOUTS, nat_set_timeouts) \
2314 _(NAT_GET_TIMEOUTS, nat_get_timeouts) \
2315 _(NAT_SET_ADDR_AND_PORT_ALLOC_ALG, nat_set_addr_and_port_alloc_alg) \
2316 _(NAT_GET_ADDR_AND_PORT_ALLOC_ALG, nat_get_addr_and_port_alloc_alg) \
2317 _(NAT_SET_MSS_CLAMPING, nat_set_mss_clamping) \
2318 _(NAT_GET_MSS_CLAMPING, nat_get_mss_clamping) \
2319 _(NAT_HA_SET_LISTENER, nat_ha_set_listener) \
2320 _(NAT_HA_SET_FAILOVER, nat_ha_set_failover) \
2321 _(NAT_HA_GET_LISTENER, nat_ha_get_listener) \
2322 _(NAT_HA_GET_FAILOVER, nat_ha_get_failover) \
2323 _(NAT_HA_FLUSH, nat_ha_flush) \
2324 _(NAT_HA_RESYNC, nat_ha_resync) \
2325 _(NAT44_ADD_DEL_ADDRESS_RANGE, nat44_add_del_address_range) \
2326 _(NAT44_INTERFACE_ADD_DEL_FEATURE, nat44_interface_add_del_feature) \
2327 _(NAT44_ADD_DEL_STATIC_MAPPING, nat44_add_del_static_mapping) \
2328 _(NAT44_ADD_DEL_STATIC_MAPPING_V2, nat44_add_del_static_mapping_v2) \
2329 _(NAT44_ADD_DEL_IDENTITY_MAPPING, nat44_add_del_identity_mapping) \
2330 _(NAT44_STATIC_MAPPING_DUMP, nat44_static_mapping_dump) \
2331 _(NAT44_IDENTITY_MAPPING_DUMP, nat44_identity_mapping_dump) \
2332 _(NAT44_ADDRESS_DUMP, nat44_address_dump) \
2333 _(NAT44_INTERFACE_DUMP, nat44_interface_dump) \
2334 _(NAT44_ADD_DEL_INTERFACE_ADDR, nat44_add_del_interface_addr) \
2335 _(NAT44_INTERFACE_ADDR_DUMP, nat44_interface_addr_dump) \
2336 _(NAT44_USER_DUMP, nat44_user_dump) \
2337 _(NAT44_USER_SESSION_DUMP, nat44_user_session_dump) \
2338 _(NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE, \
2339 nat44_interface_add_del_output_feature) \
2340 _(NAT44_INTERFACE_OUTPUT_FEATURE_DUMP, \
2341 nat44_interface_output_feature_dump) \
2342 _(NAT44_ADD_DEL_LB_STATIC_MAPPING, nat44_add_del_lb_static_mapping) \
2343 _(NAT44_LB_STATIC_MAPPING_ADD_DEL_LOCAL, \
2344 nat44_lb_static_mapping_add_del_local) \
2345 _(NAT44_LB_STATIC_MAPPING_DUMP, nat44_lb_static_mapping_dump) \
2346 _(NAT44_DEL_SESSION, nat44_del_session) \
2347 _(NAT44_FORWARDING_ENABLE_DISABLE, nat44_forwarding_enable_disable) \
2348 _(NAT44_FORWARDING_IS_ENABLED, nat44_forwarding_is_enabled)
2350 /* Set up the API message handling tables */
2351 static clib_error_t *
2352 snat_plugin_api_hookup (vlib_main_t * vm)
2354 snat_main_t *sm __attribute__ ((unused)) = &snat_main;
2356 vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base), \
2358 vl_api_##n##_t_handler, \
2360 vl_api_##n##_t_endian, \
2361 vl_api_##n##_t_print, \
2362 sizeof(vl_api_##n##_t), 1);
2363 foreach_snat_plugin_api_msg;
2369 #define vl_msg_name_crc_list
2370 #include <nat/nat_all_api_h.h>
2371 #undef vl_msg_name_crc_list
2374 setup_message_id_table (snat_main_t * sm, api_main_t * am)
2376 #define _(id,n,crc) \
2377 vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + sm->msg_id_base);
2378 foreach_vl_msg_name_crc_nat;
2383 plugin_custom_dump_configure (snat_main_t * sm)
2385 #define _(n,f) sm->api_main->msg_print_handlers \
2386 [VL_API_##n + sm->msg_id_base] \
2387 = (void *) vl_api_##f##_t_print;
2388 foreach_snat_plugin_api_msg;
2393 snat_api_init (vlib_main_t * vm, snat_main_t * sm)
2396 clib_error_t *error = 0;
2398 name = format (0, "nat_%08x%c", api_version, 0);
2400 /* Ask for a correctly-sized block of API message decode slots */
2402 vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE);
2404 error = snat_plugin_api_hookup (vm);
2406 /* Add our API messages to the global name_crc hash table */
2407 setup_message_id_table (sm, sm->api_main);
2409 plugin_custom_dump_configure (sm);
2417 * fd.io coding-style-patch-verification: ON
2420 * eval: (c-set-style "gnu")