ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
vpp/plugins/vcgn-plugin/vcgn/cnat_show.c
Ole Troan ea3e1fc875 Plugins: Clean up the plugin directory so that each plugin has its own 
directory and GNU autotools setup.

Change-Id: I6c59d1297389c9413db0c0b9bdf3b759080bf1b8
Signed-off-by: Ole Troan <ot@cisco.com>
2016-06-27 15:04:00 +00:00

811 lines
24 KiB
C
Raw Blame History

/*
*------------------------------------------------------------------
* cnat_show.c - translation database definitions
*
* Copyright (c) 2007-2014 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*------------------------------------------------------------------
*/
#include <vlib/vlib.h>
#include <vnet/vnet.h>
#include <vppinfra/vec.h>
#include <vppinfra/bitmap.h>
#include <vppinfra/hash.h>
#include <vppinfra/pool.h>
#include <vppinfra/clib.h>
#include "cnat_db.h"
#include "cnat_config.h"
#include "cnat_global.h"
#include "cnat_logging.h"
#include "spp_ctx.h"
#include "spp_timers.h"
#include "platform_common.h"
#include "cnat_syslog.h"
#include "cnat_v4_pptp_alg.h"
#include "platform_common.h"
#ifndef TOBE_PORTED
/* The following variable is in cnat_config_msg_handler.c which
* is to be ported later.. if required
*/
u32 total_address_pool_allocated = 0;
#endif
#ifndef NO_BULK_LOGGING
#define CNAT_MY_VRFMAP_PRINT \
PLATFORM_DEBUG_PRINT("i-uidx 0x%x o-uidx 0x%x i-vrfid 0x%x o-vrfid 0x%x\n" \
"status %d del time 0x%x tcp mss 0x%x pm list 0x%x\n" \
"bulk size %d\n" \
"ip n:1 %d\n" \
"NFV9 template index 0x%x\n" \
"SYSLOG template index 0x%x\n" \
"Netflow Session Logging %d \n" \
"Syslog Session Logging %d \n" \
"PCP Server 0x%x, Port %u \n", \
my_vrfmap->i_vrf, my_vrfmap->o_vrf, my_vrfmap->i_vrf_id, \
my_vrfmap->o_vrf_id, my_vrfmap->status, my_vrfmap->delete_time, \
my_vrfmap->tcp_mss, my_vrfmap->portmap_list, \
BULKSIZE_FROM_VRFMAP(my_vrfmap), \
my_vrfmap->ip_n_to_1, \
my_vrfmap->nfv9_logging_index, \
my_vrfmap->syslog_logging_index,\
my_vrfmap->nf_logging_policy, \
my_vrfmap->syslog_logging_policy, \
my_vrfmap->pcp_server_addr, \
my_vrfmap->pcp_server_port);
#else
#define CNAT_MY_VRFMAP_PRINT \
PLATFORM_DEBUG_PRINT("i-uidx 0x%x o-uidx 0x%x i-vrfid 0x%x o-vrfid 0x%x\n" \
"status %d del time 0x%x tcp mss 0x%x pm list 0x%x\n" \
"NFV9 template index 0x%x\n ip n:1 %d\n", \
my_vrfmap->i_vrf, my_vrfmap->o_vrf, my_vrfmap->i_vrf_id, \
my_vrfmap->o_vrf_id, my_vrfmap->status, my_vrfmap->delete_time, \
my_vrfmap->tcp_mss, my_vrfmap->portmap_list, \
my_vrfmap->nfv9_logging_index, my_vrfmap->ip_n_to_1);
#endif /* NO_BULK_LOGGING */
#define CNAT_MY_LOGGING_INFO_PRINT \
do { \
cnat_syslog_logging_info_t *my_syslog_info = 0; \
PLATFORM_DEBUG_PRINT("SYSLOG config: \n"); \
pool_foreach (my_syslog_info, cnat_syslog_logging_info_pool, ({ \
if (my_syslog_info->i_vrf == my_vrfmap->i_vrf) { \
PLATFORM_DEBUG_PRINT(" \
ipv4[0x%x], port[%u], hostname[%s]\n", \
my_syslog_info->ipv4_address, my_syslog_info->port, \
my_syslog_info->header_hostname); \
break; \
} \
})); \
}while (0) \
;
void printf_ipv4(u32 ad)
{
u8 a __attribute__((unused)), b __attribute__((unused)),
c __attribute__((unused)), d __attribute__((unused));
a = ad>>24;
b = (ad>>16) & 0xFF;
c = (ad>>8) & 0xFF;
d = (ad>>0) & 0xFF;
PLATFORM_DEBUG_PRINT("%d.%d.%d.%d", a, b, c, d);
}
void cnat_main_db_entry_dump (cnat_main_db_entry_t *db)
{
PLATFORM_DEBUG_PRINT("Main DB entry at %p, index %ld dst_ip %x\n",
db, db - cnat_main_db, db->dst_ipv4);
/* only dump hash next index if it's non EMPTY */
if (db->out2in_hash.next != EMPTY || db->in2out_hash.next != EMPTY)
PLATFORM_DEBUG_PRINT("out2in hash %u, in2out hash %u\n",
db->out2in_hash.next,
db->in2out_hash.next);
PLATFORM_DEBUG_PRINT("out2in key ipv4 0x%08X, port 0x%04X (%5d), vrf %d, protocol %s\n",
db->out2in_key.k.ipv4,
db->out2in_key.k.port,
db->out2in_key.k.port,
db->out2in_key.k.vrf & CNAT_VRF_MASK,
(db->out2in_key.k.vrf & CNAT_PRO_MASK) == CNAT_UDP ? "UDP" :
((db->in2out_key.k.vrf & CNAT_PRO_MASK) == CNAT_TCP ? "TCP" :
((db->in2out_key.k.vrf & CNAT_PRO_MASK) == CNAT_ICMP ? "ICMP" : "PPTP ALG")));
PLATFORM_DEBUG_PRINT("in2out key ipv4 0x%08X, port 0x%04X (%5d), vrf %d, protocol %s\n",
db->in2out_key.k.ipv4,
db->in2out_key.k.port,
db->in2out_key.k.port,
db->in2out_key.k.vrf & CNAT_VRF_MASK,
(db->in2out_key.k.vrf & CNAT_PRO_MASK) == CNAT_UDP ? "UDP" :
((db->in2out_key.k.vrf & CNAT_PRO_MASK) == CNAT_TCP ? "TCP" :
((db->in2out_key.k.vrf & CNAT_PRO_MASK) == CNAT_ICMP ? "ICMP" : "UNKNOWN")));
PLATFORM_DEBUG_PRINT("user %d, user ports (nxt) %d (prev) %d, vrfmap_index 0x%x\n",
db->user_index, db->user_ports.next, db->user_ports.prev,
db->vrfmap_index);
PLATFORM_DEBUG_PRINT("timeout %d \n", db->timeout);
PLATFORM_DEBUG_PRINT("flags 0x%x ", db->flags);
if (db->flags & CNAT_DB_FLAG_TCP_ACTIVE) {
PLATFORM_DEBUG_PRINT(" TCP_ACTIVE ");
} else if (db->flags & CNAT_DB_FLAG_UDP_ACTIVE) {
PLATFORM_DEBUG_PRINT(" UDP_ACTIVE ");
} else if (db->flags & CNAT_DB_FLAG_STATIC_PORT) {
PLATFORM_DEBUG_PRINT(" STATIC_PORT ");
}
PLATFORM_DEBUG_PRINT(" ALG dlt0 0x%02X dlt1 0x%02X\n", db->alg.alg_dlt[0], db->alg.alg_dlt[1]);
PLATFORM_DEBUG_PRINT("\n");
PLATFORM_DEBUG_PRINT("out2in_pkts: %u\n", db->out2in_pkts);
PLATFORM_DEBUG_PRINT("in2out_pkts: %u\n", db->in2out_pkts);
PLATFORM_DEBUG_PRINT("entry_expires: %u current time: %u\n", db->entry_expires, cnat_current_time);
PLATFORM_DEBUG_PRINT("-------------------------\n");
}
void cnat_user_db_entry_dump (cnat_user_db_entry_t *up)
{
u32 db_entry_index, first_db_entry_index;
cnat_main_db_entry_t *ep;
PLATFORM_DEBUG_PRINT("User DB entry at %p, index %ld\n",
up, up - cnat_user_db);
PLATFORM_DEBUG_PRINT("translation list head index %u, %u translations portmapindex 0x%x\n",
up->translation_list_head_index,
up->ntranslations, up->portmap_index);
PLATFORM_DEBUG_PRINT("source ipv4 0x%x, source port 0x%x, vrf %d\n",
up->key.k.ipv4,
up->key.k.port,
up->key.k.vrf);
first_db_entry_index = db_entry_index = up->translation_list_head_index;
if (first_db_entry_index != EMPTY) {
PLATFORM_DEBUG_PRINT("Port translation list:\n");
do {
PLATFORM_DEBUG_PRINT(" [%d]\n", db_entry_index);
ep = cnat_main_db + db_entry_index;
db_entry_index = ep->user_ports.next;
} while (first_db_entry_index != db_entry_index);
} else {
PLATFORM_DEBUG_PRINT("WARNING: empty translation list!\n");
}
PLATFORM_DEBUG_PRINT("-------------------------\n");
}
void cnat_user_db_entry_dump_summary (cnat_user_db_entry_t *up)
{
u32 db_entry_index, first_db_entry_index;
u32 total_entries = 0;
PLATFORM_DEBUG_PRINT("User DB entry at %p, index %ld\n",
up, up - cnat_user_db);
PLATFORM_DEBUG_PRINT("translation list head index %u, %u translations portmapindex 0x%x\n",
up->translation_list_head_index,
up->ntranslations, up->portmap_index);
PLATFORM_DEBUG_PRINT("source ipv4 0x%x, source port 0x%x, vrf %d\n",
up->key.k.ipv4,
up->key.k.port,
up->key.k.vrf);
first_db_entry_index = db_entry_index = up->translation_list_head_index;
if (first_db_entry_index != EMPTY) {
PLATFORM_DEBUG_PRINT("Port translation list:\n");
do {
total_entries++;
} while (first_db_entry_index != db_entry_index);
PLATFORM_DEBUG_PRINT("TOTAL_ENTRIES: %d\n", total_entries);
} else {
PLATFORM_DEBUG_PRINT("WARNING: empty translation list!\n");
}
PLATFORM_DEBUG_PRINT("-------------------------\n");
}
/* for internal development and UT only */
void cnat_db_dump_main_by_index (int argc, unsigned long *argv)
{
u32 index, i, len;
u32 active_count, scan_count;
if (argc != 1) {
PLATFORM_DEBUG_PRINT("invalid input %d\n", argc);
return;
}
index = argv[0];
len = vec_len(cnat_main_db);
active_count = pool_elts(cnat_main_db);
if (index >= active_count) {
PLATFORM_DEBUG_PRINT("Index %u >= total active entries %u\n", index, active_count);
return;
}
scan_count = 0;
for (i=0; i< len; i++) {
if(pool_is_free_index(cnat_main_db, i)) continue;
if (index == scan_count) {
cnat_main_db_entry_dump(cnat_main_db + i);
break;
}
scan_count++;
}
}
void cnat_db_dump_main (int argc, unsigned long *argv)
{
cnat_main_db_entry_t *db;
pool_foreach(db, cnat_main_db, ({
cnat_main_db_entry_dump(db);
}));
}
void cnat_db_dump_main_summary (int argc, unsigned long *argv)
{
cnat_main_db_entry_t *db;
u32 num_entries = 0;
pool_foreach(db, cnat_main_db, ({
num_entries++;
}));
PLATFORM_DEBUG_PRINT("\nNum main entries %d\n", num_entries);
}
void cnat_db_dump_user (int argc, unsigned long *argv)
{
cnat_user_db_entry_t *up;
pool_foreach(up, cnat_user_db, ({
cnat_user_db_entry_dump(up);
}));
}
void cnat_db_dump_user_summary (int argc, unsigned long *argv)
{
cnat_user_db_entry_t *up;
pool_foreach(up, cnat_user_db, ({
cnat_user_db_entry_dump_summary(up);
}));
}
void cnat_db_dump_hashes (int argc, unsigned long *argv)
{
int i;
PLATFORM_DEBUG_PRINT("Main DB out2in hash:\n");
for (i = 0; i < vec_len(cnat_out2in_hash); i++) {
if (cnat_out2in_hash[i].next != EMPTY) {
PLATFORM_DEBUG_PRINT("[%d]: %u\n", i, cnat_out2in_hash[i].next);
}
}
PLATFORM_DEBUG_PRINT("Main DB in2out hash:\n");
for (i = 0; i < vec_len(cnat_in2out_hash); i++) {
if (cnat_in2out_hash[i].next != EMPTY) {
PLATFORM_DEBUG_PRINT("[%d]: %u\n", i, cnat_in2out_hash[i].next);
}
}
PLATFORM_DEBUG_PRINT("User hash:\n");
for (i = 0; i < vec_len(cnat_user_hash); i++) {
if (cnat_user_hash[i].next != EMPTY) {
PLATFORM_DEBUG_PRINT("[%d]: %u\n", i, cnat_user_hash[i].next);
}
}
PLATFORM_DEBUG_PRINT("-------------------------\n");
}
#ifdef OLD_VRFMAP
void cnat_db_dump_cdb (int argc, unsigned long *argv)
{
int k;
int verbose=0;
int all = 0;
if (argc > 0) {
verbose = 1;
}
if (argc > 1) {
all = 1;
}
PLATFORM_DEBUG_PRINT ("%d vrfmap vectors \n", vec_len(cnat_portmap_by_vrf));
for (k = 0; k < vec_len(cnat_portmap_by_vrf); k++) {
PLATFORM_DEBUG_PRINT("index%d: status %d i_vrf 0x%x o_vrf 0x%x\n", k,
cnat_portmap_by_vrf[k].status,
cnat_portmap_by_vrf[k].i_vrf,
cnat_portmap_by_vrf[k].o_vrf);
cnat_db_dump_address_portmap(verbose, all,
cnat_portmaps[k],
cnat_portmaps_inuse[k]);
}
}
void cnat_db_dump_i_vrf (int argc, unsigned long *argv)
{
u32 k;
u32 vrf =0;
int verbose=0;
int all = 0;
if (!argc) {
PLATFORM_DEBUG_PRINT("need vrf input ,return\n");
return;
}
if (argc > 0) {
vrf = argv[0];
}
if (argc > 1) {
verbose = 1;
}
if (argc > 2) {
all = 1;
}
PLATFORM_DEBUG_PRINT ("%d vrfmap vectors \n", vec_len(cnat_portmap_by_vrf));
for (k = 0; k < vec_len(cnat_portmap_by_vrf); k++) {
if (cnat_portmap_by_vrf[k].i_vrf == vrf) {
PLATFORM_DEBUG_PRINT("%d: i_vrf 0x%x o_vrf 0x%x\n", k,
cnat_portmap_by_vrf[k].i_vrf,
cnat_portmap_by_vrf[k].o_vrf);
cnat_db_dump_address_portmap(verbose, all,
cnat_portmaps[k],
cnat_portmaps_inuse[k]);
return;
}
}
PLATFORM_DEBUG_PRINT("not found\n");
}
void cnat_db_dump_o_vrf (int argc, unsigned long *argv)
{
u32 k;
int verbose=0;
int all = 0;
u32 vrf =0;
if (!argc) {
PLATFORM_DEBUG_PRINT("need vrf input ,return\n");
return;
}
if (argc > 0) {
vrf = argv[0];
}
if (argc > 1) {
verbose = 1;
}
if (argc > 2) {
all = 1;
}
PLATFORM_DEBUG_PRINT ("%d vrfmap vectors \n", vec_len(cnat_portmap_by_vrf));
for (k = 0; k < vec_len(cnat_portmap_by_vrf); k++) {
if (cnat_portmap_by_vrf[k].o_vrf == vrf) {
PLATFORM_DEBUG_PRINT("index%d: status %d i_vrf 0x%x o_vrf 0x%x\n", k,
cnat_portmap_by_vrf[k].status,
cnat_portmap_by_vrf[k].i_vrf,
cnat_portmap_by_vrf[k].o_vrf);
cnat_db_dump_address_portmap(verbose, all,
cnat_portmaps[k],
cnat_portmaps_inuse[k]);
return;
}
}
PLATFORM_DEBUG_PRINT("not found\n");
}
#endif
#ifdef TOBE_PORTED
/* This does not seem to be used */
void cnat_db_mem_usage_cmd (int argc, unsigned long *argv)
{
pool_header_t * p;
_VEC *_v;
u32 bitmap_bytes=0, free_indices_bytes=0, vec_bytes=0, total_bytes=0;
if (cnat_main_db) {
p = pool_header(cnat_main_db);
if (p->free_bitmap) {
_v = _vec_find(p->free_bitmap);
bitmap_bytes = _v->alen;
} else {
bitmap_bytes = 0;
}
if (p->free_indices) {
_v = _vec_find(p->free_indices);
free_indices_bytes = _v->alen;
} else {
free_indices_bytes = 0;
}
_v = _vec_find(cnat_main_db);
vec_bytes = _v->alen;
} else {
vec_bytes = 0;
}
total_bytes = bitmap_bytes + free_indices_bytes + vec_bytes;
PLATFORM_DEBUG_PRINT ("Main DB: %d total bytes, %d bitmap, %d indices, %d vec\n",
total_bytes, bitmap_bytes, free_indices_bytes, vec_bytes);
PLATFORM_DEBUG_PRINT (" vector length %d\n", vec_len(cnat_main_db));
if (cnat_user_db) {
p = pool_header(cnat_user_db);
if (p->free_bitmap) {
_v = _vec_find(p->free_bitmap);
bitmap_bytes = _v->alen;
} else {
bitmap_bytes = 0;
}
if (p->free_indices) {
_v = _vec_find(p->free_indices);
free_indices_bytes = _v->alen;
} else {
free_indices_bytes = 0;
}
_v = _vec_find(cnat_user_db);
vec_bytes = _v->alen;
} else {
vec_bytes = 0;
}
total_bytes = bitmap_bytes + free_indices_bytes + vec_bytes;
PLATFORM_DEBUG_PRINT ("User DB: %d total bytes, %d bitmap, %d indices, %d vec\n",
total_bytes, bitmap_bytes, free_indices_bytes, vec_bytes);
PLATFORM_DEBUG_PRINT (" vector length %d\n", vec_len(cnat_user_db));
_v = _vec_find(cnat_out2in_hash);
PLATFORM_DEBUG_PRINT("out2in hash: %d total bytes\n", _v->alen);
_v = _vec_find(cnat_in2out_hash);
PLATFORM_DEBUG_PRINT("in2out hash: %d total bytes\n", _v->alen);
}
#endif
static void print_server_ip_address (vlib_main_t *vm, u32 ip)
{
unsigned char bytes[4];
bytes[0] = ip & 0xFF;
bytes[1] = (ip >> 8) & 0xFF;
bytes[2] = (ip >> 16) & 0xFF;
bytes[3] = (ip >> 24) & 0xFF;
vlib_cli_output(vm, "\tIP Address : %d.%d.%d.%d\n", bytes[0], bytes[1], bytes[2], bytes[3]);
}
void cnat_nfv9_show_collector (vlib_main_t *vm, cnat_nfv9_logging_info_t *my_nfv9_logging_info)
{
nfv9_server_info_t *server = nfv9_server_info_pool +
my_nfv9_logging_info->server_index;
#if 0
vlib_cli_output(vm,"\tVRF - 0x%x - %s\n", my_nfv9_logging_info->i_vrf,
my_nfv9_logging_info->deleted?"DELETED":"ACTIVE");
#endif
print_server_ip_address(vm, clib_net_to_host_u32(server->ipv4_address));
vlib_cli_output(vm,"\tPort : %d\n", server->port);
vlib_cli_output(vm,"\tTimeout : %d\n", server->timeout_rate);
vlib_cli_output(vm,"\tRefresh Rate : %d\n", server->refresh_rate);
vlib_cli_output(vm,"\tMax Pkt Size : %d\n", my_nfv9_logging_info->max_length_minus_max_record_size);
return;
}
void cnat_db_dump_policy (int argc, unsigned long *argv)
{
PLATFORM_CNAT_DB_DUMP_POLICY_PRINT();
if (cnat_nfv9_global_info.cnat_nfv9_init_done) {
if (cnat_nfv9_global_info.cnat_nfv9_global_collector_index != EMPTY) {
cnat_nfv9_logging_info_t *my_nfv9_logging_info;
nfv9_server_info_t *server __attribute__((unused));
my_nfv9_logging_info = cnat_nfv9_logging_info_pool +
cnat_nfv9_global_info.cnat_nfv9_global_collector_index;
server = nfv9_server_info_pool +
my_nfv9_logging_info->server_index;
PLATFORM_DEBUG_PRINT("NFv9 logging ip 0x%x port 0x%x refresh-rate %d timeout %d\n",
server->ipv4_address,
server->port,
server->refresh_rate,
server->timeout_rate);
PLATFORM_DEBUG_PRINT("NFv9 path_mtu = %d\n",
my_nfv9_logging_info->max_length_minus_max_record_size);
} else {
PLATFORM_DEBUG_PRINT("NFv9 global logging is not configured\n");
}
} else {
PLATFORM_DEBUG_PRINT("NFv9 LOGGING is not configured\n");
}
}
#ifdef OLD_VRFMAP
void cnat_show_cdb (int verbose)
{
int k, l, i;
for (i = 0; i < vec_len(cnat_portmap_by_vrf); i++) {
PLATFORM_DEBUG_PRINT("i_vrf %d : o_vrf %d\n",
cnat_portmap_by_vrf[i].i_vrf,
cnat_portmap_by_vrf[i].o_vrf);
}
PLATFORM_DEBUG_PRINT("port limit %d\n", cnat_main_db_max_ports_per_user);
PLATFORM_DEBUG_PRINT ("%d portmap vectors\n", vec_len(cnat_portmaps));
for (k = 0; k < vec_len(cnat_portmaps); k++) {
cnat_portmap_t *pm;
u16 *inuse;
pm = cnat_portmaps[k];
inuse = cnat_portmaps_inuse[k];
for (l = 0; l < vec_len(pm); l++) {
if (inuse[l] || verbose ) {
u32 net_address;
net_address =
spp_host_to_net_byte_order_32((pm+l)->ipv4_address);
printf_ipv4(net_address);
PLATFORM_DEBUG_PRINT (": %d inuse\n", inuse[l]);
if (verbose && inuse[l]) {
cnat_portmap_dump (pm+l, inuse+l);
}
}
}
}
}
#endif
/* v2 show command */
void cnat_show_address_portmap_sumary (cnat_portmap_v2_t *pm)
{
cnat_portmap_v2_t *my_pm =0;
u32 first_address = 0;
u32 second_address = 0;
u32 last_address = 0;
u32 i, pm_len;
if ((pm_len = vec_len(pm))) {
PLATFORM_DEBUG_PRINT("%d portmap in this list 0x%lx\n",
pm_len, (u32)pm);
for (i = 0; i < pm_len; i++) {
my_pm = pm + i;
if (!first_address) {
first_address = my_pm->ipv4_address;
} else if (!second_address) {
second_address = my_pm->ipv4_address;
}
last_address = my_pm->ipv4_address;
}
if (first_address) {
PLATFORM_DEBUG_PRINT("1. 0x%08x", first_address);
}
if (second_address) {
PLATFORM_DEBUG_PRINT(", 2. 0x%08x", second_address);
}
if ((last_address != first_address) &&
(last_address != second_address)) {
PLATFORM_DEBUG_PRINT(", ....., %d. 0x%08x", pm_len, last_address);
}
PLATFORM_DEBUG_PRINT("\n");
} else {
PLATFORM_DEBUG_PRINT("ZERO POOL ADDRESSES in this list 0x%x \n", (u32)pm);
}
}
void cnat_show_address_portmap (int verbose, int all,
cnat_portmap_v2_t *pm, u16 port_limit)
{
cnat_portmap_v2_t *my_pm =0;
u32 i, pm_len;
pm_len = vec_len(pm);
if (!all) {
cnat_show_address_portmap_sumary(pm);
} else {
PLATFORM_DEBUG_PRINT("%d portmap in this list 0x%x \n", pm_len, (u32)pm);
}
for (i = 0; i < pm_len; i++) {
my_pm = pm + i;
if (all) {
PLATFORM_DEBUG_PRINT("pm:0x%x ip address:0x%x del_time 0x%x inuse:%d\n",
(u32)my_pm, my_pm->ipv4_address, my_pm->delete_time, my_pm->inuse);
} else if (my_pm->inuse) {
PLATFORM_DEBUG_PRINT("pm:0x%x ip address:0x%x inuse:%d\n",
(u32)my_pm, my_pm->ipv4_address, my_pm->inuse);
}
if (verbose && (my_pm->inuse)) {
if(PREDICT_FALSE(!port_limit)) {
cnat_portmap_dump_v2 (my_pm, cnat_main_db_max_ports_per_user);
}
else {
cnat_portmap_dump_v2 (my_pm, port_limit);
}
}
}
PLATFORM_DEBUG_PRINT("\n");
}
void cnat_show_cdb_v2 (int verbose, int all)
{
cnat_vrfmap_t *my_vrfmap = 0;
cnat_portmap_v2_t *pm =0;
PLATFORM_DEBUG_PRINT("port limit %d\n", cnat_main_db_max_ports_per_user);
PLATFORM_DEBUG_PRINT("total address pool allocated %d\n", total_address_pool_allocated);
PLATFORM_DEBUG_PRINT("icmp rate limit %d (per core %d)\n",
cnat_main_db_icmp_rate_limit, cnat_main_db_icmp_rate_limit_core);
PLATFORM_DEBUG_PRINT("dynamic port range start %d\n", cnat_static_port_range);
if (pptp_cfg.enable == PPTP_DISABLED) {
PLATFORM_DEBUG_PRINT("PPTP alg disabled \n");
} else {
PLATFORM_DEBUG_PRINT("PPTP alg enabled \n");
}
if (ftp_alg_enabled) {
PLATFORM_DEBUG_PRINT("FTP alg enabled\n");
} else {
PLATFORM_DEBUG_PRINT("FTP alg disabled\n");
}
pool_foreach (my_vrfmap, cnat_map_by_vrf, ({
CNAT_MY_VRFMAP_PRINT
CNAT_MY_LOGGING_INFO_PRINT
PLATFORM_DEBUG_PRINT("per vrf port limit %d\n", my_vrfmap->port_limit);
pm = my_vrfmap->portmap_list;
cnat_show_address_portmap(verbose, all, pm, my_vrfmap->port_limit);
}));
}
void cnat_show_cdb_command_v2(int argc, unsigned long *argv)
{
int verbose=0;
int all = 0;
if (argc > 0) {
verbose = 1;
}
if (argc > 1) {
all = 1;
}
cnat_show_cdb_v2(verbose, all);
}
void cnat_show_ivrf_command_v2 (int argc, unsigned long *argv)
{
u32 vrf =0;
int verbose=0;
int all = 0;
cnat_vrfmap_t *my_vrfmap = 0;
cnat_portmap_v2_t *pm =0;
if (!argc) {
PLATFORM_DEBUG_PRINT("need vrf input ,return\n");
return;
}
if (argc > 0) {
vrf = argv[0];
}
if (argc > 1) {
verbose = 1;
}
if (argc > 2) {
all = 1;
}
PLATFORM_DEBUG_PRINT ("%lld vrfmap vectors \n", pool_elts(cnat_map_by_vrf));
pool_foreach (my_vrfmap, cnat_map_by_vrf, ({
if (my_vrfmap->i_vrf == vrf) {
CNAT_MY_VRFMAP_PRINT
pm = my_vrfmap->portmap_list;
cnat_show_address_portmap(verbose, all, pm,my_vrfmap->port_limit);
return;
}
}));
PLATFORM_DEBUG_PRINT("not found\n");
}
void cnat_show_ovrf_command_v2 (int argc, unsigned long *argv)
{
u32 not_found =1;
u32 vrf =0;
int verbose=0;
int all = 0;
cnat_vrfmap_t *my_vrfmap = 0;
cnat_portmap_v2_t *pm =0;
if (!argc) {
PLATFORM_DEBUG_PRINT("need vrf input ,return\n");
return;
}
if (argc > 0) {
vrf = argv[0];
}
if (argc > 1) {
verbose = 1;
}
if (argc > 2) {
all = 1;
}
PLATFORM_DEBUG_PRINT("%d vrfmap vectors \n", pool_elts(cnat_map_by_vrf));
pool_foreach (my_vrfmap, cnat_map_by_vrf, ({
if (my_vrfmap->o_vrf == vrf) {
CNAT_MY_VRFMAP_PRINT
pm = my_vrfmap->portmap_list;
cnat_show_address_portmap(verbose, all, pm,my_vrfmap->port_limit);
not_found = 0;
}
}));
if (not_found) {
PLATFORM_DEBUG_PRINT("not found\n");
}
}
void cnat_timeout_db_entry_dump (cnat_timeout_db_entry_t *up)
{
u32 db_entry_index __attribute__((unused)),
first_db_entry_index __attribute__((unused));
PLATFORM_DEBUG_PRINT("Timeout DB entry at index %ld\n", up - cnat_timeout_db);
PLATFORM_DEBUG_PRINT("Desnt key 0x%16llx\n", up->t_key.timeout_key.key64);
PLATFORM_DEBUG_PRINT("Timeout value %d\n", up->t_key.timeout_value);
PLATFORM_DEBUG_PRINT("Hash Next 0x%x\n", up->t_hash.next);
}
void cnat_db_dump_timeout ()
{
cnat_timeout_db_entry_t *up;
pool_header_t *h;
u32 used __attribute__((unused)), free __attribute__((unused));
h = pool_header(cnat_timeout_db);
free = vec_len(h->free_indices);
used = (vec_len(cnat_timeout_db) - free);
PLATFORM_DEBUG_PRINT("Timeout DB Free %d, Used %d\n",free, used);
pool_foreach(up, cnat_timeout_db, ({
cnat_timeout_db_entry_dump(up);
}));
}
Reference in New Issue View Git Blame Copy Permalink