#include <nat/nat.h>
#include <nat/nat_det.h>
#include <nat/nat64.h>
+#include <nat/nat66.h>
#include <nat/dslite.h>
#include <nat/nat_reass.h>
#include <vlibapi/api.h>
vl_api_nat_set_workers_reply_t *rmp;
int rv = 0;
uword *bitmap = 0;
- u64 mask = clib_net_to_host_u64 (mp->worker_mask);
+ u64 mask;
+
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
+ mask = clib_net_to_host_u64 (mp->worker_mask);
if (sm->num_workers < 2)
{
}
static void
-send_nat_worker_details (u32 worker_index, svm_queue_t * q, u32 context)
+send_nat_worker_details (u32 worker_index, vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat_worker_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->lcore_id = htonl (w->lcore_id);
strncpy ((char *) rmp->name, (char *) w->name, ARRAY_LEN (rmp->name) - 1);
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat_worker_dump_t_handler (vl_api_nat_worker_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
u32 *worker_index;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
vec_foreach (worker_index, sm->workers)
- send_nat_worker_details(*worker_index, q, mp->context);
+ send_nat_worker_details(*worker_index, reg, mp->context);
/* *INDENT-ON* */
}
typedef struct nat_api_walk_ctx_t_
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
u32 context;
} nat_api_walk_ctx_t;
rmp->frag_n = reass->frag_n;
rmp->is_ip4 = 1;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
rmp->frag_n = reass->frag_n;
rmp->is_ip4 = 0;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat_reass_dump_t_handler (vl_api_nat_reass_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
int rv = 0;
u32 *tmp;
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
if (sm->static_mapping_only)
{
rv = VNET_API_ERROR_FEATURE_DISABLED;
static void
send_nat44_address_details (snat_address_t * a,
- svm_queue_t * q, u32 context, u8 twice_nat)
+ vl_api_registration_t * reg, u32 context,
+ u8 twice_nat)
{
vl_api_nat44_address_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->twice_nat = twice_nat;
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_address_dump_t_handler (vl_api_nat44_address_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_address_t *a;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
vec_foreach (a, sm->addresses)
- send_nat44_address_details (a, q, mp->context, 0);
+ send_nat44_address_details (a, reg, mp->context, 0);
vec_foreach (a, sm->twice_nat_addresses)
- send_nat44_address_details (a, q, mp->context, 1);
+ send_nat44_address_details (a, reg, mp->context, 1);
/* *INDENT-ON* */
}
static void
send_nat44_interface_details (snat_interface_t * i,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg, u32 context)
{
vl_api_nat44_interface_details_t *rmp;
snat_main_t *sm = &snat_main;
nat_interface_is_inside (i);
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_interface_dump_t_handler (vl_api_nat44_interface_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_interface_t *i;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
pool_foreach (i, sm->interfaces,
({
- send_nat44_interface_details(i, q, mp->context);
+ send_nat44_interface_details(i, reg, mp->context);
}));
/* *INDENT-ON* */
}
u32 sw_if_index = ntohl (mp->sw_if_index);
int rv = 0;
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
VALIDATE_SW_IF_INDEX (mp);
rv = snat_interface_add_del_output_feature (sw_if_index, mp->is_inside,
is_del);
BAD_SW_IF_INDEX_LABEL;
-
+send_reply:
REPLY_MACRO (VL_API_NAT44_INTERFACE_ADD_DEL_OUTPUT_FEATURE_REPLY);
}
static void
send_nat44_interface_output_feature_details (snat_interface_t * i,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat44_interface_output_feature_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->context = context;
rmp->is_inside = nat_interface_is_inside (i);
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_interface_output_feature_dump_t_handler
(vl_api_nat44_interface_output_feature_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_interface_t *i;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
pool_foreach (i, sm->output_feature_interfaces,
({
- send_nat44_interface_output_feature_details(i, q, mp->context);
+ send_nat44_interface_output_feature_details(i, reg, mp->context);
}));
/* *INDENT-ON* */
}
ip4_address_t local_addr, external_addr;
u16 local_port = 0, external_port = 0;
u32 vrf_id, external_sw_if_index;
+ twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
int rv = 0;
snat_protocol_t proto;
+ u8 *tag = 0;
+
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
memcpy (&local_addr.as_u8, mp->local_ip_address, 4);
memcpy (&external_addr.as_u8, mp->external_ip_address, 4);
vrf_id = clib_net_to_host_u32 (mp->vrf_id);
external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
proto = ip_proto_to_snat_proto (mp->protocol);
+ if (mp->twice_nat)
+ twice_nat = TWICE_NAT;
+ else if (mp->self_twice_nat)
+ twice_nat = TWICE_NAT_SELF;
+ mp->tag[sizeof (mp->tag) - 1] = 0;
+ tag = format (0, "%s", mp->tag);
+ vec_terminate_c_string (tag);
rv = snat_add_static_mapping (local_addr, external_addr, local_port,
external_port, vrf_id, mp->addr_only,
external_sw_if_index, proto, mp->is_add,
- mp->twice_nat);
+ twice_nat, mp->out2in_only, tag);
+ vec_free (tag);
+
+send_reply:
REPLY_MACRO (VL_API_NAT44_ADD_DEL_STATIC_MAPPING_REPLY);
}
clib_net_to_host_u16 (mp->local_port),
clib_net_to_host_u16 (mp->external_port));
- s = format (s, "twice_nat %d ", mp->twice_nat);
+ s = format (s, "twice_nat %d out2in_only %d ",
+ mp->twice_nat, mp->out2in_only);
if (mp->vrf_id != ~0)
s = format (s, "vrf %d", clib_net_to_host_u32 (mp->vrf_id));
static void
send_nat44_static_mapping_details (snat_static_mapping_t * m,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg, u32 context)
{
vl_api_nat44_static_mapping_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->addr_only = m->addr_only;
clib_memcpy (rmp->local_ip_address, &(m->local_addr), 4);
clib_memcpy (rmp->external_ip_address, &(m->external_addr), 4);
- rmp->local_port = htons (m->local_port);
- rmp->external_port = htons (m->external_port);
rmp->external_sw_if_index = ~0;
rmp->vrf_id = htonl (m->vrf_id);
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
rmp->context = context;
- rmp->twice_nat = m->twice_nat;
+ if (m->twice_nat == TWICE_NAT)
+ rmp->twice_nat = 1;
+ else if (m->twice_nat == TWICE_NAT_SELF)
+ rmp->self_twice_nat = 1;
+ rmp->out2in_only = m->out2in_only;
+ if (m->addr_only == 0)
+ {
+ rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->external_port = htons (m->external_port);
+ rmp->local_port = htons (m->local_port);
+ }
+ if (m->tag)
+ strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
send_nat44_static_map_resolve_details (snat_static_map_resolve_t * m,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat44_static_mapping_details_t *rmp;
snat_main_t *sm = &snat_main;
ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
rmp->addr_only = m->addr_only;
clib_memcpy (rmp->local_ip_address, &(m->l_addr), 4);
- rmp->local_port = htons (m->l_port);
- rmp->external_port = htons (m->e_port);
rmp->external_sw_if_index = htonl (m->sw_if_index);
rmp->vrf_id = htonl (m->vrf_id);
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
rmp->context = context;
rmp->twice_nat = m->twice_nat;
+ if (m->addr_only == 0)
+ {
+ rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->external_port = htons (m->e_port);
+ rmp->local_port = htons (m->l_port);
+ }
+ if (m->tag)
+ strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_static_mapping_dump_t_handler (vl_api_nat44_static_mapping_dump_t
* mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_static_mapping_t *m;
snat_static_map_resolve_t *rp;
int j;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
pool_foreach (m, sm->static_mappings,
({
- if (!vec_len(m->locals) && (m->local_addr.as_u32 != m->external_addr.as_u32))
- send_nat44_static_mapping_details (m, q, mp->context);
+ if (!vec_len (m->locals) &&
+ ((m->local_port != m->external_port)
+ || (m->local_addr.as_u32 != m->external_addr.as_u32)))
+ send_nat44_static_mapping_details (m, reg, mp->context);
}));
/* *INDENT-ON* */
{
rp = sm->to_resolve + j;
if (rp->l_addr.as_u32 != 0)
- send_nat44_static_map_resolve_details (rp, q, mp->context);
+ send_nat44_static_map_resolve_details (rp, reg, mp->context);
}
}
u32 vrf_id, sw_if_index;
int rv = 0;
snat_protocol_t proto = ~0;
+ u8 *tag = 0;
+
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
if (mp->addr_only == 0)
{
addr.as_u32 = 0;
else
memcpy (&addr.as_u8, mp->ip_address, 4);
-
+ mp->tag[sizeof (mp->tag) - 1] = 0;
+ tag = format (0, "%s", mp->tag);
+ vec_terminate_c_string (tag);
rv =
snat_add_static_mapping (addr, addr, port, port, vrf_id, mp->addr_only,
- sw_if_index, proto, mp->is_add, 0);
+ sw_if_index, proto, mp->is_add, 0, 0, tag);
+
+ vec_free (tag);
+send_reply:
REPLY_MACRO (VL_API_NAT44_ADD_DEL_IDENTITY_MAPPING_REPLY);
}
static void
send_nat44_identity_mapping_details (snat_static_mapping_t * m,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg, u32 context)
{
vl_api_nat44_identity_mapping_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->vrf_id = htonl (m->vrf_id);
rmp->protocol = snat_proto_to_ip_proto (m->proto);
rmp->context = context;
+ if (m->tag)
+ strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
send_nat44_identity_map_resolve_details (snat_static_map_resolve_t * m,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat44_identity_mapping_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->vrf_id = htonl (m->vrf_id);
rmp->protocol = snat_proto_to_ip_proto (m->proto);
rmp->context = context;
+ if (m->tag)
+ strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_identity_mapping_dump_t_handler
(vl_api_nat44_identity_mapping_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_static_mapping_t *m;
snat_static_map_resolve_t *rp;
int j;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
pool_foreach (m, sm->static_mappings,
({
- if (!vec_len(m->locals) && (m->local_addr.as_u32 == m->external_addr.as_u32))
- send_nat44_identity_mapping_details (m, q, mp->context);
+ if (!vec_len (m->locals) && (m->local_port == m->external_port)
+ && (m->local_addr.as_u32 == m->external_addr.as_u32))
+ send_nat44_identity_mapping_details (m, reg, mp->context);
}));
/* *INDENT-ON* */
{
rp = sm->to_resolve + j;
if (rp->l_addr.as_u32 == 0)
- send_nat44_identity_map_resolve_details (rp, q, mp->context);
+ send_nat44_identity_map_resolve_details (rp, reg, mp->context);
}
}
u32 sw_if_index = ntohl (mp->sw_if_index);
int rv = 0;
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
VALIDATE_SW_IF_INDEX (mp);
rv = snat_add_interface_address (sm, sw_if_index, is_del, mp->twice_nat);
BAD_SW_IF_INDEX_LABEL;
-
+send_reply:
REPLY_MACRO (VL_API_NAT44_ADD_DEL_INTERFACE_ADDR_REPLY);
}
static void
send_nat44_interface_addr_details (u32 sw_if_index,
- svm_queue_t * q, u32 context, u8 twice_nat)
+ vl_api_registration_t * reg, u32 context,
+ u8 twice_nat)
{
vl_api_nat44_interface_addr_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->twice_nat = twice_nat;
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_interface_addr_dump_t_handler (vl_api_nat44_interface_addr_dump_t
* mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
u32 *i;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
vec_foreach (i, sm->auto_add_sw_if_indices)
- send_nat44_interface_addr_details(*i, q, mp->context, 0);
+ send_nat44_interface_addr_details(*i, reg, mp->context, 0);
vec_foreach (i, sm->auto_add_sw_if_indices_twice_nat)
- send_nat44_interface_addr_details(*i, q, mp->context, 1);
+ send_nat44_interface_addr_details(*i, reg, mp->context, 1);
/* *INDENT-ON* */
}
}
static void
-send_nat44_user_details (snat_user_t * u, svm_queue_t * q, u32 context)
+send_nat44_user_details (snat_user_t * u, vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat44_user_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->nstaticsessions = ntohl (u->nstaticsessions);
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_user_dump_t_handler (vl_api_nat44_user_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_main_per_thread_data_t *tsm;
snat_user_t *u;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
vec_foreach (tsm, sm->per_thread_data)
vec_foreach (u, tsm->users)
- send_nat44_user_details (u, q, mp->context);
+ send_nat44_user_details (u, reg, mp->context);
/* *INDENT-ON* */
}
static void
send_nat44_user_session_details (snat_session_t * s,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg, u32 context)
{
vl_api_nat44_user_session_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->inside_port = s->in2out.port;
rmp->protocol = ntohs (snat_proto_to_ip_proto (s->in2out.protocol));
}
+ if (s->in2out.protocol == SNAT_PROTOCOL_TCP)
+ rmp->is_closed = s->state == SNAT_SESSION_TCP_CLOSED ? 1 : 0;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_user_session_dump_t_handler (vl_api_nat44_user_session_dump_t *
mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_main_per_thread_data_t *tsm;
snat_session_t *s;
dlist_elt_t *head, *elt;
ip4_header_t ip;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
clib_memcpy (&ukey.addr, mp->ip_address, 4);
ip.src_address.as_u32 = ukey.addr.as_u32;
ukey.fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->vrf_id));
key.key = ukey.as_u64;
- if (sm->num_workers)
+ if (sm->num_workers > 1)
tsm =
vec_elt_at_index (sm->per_thread_data,
sm->worker_in2out_cb (&ip, ukey.fib_index));
{
s = pool_elt_at_index (tsm->sessions, session_index);
- send_nat44_user_session_details (s, q, mp->context);
+ send_nat44_user_session_details (s, reg, mp->context);
elt_index = elt->next;
elt = pool_elt_at_index (tsm->list_pool, elt_index);
{
snat_main_t *sm = &snat_main;
vl_api_nat44_add_del_lb_static_mapping_reply_t *rmp;
+ twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
int rv = 0;
nat44_lb_addr_port_t *locals = 0;
ip4_address_t e_addr;
snat_protocol_t proto;
+ u8 *tag = 0;
+
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
locals = unformat_nat44_lb_addr_port (mp->locals, mp->local_num);
clib_memcpy (&e_addr, mp->external_addr, 4);
proto = ip_proto_to_snat_proto (mp->protocol);
+ if (mp->twice_nat)
+ twice_nat = TWICE_NAT;
+ else if (mp->self_twice_nat)
+ twice_nat = TWICE_NAT_SELF;
+ mp->tag[sizeof (mp->tag) - 1] = 0;
+ tag = format (0, "%s", mp->tag);
+ vec_terminate_c_string (tag);
rv =
nat44_add_del_lb_static_mapping (e_addr,
clib_net_to_host_u16 (mp->external_port),
proto, clib_net_to_host_u32 (mp->vrf_id),
- locals, mp->is_add, mp->twice_nat);
+ locals, mp->is_add, twice_nat,
+ mp->out2in_only, tag);
vec_free (locals);
+ vec_free (tag);
+send_reply:
REPLY_MACRO (VL_API_NAT44_ADD_DEL_LB_STATIC_MAPPING_REPLY);
}
u8 *s;
s = format (0, "SCRIPT: nat44_add_del_lb_static_mapping ");
- s = format (s, "is_add %d twice_nat %d", mp->is_add, mp->twice_nat);
+ s = format (s, "is_add %d twice_nat %d out2in_only %d ",
+ mp->is_add, mp->twice_nat, mp->out2in_only);
FINISH;
}
static void
send_nat44_lb_static_mapping_details (snat_static_mapping_t * m,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat44_lb_static_mapping_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->protocol = snat_proto_to_ip_proto (m->proto);
rmp->vrf_id = ntohl (m->vrf_id);
rmp->context = context;
- rmp->twice_nat = m->twice_nat;
+ if (m->twice_nat == TWICE_NAT)
+ rmp->twice_nat = 1;
+ else if (m->twice_nat == TWICE_NAT_SELF)
+ rmp->self_twice_nat = 1;
+ rmp->out2in_only = m->out2in_only;
+ if (m->tag)
+ strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
locals = (vl_api_nat44_lb_addr_port_t *) rmp->locals;
vec_foreach (ap, m->locals)
rmp->local_num++;
}
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat44_lb_static_mapping_dump_t_handler
(vl_api_nat44_lb_static_mapping_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_static_mapping_t *m;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
pool_foreach (m, sm->static_mappings,
({
if (vec_len(m->locals))
- send_nat44_lb_static_mapping_details (m, q, mp->context);
+ send_nat44_lb_static_mapping_details (m, reg, mp->context);
}));
/* *INDENT-ON* */
}
int rv = 0;
snat_protocol_t proto;
+ if (sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
memcpy (&addr.as_u8, mp->address, 4);
port = clib_net_to_host_u16 (mp->port);
vrf_id = clib_net_to_host_u32 (mp->vrf_id);
rv = nat44_del_session (sm, &addr, port, proto, vrf_id, mp->is_in);
+send_reply:
REPLY_MACRO (VL_API_NAT44_DEL_SESSION_REPLY);
}
vl_api_nat44_forwarding_is_enabled_t_handler
(vl_api_nat44_forwarding_is_enabled_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
vl_api_nat44_forwarding_is_enabled_reply_t *rmp;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
rmp = vl_msg_api_alloc (sizeof (*rmp));
rmp->enabled = sm->forwarding_enabled;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void *vl_api_nat44_forwarding_is_enabled_t_print
int rv = 0;
ip4_address_t in_addr, out_addr;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
if (!mp->is_nat44)
{
rv = VNET_API_ERROR_UNIMPLEMENTED;
snat_det_map_t *dm;
ip4_address_t in_addr, out_addr;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ REPLY_MACRO (VL_API_NAT_DET_FORWARD_REPLY);
+ return;
+ }
+
if (!mp->is_nat44)
{
out_addr.as_u32 = 0;
ip4_address_t out_addr, in_addr;
snat_det_map_t *dm;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ REPLY_MACRO (VL_API_NAT_DET_REVERSE_REPLY);
+ return;
+ }
+
in_addr.as_u32 = 0;
clib_memcpy (&out_addr, mp->out_addr, 4);
dm = snat_det_map_by_out (sm, &out_addr);
}
static void
-sent_nat_det_map_details (snat_det_map_t * m, svm_queue_t * q, u32 context)
+sent_nat_det_map_details (snat_det_map_t * m, vl_api_registration_t * reg,
+ u32 context)
{
vl_api_nat_det_map_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->ses_num = htonl (m->ses_num);
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat_det_map_dump_t_handler (vl_api_nat_det_map_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
snat_det_map_t *m;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (!sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
/* *INDENT-OFF* */
vec_foreach(m, sm->det_maps)
- sent_nat_det_map_details(m, q, mp->context);
+ sent_nat_det_map_details(m, reg, mp->context);
/* *INDENT-ON* */
}
vl_api_nat_det_set_timeouts_reply_t *rmp;
int rv = 0;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
sm->udp_timeout = ntohl (mp->udp);
sm->tcp_established_timeout = ntohl (mp->tcp_established);
sm->tcp_transitory_timeout = ntohl (mp->tcp_transitory);
sm->icmp_timeout = ntohl (mp->icmp);
+send_reply:
REPLY_MACRO (VL_API_NAT_DET_SET_TIMEOUTS_REPLY);
}
vl_api_nat_det_get_timeouts_reply_t *rmp;
int rv = 0;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ REPLY_MACRO (VL_API_NAT_DET_GET_TIMEOUTS_REPLY);
+ return;
+ }
+
/* *INDENT-OFF* */
REPLY_MACRO2 (VL_API_NAT_DET_GET_TIMEOUTS_REPLY,
({
snat_det_session_t *ses;
int rv = 0;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
clib_memcpy (&out_addr, mp->out_addr, 4);
clib_memcpy (&ext_addr, mp->ext_addr, 4);
snat_det_session_t *ses;
int rv = 0;
+ if (!sm->deterministic)
+ {
+ rv = VNET_API_ERROR_UNSUPPORTED;
+ goto send_reply;
+ }
+
if (!mp->is_nat44)
{
rv = VNET_API_ERROR_UNIMPLEMENTED;
static void
send_nat_det_session_details (snat_det_session_t * s,
- svm_queue_t * q, u32 context)
+ vl_api_registration_t * reg, u32 context)
{
vl_api_nat_det_session_details_t *rmp;
snat_main_t *sm = &snat_main;
rmp->expire = ntohl (s->expire);
rmp->context = context;
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
+ vl_api_send_msg (reg, (u8 *) rmp);
}
static void
vl_api_nat_det_session_dump_t_handler (vl_api_nat_det_session_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
snat_main_t *sm = &snat_main;
ip4_address_t user_addr;
snat_det_map_t *dm;
snat_det_session_t *s, empty_ses;
u16 i;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ if (!sm->deterministic)
+ return;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
if (!mp->is_nat44)
return;
for (i = 0; i < SNAT_DET_SES_PER_USER; i++)
{
if (s->out.as_u64)
- send_nat_det_session_details (s, q, mp->context);
+ send_nat_det_session_details (s, reg, mp->context);
s++;
}
}
typedef struct nat64_api_walk_ctx_t_
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
u32 context;
nat64_db_t *db;
} nat64_api_walk_ctx_t;
rmp->vrf_id = ~0;
rmp->context = ctx->context;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat64_pool_addr_dump_t_handler (vl_api_nat64_pool_addr_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat64_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
nat_interface_is_inside (i);
rmp->context = ctx->context;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat64_interface_dump_t_handler (vl_api_nat64_interface_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat64_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
rmp->is_static = bibe->is_static;
rmp->ses_num = ntohl (bibe->ses_num);
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat64_bib_dump_t_handler (vl_api_nat64_bib_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
nat64_main_t *nm = &nat64_main;
nat64_db_t *db;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat64_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
rmp->vrf_id = ntohl (fib->ft_table_id);
rmp->proto = ste->proto;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat64_st_dump_t_handler (vl_api_nat64_st_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
nat64_main_t *nm = &nat64_main;
nat64_db_t *db;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat64_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
rmp->vrf_id = ntohl (p->vrf_id);
rmp->context = ctx->context;
- vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+ vl_api_send_msg (ctx->reg, (u8 *) rmp);
return 0;
}
static void
vl_api_nat64_prefix_dump_t_handler (vl_api_nat64_prefix_dump_t * mp)
{
- svm_queue_t *q;
+ vl_api_registration_t *reg;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (q == 0)
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
return;
nat64_api_walk_ctx_t ctx = {
- .q = q,
+ .reg = reg,
.context = mp->context,
};
dslite_main_t *dm = &dslite_main;
int rv = 0;
ip6_address_t ip6_addr;
+ ip4_address_t ip4_addr;
memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
+ memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
rv = dslite_set_aftr_ip6_addr (dm, &ip6_addr);
+ if (rv == 0)
+ rv = dslite_set_aftr_ip4_addr (dm, &ip4_addr);
REPLY_MACRO (VL_API_DSLITE_SET_AFTR_ADDR_REPLY);
}
FINISH;
}
+static void
+vl_api_dslite_get_aftr_addr_t_handler (vl_api_dslite_get_aftr_addr_t * mp)
+{
+ snat_main_t *sm = &snat_main;
+ vl_api_dslite_get_aftr_addr_reply_t *rmp;
+ dslite_main_t *dm = &dslite_main;
+ int rv = 0;
+
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
+ ({
+ memcpy (rmp->ip4_addr, &dm->aftr_ip4_addr.as_u8, 4);
+ memcpy (rmp->ip6_addr, &dm->aftr_ip6_addr.as_u8, 16);
+ }))
+ /* *INDENT-ON* */
+}
+
+static void *
+vl_api_dslite_get_aftr_addr_t_print (vl_api_dslite_get_aftr_addr_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: dslite_get_aftr_addr");
+
+ FINISH;
+}
+
+static void
+vl_api_dslite_set_b4_addr_t_handler (vl_api_dslite_set_b4_addr_t * mp)
+{
+ vl_api_dslite_set_b4_addr_reply_t *rmp;
+ snat_main_t *sm = &snat_main;
+ dslite_main_t *dm = &dslite_main;
+ int rv = 0;
+ ip6_address_t ip6_addr;
+ ip4_address_t ip4_addr;
+
+ memcpy (&ip6_addr.as_u8, mp->ip6_addr, 16);
+ memcpy (&ip4_addr.as_u8, mp->ip4_addr, 4);
+
+ rv = dslite_set_b4_ip6_addr (dm, &ip6_addr);
+ if (rv == 0)
+ rv = dslite_set_b4_ip4_addr (dm, &ip4_addr);
+
+ REPLY_MACRO (VL_API_DSLITE_SET_B4_ADDR_REPLY);
+}
+
+static void *
+vl_api_dslite_set_b4_addr_t_print (vl_api_dslite_set_b4_addr_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: dslite_set_b4_addr ");
+ s = format (s, "ip6_addr %U ip4_addr %U\n",
+ format_ip6_address, mp->ip6_addr,
+ format_ip6_address, mp->ip4_addr);
+
+ FINISH;
+}
+
+static void
+vl_api_dslite_get_b4_addr_t_handler (vl_api_dslite_get_b4_addr_t * mp)
+{
+ snat_main_t *sm = &snat_main;
+ vl_api_dslite_get_b4_addr_reply_t *rmp;
+ dslite_main_t *dm = &dslite_main;
+ int rv = 0;
+
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_DSLITE_GET_AFTR_ADDR_REPLY,
+ ({
+ memcpy (rmp->ip4_addr, &dm->b4_ip4_addr.as_u8, 4);
+ memcpy (rmp->ip6_addr, &dm->b4_ip6_addr.as_u8, 16);
+ }))
+ /* *INDENT-ON* */
+}
+
+static void *
+vl_api_dslite_get_b4_addr_t_print (vl_api_dslite_get_b4_addr_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: dslite_get_b4_addr");
+
+ FINISH;
+}
+
static void
vl_api_dslite_add_del_pool_addr_range_t_handler
(vl_api_dslite_add_del_pool_addr_range_t * mp)
REPLY_MACRO (VL_API_DSLITE_ADD_DEL_POOL_ADDR_RANGE_REPLY);
}
+static void
+send_dslite_address_details (snat_address_t * ap,
+ vl_api_registration_t * reg, u32 context)
+{
+ vl_api_dslite_address_details_t *rmp;
+ snat_main_t *sm = &snat_main;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+
+ memset (rmp, 0, sizeof (*rmp));
+
+ rmp->_vl_msg_id = ntohs (VL_API_DSLITE_ADDRESS_DETAILS + sm->msg_id_base);
+ clib_memcpy (rmp->ip_address, &(ap->addr), 4);
+ rmp->context = context;
+
+ vl_api_send_msg (reg, (u8 *) rmp);
+}
+
+static void
+vl_api_dslite_address_dump_t_handler (vl_api_dslite_address_dump_t * mp)
+{
+ vl_api_registration_t *reg;
+ dslite_main_t *dm = &dslite_main;
+ snat_address_t *ap;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ /* *INDENT-OFF* */
+ vec_foreach (ap, dm->addr_pool)
+ {
+ send_dslite_address_details (ap, reg, mp->context);
+ }
+ /* *INDENT-ON* */
+}
+
+static void *
+vl_api_dslite_address_dump_t_print (vl_api_dslite_address_dump_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: dslite_address_dump ");
+
+ FINISH;
+}
+
static void *vl_api_dslite_add_del_pool_addr_range_t_print
(vl_api_dslite_add_del_pool_addr_range_t * mp, void *handle)
{
}
+/*************/
+/*** NAT66 ***/
+/*************/
+
+static void
+vl_api_nat66_add_del_interface_t_handler (vl_api_nat66_add_del_interface_t *
+ mp)
+{
+ snat_main_t *sm = &snat_main;
+ vl_api_nat66_add_del_interface_reply_t *rmp;
+ int rv = 0;
+
+ VALIDATE_SW_IF_INDEX (mp);
+
+ rv =
+ nat66_interface_add_del (ntohl (mp->sw_if_index), mp->is_inside,
+ mp->is_add);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO (VL_API_NAT66_ADD_DEL_INTERFACE_REPLY);
+}
+
+static void *
+vl_api_nat66_add_del_interface_t_print (vl_api_nat66_add_del_interface_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: nat66_add_del_interface ");
+ s = format (s, "sw_if_index %d %s %s",
+ clib_host_to_net_u32 (mp->sw_if_index),
+ mp->is_inside ? "in" : "out", mp->is_add ? "" : "del");
+
+ FINISH;
+}
+
+static void
+ vl_api_nat66_add_del_static_mapping_t_handler
+ (vl_api_nat66_add_del_static_mapping_t * mp)
+{
+ snat_main_t *sm = &snat_main;
+ vl_api_nat66_add_del_static_mapping_reply_t *rmp;
+ ip6_address_t l_addr, e_addr;
+ int rv = 0;
+
+ memcpy (&l_addr.as_u8, mp->local_ip_address, 16);
+ memcpy (&e_addr.as_u8, mp->external_ip_address, 16);
+
+ rv =
+ nat66_static_mapping_add_del (&l_addr, &e_addr,
+ clib_net_to_host_u32 (mp->vrf_id),
+ mp->is_add);
+
+ REPLY_MACRO (VL_API_NAT66_ADD_DEL_STATIC_MAPPING_REPLY);
+}
+
+static void *vl_api_nat66_add_del_static_mapping_t_print
+ (vl_api_nat66_add_del_static_mapping_t * mp, void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: nat66_add_del_static_mapping ");
+ s = format (s, "local_ip_address %U external_ip_address %U vrf_id %d %s",
+ format_ip6_address, mp->local_ip_address,
+ format_ip6_address, mp->external_ip_address,
+ clib_net_to_host_u32 (mp->vrf_id), mp->is_add ? "" : "del");
+
+ FINISH;
+}
+
+typedef struct nat66_api_walk_ctx_t_
+{
+ svm_queue_t *q;
+ u32 context;
+} nat66_api_walk_ctx_t;
+
+static int
+nat66_api_interface_walk (snat_interface_t * i, void *arg)
+{
+ vl_api_nat66_interface_details_t *rmp;
+ snat_main_t *sm = &snat_main;
+ nat66_api_walk_ctx_t *ctx = arg;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs (VL_API_NAT66_INTERFACE_DETAILS + sm->msg_id_base);
+ rmp->sw_if_index = ntohl (i->sw_if_index);
+ rmp->is_inside = nat_interface_is_inside (i);
+ rmp->context = ctx->context;
+
+ vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+
+ return 0;
+}
+
+static void
+vl_api_nat66_interface_dump_t_handler (vl_api_nat66_interface_dump_t * mp)
+{
+ svm_queue_t *q;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0)
+ return;
+
+ nat66_api_walk_ctx_t ctx = {
+ .q = q,
+ .context = mp->context,
+ };
+
+ nat66_interfaces_walk (nat66_api_interface_walk, &ctx);
+}
+
+static void *
+vl_api_nat66_interface_dump_t_print (vl_api_nat66_interface_dump_t * mp,
+ void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: nat66_interface_dump ");
+
+ FINISH;
+}
+
+static int
+nat66_api_static_mapping_walk (nat66_static_mapping_t * m, void *arg)
+{
+ vl_api_nat66_static_mapping_details_t *rmp;
+ nat66_main_t *nm = &nat66_main;
+ snat_main_t *sm = &snat_main;
+ nat66_api_walk_ctx_t *ctx = arg;
+ fib_table_t *fib;
+ vlib_counter_t vc;
+
+ fib = fib_table_get (m->fib_index, FIB_PROTOCOL_IP6);
+ if (!fib)
+ return -1;
+
+ vlib_get_combined_counter (&nm->session_counters, m - nm->sm, &vc);
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id =
+ ntohs (VL_API_NAT66_STATIC_MAPPING_DETAILS + sm->msg_id_base);
+ clib_memcpy (rmp->local_ip_address, &m->l_addr, 16);
+ clib_memcpy (rmp->external_ip_address, &m->e_addr, 16);
+ rmp->vrf_id = ntohl (fib->ft_table_id);
+ rmp->total_bytes = clib_host_to_net_u64 (vc.bytes);
+ rmp->total_pkts = clib_host_to_net_u64 (vc.packets);
+ rmp->context = ctx->context;
+
+ vl_msg_api_send_shmem (ctx->q, (u8 *) & rmp);
+
+ return 0;
+}
+
+static void
+vl_api_nat66_static_mapping_dump_t_handler (vl_api_nat66_static_mapping_dump_t
+ * mp)
+{
+ svm_queue_t *q;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0)
+ return;
+
+ nat66_api_walk_ctx_t ctx = {
+ .q = q,
+ .context = mp->context,
+ };
+
+ nat66_static_mappings_walk (nat66_api_static_mapping_walk, &ctx);
+}
+
+static void *
+vl_api_nat66_static_mapping_dump_t_print (vl_api_nat66_static_mapping_dump_t *
+ mp, void *handle)
+{
+ u8 *s;
+
+ s = format (0, "SCRIPT: nat66_static_mapping_dump ");
+
+ FINISH;
+}
+
+
/* List of message types that this plugin understands */
#define foreach_snat_plugin_api_msg \
_(NAT_CONTROL_PING, nat_control_ping) \
_(NAT64_PREFIX_DUMP, nat64_prefix_dump) \
_(NAT64_ADD_DEL_INTERFACE_ADDR, nat64_add_del_interface_addr) \
_(DSLITE_ADD_DEL_POOL_ADDR_RANGE, dslite_add_del_pool_addr_range) \
-_(DSLITE_SET_AFTR_ADDR, dslite_set_aftr_addr)
+_(DSLITE_ADDRESS_DUMP, dslite_address_dump) \
+_(DSLITE_SET_AFTR_ADDR, dslite_set_aftr_addr) \
+_(DSLITE_GET_AFTR_ADDR, dslite_get_aftr_addr) \
+_(DSLITE_SET_B4_ADDR, dslite_set_b4_addr) \
+_(DSLITE_GET_B4_ADDR, dslite_get_b4_addr) \
+_(NAT66_ADD_DEL_INTERFACE, nat66_add_del_interface) \
+_(NAT66_INTERFACE_DUMP, nat66_interface_dump) \
+_(NAT66_ADD_DEL_STATIC_MAPPING, nat66_add_del_static_mapping) \
+_(NAT66_STATIC_MAPPING_DUMP, nat66_static_mapping_dump)
/* Set up the API message handling tables */
static clib_error_t *
Code Review / vpp.git / blobdiff