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_det.h>
23 #include <nat/nat64.h>
24 #include <nat/nat66.h>
25 #include <nat/dslite.h>
26 #include <nat/nat_reass.h>
27 #include <nat/nat_inlines.h>
28 #include <vlibapi/api.h>
29 #include <vlibmemory/api.h>
31 #include <nat/nat_msg_enum.h>
32 #include <vnet/fib/fib_table.h>
34 #define vl_api_nat44_lb_addr_port_t_endian vl_noop_handler
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); \
66 /******************************/
67 /*** Common NAT plugin APIs ***/
68 /******************************/
71 vl_api_nat_control_ping_t_handler (vl_api_nat_control_ping_t * mp)
73 vl_api_nat_control_ping_reply_t *rmp;
74 snat_main_t *sm = &snat_main;
78 REPLY_MACRO2 (VL_API_NAT_CONTROL_PING_REPLY,
80 rmp->vpe_pid = ntohl (getpid ());
86 vl_api_nat_control_ping_t_print (vl_api_nat_control_ping_t * mp, void *handle)
90 s = format (0, "SCRIPT: nat_control_ping ");
96 vl_api_nat_show_config_t_handler (vl_api_nat_show_config_t * mp)
98 vl_api_nat_show_config_reply_t *rmp;
99 snat_main_t *sm = &snat_main;
100 dslite_main_t *dm = &dslite_main;
101 nat64_main_t *n64m = &nat64_main;
105 REPLY_MACRO2 (VL_API_NAT_SHOW_CONFIG_REPLY,
107 rmp->translation_buckets = htonl (sm->translation_buckets);
108 rmp->translation_memory_size = htonl (sm->translation_memory_size);
109 rmp->user_buckets = htonl (sm->user_buckets);
110 rmp->user_memory_size = htonl (sm->user_memory_size);
111 rmp->max_translations_per_user = htonl (sm->max_translations_per_user);
112 rmp->outside_vrf_id = htonl (sm->outside_vrf_id);
113 rmp->inside_vrf_id = htonl (sm->inside_vrf_id);
114 rmp->static_mapping_only = sm->static_mapping_only;
115 rmp->static_mapping_connection_tracking =
116 sm->static_mapping_connection_tracking;
117 rmp->deterministic = sm->deterministic;
118 rmp->endpoint_dependent = sm->endpoint_dependent;
119 rmp->out2in_dpo = sm->out2in_dpo;
120 rmp->dslite_ce = dm->is_ce;
121 rmp->nat64_bib_buckets = n64m->bib_buckets;
122 rmp->nat64_bib_memory_size = n64m->bib_memory_size;
123 rmp->nat64_st_buckets = n64m->st_buckets;
124 rmp->nat64_st_memory_size = n64m->st_memory_size;
130 vl_api_nat_show_config_t_print (vl_api_nat_show_config_t * mp, void *handle)
134 s = format (0, "SCRIPT: nat_show_config ");
140 vl_api_nat_set_workers_t_handler (vl_api_nat_set_workers_t * mp)
142 snat_main_t *sm = &snat_main;
143 vl_api_nat_set_workers_reply_t *rmp;
148 if (sm->deterministic)
150 rv = VNET_API_ERROR_UNSUPPORTED;
154 mask = clib_net_to_host_u64 (mp->worker_mask);
156 if (sm->num_workers < 2)
158 rv = VNET_API_ERROR_FEATURE_DISABLED;
162 bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
163 rv = snat_set_workers (bitmap);
164 clib_bitmap_free (bitmap);
167 REPLY_MACRO (VL_API_NAT_SET_WORKERS_REPLY);
171 vl_api_nat_set_workers_t_print (vl_api_nat_set_workers_t * mp, void *handle)
177 u64 mask = clib_net_to_host_u64 (mp->worker_mask);
179 s = format (0, "SCRIPT: nat_set_workers ");
180 bitmap = clib_bitmap_set_multiple (bitmap, 0, mask, BITS (mask));
182 clib_bitmap_foreach (i, bitmap,
185 s = format (s, "%d", i);
187 s = format (s, ",%d", i);
191 clib_bitmap_free (bitmap);
196 send_nat_worker_details (u32 worker_index, vl_api_registration_t * reg,
199 vl_api_nat_worker_details_t *rmp;
200 snat_main_t *sm = &snat_main;
201 vlib_worker_thread_t *w =
202 vlib_worker_threads + worker_index + sm->first_worker_index;
204 rmp = vl_msg_api_alloc (sizeof (*rmp));
205 memset (rmp, 0, sizeof (*rmp));
206 rmp->_vl_msg_id = ntohs (VL_API_NAT_WORKER_DETAILS + sm->msg_id_base);
207 rmp->context = context;
208 rmp->worker_index = htonl (worker_index);
209 rmp->lcore_id = htonl (w->lcore_id);
210 strncpy ((char *) rmp->name, (char *) w->name, ARRAY_LEN (rmp->name) - 1);
212 vl_api_send_msg (reg, (u8 *) rmp);
216 vl_api_nat_worker_dump_t_handler (vl_api_nat_worker_dump_t * mp)
218 vl_api_registration_t *reg;
219 snat_main_t *sm = &snat_main;
222 if (sm->deterministic)
225 reg = vl_api_client_index_to_registration (mp->client_index);
230 vec_foreach (worker_index, sm->workers)
231 send_nat_worker_details(*worker_index, reg, mp->context);
236 vl_api_nat_worker_dump_t_print (vl_api_nat_worker_dump_t * mp, void *handle)
240 s = format (0, "SCRIPT: nat_worker_dump ");
246 vl_api_nat_ipfix_enable_disable_t_handler (vl_api_nat_ipfix_enable_disable_t *
249 snat_main_t *sm = &snat_main;
250 vl_api_nat_ipfix_enable_disable_reply_t *rmp;
253 rv = snat_ipfix_logging_enable_disable (mp->enable,
259 REPLY_MACRO (VL_API_NAT_IPFIX_ENABLE_DISABLE_REPLY);
263 vl_api_nat_ipfix_enable_disable_t_print (vl_api_nat_ipfix_enable_disable_t *
268 s = format (0, "SCRIPT: nat_ipfix_enable_disable ");
270 s = format (s, "domain %d ", clib_net_to_host_u32 (mp->domain_id));
272 s = format (s, "src_port %d ", clib_net_to_host_u16 (mp->src_port));
274 s = format (s, "disable ");
280 vl_api_nat_set_reass_t_handler (vl_api_nat_set_reass_t * mp)
282 snat_main_t *sm = &snat_main;
283 vl_api_nat_set_reass_reply_t *rmp;
287 nat_reass_set (ntohl (mp->timeout), ntohs (mp->max_reass), mp->max_frag,
288 mp->drop_frag, mp->is_ip6);
290 REPLY_MACRO (VL_API_NAT_SET_REASS_REPLY);
294 vl_api_nat_set_reass_t_print (vl_api_nat_set_reass_t * mp, void *handle)
298 s = format (0, "SCRIPT: nat_set_reass ");
299 s = format (s, "timeout %d max_reass %d max_frag %d drop_frag %d is_ip6 %d",
300 clib_host_to_net_u32 (mp->timeout),
301 clib_host_to_net_u16 (mp->max_reass),
302 mp->max_frag, mp->drop_frag, mp->is_ip6);
308 vl_api_nat_get_reass_t_handler (vl_api_nat_get_reass_t * mp)
310 snat_main_t *sm = &snat_main;
311 vl_api_nat_get_reass_reply_t *rmp;
315 REPLY_MACRO2 (VL_API_NAT_GET_REASS_REPLY,
317 rmp->ip4_timeout = htonl (nat_reass_get_timeout(0));
318 rmp->ip4_max_reass = htons (nat_reass_get_max_reass(0));
319 rmp->ip4_max_frag = nat_reass_get_max_frag(0);
320 rmp->ip4_drop_frag = nat_reass_is_drop_frag(0);
321 rmp->ip6_timeout = htonl (nat_reass_get_timeout(1));
322 rmp->ip6_max_reass = htons (nat_reass_get_max_reass(1));
323 rmp->ip6_max_frag = nat_reass_get_max_frag(1);
324 rmp->ip6_drop_frag = nat_reass_is_drop_frag(1);
330 vl_api_nat_get_reass_t_print (vl_api_nat_get_reass_t * mp, void *handle)
334 s = format (0, "SCRIPT: nat_get_reass");
339 typedef struct nat_api_walk_ctx_t_
341 vl_api_registration_t *reg;
343 } nat_api_walk_ctx_t;
346 nat_ip4_reass_walk_api (nat_reass_ip4_t * reass, void *arg)
348 vl_api_nat_reass_details_t *rmp;
349 snat_main_t *sm = &snat_main;
350 nat_api_walk_ctx_t *ctx = arg;
352 rmp = vl_msg_api_alloc (sizeof (*rmp));
353 memset (rmp, 0, sizeof (*rmp));
354 rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
355 rmp->context = ctx->context;
356 clib_memcpy (rmp->src_addr, &(reass->key.src), 4);
357 clib_memcpy (rmp->dst_addr, &(reass->key.dst), 4);
358 rmp->proto = reass->key.proto;
359 rmp->frag_id = ntohl (reass->key.frag_id);
360 rmp->frag_n = reass->frag_n;
363 vl_api_send_msg (ctx->reg, (u8 *) rmp);
369 nat_ip6_reass_walk_api (nat_reass_ip6_t * reass, void *arg)
371 vl_api_nat_reass_details_t *rmp;
372 snat_main_t *sm = &snat_main;
373 nat_api_walk_ctx_t *ctx = arg;
375 rmp = vl_msg_api_alloc (sizeof (*rmp));
376 memset (rmp, 0, sizeof (*rmp));
377 rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
378 rmp->context = ctx->context;
379 clib_memcpy (rmp->src_addr, &(reass->key.src), 16);
380 clib_memcpy (rmp->dst_addr, &(reass->key.dst), 16);
381 rmp->proto = reass->key.proto;
382 rmp->frag_id = ntohl (reass->key.frag_id);
383 rmp->frag_n = reass->frag_n;
386 vl_api_send_msg (ctx->reg, (u8 *) rmp);
392 vl_api_nat_reass_dump_t_handler (vl_api_nat_reass_dump_t * mp)
394 vl_api_registration_t *reg;
396 reg = vl_api_client_index_to_registration (mp->client_index);
400 nat_api_walk_ctx_t ctx = {
402 .context = mp->context,
405 nat_ip4_reass_walk (nat_ip4_reass_walk_api, &ctx);
406 nat_ip6_reass_walk (nat_ip6_reass_walk_api, &ctx);
410 vl_api_nat_reass_dump_t_print (vl_api_nat_reass_dump_t * mp, void *handle)
414 s = format (0, "SCRIPT: nat_reass_dump");
423 vl_api_nat44_add_del_address_range_t_handler
424 (vl_api_nat44_add_del_address_range_t * mp)
426 snat_main_t *sm = &snat_main;
427 vl_api_nat44_add_del_address_range_reply_t *rmp;
428 ip4_address_t this_addr;
429 u32 start_host_order, end_host_order;
435 if (sm->deterministic)
437 rv = VNET_API_ERROR_UNSUPPORTED;
441 if (sm->static_mapping_only)
443 rv = VNET_API_ERROR_FEATURE_DISABLED;
447 tmp = (u32 *) mp->first_ip_address;
448 start_host_order = clib_host_to_net_u32 (tmp[0]);
449 tmp = (u32 *) mp->last_ip_address;
450 end_host_order = clib_host_to_net_u32 (tmp[0]);
452 count = (end_host_order - start_host_order) + 1;
454 vrf_id = clib_host_to_net_u32 (mp->vrf_id);
457 nat_log_info ("%U - %U, %d addresses...",
458 format_ip4_address, mp->first_ip_address,
459 format_ip4_address, mp->last_ip_address, count);
461 memcpy (&this_addr.as_u8, mp->first_ip_address, 4);
463 for (i = 0; i < count; i++)
466 rv = snat_add_address (sm, &this_addr, vrf_id, mp->twice_nat);
468 rv = snat_del_address (sm, this_addr, 0, mp->twice_nat);
474 nat44_add_del_address_dpo (this_addr, mp->is_add);
476 increment_v4_address (&this_addr);
480 REPLY_MACRO (VL_API_NAT44_ADD_DEL_ADDRESS_RANGE_REPLY);
483 static void *vl_api_nat44_add_del_address_range_t_print
484 (vl_api_nat44_add_del_address_range_t * mp, void *handle)
488 s = format (0, "SCRIPT: nat44_add_address_range ");
489 s = format (s, "%U ", format_ip4_address, mp->first_ip_address);
490 if (memcmp (mp->first_ip_address, mp->last_ip_address, 4))
492 s = format (s, " - %U ", format_ip4_address, mp->last_ip_address);
494 s = format (s, "twice_nat %d ", mp->twice_nat);
499 send_nat44_address_details (snat_address_t * a,
500 vl_api_registration_t * reg, u32 context,
503 vl_api_nat44_address_details_t *rmp;
504 snat_main_t *sm = &snat_main;
506 rmp = vl_msg_api_alloc (sizeof (*rmp));
507 memset (rmp, 0, sizeof (*rmp));
508 rmp->_vl_msg_id = ntohs (VL_API_NAT44_ADDRESS_DETAILS + sm->msg_id_base);
509 clib_memcpy (rmp->ip_address, &(a->addr), 4);
510 if (a->fib_index != ~0)
512 fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP4);
513 rmp->vrf_id = ntohl (fib->ft_table_id);
517 rmp->twice_nat = twice_nat;
518 rmp->context = context;
520 vl_api_send_msg (reg, (u8 *) rmp);
524 vl_api_nat44_address_dump_t_handler (vl_api_nat44_address_dump_t * mp)
526 vl_api_registration_t *reg;
527 snat_main_t *sm = &snat_main;
530 if (sm->deterministic)
533 reg = vl_api_client_index_to_registration (mp->client_index);
538 vec_foreach (a, sm->addresses)
539 send_nat44_address_details (a, reg, mp->context, 0);
540 vec_foreach (a, sm->twice_nat_addresses)
541 send_nat44_address_details (a, reg, mp->context, 1);
546 vl_api_nat44_address_dump_t_print (vl_api_nat44_address_dump_t * mp,
551 s = format (0, "SCRIPT: nat44_address_dump ");
557 vl_api_nat44_interface_add_del_feature_t_handler
558 (vl_api_nat44_interface_add_del_feature_t * mp)
560 snat_main_t *sm = &snat_main;
561 vl_api_nat44_interface_add_del_feature_reply_t *rmp;
562 u8 is_del = mp->is_add == 0;
563 u32 sw_if_index = ntohl (mp->sw_if_index);
566 VALIDATE_SW_IF_INDEX (mp);
568 rv = snat_interface_add_del (sw_if_index, mp->is_inside, is_del);
570 BAD_SW_IF_INDEX_LABEL;
572 REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_FEATURE_REPLY);
575 static void *vl_api_nat44_interface_add_del_feature_t_print
576 (vl_api_nat44_interface_add_del_feature_t * mp, void *handle)
580 s = format (0, "SCRIPT: nat44_interface_add_del_feature ");
581 s = format (s, "sw_if_index %d %s %s",
582 clib_host_to_net_u32 (mp->sw_if_index),
583 mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
589 send_nat44_interface_details (snat_interface_t * i,
590 vl_api_registration_t * reg, u32 context)
592 vl_api_nat44_interface_details_t *rmp;
593 snat_main_t *sm = &snat_main;
595 rmp = vl_msg_api_alloc (sizeof (*rmp));
596 memset (rmp, 0, sizeof (*rmp));
597 rmp->_vl_msg_id = ntohs (VL_API_NAT44_INTERFACE_DETAILS + sm->msg_id_base);
598 rmp->sw_if_index = ntohl (i->sw_if_index);
599 rmp->is_inside = (nat_interface_is_inside (i)
600 && nat_interface_is_outside (i)) ? 2 :
601 nat_interface_is_inside (i);
602 rmp->context = context;
604 vl_api_send_msg (reg, (u8 *) rmp);
608 vl_api_nat44_interface_dump_t_handler (vl_api_nat44_interface_dump_t * mp)
610 vl_api_registration_t *reg;
611 snat_main_t *sm = &snat_main;
614 reg = vl_api_client_index_to_registration (mp->client_index);
619 pool_foreach (i, sm->interfaces,
621 send_nat44_interface_details(i, reg, mp->context);
627 vl_api_nat44_interface_dump_t_print (vl_api_nat44_interface_dump_t * mp,
632 s = format (0, "SCRIPT: nat44_interface_dump ");
638 vl_api_nat44_interface_add_del_output_feature_t_handler
639 (vl_api_nat44_interface_add_del_output_feature_t * mp)
641 snat_main_t *sm = &snat_main;
642 vl_api_nat44_interface_add_del_output_feature_reply_t *rmp;
643 u8 is_del = mp->is_add == 0;
644 u32 sw_if_index = ntohl (mp->sw_if_index);
647 if (sm->deterministic)
649 rv = VNET_API_ERROR_UNSUPPORTED;
653 VALIDATE_SW_IF_INDEX (mp);
655 rv = snat_interface_add_del_output_feature (sw_if_index, mp->is_inside,
658 BAD_SW_IF_INDEX_LABEL;
660 REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE_REPLY);
663 static void *vl_api_nat44_interface_add_del_output_feature_t_print
664 (vl_api_nat44_interface_add_del_output_feature_t * mp, void *handle)
668 s = format (0, "SCRIPT: nat44_interface_add_del_output_feature ");
669 s = format (s, "sw_if_index %d %s %s",
670 clib_host_to_net_u32 (mp->sw_if_index),
671 mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
677 send_nat44_interface_output_feature_details (snat_interface_t * i,
678 vl_api_registration_t * reg,
681 vl_api_nat44_interface_output_feature_details_t *rmp;
682 snat_main_t *sm = &snat_main;
684 rmp = vl_msg_api_alloc (sizeof (*rmp));
685 memset (rmp, 0, sizeof (*rmp));
687 ntohs (VL_API_NAT44_INTERFACE_OUTPUT_FEATURE_DETAILS + sm->msg_id_base);
688 rmp->sw_if_index = ntohl (i->sw_if_index);
689 rmp->context = context;
690 rmp->is_inside = nat_interface_is_inside (i);
692 vl_api_send_msg (reg, (u8 *) rmp);
696 vl_api_nat44_interface_output_feature_dump_t_handler
697 (vl_api_nat44_interface_output_feature_dump_t * mp)
699 vl_api_registration_t *reg;
700 snat_main_t *sm = &snat_main;
703 if (sm->deterministic)
706 reg = vl_api_client_index_to_registration (mp->client_index);
711 pool_foreach (i, sm->output_feature_interfaces,
713 send_nat44_interface_output_feature_details(i, reg, mp->context);
718 static void *vl_api_nat44_interface_output_feature_dump_t_print
719 (vl_api_nat44_interface_output_feature_dump_t * mp, void *handle)
723 s = format (0, "SCRIPT: nat44_interface_output_feature_dump ");
729 vl_api_nat44_add_del_static_mapping_t_handler
730 (vl_api_nat44_add_del_static_mapping_t * mp)
732 snat_main_t *sm = &snat_main;
733 vl_api_nat44_add_del_static_mapping_reply_t *rmp;
734 ip4_address_t local_addr, external_addr;
735 u16 local_port = 0, external_port = 0;
736 u32 vrf_id, external_sw_if_index;
737 twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
739 snat_protocol_t proto;
742 if (sm->deterministic)
744 rv = VNET_API_ERROR_UNSUPPORTED;
748 memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
749 memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
750 if (mp->addr_only == 0)
752 local_port = clib_net_to_host_u16 (mp->local_port);
753 external_port = clib_net_to_host_u16 (mp->external_port);
755 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
756 external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
757 proto = ip_proto_to_snat_proto (mp->protocol);
759 twice_nat = TWICE_NAT;
760 else if (mp->self_twice_nat)
761 twice_nat = TWICE_NAT_SELF;
762 mp->tag[sizeof (mp->tag) - 1] = 0;
763 tag = format (0, "%s", mp->tag);
764 vec_terminate_c_string (tag);
766 rv = snat_add_static_mapping (local_addr, external_addr, local_port,
767 external_port, vrf_id, mp->addr_only,
768 external_sw_if_index, proto, mp->is_add,
769 twice_nat, mp->out2in_only, tag);
774 REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_REPLY);
777 static void *vl_api_nat44_add_del_static_mapping_t_print
778 (vl_api_nat44_add_del_static_mapping_t * mp, void *handle)
782 s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
783 s = format (s, "protocol %d local_addr %U external_addr %U ",
785 format_ip4_address, mp->local_ip_address,
786 format_ip4_address, mp->external_ip_address);
788 if (mp->addr_only == 0)
789 s = format (s, "local_port %d external_port %d ",
790 clib_net_to_host_u16 (mp->local_port),
791 clib_net_to_host_u16 (mp->external_port));
793 s = format (s, "twice_nat %d out2in_only %d ",
794 mp->twice_nat, mp->out2in_only);
796 if (mp->vrf_id != ~0)
797 s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
799 if (mp->external_sw_if_index != ~0)
800 s = format (s, "external_sw_if_index %d",
801 clib_net_to_host_u32 (mp->external_sw_if_index));
806 send_nat44_static_mapping_details (snat_static_mapping_t * m,
807 vl_api_registration_t * reg, u32 context)
809 vl_api_nat44_static_mapping_details_t *rmp;
810 snat_main_t *sm = &snat_main;
812 rmp = vl_msg_api_alloc (sizeof (*rmp));
813 memset (rmp, 0, sizeof (*rmp));
815 ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
816 rmp->addr_only = m->addr_only;
817 clib_memcpy (rmp->local_ip_address, &(m->local_addr), 4);
818 clib_memcpy (rmp->external_ip_address, &(m->external_addr), 4);
819 rmp->external_sw_if_index = ~0;
820 rmp->vrf_id = htonl (m->vrf_id);
821 rmp->context = context;
822 if (m->twice_nat == TWICE_NAT)
824 else if (m->twice_nat == TWICE_NAT_SELF)
825 rmp->self_twice_nat = 1;
826 rmp->out2in_only = m->out2in_only;
827 if (m->addr_only == 0)
829 rmp->protocol = snat_proto_to_ip_proto (m->proto);
830 rmp->external_port = htons (m->external_port);
831 rmp->local_port = htons (m->local_port);
834 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
836 vl_api_send_msg (reg, (u8 *) rmp);
840 send_nat44_static_map_resolve_details (snat_static_map_resolve_t * m,
841 vl_api_registration_t * reg,
844 vl_api_nat44_static_mapping_details_t *rmp;
845 snat_main_t *sm = &snat_main;
847 rmp = vl_msg_api_alloc (sizeof (*rmp));
848 memset (rmp, 0, sizeof (*rmp));
850 ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
851 rmp->addr_only = m->addr_only;
852 clib_memcpy (rmp->local_ip_address, &(m->l_addr), 4);
853 rmp->external_sw_if_index = htonl (m->sw_if_index);
854 rmp->vrf_id = htonl (m->vrf_id);
855 rmp->context = context;
856 rmp->twice_nat = m->twice_nat;
857 if (m->addr_only == 0)
859 rmp->protocol = snat_proto_to_ip_proto (m->proto);
860 rmp->external_port = htons (m->e_port);
861 rmp->local_port = htons (m->l_port);
864 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
866 vl_api_send_msg (reg, (u8 *) rmp);
870 vl_api_nat44_static_mapping_dump_t_handler (vl_api_nat44_static_mapping_dump_t
873 vl_api_registration_t *reg;
874 snat_main_t *sm = &snat_main;
875 snat_static_mapping_t *m;
876 snat_static_map_resolve_t *rp;
879 if (sm->deterministic)
882 reg = vl_api_client_index_to_registration (mp->client_index);
887 pool_foreach (m, sm->static_mappings,
889 if (!vec_len (m->locals) &&
890 ((m->local_port != m->external_port)
891 || (m->local_addr.as_u32 != m->external_addr.as_u32)))
892 send_nat44_static_mapping_details (m, reg, mp->context);
896 for (j = 0; j < vec_len (sm->to_resolve); j++)
898 rp = sm->to_resolve + j;
899 if (rp->l_addr.as_u32 != 0)
900 send_nat44_static_map_resolve_details (rp, reg, mp->context);
905 vl_api_nat44_static_mapping_dump_t_print (vl_api_nat44_static_mapping_dump_t *
910 s = format (0, "SCRIPT: nat44_static_mapping_dump ");
916 vl_api_nat44_add_del_identity_mapping_t_handler
917 (vl_api_nat44_add_del_identity_mapping_t * mp)
919 snat_main_t *sm = &snat_main;
920 vl_api_nat44_add_del_identity_mapping_reply_t *rmp;
923 u32 vrf_id, sw_if_index;
925 snat_protocol_t proto = ~0;
928 if (sm->deterministic)
930 rv = VNET_API_ERROR_UNSUPPORTED;
934 if (mp->addr_only == 0)
936 port = clib_net_to_host_u16 (mp->port);
937 proto = ip_proto_to_snat_proto (mp->protocol);
939 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
940 sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
941 if (sw_if_index != ~0)
944 memcpy (&addr.as_u8, mp->ip_address, 4);
945 mp->tag[sizeof (mp->tag) - 1] = 0;
946 tag = format (0, "%s", mp->tag);
947 vec_terminate_c_string (tag);
950 snat_add_static_mapping (addr, addr, port, port, vrf_id, mp->addr_only,
951 sw_if_index, proto, mp->is_add, 0, 0, tag);
956 REPLY_MACRO (VL_API_NAT44_ADD_DEL_IDENTITY_MAPPING_REPLY);
959 static void *vl_api_nat44_add_del_identity_mapping_t_print
960 (vl_api_nat44_add_del_identity_mapping_t * mp, void *handle)
964 s = format (0, "SCRIPT: nat44_add_del_identity_mapping ");
965 if (mp->sw_if_index != ~0)
966 s = format (s, "sw_if_index %d", clib_net_to_host_u32 (mp->sw_if_index));
968 s = format (s, "addr %U", format_ip4_address, mp->ip_address);
970 if (mp->addr_only == 0)
972 format (s, "protocol %d port %d", mp->protocol,
973 clib_net_to_host_u16 (mp->port));
975 if (mp->vrf_id != ~0)
976 s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
982 send_nat44_identity_mapping_details (snat_static_mapping_t * m,
983 vl_api_registration_t * reg, u32 context)
985 vl_api_nat44_identity_mapping_details_t *rmp;
986 snat_main_t *sm = &snat_main;
988 rmp = vl_msg_api_alloc (sizeof (*rmp));
989 memset (rmp, 0, sizeof (*rmp));
991 ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
992 rmp->addr_only = m->addr_only;
993 clib_memcpy (rmp->ip_address, &(m->local_addr), 4);
994 rmp->port = htons (m->local_port);
995 rmp->sw_if_index = ~0;
996 rmp->vrf_id = htonl (m->vrf_id);
997 rmp->protocol = snat_proto_to_ip_proto (m->proto);
998 rmp->context = context;
1000 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1002 vl_api_send_msg (reg, (u8 *) rmp);
1006 send_nat44_identity_map_resolve_details (snat_static_map_resolve_t * m,
1007 vl_api_registration_t * reg,
1010 vl_api_nat44_identity_mapping_details_t *rmp;
1011 snat_main_t *sm = &snat_main;
1013 rmp = vl_msg_api_alloc (sizeof (*rmp));
1014 memset (rmp, 0, sizeof (*rmp));
1016 ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
1017 rmp->addr_only = m->addr_only;
1018 rmp->port = htons (m->l_port);
1019 rmp->sw_if_index = htonl (m->sw_if_index);
1020 rmp->vrf_id = htonl (m->vrf_id);
1021 rmp->protocol = snat_proto_to_ip_proto (m->proto);
1022 rmp->context = context;
1024 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1026 vl_api_send_msg (reg, (u8 *) rmp);
1030 vl_api_nat44_identity_mapping_dump_t_handler
1031 (vl_api_nat44_identity_mapping_dump_t * mp)
1033 vl_api_registration_t *reg;
1034 snat_main_t *sm = &snat_main;
1035 snat_static_mapping_t *m;
1036 snat_static_map_resolve_t *rp;
1039 if (sm->deterministic)
1042 reg = vl_api_client_index_to_registration (mp->client_index);
1047 pool_foreach (m, sm->static_mappings,
1049 if (!vec_len (m->locals) && (m->local_port == m->external_port)
1050 && (m->local_addr.as_u32 == m->external_addr.as_u32))
1051 send_nat44_identity_mapping_details (m, reg, mp->context);
1055 for (j = 0; j < vec_len (sm->to_resolve); j++)
1057 rp = sm->to_resolve + j;
1058 if (rp->l_addr.as_u32 == 0)
1059 send_nat44_identity_map_resolve_details (rp, reg, mp->context);
1063 static void *vl_api_nat44_identity_mapping_dump_t_print
1064 (vl_api_nat44_identity_mapping_dump_t * mp, void *handle)
1068 s = format (0, "SCRIPT: nat44_identity_mapping_dump ");
1074 vl_api_nat44_add_del_interface_addr_t_handler
1075 (vl_api_nat44_add_del_interface_addr_t * mp)
1077 snat_main_t *sm = &snat_main;
1078 vl_api_nat44_add_del_interface_addr_reply_t *rmp;
1079 u8 is_del = mp->is_add == 0;
1080 u32 sw_if_index = ntohl (mp->sw_if_index);
1083 if (sm->deterministic)
1085 rv = VNET_API_ERROR_UNSUPPORTED;
1089 VALIDATE_SW_IF_INDEX (mp);
1091 rv = snat_add_interface_address (sm, sw_if_index, is_del, mp->twice_nat);
1093 BAD_SW_IF_INDEX_LABEL;
1095 REPLY_MACRO (VL_API_NAT44_ADD_DEL_INTERFACE_ADDR_REPLY);
1098 static void *vl_api_nat44_add_del_interface_addr_t_print
1099 (vl_api_nat44_add_del_interface_addr_t * mp, void *handle)
1103 s = format (0, "SCRIPT: nat44_add_del_interface_addr ");
1104 s = format (s, "sw_if_index %d twice_nat %d %s",
1105 clib_host_to_net_u32 (mp->sw_if_index),
1106 mp->twice_nat, mp->is_add ? "" : "del");
1112 send_nat44_interface_addr_details (u32 sw_if_index,
1113 vl_api_registration_t * reg, u32 context,
1116 vl_api_nat44_interface_addr_details_t *rmp;
1117 snat_main_t *sm = &snat_main;
1119 rmp = vl_msg_api_alloc (sizeof (*rmp));
1120 memset (rmp, 0, sizeof (*rmp));
1122 ntohs (VL_API_NAT44_INTERFACE_ADDR_DETAILS + sm->msg_id_base);
1123 rmp->sw_if_index = ntohl (sw_if_index);
1124 rmp->twice_nat = twice_nat;
1125 rmp->context = context;
1127 vl_api_send_msg (reg, (u8 *) rmp);
1131 vl_api_nat44_interface_addr_dump_t_handler (vl_api_nat44_interface_addr_dump_t
1134 vl_api_registration_t *reg;
1135 snat_main_t *sm = &snat_main;
1138 if (sm->deterministic)
1141 reg = vl_api_client_index_to_registration (mp->client_index);
1146 vec_foreach (i, sm->auto_add_sw_if_indices)
1147 send_nat44_interface_addr_details(*i, reg, mp->context, 0);
1148 vec_foreach (i, sm->auto_add_sw_if_indices_twice_nat)
1149 send_nat44_interface_addr_details(*i, reg, mp->context, 1);
1154 vl_api_nat44_interface_addr_dump_t_print (vl_api_nat44_interface_addr_dump_t *
1159 s = format (0, "SCRIPT: nat44_interface_addr_dump ");
1165 send_nat44_user_details (snat_user_t * u, vl_api_registration_t * reg,
1168 vl_api_nat44_user_details_t *rmp;
1169 snat_main_t *sm = &snat_main;
1170 ip4_main_t *im = &ip4_main;
1172 rmp = vl_msg_api_alloc (sizeof (*rmp));
1173 memset (rmp, 0, sizeof (*rmp));
1174 rmp->_vl_msg_id = ntohs (VL_API_NAT44_USER_DETAILS + sm->msg_id_base);
1176 if (!pool_is_free_index (im->fibs, u->fib_index))
1178 fib_table_t *fib = fib_table_get (u->fib_index, FIB_PROTOCOL_IP4);
1179 rmp->vrf_id = ntohl (fib->ft_table_id);
1182 clib_memcpy (rmp->ip_address, &(u->addr), 4);
1183 rmp->nsessions = ntohl (u->nsessions);
1184 rmp->nstaticsessions = ntohl (u->nstaticsessions);
1185 rmp->context = context;
1187 vl_api_send_msg (reg, (u8 *) rmp);
1191 vl_api_nat44_user_dump_t_handler (vl_api_nat44_user_dump_t * mp)
1193 vl_api_registration_t *reg;
1194 snat_main_t *sm = &snat_main;
1195 snat_main_per_thread_data_t *tsm;
1198 if (sm->deterministic)
1201 reg = vl_api_client_index_to_registration (mp->client_index);
1206 vec_foreach (tsm, sm->per_thread_data)
1208 pool_foreach (u, tsm->users,
1210 send_nat44_user_details (u, reg, mp->context);
1217 vl_api_nat44_user_dump_t_print (vl_api_nat44_user_dump_t * mp, void *handle)
1221 s = format (0, "SCRIPT: nat44_user_dump ");
1227 send_nat44_user_session_details (snat_session_t * s,
1228 vl_api_registration_t * reg, u32 context)
1230 vl_api_nat44_user_session_details_t *rmp;
1231 snat_main_t *sm = &snat_main;
1233 rmp = vl_msg_api_alloc (sizeof (*rmp));
1234 memset (rmp, 0, sizeof (*rmp));
1236 ntohs (VL_API_NAT44_USER_SESSION_DETAILS + sm->msg_id_base);
1237 clib_memcpy (rmp->outside_ip_address, (&s->out2in.addr), 4);
1238 clib_memcpy (rmp->inside_ip_address, (&s->in2out.addr), 4);
1239 rmp->is_static = snat_is_session_static (s) ? 1 : 0;
1240 rmp->is_twicenat = is_twice_nat_session (s) ? 1 : 0;
1241 rmp->ext_host_valid = is_ed_session (s)
1242 || is_fwd_bypass_session (s) ? 1 : 0;
1243 rmp->last_heard = clib_host_to_net_u64 ((u64) s->last_heard);
1244 rmp->total_bytes = clib_host_to_net_u64 (s->total_bytes);
1245 rmp->total_pkts = ntohl (s->total_pkts);
1246 rmp->context = context;
1247 if (snat_is_unk_proto_session (s))
1249 rmp->outside_port = 0;
1250 rmp->inside_port = 0;
1251 rmp->protocol = ntohs (s->in2out.port);
1255 rmp->outside_port = s->out2in.port;
1256 rmp->inside_port = s->in2out.port;
1257 rmp->protocol = ntohs (snat_proto_to_ip_proto (s->in2out.protocol));
1259 if (is_ed_session (s) || is_fwd_bypass_session (s))
1261 clib_memcpy (rmp->ext_host_address, &s->ext_host_addr, 4);
1262 rmp->ext_host_port = s->ext_host_port;
1263 if (is_twice_nat_session (s))
1265 clib_memcpy (rmp->ext_host_nat_address, &s->ext_host_nat_addr, 4);
1266 rmp->ext_host_nat_port = s->ext_host_nat_port;
1270 vl_api_send_msg (reg, (u8 *) rmp);
1274 vl_api_nat44_user_session_dump_t_handler (vl_api_nat44_user_session_dump_t *
1277 vl_api_registration_t *reg;
1278 snat_main_t *sm = &snat_main;
1279 snat_main_per_thread_data_t *tsm;
1281 clib_bihash_kv_8_8_t key, value;
1282 snat_user_key_t ukey;
1284 u32 session_index, head_index, elt_index;
1285 dlist_elt_t *head, *elt;
1288 if (sm->deterministic)
1291 reg = vl_api_client_index_to_registration (mp->client_index);
1295 clib_memcpy (&ukey.addr, mp->ip_address, 4);
1296 ip.src_address.as_u32 = ukey.addr.as_u32;
1297 ukey.fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->vrf_id));
1298 key.key = ukey.as_u64;
1299 if (sm->num_workers > 1)
1301 vec_elt_at_index (sm->per_thread_data,
1302 sm->worker_in2out_cb (&ip, ukey.fib_index));
1304 tsm = vec_elt_at_index (sm->per_thread_data, sm->num_workers);
1305 if (clib_bihash_search_8_8 (&tsm->user_hash, &key, &value))
1307 u = pool_elt_at_index (tsm->users, value.value);
1308 if (!u->nsessions && !u->nstaticsessions)
1311 head_index = u->sessions_per_user_list_head_index;
1312 head = pool_elt_at_index (tsm->list_pool, head_index);
1313 elt_index = head->next;
1314 elt = pool_elt_at_index (tsm->list_pool, elt_index);
1315 session_index = elt->value;
1316 while (session_index != ~0)
1318 s = pool_elt_at_index (tsm->sessions, session_index);
1320 send_nat44_user_session_details (s, reg, mp->context);
1322 elt_index = elt->next;
1323 elt = pool_elt_at_index (tsm->list_pool, elt_index);
1324 session_index = elt->value;
1329 vl_api_nat44_user_session_dump_t_print (vl_api_nat44_user_session_dump_t * mp,
1334 s = format (0, "SCRIPT: nat44_user_session_dump ");
1335 s = format (s, "ip_address %U vrf_id %d\n",
1336 format_ip4_address, mp->ip_address,
1337 clib_net_to_host_u32 (mp->vrf_id));
1342 static nat44_lb_addr_port_t *
1343 unformat_nat44_lb_addr_port (vl_api_nat44_lb_addr_port_t * addr_port_pairs,
1344 u8 addr_port_pair_num)
1347 nat44_lb_addr_port_t *lb_addr_port_pairs = 0, lb_addr_port;
1348 vl_api_nat44_lb_addr_port_t *ap;
1350 for (i = 0; i < addr_port_pair_num; i++)
1352 ap = &addr_port_pairs[i];
1353 memset (&lb_addr_port, 0, sizeof (lb_addr_port));
1354 clib_memcpy (&lb_addr_port.addr, ap->addr, 4);
1355 lb_addr_port.port = clib_net_to_host_u16 (ap->port);
1356 lb_addr_port.probability = ap->probability;
1357 lb_addr_port.vrf_id = clib_net_to_host_u32 (ap->vrf_id);
1358 vec_add1 (lb_addr_port_pairs, lb_addr_port);
1361 return lb_addr_port_pairs;
1365 vl_api_nat44_add_del_lb_static_mapping_t_handler
1366 (vl_api_nat44_add_del_lb_static_mapping_t * mp)
1368 snat_main_t *sm = &snat_main;
1369 vl_api_nat44_add_del_lb_static_mapping_reply_t *rmp;
1370 twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
1372 nat44_lb_addr_port_t *locals = 0;
1373 ip4_address_t e_addr;
1374 snat_protocol_t proto;
1377 if (!sm->endpoint_dependent)
1379 rv = VNET_API_ERROR_UNSUPPORTED;
1383 locals = unformat_nat44_lb_addr_port (mp->locals, mp->local_num);
1384 clib_memcpy (&e_addr, mp->external_addr, 4);
1385 proto = ip_proto_to_snat_proto (mp->protocol);
1387 twice_nat = TWICE_NAT;
1388 else if (mp->self_twice_nat)
1389 twice_nat = TWICE_NAT_SELF;
1390 mp->tag[sizeof (mp->tag) - 1] = 0;
1391 tag = format (0, "%s", mp->tag);
1392 vec_terminate_c_string (tag);
1395 nat44_add_del_lb_static_mapping (e_addr,
1396 clib_net_to_host_u16 (mp->external_port),
1397 proto, locals, mp->is_add, twice_nat,
1398 mp->out2in_only, tag);
1404 REPLY_MACRO (VL_API_NAT44_ADD_DEL_LB_STATIC_MAPPING_REPLY);
1407 static void *vl_api_nat44_add_del_lb_static_mapping_t_print
1408 (vl_api_nat44_add_del_lb_static_mapping_t * mp, void *handle)
1412 s = format (0, "SCRIPT: nat44_add_del_lb_static_mapping ");
1413 s = format (s, "is_add %d twice_nat %d out2in_only %d ",
1414 mp->is_add, mp->twice_nat, mp->out2in_only);
1420 send_nat44_lb_static_mapping_details (snat_static_mapping_t * m,
1421 vl_api_registration_t * reg,
1424 vl_api_nat44_lb_static_mapping_details_t *rmp;
1425 snat_main_t *sm = &snat_main;
1426 nat44_lb_addr_port_t *ap;
1427 vl_api_nat44_lb_addr_port_t *locals;
1430 vl_msg_api_alloc (sizeof (*rmp) +
1431 (vec_len (m->locals) * sizeof (nat44_lb_addr_port_t)));
1432 memset (rmp, 0, sizeof (*rmp));
1434 ntohs (VL_API_NAT44_LB_STATIC_MAPPING_DETAILS + sm->msg_id_base);
1436 clib_memcpy (rmp->external_addr, &(m->external_addr), 4);
1437 rmp->external_port = ntohs (m->external_port);
1438 rmp->protocol = snat_proto_to_ip_proto (m->proto);
1439 rmp->context = context;
1440 if (m->twice_nat == TWICE_NAT)
1442 else if (m->twice_nat == TWICE_NAT_SELF)
1443 rmp->self_twice_nat = 1;
1444 rmp->out2in_only = m->out2in_only;
1446 strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
1448 locals = (vl_api_nat44_lb_addr_port_t *) rmp->locals;
1449 vec_foreach (ap, m->locals)
1451 clib_memcpy (locals->addr, &(ap->addr), 4);
1452 locals->port = htons (ap->port);
1453 locals->probability = ap->probability;
1454 locals->vrf_id = ntohl (ap->vrf_id);
1459 vl_api_send_msg (reg, (u8 *) rmp);
1463 vl_api_nat44_lb_static_mapping_dump_t_handler
1464 (vl_api_nat44_lb_static_mapping_dump_t * mp)
1466 vl_api_registration_t *reg;
1467 snat_main_t *sm = &snat_main;
1468 snat_static_mapping_t *m;
1470 if (!sm->endpoint_dependent)
1473 reg = vl_api_client_index_to_registration (mp->client_index);
1478 pool_foreach (m, sm->static_mappings,
1480 if (vec_len(m->locals))
1481 send_nat44_lb_static_mapping_details (m, reg, mp->context);
1486 static void *vl_api_nat44_lb_static_mapping_dump_t_print
1487 (vl_api_nat44_lb_static_mapping_dump_t * mp, void *handle)
1491 s = format (0, "SCRIPT: nat44_lb_static_mapping_dump ");
1497 vl_api_nat44_del_session_t_handler (vl_api_nat44_del_session_t * mp)
1499 snat_main_t *sm = &snat_main;
1500 vl_api_nat44_del_session_reply_t *rmp;
1501 ip4_address_t addr, eh_addr;
1505 snat_protocol_t proto;
1507 if (sm->deterministic)
1509 rv = VNET_API_ERROR_UNSUPPORTED;
1513 memcpy (&addr.as_u8, mp->address, 4);
1514 port = clib_net_to_host_u16 (mp->port);
1515 vrf_id = clib_net_to_host_u32 (mp->vrf_id);
1516 proto = ip_proto_to_snat_proto (mp->protocol);
1517 memcpy (&eh_addr.as_u8, mp->ext_host_address, 4);
1518 eh_port = clib_net_to_host_u16 (mp->ext_host_port);
1520 if (mp->ext_host_valid)
1522 nat44_del_ed_session (sm, &addr, port, &eh_addr, eh_port, mp->protocol,
1525 rv = nat44_del_session (sm, &addr, port, proto, vrf_id, mp->is_in);
1528 REPLY_MACRO (VL_API_NAT44_DEL_SESSION_REPLY);
1532 vl_api_nat44_del_session_t_print (vl_api_nat44_del_session_t * mp,
1537 s = format (0, "SCRIPT: nat44_add_del_static_mapping ");
1538 s = format (s, "addr %U port %d protocol %d vrf_id %d is_in %d",
1539 format_ip4_address, mp->address,
1540 clib_net_to_host_u16 (mp->port),
1541 mp->protocol, clib_net_to_host_u32 (mp->vrf_id), mp->is_in);
1542 if (mp->ext_host_valid)
1543 s = format (s, "ext_host_address %U ext_host_port %d",
1544 format_ip4_address, mp->ext_host_address,
1545 clib_net_to_host_u16 (mp->ext_host_port));
1551 vl_api_nat44_forwarding_enable_disable_t_handler
1552 (vl_api_nat44_forwarding_enable_disable_t * mp)
1554 snat_main_t *sm = &snat_main;
1555 vl_api_nat44_forwarding_enable_disable_reply_t *rmp;
1557 u32 *ses_to_be_removed = 0, *ses_index;
1558 snat_main_per_thread_data_t *tsm;
1561 sm->forwarding_enabled = mp->enable != 0;
1563 if (mp->enable == 0)
1566 vec_foreach (tsm, sm->per_thread_data)
1568 pool_foreach (s, tsm->sessions,
1570 if (is_fwd_bypass_session(s))
1572 vec_add1 (ses_to_be_removed, s - tsm->sessions);
1575 vec_foreach (ses_index, ses_to_be_removed)
1577 s = pool_elt_at_index(tsm->sessions, ses_index[0]);
1578 nat_free_session_data (sm, s, tsm - sm->per_thread_data);
1579 nat44_delete_session (sm, s, tsm - sm->per_thread_data);
1581 vec_free (ses_to_be_removed);
1586 REPLY_MACRO (VL_API_NAT44_FORWARDING_ENABLE_DISABLE_REPLY);
1589 static void *vl_api_nat44_forwarding_enable_disable_t_print
1590 (vl_api_nat44_forwarding_enable_disable_t * mp, void *handle)
1594 s = format (0, "SCRIPT: nat44_forwarding_enable_disable ");
1595 s = format (s, "enable %d", mp->enable != 0);
1601 vl_api_nat44_forwarding_is_enabled_t_handler
1602 (vl_api_nat44_forwarding_is_enabled_t * mp)
1604 vl_api_registration_t *reg;
1605 snat_main_t *sm = &snat_main;
1606 vl_api_nat44_forwarding_is_enabled_reply_t *rmp;
1608 reg = vl_api_client_index_to_registration (mp->client_index);
1612 rmp = vl_msg_api_alloc (sizeof (*rmp));
1613 memset (rmp, 0, sizeof (*rmp));
1615 ntohs (VL_API_NAT44_FORWARDING_IS_ENABLED_REPLY + sm->msg_id_base);
1616 rmp->context = mp->context;
1618 rmp->enabled = sm->forwarding_enabled;
1620 vl_api_send_msg (reg, (u8 *) rmp);
1623 static void *vl_api_nat44_forwarding_is_enabled_t_print
1624 (vl_api_nat44_forwarding_is_enabled_t * mp, void *handle)
1628 s = format (0, "SCRIPT: nat44_forwarding_is_enabled ");
1633 /*******************************/
1634 /*** Deterministic NAT (CGN) ***/
1635 /*******************************/
1638 vl_api_nat_det_add_del_map_t_handler (vl_api_nat_det_add_del_map_t * mp)
1640 snat_main_t *sm = &snat_main;
1641 vl_api_nat_det_add_del_map_reply_t *rmp;
1643 ip4_address_t in_addr, out_addr;
1645 if (!sm->deterministic)
1647 rv = VNET_API_ERROR_UNSUPPORTED;
1653 rv = VNET_API_ERROR_UNIMPLEMENTED;
1657 clib_memcpy (&in_addr, mp->in_addr, 4);
1658 clib_memcpy (&out_addr, mp->out_addr, 4);
1659 rv = snat_det_add_map (sm, &in_addr, mp->in_plen, &out_addr,
1660 mp->out_plen, mp->is_add);
1663 REPLY_MACRO (VL_API_NAT_DET_ADD_DEL_MAP_REPLY);
1667 vl_api_nat_det_add_del_map_t_print (vl_api_nat_det_add_del_map_t * mp,
1672 s = format (0, "SCRIPT: nat_det_add_del_map ");
1673 s = format (s, "inside address %U/%d outside address %U/%d\n",
1674 format_ip4_address, mp->in_addr, mp->in_plen,
1675 format_ip4_address, mp->out_addr, mp->out_plen);
1681 vl_api_nat_det_forward_t_handler (vl_api_nat_det_forward_t * mp)
1683 snat_main_t *sm = &snat_main;
1684 vl_api_nat_det_forward_reply_t *rmp;
1686 u16 lo_port = 0, hi_port = 0;
1688 ip4_address_t in_addr, out_addr;
1690 if (!sm->deterministic)
1692 rv = VNET_API_ERROR_UNSUPPORTED;
1693 REPLY_MACRO (VL_API_NAT_DET_FORWARD_REPLY);
1699 out_addr.as_u32 = 0;
1700 rv = VNET_API_ERROR_UNIMPLEMENTED;
1704 out_addr.as_u32 = 0;
1705 clib_memcpy (&in_addr, mp->in_addr, 4);
1706 dm = snat_det_map_by_user (sm, &in_addr);
1709 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1713 snat_det_forward (dm, &in_addr, &out_addr, &lo_port);
1714 hi_port = lo_port + dm->ports_per_host - 1;
1718 REPLY_MACRO2 (VL_API_NAT_DET_FORWARD_REPLY,
1720 rmp->out_port_lo = ntohs (lo_port);
1721 rmp->out_port_hi = ntohs (hi_port);
1722 clib_memcpy (rmp->out_addr, &out_addr, 4);
1728 vl_api_nat_det_forward_t_print (vl_api_nat_det_forward_t * mp, void *handle)
1732 s = format (0, "SCRIPT: nat_det_forward");
1733 s = format (s, "inside ip address %U\n", format_ip4_address, mp->in_addr);
1739 vl_api_nat_det_reverse_t_handler (vl_api_nat_det_reverse_t * mp)
1741 snat_main_t *sm = &snat_main;
1742 vl_api_nat_det_reverse_reply_t *rmp;
1744 ip4_address_t out_addr, in_addr;
1747 if (!sm->deterministic)
1749 rv = VNET_API_ERROR_UNSUPPORTED;
1750 REPLY_MACRO (VL_API_NAT_DET_REVERSE_REPLY);
1755 clib_memcpy (&out_addr, mp->out_addr, 4);
1756 dm = snat_det_map_by_out (sm, &out_addr);
1759 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1763 snat_det_reverse (dm, &out_addr, htons (mp->out_port), &in_addr);
1767 REPLY_MACRO2 (VL_API_NAT_DET_REVERSE_REPLY,
1770 memset (rmp->in_addr, 0, 16);
1771 clib_memcpy (rmp->in_addr, &in_addr, 4);
1777 vl_api_nat_det_reverse_t_print (vl_api_nat_det_reverse_t * mp, void *handle)
1781 s = format (0, "SCRIPT: nat_det_reverse");
1782 s = format (s, "outside ip address %U outside port %d",
1783 format_ip4_address, mp->out_addr, ntohs (mp->out_port));
1789 sent_nat_det_map_details (snat_det_map_t * m, vl_api_registration_t * reg,
1792 vl_api_nat_det_map_details_t *rmp;
1793 snat_main_t *sm = &snat_main;
1795 rmp = vl_msg_api_alloc (sizeof (*rmp));
1796 memset (rmp, 0, sizeof (*rmp));
1797 rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_MAP_DETAILS + sm->msg_id_base);
1799 clib_memcpy (rmp->in_addr, &m->in_addr, 4);
1800 rmp->in_plen = m->in_plen;
1801 clib_memcpy (rmp->out_addr, &m->out_addr, 4);
1802 rmp->out_plen = m->out_plen;
1803 rmp->sharing_ratio = htonl (m->sharing_ratio);
1804 rmp->ports_per_host = htons (m->ports_per_host);
1805 rmp->ses_num = htonl (m->ses_num);
1806 rmp->context = context;
1808 vl_api_send_msg (reg, (u8 *) rmp);
1812 vl_api_nat_det_map_dump_t_handler (vl_api_nat_det_map_dump_t * mp)
1814 vl_api_registration_t *reg;
1815 snat_main_t *sm = &snat_main;
1818 if (!sm->deterministic)
1821 reg = vl_api_client_index_to_registration (mp->client_index);
1826 vec_foreach(m, sm->det_maps)
1827 sent_nat_det_map_details(m, reg, mp->context);
1832 vl_api_nat_det_map_dump_t_print (vl_api_nat_det_map_dump_t * mp, void *handle)
1836 s = format (0, "SCRIPT: nat_det_map_dump ");
1842 vl_api_nat_det_set_timeouts_t_handler (vl_api_nat_det_set_timeouts_t * mp)
1844 snat_main_t *sm = &snat_main;
1845 vl_api_nat_det_set_timeouts_reply_t *rmp;
1848 if (!sm->deterministic)
1850 rv = VNET_API_ERROR_UNSUPPORTED;
1854 sm->udp_timeout = ntohl (mp->udp);
1855 sm->tcp_established_timeout = ntohl (mp->tcp_established);
1856 sm->tcp_transitory_timeout = ntohl (mp->tcp_transitory);
1857 sm->icmp_timeout = ntohl (mp->icmp);
1860 REPLY_MACRO (VL_API_NAT_DET_SET_TIMEOUTS_REPLY);
1864 vl_api_nat_det_set_timeouts_t_print (vl_api_nat_det_set_timeouts_t * mp,
1869 s = format (0, "SCRIPT: nat_det_set_timeouts ");
1870 s = format (s, "udp %d tcp_established %d tcp_transitory %d icmp %d\n",
1872 ntohl (mp->tcp_established),
1873 ntohl (mp->tcp_transitory), ntohl (mp->icmp));
1879 vl_api_nat_det_get_timeouts_t_handler (vl_api_nat_det_get_timeouts_t * mp)
1881 snat_main_t *sm = &snat_main;
1882 vl_api_nat_det_get_timeouts_reply_t *rmp;
1885 if (!sm->deterministic)
1887 rv = VNET_API_ERROR_UNSUPPORTED;
1888 REPLY_MACRO (VL_API_NAT_DET_GET_TIMEOUTS_REPLY);
1893 REPLY_MACRO2 (VL_API_NAT_DET_GET_TIMEOUTS_REPLY,
1895 rmp->udp = htonl (sm->udp_timeout);
1896 rmp->tcp_established = htonl (sm->tcp_established_timeout);
1897 rmp->tcp_transitory = htonl (sm->tcp_transitory_timeout);
1898 rmp->icmp = htonl (sm->icmp_timeout);
1904 vl_api_nat_det_get_timeouts_t_print (vl_api_nat_det_get_timeouts_t * mp,
1909 s = format (0, "SCRIPT: nat_det_get_timeouts");
1915 vl_api_nat_det_close_session_out_t_handler (vl_api_nat_det_close_session_out_t
1918 snat_main_t *sm = &snat_main;
1919 vl_api_nat_det_close_session_out_reply_t *rmp;
1920 ip4_address_t out_addr, ext_addr, in_addr;
1921 snat_det_out_key_t key;
1923 snat_det_session_t *ses;
1926 if (!sm->deterministic)
1928 rv = VNET_API_ERROR_UNSUPPORTED;
1932 clib_memcpy (&out_addr, mp->out_addr, 4);
1933 clib_memcpy (&ext_addr, mp->ext_addr, 4);
1935 dm = snat_det_map_by_out (sm, &out_addr);
1938 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1941 snat_det_reverse (dm, &ext_addr, ntohs (mp->out_port), &in_addr);
1942 key.ext_host_addr = ext_addr;
1943 key.ext_host_port = mp->ext_port;
1944 key.out_port = mp->out_port;
1945 ses = snat_det_get_ses_by_out (dm, &in_addr, key.as_u64);
1948 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1951 snat_det_ses_close (dm, ses);
1954 REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
1958 vl_api_nat_det_close_session_out_t_print (vl_api_nat_det_close_session_out_t *
1963 s = format (0, "SCRIPT: nat_det_close_session_out ");
1964 s = format (s, "out_addr %U out_port %d "
1965 "ext_addr %U ext_port %d\n",
1966 format_ip4_address, mp->out_addr, ntohs (mp->out_port),
1967 format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
1973 vl_api_nat_det_close_session_in_t_handler (vl_api_nat_det_close_session_in_t *
1976 snat_main_t *sm = &snat_main;
1977 vl_api_nat_det_close_session_in_reply_t *rmp;
1978 ip4_address_t in_addr, ext_addr;
1979 snat_det_out_key_t key;
1981 snat_det_session_t *ses;
1984 if (!sm->deterministic)
1986 rv = VNET_API_ERROR_UNSUPPORTED;
1992 rv = VNET_API_ERROR_UNIMPLEMENTED;
1996 clib_memcpy (&in_addr, mp->in_addr, 4);
1997 clib_memcpy (&ext_addr, mp->ext_addr, 4);
1999 dm = snat_det_map_by_user (sm, &in_addr);
2002 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2005 key.ext_host_addr = ext_addr;
2006 key.ext_host_port = mp->ext_port;
2007 ses = snat_det_find_ses_by_in (dm, &in_addr, mp->in_port, key);
2010 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2013 snat_det_ses_close (dm, ses);
2016 REPLY_MACRO (VL_API_NAT_DET_CLOSE_SESSION_OUT_REPLY);
2020 vl_api_nat_det_close_session_in_t_print (vl_api_nat_det_close_session_in_t *
2024 s = format (0, "SCRIPT: nat_det_close_session_in ");
2025 s = format (s, "in_addr %U in_port %d ext_addr %U ext_port %d\n",
2026 format_ip4_address, mp->in_addr, ntohs (mp->in_port),
2027 format_ip4_address, mp->ext_addr, ntohs (mp->ext_port));
2033 send_nat_det_session_details (snat_det_session_t * s,
2034 vl_api_registration_t * reg, u32 context)
2036 vl_api_nat_det_session_details_t *rmp;
2037 snat_main_t *sm = &snat_main;
2039 rmp = vl_msg_api_alloc (sizeof (*rmp));
2040 memset (rmp, 0, sizeof (*rmp));
2041 rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_SESSION_DETAILS + sm->msg_id_base);
2042 rmp->in_port = s->in_port;
2043 clib_memcpy (rmp->ext_addr, &s->out.ext_host_addr, 4);
2044 rmp->ext_port = s->out.ext_host_port;
2045 rmp->out_port = s->out.out_port;
2046 rmp->state = s->state;
2047 rmp->expire = ntohl (s->expire);
2048 rmp->context = context;
2050 vl_api_send_msg (reg, (u8 *) rmp);
2054 vl_api_nat_det_session_dump_t_handler (vl_api_nat_det_session_dump_t * mp)
2056 vl_api_registration_t *reg;
2057 snat_main_t *sm = &snat_main;
2058 ip4_address_t user_addr;
2060 snat_det_session_t *s, empty_ses;
2063 if (!sm->deterministic)
2066 reg = vl_api_client_index_to_registration (mp->client_index);
2072 memset (&empty_ses, 0, sizeof (empty_ses));
2073 clib_memcpy (&user_addr, mp->user_addr, 4);
2074 dm = snat_det_map_by_user (sm, &user_addr);
2078 s = dm->sessions + snat_det_user_ses_offset (&user_addr, dm->in_plen);
2079 for (i = 0; i < SNAT_DET_SES_PER_USER; i++)
2082 send_nat_det_session_details (s, reg, mp->context);
2088 vl_api_nat_det_session_dump_t_print (vl_api_nat_det_session_dump_t * mp,
2093 s = format (0, "SCRIPT: nat_det_session_dump ");
2094 s = format (s, "user_addr %U\n", format_ip4_address, mp->user_addr);
2104 vl_api_nat64_add_del_pool_addr_range_t_handler
2105 (vl_api_nat64_add_del_pool_addr_range_t * mp)
2107 vl_api_nat64_add_del_pool_addr_range_reply_t *rmp;
2108 snat_main_t *sm = &snat_main;
2110 ip4_address_t this_addr;
2111 u32 start_host_order, end_host_order;
2116 tmp = (u32 *) mp->start_addr;
2117 start_host_order = clib_host_to_net_u32 (tmp[0]);
2118 tmp = (u32 *) mp->end_addr;
2119 end_host_order = clib_host_to_net_u32 (tmp[0]);
2121 count = (end_host_order - start_host_order) + 1;
2123 vrf_id = clib_host_to_net_u32 (mp->vrf_id);
2125 memcpy (&this_addr.as_u8, mp->start_addr, 4);
2127 for (i = 0; i < count; i++)
2129 if ((rv = nat64_add_del_pool_addr (&this_addr, vrf_id, mp->is_add)))
2132 increment_v4_address (&this_addr);
2136 REPLY_MACRO (VL_API_NAT64_ADD_DEL_POOL_ADDR_RANGE_REPLY);
2139 static void *vl_api_nat64_add_del_pool_addr_range_t_print
2140 (vl_api_nat64_add_del_pool_addr_range_t * mp, void *handle)
2144 s = format (0, "SCRIPT: nat64_add_del_pool_addr_range ");
2145 s = format (s, "%U - %U vrf_id %u %s\n",
2146 format_ip4_address, mp->start_addr,
2147 format_ip4_address, mp->end_addr,
2148 ntohl (mp->vrf_id), mp->is_add ? "" : "del");
2153 typedef struct nat64_api_walk_ctx_t_
2155 vl_api_registration_t *reg;
2158 } nat64_api_walk_ctx_t;
2161 nat64_api_pool_walk (snat_address_t * a, void *arg)
2163 vl_api_nat64_pool_addr_details_t *rmp;
2164 snat_main_t *sm = &snat_main;
2165 nat64_api_walk_ctx_t *ctx = arg;
2167 rmp = vl_msg_api_alloc (sizeof (*rmp));
2168 memset (rmp, 0, sizeof (*rmp));
2169 rmp->_vl_msg_id = ntohs (VL_API_NAT64_POOL_ADDR_DETAILS + sm->msg_id_base);
2170 clib_memcpy (rmp->address, &(a->addr), 4);
2171 if (a->fib_index != ~0)
2173 fib_table_t *fib = fib_table_get (a->fib_index, FIB_PROTOCOL_IP6);
2176 rmp->vrf_id = ntohl (fib->ft_table_id);
2180 rmp->context = ctx->context;
2182 vl_api_send_msg (ctx->reg, (u8 *) rmp);
2188 vl_api_nat64_pool_addr_dump_t_handler (vl_api_nat64_pool_addr_dump_t * mp)
2190 vl_api_registration_t *reg;
2192 reg = vl_api_client_index_to_registration (mp->client_index);
2196 nat64_api_walk_ctx_t ctx = {
2198 .context = mp->context,
2201 nat64_pool_addr_walk (nat64_api_pool_walk, &ctx);
2205 vl_api_nat64_pool_addr_dump_t_print (vl_api_nat64_pool_addr_dump_t * mp,
2210 s = format (0, "SCRIPT: nat64_pool_addr_dump\n");
2216 vl_api_nat64_add_del_interface_t_handler (vl_api_nat64_add_del_interface_t *
2219 snat_main_t *sm = &snat_main;
2220 vl_api_nat64_add_del_interface_reply_t *rmp;
2223 VALIDATE_SW_IF_INDEX (mp);
2226 nat64_add_del_interface (ntohl (mp->sw_if_index), mp->is_inside,
2229 BAD_SW_IF_INDEX_LABEL;
2231 REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_REPLY);
2235 vl_api_nat64_add_del_interface_t_print (vl_api_nat64_add_del_interface_t * mp,
2240 s = format (0, "SCRIPT: nat64_add_del_interface ");
2241 s = format (s, "sw_if_index %d %s %s",
2242 clib_host_to_net_u32 (mp->sw_if_index),
2243 mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
2249 nat64_api_interface_walk (snat_interface_t * i, void *arg)
2251 vl_api_nat64_interface_details_t *rmp;
2252 snat_main_t *sm = &snat_main;
2253 nat64_api_walk_ctx_t *ctx = arg;
2255 rmp = vl_msg_api_alloc (sizeof (*rmp));
2256 memset (rmp, 0, sizeof (*rmp));
2257 rmp->_vl_msg_id = ntohs (VL_API_NAT64_INTERFACE_DETAILS + sm->msg_id_base);
2258 rmp->sw_if_index = ntohl (i->sw_if_index);
2259 rmp->is_inside = (nat_interface_is_inside (i)
2260 && nat_interface_is_outside (i)) ? 2 :
2261 nat_interface_is_inside (i);
2262 rmp->context = ctx->context;
2264 vl_api_send_msg (ctx->reg, (u8 *) rmp);
2270 vl_api_nat64_interface_dump_t_handler (vl_api_nat64_interface_dump_t * mp)
2272 vl_api_registration_t *reg;
2274 reg = vl_api_client_index_to_registration (mp->client_index);
2278 nat64_api_walk_ctx_t ctx = {
2280 .context = mp->context,
2283 nat64_interfaces_walk (nat64_api_interface_walk, &ctx);
2287 vl_api_nat64_interface_dump_t_print (vl_api_nat64_interface_dump_t * mp,
2292 s = format (0, "SCRIPT: snat_interface_dump ");
2298 vl_api_nat64_add_del_static_bib_t_handler
2299 (vl_api_nat64_add_del_static_bib_t * mp)
2301 snat_main_t *sm = &snat_main;
2302 vl_api_nat64_add_del_static_bib_reply_t *rmp;
2303 ip6_address_t in_addr;
2304 ip4_address_t out_addr;
2307 memcpy (&in_addr.as_u8, mp->i_addr, 16);
2308 memcpy (&out_addr.as_u8, mp->o_addr, 4);
2311 nat64_add_del_static_bib_entry (&in_addr, &out_addr,
2312 clib_net_to_host_u16 (mp->i_port),
2313 clib_net_to_host_u16 (mp->o_port),
2315 clib_net_to_host_u32 (mp->vrf_id),
2318 REPLY_MACRO (VL_API_NAT64_ADD_DEL_STATIC_BIB_REPLY);
2321 static void *vl_api_nat64_add_del_static_bib_t_print
2322 (vl_api_nat64_add_del_static_bib_t * mp, void *handle)
2326 s = format (0, "SCRIPT: nat64_add_del_static_bib ");
2327 s = format (s, "protocol %d i_addr %U o_addr %U ",
2329 format_ip6_address, mp->i_addr, format_ip4_address, mp->o_addr);
2331 if (mp->vrf_id != ~0)
2332 s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
2338 nat64_api_bib_walk (nat64_db_bib_entry_t * bibe, void *arg)
2340 vl_api_nat64_bib_details_t *rmp;
2341 snat_main_t *sm = &snat_main;
2342 nat64_api_walk_ctx_t *ctx = arg;
2345 fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2349 rmp = vl_msg_api_alloc (sizeof (*rmp));
2350 memset (rmp, 0, sizeof (*rmp));
2351 rmp->_vl_msg_id = ntohs (VL_API_NAT64_BIB_DETAILS + sm->msg_id_base);
2352 rmp->context = ctx->context;
2353 clib_memcpy (rmp->i_addr, &(bibe->in_addr), 16);
2354 clib_memcpy (rmp->o_addr, &(bibe->out_addr), 4);
2355 rmp->i_port = bibe->in_port;
2356 rmp->o_port = bibe->out_port;
2357 rmp->vrf_id = ntohl (fib->ft_table_id);
2358 rmp->proto = bibe->proto;
2359 rmp->is_static = bibe->is_static;
2360 rmp->ses_num = ntohl (bibe->ses_num);
2362 vl_api_send_msg (ctx->reg, (u8 *) rmp);
2368 vl_api_nat64_bib_dump_t_handler (vl_api_nat64_bib_dump_t * mp)
2370 vl_api_registration_t *reg;
2371 nat64_main_t *nm = &nat64_main;
2374 reg = vl_api_client_index_to_registration (mp->client_index);
2378 nat64_api_walk_ctx_t ctx = {
2380 .context = mp->context,
2384 vec_foreach (db, nm->db)
2385 nat64_db_bib_walk (db, mp->proto, nat64_api_bib_walk, &ctx);
2390 vl_api_nat64_bib_dump_t_print (vl_api_nat64_bib_dump_t * mp, void *handle)
2394 s = format (0, "SCRIPT: snat_bib_dump protocol %d", mp->proto);
2400 vl_api_nat64_set_timeouts_t_handler (vl_api_nat64_set_timeouts_t * mp)
2402 snat_main_t *sm = &snat_main;
2403 vl_api_nat64_set_timeouts_reply_t *rmp;
2406 rv = nat64_set_icmp_timeout (ntohl (mp->icmp));
2409 rv = nat64_set_udp_timeout (ntohl (mp->udp));
2413 nat64_set_tcp_timeouts (ntohl (mp->tcp_trans), ntohl (mp->tcp_est),
2414 ntohl (mp->tcp_incoming_syn));
2417 REPLY_MACRO (VL_API_NAT64_SET_TIMEOUTS_REPLY);
2420 static void *vl_api_nat64_set_timeouts_t_print
2421 (vl_api_nat64_set_timeouts_t * mp, void *handle)
2425 s = format (0, "SCRIPT: nat64_set_timeouts ");
2428 "udp %d icmp %d, tcp_trans %d, tcp_est %d, tcp_incoming_syn %d\n",
2429 ntohl (mp->udp), ntohl (mp->icmp), ntohl (mp->tcp_trans),
2430 ntohl (mp->tcp_est), ntohl (mp->tcp_incoming_syn));
2436 vl_api_nat64_get_timeouts_t_handler (vl_api_nat64_get_timeouts_t * mp)
2438 snat_main_t *sm = &snat_main;
2439 vl_api_nat64_get_timeouts_reply_t *rmp;
2443 REPLY_MACRO2 (VL_API_NAT64_GET_TIMEOUTS_REPLY,
2445 rmp->udp = htonl (nat64_get_udp_timeout());
2446 rmp->icmp = htonl (nat64_get_icmp_timeout());
2447 rmp->tcp_trans = htonl (nat64_get_tcp_trans_timeout());
2448 rmp->tcp_est = htonl (nat64_get_tcp_est_timeout());
2449 rmp->tcp_incoming_syn = htonl (nat64_get_tcp_incoming_syn_timeout());
2454 static void *vl_api_nat64_get_timeouts_t_print
2455 (vl_api_nat64_get_timeouts_t * mp, void *handle)
2459 s = format (0, "SCRIPT: nat64_get_timeouts");
2465 nat64_api_st_walk (nat64_db_st_entry_t * ste, void *arg)
2467 vl_api_nat64_st_details_t *rmp;
2468 snat_main_t *sm = &snat_main;
2469 nat64_api_walk_ctx_t *ctx = arg;
2470 nat64_db_bib_entry_t *bibe;
2473 bibe = nat64_db_bib_entry_by_index (ctx->db, ste->proto, ste->bibe_index);
2477 fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
2481 rmp = vl_msg_api_alloc (sizeof (*rmp));
2482 memset (rmp, 0, sizeof (*rmp));
2483 rmp->_vl_msg_id = ntohs (VL_API_NAT64_ST_DETAILS + sm->msg_id_base);
2484 rmp->context = ctx->context;
2485 clib_memcpy (rmp->il_addr, &(bibe->in_addr), 16);
2486 clib_memcpy (rmp->ol_addr, &(bibe->out_addr), 4);
2487 rmp->il_port = bibe->in_port;
2488 rmp->ol_port = bibe->out_port;
2489 clib_memcpy (rmp->ir_addr, &(ste->in_r_addr), 16);
2490 clib_memcpy (rmp->or_addr, &(ste->out_r_addr), 4);
2491 rmp->il_port = ste->r_port;
2492 rmp->vrf_id = ntohl (fib->ft_table_id);
2493 rmp->proto = ste->proto;
2495 vl_api_send_msg (ctx->reg, (u8 *) rmp);
2501 vl_api_nat64_st_dump_t_handler (vl_api_nat64_st_dump_t * mp)
2503 vl_api_registration_t *reg;
2504 nat64_main_t *nm = &nat64_main;
2507 reg = vl_api_client_index_to_registration (mp->client_index);
2511 nat64_api_walk_ctx_t ctx = {
2513 .context = mp->context,
2517 vec_foreach (db, nm->db)
2520 nat64_db_st_walk (db, mp->proto, nat64_api_st_walk, &ctx);
2526 vl_api_nat64_st_dump_t_print (vl_api_nat64_st_dump_t * mp, void *handle)
2530 s = format (0, "SCRIPT: snat_st_dump protocol %d", mp->proto);
2536 vl_api_nat64_add_del_prefix_t_handler (vl_api_nat64_add_del_prefix_t * mp)
2538 vl_api_nat64_add_del_prefix_reply_t *rmp;
2539 snat_main_t *sm = &snat_main;
2540 ip6_address_t prefix;
2543 memcpy (&prefix.as_u8, mp->prefix, 16);
2546 nat64_add_del_prefix (&prefix, mp->prefix_len,
2547 clib_net_to_host_u32 (mp->vrf_id), mp->is_add);
2548 REPLY_MACRO (VL_API_NAT64_ADD_DEL_PREFIX_REPLY);
2552 vl_api_nat64_add_del_prefix_t_print (vl_api_nat64_add_del_prefix_t * mp,
2557 s = format (0, "SCRIPT: nat64_add_del_prefix %U/%u vrf_id %u %s\n",
2558 format_ip6_address, mp->prefix, mp->prefix_len,
2559 ntohl (mp->vrf_id), mp->is_add ? "" : "del");
2565 nat64_api_prefix_walk (nat64_prefix_t * p, void *arg)
2567 vl_api_nat64_prefix_details_t *rmp;
2568 snat_main_t *sm = &snat_main;
2569 nat64_api_walk_ctx_t *ctx = arg;
2571 rmp = vl_msg_api_alloc (sizeof (*rmp));
2572 memset (rmp, 0, sizeof (*rmp));
2573 rmp->_vl_msg_id = ntohs (VL_API_NAT64_PREFIX_DETAILS + sm->msg_id_base);
2574 clib_memcpy (rmp->prefix, &(p->prefix), 16);
2575 rmp->prefix_len = p->plen;
2576 rmp->vrf_id = ntohl (p->vrf_id);
2577 rmp->context = ctx->context;
2579 vl_api_send_msg (ctx->reg, (u8 *) rmp);
2585 vl_api_nat64_prefix_dump_t_handler (vl_api_nat64_prefix_dump_t * mp)
2587 vl_api_registration_t *reg;
2589 reg = vl_api_client_index_to_registration (mp->client_index);
2593 nat64_api_walk_ctx_t ctx = {
2595 .context = mp->context,
2598 nat64_prefix_walk (nat64_api_prefix_walk, &ctx);
2602 vl_api_nat64_prefix_dump_t_print (vl_api_nat64_prefix_dump_t * mp,
2607 s = format (0, "SCRIPT: nat64_prefix_dump\n");
2613 vl_api_nat64_add_del_interface_addr_t_handler
2614 (vl_api_nat64_add_del_interface_addr_t * mp)
2616 snat_main_t *sm = &snat_main;
2617 vl_api_nat64_add_del_interface_addr_reply_t *rmp;
2618 u32 sw_if_index = ntohl (mp->sw_if_index);
2621 VALIDATE_SW_IF_INDEX (mp);
2623 rv = nat64_add_interface_address (sw_if_index, mp->is_add);
2625 BAD_SW_IF_INDEX_LABEL;
2627 REPLY_MACRO (VL_API_NAT64_ADD_DEL_INTERFACE_ADDR_REPLY);
2630 static void *vl_api_nat64_add_del_interface_addr_t_print
2631 (vl_api_nat64_add_del_interface_addr_t * mp, void *handle)
2635 s = format (0, "SCRIPT: nat64_add_del_interface_addr ");
2636 s = format (s, "sw_if_index %d %s",
2637 clib_host_to_net_u32 (mp->sw_if_index),
2638 mp->is_add ? "" : "del");
2648 vl_api_dslite_set_aftr_addr_t_handler (vl_api_dslite_set_aftr_addr_t * mp)
2650 vl_api_dslite_set_aftr_addr_reply_t *rmp;
2651 snat_main_t *sm = &snat_main;
2652 dslite_main_t *dm = &dslite_main;
2654 ip6_address_t ip6_addr;
2655 ip4_address_t ip4_addr;
2657 memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
2658 memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
2660 rv = dslite_set_aftr_ip6_addr (dm, &ip6_addr);
2662 rv = dslite_set_aftr_ip4_addr (dm, &ip4_addr);
2664 REPLY_MACRO (VL_API_DSLITE_SET_AFTR_ADDR_REPLY);
2668 vl_api_dslite_set_aftr_addr_t_print (vl_api_dslite_set_aftr_addr_t * mp,
2673 s = format (0, "SCRIPT: dslite_set_aftr_addr ");
2674 s = format (s, "ip6_addr %U ip4_addr %U\n",
2675 format_ip6_address, mp->ip6_addr,
2676 format_ip4_address, mp->ip4_addr);
2682 vl_api_dslite_get_aftr_addr_t_handler (vl_api_dslite_get_aftr_addr_t * mp)
2684 snat_main_t *sm = &snat_main;
2685 vl_api_dslite_get_aftr_addr_reply_t *rmp;
2686 dslite_main_t *dm = &dslite_main;
2690 REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
2692 memcpy (rmp->ip4_addr, &dm->aftr_ip4_addr.as_u8, 4);
2693 memcpy (rmp->ip6_addr, &dm->aftr_ip6_addr.as_u8, 16);
2699 vl_api_dslite_get_aftr_addr_t_print (vl_api_dslite_get_aftr_addr_t * mp,
2704 s = format (0, "SCRIPT: dslite_get_aftr_addr");
2710 vl_api_dslite_set_b4_addr_t_handler (vl_api_dslite_set_b4_addr_t * mp)
2712 vl_api_dslite_set_b4_addr_reply_t *rmp;
2713 snat_main_t *sm = &snat_main;
2714 dslite_main_t *dm = &dslite_main;
2716 ip6_address_t ip6_addr;
2717 ip4_address_t ip4_addr;
2719 memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
2720 memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
2722 rv = dslite_set_b4_ip6_addr (dm, &ip6_addr);
2724 rv = dslite_set_b4_ip4_addr (dm, &ip4_addr);
2726 REPLY_MACRO (VL_API_DSLITE_SET_B4_ADDR_REPLY);
2730 vl_api_dslite_set_b4_addr_t_print (vl_api_dslite_set_b4_addr_t * mp,
2735 s = format (0, "SCRIPT: dslite_set_b4_addr ");
2736 s = format (s, "ip6_addr %U ip4_addr %U\n",
2737 format_ip6_address, mp->ip6_addr,
2738 format_ip6_address, mp->ip4_addr);
2744 vl_api_dslite_get_b4_addr_t_handler (vl_api_dslite_get_b4_addr_t * mp)
2746 snat_main_t *sm = &snat_main;
2747 vl_api_dslite_get_b4_addr_reply_t *rmp;
2748 dslite_main_t *dm = &dslite_main;
2752 REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
2754 memcpy (rmp->ip4_addr, &dm->b4_ip4_addr.as_u8, 4);
2755 memcpy (rmp->ip6_addr, &dm->b4_ip6_addr.as_u8, 16);
2761 vl_api_dslite_get_b4_addr_t_print (vl_api_dslite_get_b4_addr_t * mp,
2766 s = format (0, "SCRIPT: dslite_get_b4_addr");
2772 vl_api_dslite_add_del_pool_addr_range_t_handler
2773 (vl_api_dslite_add_del_pool_addr_range_t * mp)
2775 vl_api_dslite_add_del_pool_addr_range_reply_t *rmp;
2776 snat_main_t *sm = &snat_main;
2777 dslite_main_t *dm = &dslite_main;
2779 ip4_address_t this_addr;
2780 u32 start_host_order, end_host_order;
2784 tmp = (u32 *) mp->start_addr;
2785 start_host_order = clib_host_to_net_u32 (tmp[0]);
2786 tmp = (u32 *) mp->end_addr;
2787 end_host_order = clib_host_to_net_u32 (tmp[0]);
2789 count = (end_host_order - start_host_order) + 1;
2790 memcpy (&this_addr.as_u8, mp->start_addr, 4);
2792 for (i = 0; i < count; i++)
2794 if ((rv = dslite_add_del_pool_addr (dm, &this_addr, mp->is_add)))
2797 increment_v4_address (&this_addr);
2801 REPLY_MACRO (VL_API_DSLITE_ADD_DEL_POOL_ADDR_RANGE_REPLY);
2805 send_dslite_address_details (snat_address_t * ap,
2806 vl_api_registration_t * reg, u32 context)
2808 vl_api_dslite_address_details_t *rmp;
2809 snat_main_t *sm = &snat_main;
2811 rmp = vl_msg_api_alloc (sizeof (*rmp));
2813 memset (rmp, 0, sizeof (*rmp));
2815 rmp->_vl_msg_id = ntohs (VL_API_DSLITE_ADDRESS_DETAILS + sm->msg_id_base);
2816 clib_memcpy (rmp->ip_address, &(ap->addr), 4);
2817 rmp->context = context;
2819 vl_api_send_msg (reg, (u8 *) rmp);
2823 vl_api_dslite_address_dump_t_handler (vl_api_dslite_address_dump_t * mp)
2825 vl_api_registration_t *reg;
2826 dslite_main_t *dm = &dslite_main;
2829 reg = vl_api_client_index_to_registration (mp->client_index);
2834 vec_foreach (ap, dm->addr_pool)
2836 send_dslite_address_details (ap, reg, mp->context);
2842 vl_api_dslite_address_dump_t_print (vl_api_dslite_address_dump_t * mp,
2847 s = format (0, "SCRIPT: dslite_address_dump ");
2852 static void *vl_api_dslite_add_del_pool_addr_range_t_print
2853 (vl_api_dslite_add_del_pool_addr_range_t * mp, void *handle)
2857 s = format (0, "SCRIPT: dslite_add_del_pool_addr_range ");
2858 s = format (s, "%U - %U\n",
2859 format_ip4_address, mp->start_addr,
2860 format_ip4_address, mp->end_addr);
2871 vl_api_nat66_add_del_interface_t_handler (vl_api_nat66_add_del_interface_t *
2874 snat_main_t *sm = &snat_main;
2875 vl_api_nat66_add_del_interface_reply_t *rmp;
2878 VALIDATE_SW_IF_INDEX (mp);
2881 nat66_interface_add_del (ntohl (mp->sw_if_index), mp->is_inside,
2884 BAD_SW_IF_INDEX_LABEL;
2886 REPLY_MACRO (VL_API_NAT66_ADD_DEL_INTERFACE_REPLY);
2890 vl_api_nat66_add_del_interface_t_print (vl_api_nat66_add_del_interface_t * mp,
2895 s = format (0, "SCRIPT: nat66_add_del_interface ");
2896 s = format (s, "sw_if_index %d %s %s",
2897 clib_host_to_net_u32 (mp->sw_if_index),
2898 mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
2904 vl_api_nat66_add_del_static_mapping_t_handler
2905 (vl_api_nat66_add_del_static_mapping_t * mp)
2907 snat_main_t *sm = &snat_main;
2908 vl_api_nat66_add_del_static_mapping_reply_t *rmp;
2909 ip6_address_t l_addr, e_addr;
2912 memcpy (&l_addr.as_u8, mp->local_ip_address, 16);
2913 memcpy (&e_addr.as_u8, mp->external_ip_address, 16);
2916 nat66_static_mapping_add_del (&l_addr, &e_addr,
2917 clib_net_to_host_u32 (mp->vrf_id),
2920 REPLY_MACRO (VL_API_NAT66_ADD_DEL_STATIC_MAPPING_REPLY);
2923 static void *vl_api_nat66_add_del_static_mapping_t_print
2924 (vl_api_nat66_add_del_static_mapping_t * mp, void *handle)
2928 s = format (0, "SCRIPT: nat66_add_del_static_mapping ");
2929 s = format (s, "local_ip_address %U external_ip_address %U vrf_id %d %s",
2930 format_ip6_address, mp->local_ip_address,
2931 format_ip6_address, mp->external_ip_address,
2932 clib_net_to_host_u32 (mp->vrf_id), mp->is_add ? "" : "del");
2937 typedef struct nat66_api_walk_ctx_t_
2941 } nat66_api_walk_ctx_t;
2944 nat66_api_interface_walk (snat_interface_t * i, void *arg)
2946 vl_api_nat66_interface_details_t *rmp;
2947 snat_main_t *sm = &snat_main;
2948 nat66_api_walk_ctx_t *ctx = arg;
2950 rmp = vl_msg_api_alloc (sizeof (*rmp));
2951 memset (rmp, 0, sizeof (*rmp));
2952 rmp->_vl_msg_id = ntohs (VL_API_NAT66_INTERFACE_DETAILS + sm->msg_id_base);
2953 rmp->sw_if_index = ntohl (i->sw_if_index);
2954 rmp->is_inside = nat_interface_is_inside (i);
2955 rmp->context = ctx->context;
2957 vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
2963 vl_api_nat66_interface_dump_t_handler (vl_api_nat66_interface_dump_t * mp)
2967 q = vl_api_client_index_to_input_queue (mp->client_index);
2971 nat66_api_walk_ctx_t ctx = {
2973 .context = mp->context,
2976 nat66_interfaces_walk (nat66_api_interface_walk, &ctx);
2980 vl_api_nat66_interface_dump_t_print (vl_api_nat66_interface_dump_t * mp,
2985 s = format (0, "SCRIPT: nat66_interface_dump ");
2991 nat66_api_static_mapping_walk (nat66_static_mapping_t * m, void *arg)
2993 vl_api_nat66_static_mapping_details_t *rmp;
2994 nat66_main_t *nm = &nat66_main;
2995 snat_main_t *sm = &snat_main;
2996 nat66_api_walk_ctx_t *ctx = arg;
3000 fib = fib_table_get (m->fib_index, FIB_PROTOCOL_IP6);
3004 vlib_get_combined_counter (&nm->session_counters, m - nm->sm, &vc);
3006 rmp = vl_msg_api_alloc (sizeof (*rmp));
3007 memset (rmp, 0, sizeof (*rmp));
3009 ntohs (VL_API_NAT66_STATIC_MAPPING_DETAILS + sm->msg_id_base);
3010 clib_memcpy (rmp->local_ip_address, &m->l_addr, 16);
3011 clib_memcpy (rmp->external_ip_address, &m->e_addr, 16);
3012 rmp->vrf_id = ntohl (fib->ft_table_id);
3013 rmp->total_bytes = clib_host_to_net_u64 (vc.bytes);
3014 rmp->total_pkts = clib_host_to_net_u64 (vc.packets);
3015 rmp->context = ctx->context;
3017 vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
3023 vl_api_nat66_static_mapping_dump_t_handler (vl_api_nat66_static_mapping_dump_t
3028 q = vl_api_client_index_to_input_queue (mp->client_index);
3032 nat66_api_walk_ctx_t ctx = {
3034 .context = mp->context,
3037 nat66_static_mappings_walk (nat66_api_static_mapping_walk, &ctx);
3041 vl_api_nat66_static_mapping_dump_t_print (vl_api_nat66_static_mapping_dump_t *
3046 s = format (0, "SCRIPT: nat66_static_mapping_dump ");
3052 /* List of message types that this plugin understands */
3053 #define foreach_snat_plugin_api_msg \
3054 _(NAT_CONTROL_PING, nat_control_ping) \
3055 _(NAT_SHOW_CONFIG, nat_show_config) \
3056 _(NAT_SET_WORKERS, nat_set_workers) \
3057 _(NAT_WORKER_DUMP, nat_worker_dump) \
3058 _(NAT_IPFIX_ENABLE_DISABLE, nat_ipfix_enable_disable) \
3059 _(NAT_SET_REASS, nat_set_reass) \
3060 _(NAT_GET_REASS, nat_get_reass) \
3061 _(NAT_REASS_DUMP, nat_reass_dump) \
3062 _(NAT44_ADD_DEL_ADDRESS_RANGE, nat44_add_del_address_range) \
3063 _(NAT44_INTERFACE_ADD_DEL_FEATURE, nat44_interface_add_del_feature) \
3064 _(NAT44_ADD_DEL_STATIC_MAPPING, nat44_add_del_static_mapping) \
3065 _(NAT44_ADD_DEL_IDENTITY_MAPPING, nat44_add_del_identity_mapping) \
3066 _(NAT44_STATIC_MAPPING_DUMP, nat44_static_mapping_dump) \
3067 _(NAT44_IDENTITY_MAPPING_DUMP, nat44_identity_mapping_dump) \
3068 _(NAT44_ADDRESS_DUMP, nat44_address_dump) \
3069 _(NAT44_INTERFACE_DUMP, nat44_interface_dump) \
3070 _(NAT44_ADD_DEL_INTERFACE_ADDR, nat44_add_del_interface_addr) \
3071 _(NAT44_INTERFACE_ADDR_DUMP, nat44_interface_addr_dump) \
3072 _(NAT44_USER_DUMP, nat44_user_dump) \
3073 _(NAT44_USER_SESSION_DUMP, nat44_user_session_dump) \
3074 _(NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE, \
3075 nat44_interface_add_del_output_feature) \
3076 _(NAT44_INTERFACE_OUTPUT_FEATURE_DUMP, \
3077 nat44_interface_output_feature_dump) \
3078 _(NAT44_ADD_DEL_LB_STATIC_MAPPING, nat44_add_del_lb_static_mapping) \
3079 _(NAT44_LB_STATIC_MAPPING_DUMP, nat44_lb_static_mapping_dump) \
3080 _(NAT44_DEL_SESSION, nat44_del_session) \
3081 _(NAT44_FORWARDING_ENABLE_DISABLE, nat44_forwarding_enable_disable) \
3082 _(NAT44_FORWARDING_IS_ENABLED, nat44_forwarding_is_enabled) \
3083 _(NAT_DET_ADD_DEL_MAP, nat_det_add_del_map) \
3084 _(NAT_DET_FORWARD, nat_det_forward) \
3085 _(NAT_DET_REVERSE, nat_det_reverse) \
3086 _(NAT_DET_MAP_DUMP, nat_det_map_dump) \
3087 _(NAT_DET_SET_TIMEOUTS, nat_det_set_timeouts) \
3088 _(NAT_DET_GET_TIMEOUTS, nat_det_get_timeouts) \
3089 _(NAT_DET_CLOSE_SESSION_OUT, nat_det_close_session_out) \
3090 _(NAT_DET_CLOSE_SESSION_IN, nat_det_close_session_in) \
3091 _(NAT_DET_SESSION_DUMP, nat_det_session_dump) \
3092 _(NAT64_ADD_DEL_POOL_ADDR_RANGE, nat64_add_del_pool_addr_range) \
3093 _(NAT64_POOL_ADDR_DUMP, nat64_pool_addr_dump) \
3094 _(NAT64_ADD_DEL_INTERFACE, nat64_add_del_interface) \
3095 _(NAT64_INTERFACE_DUMP, nat64_interface_dump) \
3096 _(NAT64_ADD_DEL_STATIC_BIB, nat64_add_del_static_bib) \
3097 _(NAT64_BIB_DUMP, nat64_bib_dump) \
3098 _(NAT64_SET_TIMEOUTS, nat64_set_timeouts) \
3099 _(NAT64_GET_TIMEOUTS, nat64_get_timeouts) \
3100 _(NAT64_ST_DUMP, nat64_st_dump) \
3101 _(NAT64_ADD_DEL_PREFIX, nat64_add_del_prefix) \
3102 _(NAT64_PREFIX_DUMP, nat64_prefix_dump) \
3103 _(NAT64_ADD_DEL_INTERFACE_ADDR, nat64_add_del_interface_addr) \
3104 _(DSLITE_ADD_DEL_POOL_ADDR_RANGE, dslite_add_del_pool_addr_range) \
3105 _(DSLITE_ADDRESS_DUMP, dslite_address_dump) \
3106 _(DSLITE_SET_AFTR_ADDR, dslite_set_aftr_addr) \
3107 _(DSLITE_GET_AFTR_ADDR, dslite_get_aftr_addr) \
3108 _(DSLITE_SET_B4_ADDR, dslite_set_b4_addr) \
3109 _(DSLITE_GET_B4_ADDR, dslite_get_b4_addr) \
3110 _(NAT66_ADD_DEL_INTERFACE, nat66_add_del_interface) \
3111 _(NAT66_INTERFACE_DUMP, nat66_interface_dump) \
3112 _(NAT66_ADD_DEL_STATIC_MAPPING, nat66_add_del_static_mapping) \
3113 _(NAT66_STATIC_MAPPING_DUMP, nat66_static_mapping_dump)
3115 /* Set up the API message handling tables */
3116 static clib_error_t *
3117 snat_plugin_api_hookup (vlib_main_t * vm)
3119 snat_main_t *sm __attribute__ ((unused)) = &snat_main;
3121 vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base), \
3123 vl_api_##n##_t_handler, \
3125 vl_api_##n##_t_endian, \
3126 vl_api_##n##_t_print, \
3127 sizeof(vl_api_##n##_t), 1);
3128 foreach_snat_plugin_api_msg;
3134 #define vl_msg_name_crc_list
3135 #include <nat/nat_all_api_h.h>
3136 #undef vl_msg_name_crc_list
3139 setup_message_id_table (snat_main_t * sm, api_main_t * am)
3141 #define _(id,n,crc) \
3142 vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + sm->msg_id_base);
3143 foreach_vl_msg_name_crc_nat;
3148 plugin_custom_dump_configure (snat_main_t * sm)
3150 #define _(n,f) sm->api_main->msg_print_handlers \
3151 [VL_API_##n + sm->msg_id_base] \
3152 = (void *) vl_api_##f##_t_print;
3153 foreach_snat_plugin_api_msg;
3158 snat_api_init (vlib_main_t * vm, snat_main_t * sm)
3161 clib_error_t *error = 0;
3163 name = format (0, "nat_%08x%c", api_version, 0);
3165 /* Ask for a correctly-sized block of API message decode slots */
3167 vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE);
3169 error = snat_plugin_api_hookup (vm);
3171 /* Add our API messages to the global name_crc hash table */
3172 setup_message_id_table (sm, sm->api_main);
3174 plugin_custom_dump_configure (sm);
3182 * fd.io coding-style-patch-verification: ON
3185 * eval: (c-set-style "gnu")