diff options
Diffstat (limited to 'VNFs/vCGNAPT/pipeline/pipeline_cgnapt_be.c')
| -rw-r--r-- | VNFs/vCGNAPT/pipeline/pipeline_cgnapt_be.c | 10963 |
1 files changed, 10963 insertions, 0 deletions
diff --git a/VNFs/vCGNAPT/pipeline/pipeline_cgnapt_be.c b/VNFs/vCGNAPT/pipeline/pipeline_cgnapt_be.c new file mode 100644 index 00000000..9a05a4da --- /dev/null +++ b/VNFs/vCGNAPT/pipeline/pipeline_cgnapt_be.c @@ -0,0 +1,10963 @@ +/* +// Copyright (c) 2017 Intel Corporation +// +// 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. +*/ + +/** + * @file + * Pipeline CG-NAPT BE Implementation. + * + * Implementation of Pipeline CG-NAPT Back End (BE). + * Provides NAPT service on dataplane packets. + * Runs on a core as defined in the config file. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> + +#include <rte_common.h> +#include <rte_malloc.h> +#include <rte_ip.h> +#include <rte_tcp.h> +#include <rte_udp.h> +#include <rte_icmp.h> +#include <rte_hash.h> +#include <rte_byteorder.h> +#include <rte_table_lpm.h> +#include <rte_table_hash.h> +#include <rte_table_stub.h> +#include <rte_ring.h> +#include <rte_mempool.h> + +#include <rte_jhash.h> +#include <rte_cycles.h> +#include <rte_ethdev.h> +#include <rte_pipeline.h> +#include <rte_timer.h> +#include <rte_config.h> +#include <rte_prefetch.h> +#include <rte_hexdump.h> + +#include "pipeline_cgnapt_be.h" +#include "pipeline_cgnapt_common.h" +#include "pipeline_actions_common.h" +#include "hash_func.h" +#include "pipeline_arpicmp_be.h" +#include "vnf_common.h" +#include "app.h" +#include "pipeline_common_be.h" +#include "vnf_common.h" +#include "lib_sip_alg.h" +#include "lib_icmpv6.h" + +#include "pipeline_common_fe.h" +#ifdef CT_CGNAT +#include "rte_ct_tcp.h" +#include "rte_cnxn_tracking.h" +#endif +#ifdef FTP_ALG +#include "lib_ftp_alg.h" +#endif +#ifdef PCP_ENABLE +#include "cgnapt_pcp_be.h" +#endif + +/* To maintain all cgnapt pipeline pointers used for all stats */ +struct pipeline_cgnapt *all_pipeline_cgnapt[128]; +uint8_t n_cgnapt_pipeline; + +/* To know egress or ingress port */ +static uint8_t cgnapt_in_port_egress_prv[PIPELINE_MAX_PORT_IN]; +static uint8_t cgnapt_prv_que_port_index[PIPELINE_MAX_PORT_IN]; + +/* Max port per client declarations */ + +struct rte_hash_parameters max_port_per_client_hash_params = { + .name = "MAX_PORT_PER_CLIENT", + .entries = MAX_DYN_ENTRY, + .key_len = sizeof(struct max_port_per_client_key), + .hash_func = rte_jhash, + .hash_func_init_val = 0, +}; +#ifdef CT_CGNAT +struct rte_ct_cnxn_tracker *cgnat_cnxn_tracker; +#endif + +/***** Common Port Allocation declarations *****/ + +struct rte_ring *port_alloc_ring[MAX_CGNAPT_SETS] = { NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL }; +const char *napt_port_alloc_ring_name[MAX_CGNAPT_SETS] = { + "NAPT_PORT_ALLOC_0 ", + "NAPT_PORT_ALLOC_1 ", + "NAPT_PORT_ALLOC_2 ", + "NAPT_PORT_ALLOC_3 ", + "NAPT_PORT_ALLOC_4 ", + "NAPT_PORT_ALLOC_5 ", + "NAPT_PORT_ALLOC_6 ", + "NAPT_PORT_ALLOC_7 " +}; + +int vnf_set_count = -1; + +struct app_params *myApp; + +/***** Common Port Allocation declarations *****/ +int napt_port_alloc_elem_count; + +/***** Common Table declarations *****/ +struct rte_hash_parameters napt_common_table_hash_params = { + .name = "NAPT_COM_TBL", + .entries = MAX_NAPT_ENTRIES, + .key_len = sizeof(struct pipeline_cgnapt_entry_key), + .hash_func = rte_jhash, + .hash_func_init_val = 0, + .extra_flag = 1, +}; + +/***** ARP local cache *****/ +uint8_t link_hw_laddr_valid[MAX_NUM_LOCAL_MAC_ADDRESS] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 +}; + +struct ether_addr link_hw_laddr[MAX_NUM_LOCAL_MAC_ADDRESS] = { + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, + {.addr_bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00} } +}; + +/****** NAT64 declarations *****/ + +uint8_t well_known_prefix[16] = { + 0x00, 0x64, 0xff, 0x9b, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 +}; + +static uint32_t local_get_nh_ipv4( + uint32_t ip, + uint32_t *port, + uint32_t *nhip, + struct pipeline_cgnapt *p_nat); + +static void do_local_nh_ipv4_cache( + uint32_t dest_if, + struct pipeline_cgnapt *p_nat); + +static uint32_t local_get_nh_ipv6( + uint8_t *ip, + uint32_t *port, + uint8_t nhip[], + struct pipeline_cgnapt *p_nat); + +static void do_local_nh_ipv6_cache( + uint32_t dest_if, + struct pipeline_cgnapt *p_nat); + +static uint8_t check_arp_icmp( + struct rte_mbuf *pkt, + uint64_t pkt_mask, + struct pipeline_cgnapt *p_nat); + +/* Finds next power of two for n. If n itself + * is a power of two then returns n + * + * @param n + * Value usually 32-bit value + * + * @return + * Value after roundup to power of 2 +*/ +uint64_t nextPowerOf2(uint64_t n) +{ + n--; + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + n |= n >> 32; + n++; + return n; +} + +/** + * Function to get MAC addr of local link + * + * @params out_port + * Physical port number + * + * @return + * Outport Link MAC addr + */ + +struct ether_addr *get_local_link_hw_addr(uint8_t out_port) +{ + return &link_hw_laddr[out_port]; +} + +/** + * Function to get MAC addr from array instead of hash table + * + * @params out_port + * Physical port number + * + * @return + * Outport Link MAC addr + */ + +uint8_t local_dest_mac_present(uint8_t out_port) +{ + return link_hw_laddr_valid[out_port]; +} + +/** + * Function to get IPv4-IP NH from thread local array + * + * @params ip + * IPv4 - IP + * @params port + * NH port number + * @params nhip + * NHIP of IPv4 type + * @params p_nat + * CGNAPT pipeline ptr + * + * @return + * 1 on success, 0 for failure + */ + +static uint32_t local_get_nh_ipv4( + uint32_t ip, + uint32_t *port, + uint32_t *nhip, + struct pipeline_cgnapt *p_nat) +{ + int i; + for (i = 0; i < p_nat->local_lib_arp_route_ent_cnt; i++) { + if (((p_nat->local_lib_arp_route_table[i].ip & + p_nat->local_lib_arp_route_table[i].mask) == + (ip & p_nat->local_lib_arp_route_table[i].mask))) { + *port = p_nat->local_lib_arp_route_table[i].port; + + *nhip = p_nat->local_lib_arp_route_table[i].nh; + return 1; + } + } + return 0; +} + +/** + * Function to make local copy for NH of type IPv4 + * + * @params dest_if + * Physical port number + * @params p_nat + * CGNAPT pipeline ptr + * + */ + +static void do_local_nh_ipv4_cache( + uint32_t dest_if, + struct pipeline_cgnapt *p_nat) +{ + + /* Search for the entry and do local copy */ + int i; + + for (i = 0; i < MAX_ARP_RT_ENTRY; i++) { + if (lib_arp_route_table[i].port == dest_if) { + + struct lib_arp_route_table_entry *lentry = + &p_nat->local_lib_arp_route_table + [p_nat->local_lib_arp_route_ent_cnt]; + + lentry->ip = lib_arp_route_table[i].ip; + lentry->mask = lib_arp_route_table[i].mask; + lentry->port = lib_arp_route_table[i].port; + lentry->nh = lib_arp_route_table[i].nh; + + p_nat->local_lib_arp_route_ent_cnt++; + break; + } + } +} + + +/** + * Function to get IPv6-IP NH from thread local array + * + * @params ip + * Pointer to starting addr of IPv6 + * @params port + * NH port number + * @params nhip + * NHIP of IPv6 type + * @params p_nat + * CGNAPT pipeline ptr + * + * @return + * 1 on success, 0 for failure + */ + +static uint32_t local_get_nh_ipv6( + uint8_t *ip, + uint32_t *port, + uint8_t nhip[], + struct pipeline_cgnapt *p_nat) +{ + int i = 0; + uint8_t netmask_ipv6[16]; + uint8_t k = 0, l = 0, depthflags = 0, depthflags1 = 0; + + for (i = 0; i < p_nat->local_lib_nd_route_ent_cnt; i++) { + + convert_prefixlen_to_netmask_ipv6( + p_nat->local_lib_nd_route_table[i].depth, + netmask_ipv6); + + for (k = 0; k < 16; k++) + if (p_nat->local_lib_nd_route_table[i].ipv6[k] & + netmask_ipv6[k]) + depthflags++; + + for (l = 0; l < 16; l++) + if (ip[l] & netmask_ipv6[l]) + depthflags1++; + + int j = 0; + if (depthflags == depthflags1) { + *port = p_nat->local_lib_nd_route_table[i].port; + + for (j = 0; j < 16; j++) + nhip[j] = p_nat->local_lib_nd_route_table[i]. + nhipv6[j]; + return 1; + } + + depthflags = 0; + depthflags1 = 0; + } + return 0; +} + + +/** + * Function to make local copy for NH of type IPv6 + * + * @params dest_if + * Physical port number + * @params p_nat + * CGNAPT pipeline ptr + * + */ + +static void do_local_nh_ipv6_cache( + uint32_t dest_if, + struct pipeline_cgnapt *p_nat) +{ + /* Search for the entry and do local copy */ + int i, l; + for (i = 0; i < MAX_ND_RT_ENTRY; i++) { + + if (lib_nd_route_table[i].port == dest_if) { + + struct lib_nd_route_table_entry *lentry = + &p_nat->local_lib_nd_route_table + [p_nat->local_lib_nd_route_ent_cnt]; + + for (l = 0; l < 16; l++) { + lentry->ipv6[l] = + lib_nd_route_table[i].ipv6[l]; + lentry->nhipv6[l] = + lib_nd_route_table[i].nhipv6[l]; + } + lentry->depth = lib_nd_route_table[i].depth; + lentry->port = lib_nd_route_table[i].port; + + p_nat->local_lib_nd_route_ent_cnt++; + break; + } //if + } //for +} + +#ifdef SIP_ALG +/* Commented code may be required for future usage, Please keep it*/ +#if 0 +static int retrieve_cgnapt_entry_alg( + struct pipeline_cgnapt_entry_key *key, + struct cgnapt_table_entry **entry_ptr1, + struct cgnapt_table_entry **entry_ptr2) +{ + #ifdef CGNAPT_DBG_PRNT + printf("retrieve_cgnapt_entry key detail Entry:" + "0x%x, %d, %d\n", key->ip, key->port, + key->pid); + #endif + + int position = rte_hash_lookup(napt_common_table, key); + if (position < 0) { + printf("Invalid cgnapt entry position(first_key): %d\n", + position); + return 0; + } + + *entry_ptr1 = &napt_hash_tbl_entries[position]; + + uint32_t prv_ip = (*entry_ptr1)->data.prv_ip; + uint32_t prv_port = (*entry_ptr1)->data.prv_port; + uint32_t prv_phy_port = (*entry_ptr1)->data.prv_phy_port; + + struct pipeline_cgnapt_entry_key second_key; + second_key.ip = prv_ip; + second_key.port = prv_port; + second_key.pid = prv_phy_port; + + position = rte_hash_lookup(napt_common_table, &second_key); + if (position < 0) { + printf("Invalid cgnapt entry position(second_key): %d\n", + position); + return 0; + } + + *entry_ptr2 = &napt_hash_tbl_entries[position]; + + return 1; +} +#endif + +int add_dynamic_cgnapt_entry_alg( + struct pipeline *p, + struct pipeline_cgnapt_entry_key *key, + struct cgnapt_table_entry **entry_ptr1, + struct cgnapt_table_entry **entry_ptr2) +{ + int port_num = 0, ret; + + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) { + printf("Th%d add_dynamic_cgnapt_entry key detail Entry:" + "0x%x, %d, %d\n", p_nat->pipeline_num, key->ip, key->port, + key->pid); + } + #endif + + int32_t position = rte_hash_lookup(napt_common_table, key); + if (position >= 0) { + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) { + printf("%s: cgnapt entry exists in " + "position(first_key): %d\n", __func__, position); + } + #endif + *entry_ptr1 = &napt_hash_tbl_entries[position]; + /* not required, as it is not used in the caller */ + *entry_ptr2 = NULL; + return 1; + } + + + ret = increment_max_port_counter(key->ip, key->pid, p_nat); + if (ret == MAX_PORT_INC_ERROR) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("add_dynamic_cgnapt_entry:" + "increment_max_port_counter-1 failed\n"); + #endif + + return 0; + } + + if (ret == MAX_PORT_INC_REACHED) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("add_dynamic_cgnapt_entry:" + "increment_max_port_counter-2 failed\n"); + #endif + + return 0; + } + + uint32_t public_ip; + port_num = get_free_iport(p_nat, &public_ip); + + if (port_num == -1) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("add_dynamic_cgnapt_entry: %d\n", port_num); + printf("add_dynamic_cgnapt_entry key detail:0x%x, " + "%d, %d\n", key->ip, key->port, key->pid); + } + #endif + + return 0; + } + + /* check for max_clients_per_ip */ + if (rte_atomic16_read + (&all_public_ip + [rte_jhash(&public_ip, 4, 0) % 16].count) == + p_nat->max_clients_per_ip) { + /* For now just bail out + * In future we can think about + * retrying getting a new iport + */ + release_iport(port_num, public_ip, p_nat); + + return 0; + } + + rte_atomic16_inc(&all_public_ip + [rte_jhash(&public_ip, 4, 0) % + 16].count); + + #ifdef CGNAPT_DBG_PRNT + if ((rte_jhash(&public_ip, 4, 0) % 16) == 8) + printf("pub ip:%x coutn:%d\n", public_ip, + rte_atomic16_read(&all_public_ip + [rte_jhash(&public_ip, 4, 0) % 16].count)); + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 0) { + printf("add_dynamic_cgnapt_entry: %d\n", + port_num); + printf("add_dynamic_cgnapt_entry key detail: " + "0x%x, %d, %d\n", key->ip, key->port, key->pid); + } + #endif + + struct cgnapt_table_entry entry = { + .head = { + .action = RTE_PIPELINE_ACTION_PORT, + /* made it configurable below */ + {.port_id = p->port_out_id[0]}, + }, + + .data = { + .prv_port = key->port, + .pub_ip = public_ip, + .pub_port = port_num, + .prv_phy_port = key->pid, + .pub_phy_port = get_pub_to_prv_port( + &public_ip, + IP_VERSION_4), + .ttl = 0, + /* if(timeout == -1) : static entry + * if(timeout == 0 ) : dynamic entry + * if(timeout > 0 ) : PCP requested entry + */ + .timeout = 0, + #ifdef PCP_ENABLE + .timer = NULL, + #endif + } + }; + + entry.data.u.prv_ip = key->ip; + entry.data.type = CGNAPT_ENTRY_IPV4; + + entry.head.port_id = entry.data.pub_phy_port; /* outgoing port info */ + + struct pipeline_cgnapt_entry_key second_key; + /* Need to add a second ingress entry */ + second_key.ip = public_ip; + second_key.port = port_num; + second_key.pid = 0xffff; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("add_dynamic_cgnapt_entry second key detail:" + "0x%x, %d, %d\n", second_key.ip, second_key.port, + second_key.pid); + #endif + + int32_t position1 = rte_hash_add_key(napt_common_table, (void *)key); + + if (position1 < 0) { + printf("CG-NAPT entry add failed ...returning " + "without adding ... %d\n", position1); + return 0; + } + + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG) { + printf("add_dynamic_cgnapt_entry:"); + print_key(key); + print_cgnapt_entry(&entry); + } + #endif + + memcpy(&napt_hash_tbl_entries[position1], &entry, + sizeof(struct cgnapt_table_entry)); + + /* this pointer is returned to pkt miss function */ + *entry_ptr1 = &napt_hash_tbl_entries[position1]; + + p_nat->n_cgnapt_entry_added++; + p_nat->dynCgnaptCount++; + + /* Now modify the forward port for reverse entry */ + + /* outgoing port info */ + entry.head.port_id = entry.data.prv_phy_port; + + int32_t position2 = rte_hash_add_key(napt_common_table, &second_key); + + if (position2 < 0) { + printf("CG-NAPT entry reverse bulk add failed ..." + "returning with fwd add ...%d\n", + position2); + return 0; + } + + memcpy(&napt_hash_tbl_entries[position2], &entry, + sizeof(struct cgnapt_table_entry)); + + *entry_ptr2 = &napt_hash_tbl_entries[position2]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) { + printf("add_dynamic_cgnapt_entry position: %d, %d\n", + position1, position2); + printf("add_dynamic_cgnapt_entry: entry_ptr1: %p, " + "entry_ptr2: %p\n", *entry_ptr1, *entry_ptr2); + } + #endif + + timer_thread_enqueue(key, &second_key, *entry_ptr1, + *entry_ptr2, (struct pipeline *)p_nat); + + p_nat->n_cgnapt_entry_added++; + p_nat->dynCgnaptCount++; + + return 1; +} + +#endif + +void hw_checksum(struct rte_mbuf *pkt, enum PKT_TYPE ver) +{ + struct tcp_hdr *tcp = NULL; + struct udp_hdr *udp = NULL; + struct icmp_hdr *icmp = NULL; + uint8_t *protocol; + void *ip_header = NULL; + uint16_t prot_offset = 0; + uint32_t pkt_type_is_ipv4 = 1; + int temp = 0; + pkt->ol_flags |= PKT_TX_IP_CKSUM; + pkt->l2_len = ETH_HDR_SIZE; + + + + switch (ver) { + case PKT_TYPE_IPV4to6: + temp = -20; + case PKT_TYPE_IPV6: + + ip_header = RTE_MBUF_METADATA_UINT32_PTR(pkt, + MBUF_HDR_ROOM + ETH_HDR_SIZE + temp); + + pkt_type_is_ipv4 = 0; + pkt->ol_flags |= PKT_TX_IPV6; + pkt->l3_len = + sizeof(struct ipv6_hdr); + tcp = (struct tcp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + udp = (struct udp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + icmp = (struct icmp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + + prot_offset = PROT_OFST_IP6 + temp; + break; + case PKT_TYPE_IPV6to4: + temp = 20; + case PKT_TYPE_IPV4: + + ip_header = RTE_MBUF_METADATA_UINT32_PTR(pkt, + MBUF_HDR_ROOM + ETH_HDR_SIZE + temp); + + pkt->ol_flags |= PKT_TX_IPV4; + pkt->l3_len = + sizeof(struct ipv4_hdr); + tcp = (struct tcp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + udp = (struct udp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + icmp = (struct icmp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + struct ipv4_hdr *ip_hdr = + (struct ipv4_hdr *)ip_header; + ip_hdr->hdr_checksum = 0; + + prot_offset = PROT_OFST_IP4 + temp; + break; + default: + printf("hw_checksum: pkt version is invalid\n"); + } + protocol = (uint8_t *) RTE_MBUF_METADATA_UINT8_PTR(pkt, + prot_offset); + + switch (*protocol) { + case IP_PROTOCOL_TCP: /* 6 */ + tcp->cksum = 0; + pkt->ol_flags |= PKT_TX_TCP_CKSUM; + if (pkt_type_is_ipv4) { + tcp->cksum = rte_ipv4_phdr_cksum( + (struct ipv4_hdr *)ip_header, + pkt->ol_flags); + } else { + tcp->cksum = rte_ipv6_phdr_cksum( + (struct ipv6_hdr *)ip_header, + pkt->ol_flags); + } + break; + case IP_PROTOCOL_UDP: /* 17 */ + udp->dgram_cksum = 0; + pkt->ol_flags |= PKT_TX_UDP_CKSUM; + if (pkt_type_is_ipv4) { + udp->dgram_cksum = + rte_ipv4_phdr_cksum( + (struct ipv4_hdr *)ip_header, + pkt->ol_flags); + } else { + udp->dgram_cksum = + rte_ipv6_phdr_cksum( + (struct ipv6_hdr *)ip_header, + pkt->ol_flags); + } + break; + case IP_PROTOCOL_ICMP: /* 1 */ + if (pkt_type_is_ipv4) { + /* ICMP checksum code */ + struct ipv4_hdr *ip_hdr = + (struct ipv4_hdr *)ip_header; + int size = rte_bswap16(ip_hdr->total_length) - 20; + icmp->icmp_cksum = 0; + icmp->icmp_cksum = + ~rte_raw_cksum(icmp, + size); + } + break; + + default: + printf("hw_checksum() : Neither TCP or UDP pkt\n"); + break; + } +} + + +void sw_checksum(struct rte_mbuf *pkt, enum PKT_TYPE ver) +{ + struct tcp_hdr *tcp = NULL; + struct udp_hdr *udp = NULL; + struct icmp_hdr *icmp = NULL; + uint8_t *protocol; + void *ip_header = NULL; + uint16_t prot_offset = 0; + uint32_t pkt_type_is_ipv4 = 1; + int temp = 0; + + switch (ver) { + case PKT_TYPE_IPV4to6: + temp = -20; + case PKT_TYPE_IPV6: + + ip_header = RTE_MBUF_METADATA_UINT32_PTR(pkt, + MBUF_HDR_ROOM + ETH_HDR_SIZE + temp); + + pkt_type_is_ipv4 = 0; + tcp = (struct tcp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + udp = (struct udp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + icmp = (struct icmp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv6_hdr)); + + prot_offset = PROT_OFST_IP6 + temp; + break; + case PKT_TYPE_IPV6to4: + temp = 20; + case PKT_TYPE_IPV4: + + ip_header = RTE_MBUF_METADATA_UINT32_PTR(pkt, + MBUF_HDR_ROOM + ETH_HDR_SIZE + temp); + + tcp = (struct tcp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + udp = (struct udp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + icmp = (struct icmp_hdr *) + ((unsigned char *)ip_header + + sizeof(struct ipv4_hdr)); + + prot_offset = PROT_OFST_IP4 + temp; + break; + default: + printf("sw_checksum: pkt version is invalid\n"); + } + protocol = (uint8_t *) RTE_MBUF_METADATA_UINT8_PTR(pkt, + prot_offset); + + switch (*protocol) { + case IP_PROTOCOL_TCP: /* 6 */ + tcp->cksum = 0; + if (pkt_type_is_ipv4) { + struct ipv4_hdr *ip_hdr = + (struct ipv4_hdr *)ip_header; + tcp->cksum = rte_ipv4_udptcp_cksum(ip_hdr, + (void *)tcp); + ip_hdr->hdr_checksum = 0; + ip_hdr->hdr_checksum = rte_ipv4_cksum( + (struct ipv4_hdr *)ip_hdr); + } else { + tcp->cksum = rte_ipv6_udptcp_cksum( + (struct ipv6_hdr *) + ip_header, (void *)tcp); + } + break; + case IP_PROTOCOL_UDP: /* 17 */ + udp->dgram_cksum = 0; + if (pkt_type_is_ipv4) { + struct ipv4_hdr *ip_hdr = + (struct ipv4_hdr *)ip_header; + udp->dgram_cksum = rte_ipv4_udptcp_cksum( + ip_hdr, (void *)udp); + ip_hdr->hdr_checksum = 0; + ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr); + } else { + udp->dgram_cksum = rte_ipv6_udptcp_cksum( + (struct ipv6_hdr *) + ip_header, (void *)udp); + } + break; + case IP_PROTOCOL_ICMP: /* 1 */ + if (pkt_type_is_ipv4) { + /* ICMP checksum code */ + struct ipv4_hdr *ip_hdr = + (struct ipv4_hdr *)ip_header; + int size = rte_bswap16(ip_hdr->total_length) - 20; + icmp->icmp_cksum = 0; + icmp->icmp_cksum = + ~rte_raw_cksum(icmp, + size); + ip_hdr->hdr_checksum = 0; + ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr); + } + break; + + default: + printf("sw_checksum() : Neither TCP or UDP pkt\n"); + break; + } +} + +static uint8_t check_arp_icmp( + struct rte_mbuf *pkt, + uint64_t pkt_mask, + struct pipeline_cgnapt *p_nat) +{ + uint32_t eth_proto_offset = MBUF_HDR_ROOM + 12; + uint16_t *eth_proto = RTE_MBUF_METADATA_UINT16_PTR( + pkt, eth_proto_offset); + struct app_link_params *link; + uint8_t solicited_node_multicast_addr[16] = { + 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00}; + + /* ARP outport number */ + uint16_t out_port = p_nat->p.n_ports_out - 1; + + uint8_t *protocol; + uint32_t prot_offset; + + link = &myApp->link_params[pkt->port]; + + + switch (rte_be_to_cpu_16(*eth_proto)) { + + case ETH_TYPE_ARP: + + rte_pipeline_port_out_packet_insert( + p_nat->p.p, + out_port, + pkt); + + /* + * Pkt mask should be changed, and not changing the + * drop mask + */ + p_nat->invalid_packets |= pkt_mask; + p_nat->arpicmpPktCount++; + + return 0; + break; + case ETH_TYPE_IPV4: { + /* header room + eth hdr size + + * src_aadr offset in ip header + */ + uint32_t dst_addr_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + IP_HDR_DST_ADR_OFST; + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, + dst_addr_offset); + prot_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_PROTOCOL_OFST; + protocol = RTE_MBUF_METADATA_UINT8_PTR(pkt, + prot_offset); + if ((*protocol == IP_PROTOCOL_ICMP) && + link->ip == rte_be_to_cpu_32(*dst_addr)) { + + if (is_phy_port_privte(pkt->port)) { + + rte_pipeline_port_out_packet_insert( + p_nat->p.p, out_port, pkt); + + /* + * Pkt mask should be changed, + * and not changing the drop mask + */ + + p_nat->invalid_packets |= pkt_mask; + p_nat->arpicmpPktCount++; + + return 0; + } + } + return 1; + } + break; + + #ifdef IPV6 + case ETH_TYPE_IPV6: + if (dual_stack_enable) { + + /* Commented code may be required for future usage, + * Please keep it + */ + //uint32_t dst_addr_offset = MBUF_HDR_ROOM + + // ETH_HDR_SIZE + IPV6_HDR_DST_ADR_OFST; + //uint32_t *dst_addr = + // RTE_MBUF_METADATA_UINT32_PTR(pkt, + // dst_addr_offset); + uint32_t prot_offset_ipv6 = MBUF_HDR_ROOM + + ETH_HDR_SIZE + IPV6_HDR_PROTOCOL_OFST; + struct ipv6_hdr *ipv6_h; + + ipv6_h = (struct ipv6_hdr *) MBUF_HDR_ROOM + + ETH_HDR_SIZE; + protocol = RTE_MBUF_METADATA_UINT8_PTR(pkt, + prot_offset_ipv6); + + if (ipv6_h->proto == ICMPV6_PROTOCOL_ID) { + if (!memcmp(ipv6_h->dst_addr, link->ipv6, 16) + || !memcmp(ipv6_h->dst_addr, + solicited_node_multicast_addr, 13)) { + rte_pipeline_port_out_packet_insert( + p_nat->p.p, out_port, pkt); + /* + * Pkt mask should be changed, + * and not changing the drop mask + */ + p_nat->invalid_packets |= pkt_mask; + p_nat->arpicmpPktCount++; + } else { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount1++; + #endif + } + return 0; + } + } + break; + #endif + default: + return 1; + } + return 1; +} + +/** + * Function to create common NAPT table + * Called during pipeline initialization + * Creates the common NAPT table + * If it is not already created and stores its pointer + * in global napt_common_table pointer. + * + * @params nFlows + * Max number of NAPT flows. This parameter is configurable via config file. + * + * @return + * 0 on success, negative on error. + */ +int create_napt_common_table(uint32_t nFlows) +{ + if (napt_common_table != NULL) { + printf("napt_common_table already exists.\n"); + return -1; + } + + napt_common_table = rte_hash_create(&napt_common_table_hash_params); + + if (napt_common_table == NULL) { + printf("napt_common_table creation failed.\n"); + return -2; + } + + uint32_t number_of_entries = nFlows; + + uint32_t size = + RTE_CACHE_LINE_ROUNDUP(sizeof(struct cgnapt_table_entry) * + number_of_entries); + napt_hash_tbl_entries = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE); + + if (napt_hash_tbl_entries == NULL) { + printf("napt_hash_tbl_entries creation failed. %d, %d\n", + nFlows, (int)sizeof(struct cgnapt_table_entry)); + return -3; + } + + return 0; +} + +/** + * Function to initialize bulk port allocation data structures + * Called during pipeline initialization. + * + * Creates the port alloc ring for the VNF_set this pipeline belongs + * + * Creates global port allocation buffer pool + * + * Initializes the port alloc ring according to config data + * + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 on success, negative on error. + */ +int napt_port_alloc_init(struct pipeline_cgnapt *p_nat) +{ + p_nat->allocated_ports = NULL; + p_nat->free_ports = NULL; + + uint32_t vnf_set_num = p_nat->vnf_set; + /*uint32_t vnf_set_num = get_vnf_set_num(p_nat->pipeline_num); */ + + printf("VNF set number for CGNAPT %d is %d.\n", p_nat->pipeline_num, + vnf_set_num); + if (vnf_set_num == 0xFF) { + printf("VNF set number for CGNAPT %d is invalid %d.\n", + p_nat->pipeline_num, vnf_set_num); + return -1; + } + + p_nat->port_alloc_ring = port_alloc_ring[vnf_set_num]; + if (p_nat->port_alloc_ring != NULL) { + printf("CGNAPT%d port_alloc_ring already exists.\n", + p_nat->pipeline_num); + return 1; + } + + printf("napt_port_alloc_elem_count :%d\n", + napt_port_alloc_elem_count); + napt_port_alloc_elem_count += 1; + napt_port_alloc_elem_count = + nextPowerOf2(napt_port_alloc_elem_count); + printf("Next power of napt_port_alloc_elem_count: %d\n", + napt_port_alloc_elem_count); + + port_alloc_ring[vnf_set_num] = + rte_ring_create(napt_port_alloc_ring_name[vnf_set_num], + napt_port_alloc_elem_count, rte_socket_id(), 0); + p_nat->port_alloc_ring = port_alloc_ring[vnf_set_num]; + if (p_nat->port_alloc_ring == NULL) { + printf("CGNAPT%d - Failed to create port_alloc_ring\n", + p_nat->pipeline_num); + return -1; + } + + /* Create port alloc buffer */ + /* Only one pool is enough for all vnf sets */ + if (napt_port_pool == NULL) { + + napt_port_pool = rte_mempool_create( + "napt_port_pool", + napt_port_alloc_elem_count, + sizeof(struct napt_port_alloc_elem), + 0, 0, NULL, NULL, NULL, + NULL, rte_socket_id(), 0); + } + + if (napt_port_pool == NULL) { + printf("CGNAPT - Create port pool failed\n"); + return -1; + } + + /* Add all available public IP addresses and ports to the ring */ + uint32_t i, j = 0; + +#ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + printf("******* pub_ip_range_count:%d ***********\n", + p_nat->pub_ip_range_count); + /* Initialize all public IP's addresses */ + int if_addrs; + uint32_t max_ips_remain; + + for (if_addrs = 0; if_addrs < p_nat->pub_ip_range_count; + if_addrs++) { + /* Add all available addresses to the ring */ + + for (i = p_nat->pub_ip_range[if_addrs].start_ip; + i <= p_nat->pub_ip_range[if_addrs].end_ip;) { + /* 1. Get a port alloc buffer from napt_port_pool */ + void *portsBuf; + + if (j == 0) { + /* get new napt_port_alloc_elem from pool */ + if (rte_mempool_get(napt_port_pool, + &portsBuf) < 0) { + printf("CGNAPT - Error in getting port " + "alloc buffer\n"); + return -1; + } + } + + /* 2. Populate it with available ports and ip addr */ + struct napt_port_alloc_elem *pb = + (struct napt_port_alloc_elem *)portsBuf; + + int temp; + temp = p_nat->pub_ip_range[if_addrs].end_ip - + i + 1; + + /* Check if remaining port count is greater + * than or equals to bulk count, if not give + * remaining count ports than giving bulk count + */ + if (temp < NUM_NAPT_PORT_BULK_ALLOC) + max_ips_remain = temp; + else + max_ips_remain = + NUM_NAPT_PORT_BULK_ALLOC; + + for (j = 0; j < max_ips_remain; j++) { + pb->count = j + 1; + pb->ip_addr[j] = i + j; + pb->ports[j] = 0; + if ((i + j) == + p_nat->pub_ip_range[if_addrs]. + end_ip) + break; + } + + /* 3. add the port alloc buffer to ring */ + if (rte_ring_enqueue(p_nat->port_alloc_ring, + portsBuf) != 0) { + printf("CGNAPT%d - Enqueue error - i %d,", + p_nat->pipeline_num, i); + printf("j %d, if_addrs %d, pb %p\n", + j, if_addrs, pb); + rte_ring_dump(stdout, + p_nat->port_alloc_ring); + rte_mempool_put(napt_port_pool, + portsBuf); + return -1; + } + + /* reset j and advance i */ + j = 0; + i += max_ips_remain; + } + } + + return 1; + } +#endif + + printf("******* p_nat->pub_ip_count:%d ***********\n", + p_nat->pub_ip_count); + /* Initialize all public IP's ports */ + int if_ports; + uint32_t max_ports_remain; + + for (if_ports = 0; if_ports < p_nat->pub_ip_count; if_ports++) { + /* Add all available ports to the ring */ + + for (i = p_nat->pub_ip_port_set[if_ports].start_port; + i <= p_nat->pub_ip_port_set[if_ports].end_port;) { + /* 1. Get a port alloc buffer from napt_port_pool */ + void *portsBuf; + + if (j == 0) { + /* get new napt_port_alloc_elem from pool */ + if (rte_mempool_get(napt_port_pool, &portsBuf) < + 0) { + printf("CGNAPT - Error in getting " + "port alloc buffer\n"); + return -1; + } + } + + /* 2. Populate it with available ports and ip addr */ + struct napt_port_alloc_elem *pb = + (struct napt_port_alloc_elem *)portsBuf; + + int temp; + temp = p_nat->pub_ip_port_set[if_ports].end_port - + i + 1; + /* Check if remaining port count is greater + * than or equals to bulk count, if not give + * remaining count ports than giving bulk count + */ + if (temp < NUM_NAPT_PORT_BULK_ALLOC) + max_ports_remain = temp; + else + max_ports_remain = + NUM_NAPT_PORT_BULK_ALLOC; + + for (j = 0; j < max_ports_remain; j++) { + pb->count = j + 1; + pb->ip_addr[j] = + p_nat->pub_ip_port_set[if_ports].ip; + pb->ports[j] = i + j; + if ((i + j) == p_nat->pub_ip_port_set + [if_ports].end_port) + break; + } + + /* 3. add the port alloc buffer to ring */ + if (rte_ring_enqueue(p_nat->port_alloc_ring, + portsBuf) != 0) { + printf("CGNAPT%d - Enqueue error - i %d, j %d, " + " if_ports %d, pb %p\n", p_nat->pipeline_num, + i, j, if_ports, pb); + + rte_ring_dump(stdout, p_nat->port_alloc_ring); + rte_mempool_put(napt_port_pool, portsBuf); + return -1; + } + + /* reset j and advance i */ + j = 0; + i += max_ports_remain; + } + } + + return 1; +} + +static pipeline_msg_req_handler handlers[] = { + [PIPELINE_MSG_REQ_PING] = + pipeline_msg_req_ping_handler, + [PIPELINE_MSG_REQ_STATS_PORT_IN] = + pipeline_msg_req_stats_port_in_handler, + [PIPELINE_MSG_REQ_STATS_PORT_OUT] = + pipeline_msg_req_stats_port_out_handler, + [PIPELINE_MSG_REQ_STATS_TABLE] = pipeline_msg_req_stats_table_handler, + [PIPELINE_MSG_REQ_PORT_IN_ENABLE] = + pipeline_msg_req_port_in_enable_handler, + [PIPELINE_MSG_REQ_PORT_IN_DISABLE] = + pipeline_msg_req_port_in_disable_handler, + [PIPELINE_MSG_REQ_CUSTOM] = + pipeline_cgnapt_msg_req_custom_handler, +}; + +static pipeline_msg_req_handler custom_handlers[] = { + [PIPELINE_CGNAPT_MSG_REQ_ENTRY_ADD] = + pipeline_cgnapt_msg_req_entry_add_handler, + [PIPELINE_CGNAPT_MSG_REQ_ENTRY_DEL] = + pipeline_cgnapt_msg_req_entry_del_handler, + [PIPELINE_CGNAPT_MSG_REQ_ENTRY_SYNC] = + pipeline_cgnapt_msg_req_entry_sync_handler, + [PIPELINE_CGNAPT_MSG_REQ_ENTRY_DBG] = + pipeline_cgnapt_msg_req_entry_dbg_handler, + [PIPELINE_CGNAPT_MSG_REQ_ENTRY_ADDM] = + pipeline_cgnapt_msg_req_entry_addm_handler, + [PIPELINE_CGNAPT_MSG_REQ_VER] = + pipeline_cgnapt_msg_req_ver_handler, + [PIPELINE_CGNAPT_MSG_REQ_NSP_ADD] = + pipeline_cgnapt_msg_req_nsp_add_handler, + [PIPELINE_CGNAPT_MSG_REQ_NSP_DEL] = + pipeline_cgnapt_msg_req_nsp_del_handler, + + #ifdef PCP_ENABLE + [PIPELINE_CGNAPT_MSG_REQ_PCP] = + pipeline_cgnapt_msg_req_pcp_handler, + #endif +}; + +/** + * Function to convert an IPv6 packet to IPv4 packet + * + * @param pkt + * A pointer to packet mbuf + * @param in_ipv6_hdr + * A pointer to IPv6 header in the given pkt + * + */ +static void +convert_ipv6_to_ipv4(struct rte_mbuf *pkt, struct ipv6_hdr *in_ipv6_hdr) +{ + uint32_t ip_hdr_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE; + + uint8_t *eth_hdr_p = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *ipv6_hdr_p = RTE_MBUF_METADATA_UINT8_PTR(pkt, ip_hdr_offset); + + struct ether_hdr eth_hdr; + struct ipv4_hdr *ipv4_hdr_p; + uint16_t frag_off = 0x4000; + struct cgnapt_nsp_node *ll = nsp_ll; + uint8_t ipv4_dest[4]; + int nsp = 0; + + memcpy(ð_hdr, eth_hdr_p, sizeof(struct ether_hdr)); + memcpy(in_ipv6_hdr, ipv6_hdr_p, sizeof(struct ipv6_hdr)); + + eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4); + + char *data_area_p = rte_pktmbuf_adj(pkt, 20); + if (data_area_p == NULL) { + printf("convert_ipv6_to_ipv4:data_area_p is NULL\n"); + return; + } + ipv4_hdr_p = (struct ipv4_hdr *)(data_area_p + ETH_HDR_SIZE); + memset(ipv4_hdr_p, 0, sizeof(struct ipv4_hdr)); + + memcpy(data_area_p, ð_hdr, sizeof(struct ether_hdr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG == 1) + printf("convert_ipv6_to_ipv4: eth_hdr_p(%p), data_area_p(%p), " + "ipv4_hdr_p(%p)\n", eth_hdr_p, data_area_p, ipv4_hdr_p); + #endif + + ipv4_hdr_p->version_ihl = 0x4 << 4 | 0x5; + ipv4_hdr_p->type_of_service = + rte_be_to_cpu_32(in_ipv6_hdr->vtc_flow) & 0x0ff00000 >> 20; + ipv4_hdr_p->total_length = + rte_cpu_to_be_16(rte_be_to_cpu_16( + in_ipv6_hdr->payload_len) + 20); + ipv4_hdr_p->packet_id = 0; + ipv4_hdr_p->fragment_offset = rte_cpu_to_be_16(frag_off); + ipv4_hdr_p->time_to_live = in_ipv6_hdr->hop_limits; + ipv4_hdr_p->next_proto_id = in_ipv6_hdr->proto; + ipv4_hdr_p->hdr_checksum = 0; + ipv4_hdr_p->src_addr = 0; + + while (ll != NULL) { + if (!memcmp + (&in_ipv6_hdr->dst_addr[0], &ll->nsp.prefix[0], + ll->nsp.depth / 8)) { + if (ll->nsp.depth == 32) + memcpy(&ipv4_dest[0], &in_ipv6_hdr->dst_addr[4], + 4); + else if (ll->nsp.depth == 40) { + ipv4_dest[0] = in_ipv6_hdr->dst_addr[5]; + ipv4_dest[1] = in_ipv6_hdr->dst_addr[6]; + ipv4_dest[2] = in_ipv6_hdr->dst_addr[7]; + ipv4_dest[3] = in_ipv6_hdr->dst_addr[9]; + } else if (ll->nsp.depth == 48) { + ipv4_dest[0] = in_ipv6_hdr->dst_addr[6]; + ipv4_dest[1] = in_ipv6_hdr->dst_addr[7]; + ipv4_dest[2] = in_ipv6_hdr->dst_addr[9]; + ipv4_dest[3] = in_ipv6_hdr->dst_addr[10]; + } else if (ll->nsp.depth == 56) { + ipv4_dest[0] = in_ipv6_hdr->dst_addr[7]; + ipv4_dest[1] = in_ipv6_hdr->dst_addr[9]; + ipv4_dest[2] = in_ipv6_hdr->dst_addr[10]; + ipv4_dest[3] = in_ipv6_hdr->dst_addr[11]; + } else if (ll->nsp.depth == 64) { + ipv4_dest[0] = in_ipv6_hdr->dst_addr[9]; + ipv4_dest[1] = in_ipv6_hdr->dst_addr[10]; + ipv4_dest[2] = in_ipv6_hdr->dst_addr[11]; + ipv4_dest[3] = in_ipv6_hdr->dst_addr[12]; + } else if (ll->nsp.depth == 96) { + ipv4_dest[0] = in_ipv6_hdr->dst_addr[12]; + ipv4_dest[1] = in_ipv6_hdr->dst_addr[13]; + ipv4_dest[2] = in_ipv6_hdr->dst_addr[14]; + ipv4_dest[3] = in_ipv6_hdr->dst_addr[15]; + } + + nsp = 1; + break; + } + + ll = ll->next; + } + + if (nsp) + memcpy(&ipv4_hdr_p->dst_addr, &ipv4_dest[0], 4); + else + memcpy(&ipv4_hdr_p->dst_addr, &in_ipv6_hdr->dst_addr[12], 4); + +} + +/** + * Function to convert an IPv4 packet to IPv6 packet + * + * @param pkt + * A pointer to packet mbuf + * @param in_ipv4_hdr + * A pointer to IPv4 header in the given pkt + * + */ +static void +convert_ipv4_to_ipv6(struct rte_mbuf *pkt, struct ipv4_hdr *in_ipv4_hdr) +{ + uint32_t ip_hdr_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE; + + uint8_t *eth_hdr_p = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *ipv4_hdr_p = RTE_MBUF_METADATA_UINT8_PTR(pkt, ip_hdr_offset); + + struct ether_hdr eth_hdr; + struct ipv6_hdr *ipv6_hdr_p; + + memcpy(ð_hdr, eth_hdr_p, sizeof(struct ether_hdr)); + memcpy(in_ipv4_hdr, ipv4_hdr_p, sizeof(struct ipv4_hdr)); + + eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv6); + + char *data_area_p = rte_pktmbuf_prepend(pkt, 20); + if (data_area_p == NULL) { + printf("convert_ipv4_to_ipv6:data_area_p is NULL\n"); + return; + } + ipv6_hdr_p = (struct ipv6_hdr *)(data_area_p + ETH_HDR_SIZE); + memset(ipv6_hdr_p, 0, sizeof(struct ipv6_hdr)); + + memcpy(data_area_p, ð_hdr, sizeof(struct ether_hdr)); + + ipv6_hdr_p->vtc_flow = + rte_cpu_to_be_32((0x6 << 28) | + (in_ipv4_hdr->type_of_service << 20)); + ipv6_hdr_p->payload_len = + rte_cpu_to_be_16(rte_be_to_cpu_16( + in_ipv4_hdr->total_length) - 20); + ipv6_hdr_p->proto = in_ipv4_hdr->next_proto_id; + ipv6_hdr_p->hop_limits = in_ipv4_hdr->time_to_live; + + ipv6_hdr_p->src_addr[0] = 0x00; + ipv6_hdr_p->src_addr[1] = 0x64; + ipv6_hdr_p->src_addr[2] = 0xff; + ipv6_hdr_p->src_addr[3] = 0x9b; + ipv6_hdr_p->src_addr[4] = 0x00; + ipv6_hdr_p->src_addr[5] = 0x00; + ipv6_hdr_p->src_addr[6] = 0x00; + ipv6_hdr_p->src_addr[7] = 0x00; + ipv6_hdr_p->src_addr[8] = 0x00; + ipv6_hdr_p->src_addr[9] = 0x00; + ipv6_hdr_p->src_addr[10] = 0x00; + ipv6_hdr_p->src_addr[11] = 0x00; + memcpy(&ipv6_hdr_p->src_addr[12], &in_ipv4_hdr->src_addr, 4); + + memset(&ipv6_hdr_p->dst_addr, 0, 16); + + return; + +} + +/** + * Output port handler + * + * @param pkt + * A pointer to packet mbuf + * @param arg + * Unused void pointer + * + */ +#ifdef PIPELINE_CGNAPT_INSTRUMENTATION +static void +pkt_work_cgnapt_out(__rte_unused struct rte_mbuf *pkt, __rte_unused void *arg) +{ +#ifdef PIPELINE_CGNAPT_INSTRUMENTATION + if ((cgnapt_num_func_to_inst == 5) + && (cgnapt_inst_index < INST_ARRAY_SIZE)) { + if (cgnapt_inst5_flag == 0) { + uint8_t *inst5_sig = + RTE_MBUF_METADATA_UINT8_PTR(pkt, + CGNAPT_INST5_OFST); + if (*inst5_sig == CGNAPT_INST5_SIG) { + cgnapt_inst5_flag = 1; + inst_end_time[cgnapt_inst_index] = + rte_get_tsc_cycles(); + cgnapt_inst_index++; + } + } + } +#endif + + /* cgnapt_pkt_out_count++; */ + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG) + print_pkt(pkt); + #endif +} +#endif + +/** + * Output port handler to handle 4 pkts + * + * @param pkt + * A pointer to packet mbuf + * @param arg + * Inport handler argument pointer + * + */ +#ifdef PIPELINE_CGNAPT_INSTRUMENTATION +static void pkt4_work_cgnapt_out(struct rte_mbuf **pkt, void *arg) +{ + (void)pkt; + (void)arg; +/* TO BE IMPLEMENTED IF REQUIRED */ +} +#endif + +#ifdef PIPELINE_CGNAPT_INSTRUMENTATION +PIPELINE_CGNAPT_PORT_OUT_AH(port_out_ah_cgnapt, + pkt_work_cgnapt_out, pkt4_work_cgnapt_out); + +PIPELINE_CGNAPT_PORT_OUT_BAH(port_out_ah_cgnapt_bulk, + pkt_work_cgnapt_out, pkt4_work_cgnapt_out); +#endif + +/** + * Function to validate the packet and return version + * + * @param pkt + * A pointer to packet mbuf + * + * @return + * IP version of the valid pkt, -1 if invalid pkt + */ +int rte_get_pkt_ver(struct rte_mbuf *pkt) +{ + uint32_t eth_proto_offset = MBUF_HDR_ROOM + 12; + uint16_t *eth_proto = + RTE_MBUF_METADATA_UINT16_PTR(pkt, eth_proto_offset); + + if (*eth_proto == rte_be_to_cpu_16(ETHER_TYPE_IPv4)) + return IP_VERSION_4; + + if (dual_stack_enable + && (*eth_proto == rte_be_to_cpu_16(ETHER_TYPE_IPv6))) + return IP_VERSION_6; + + /* Check the protocol first, if not UDP or TCP return */ + + return -1; +} + +/** + * A method to print the NAPT entry + * + * @param ent + * A pointer to struct cgnapt_table_entry + */ +void my_print_entry(struct cgnapt_table_entry *ent) +{ + printf("CGNAPT key:\n"); + printf("entry_type :%d\n", ent->data.type); + printf("prv_ip: %x %x %x %x\n", ent->data.u.u32_prv_ipv6[0], + ent->data.u.u32_prv_ipv6[1], ent->data.u.u32_prv_ipv6[2], + ent->data.u.u32_prv_ipv6[3]); + printf("prv_port:%d\n", ent->data.prv_port); + + printf("pub_ip:%x\n", ent->data.pub_ip); + printf("prv_phy_port:%d\n", ent->data.prv_phy_port); + printf("pub_phy_port:%d\n", ent->data.pub_phy_port); +} + +/** + * Function to print common CGNAPT table entries + * + */ +void print_common_table(void) +{ + uint32_t count = 0; + const void *key; + void *data; + uint32_t next = 0; + int32_t index = 0; + do { + index = rte_hash_iterate(napt_common_table, + &key, &data, &next); + + if ((index != -EINVAL) && (index != -ENOENT)) { + printf("\n%04d ", count); + //print_key((struct pipeline_cgnapt_entry_key *)key); + rte_hexdump(stdout, "KEY", key, + sizeof(struct pipeline_cgnapt_entry_key)); + int32_t position = rte_hash_lookup( + napt_common_table, key); + print_cgnapt_entry(&napt_hash_tbl_entries[position]); + } + + count++; + } while (index != -ENOENT); +} + +/** + * Input port handler for mixed traffic + * This is the main method in this file when running in mixed traffic mode. + * Starting from the packet burst it filters unwanted packets, + * calculates keys, does lookup and then based on the lookup + * updates NAPT table and does packet NAPT translation. + * + * @param rte_p + * A pointer to struct rte_pipeline + * @param pkts + * A pointer to array of packets mbuf + * @param n_pkts + * Number of packets in the burst + * @param arg + * Void pointer + * + * @return + * int that is not checked by caller + */ + +static int cgnapt_in_port_ah_mix(struct rte_pipeline *rte_p, + struct rte_mbuf **pkts, + uint32_t n_pkts, void *arg) +{ +/* +* Code flow +* +* 1. Read packet version, if invalid drop the packet +* 2. Check protocol, if not UDP or TCP drop the packet +* 3. Bring all valid packets together - useful for bulk lookup +* and calculate key for all packets +* a. If IPv4 : calculate key with full IP +* b. If IPv6 : calculate key with last 32-bit of IP +* 4. Do bulk lookup with rte_hash_lookup_bulk(), if something went wrong +* drop all packets +* 5. For lookup hit packets, read entry from table +* 6. For lookup miss packets, add dynamic entry to table +* 7. If pkt is IPv6 +* a. If egress pkt, convert to IPv4 and NAPT it +* b. If ingress, drop the pkt +* 8. If pkt is IPv4 +* a. If egress pkt, NAPT it. Get MAC +* b. If first ingress pkt (with no egress entry), drop the pkt +* If not first ingress pkt +* I. If IPv6 converted packet, convert back to IPv6, + NAPT it & get MAC +* II. If IPv4 packet, NAPT it & get MAC +* 9. Send all packets out to corresponding ports +*/ + struct pipeline_cgnapt_in_port_h_arg *ap = arg; + struct pipeline_cgnapt *p_nat = ap->p; + uint8_t compacting_map[RTE_HASH_LOOKUP_BULK_MAX]; + uint32_t packets_for_lookup = 0; + uint32_t i; + + p_nat->valid_packets = 0; + p_nat->invalid_packets = 0; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("cgnapt_key hit fn: %" PRIu32 "\n", n_pkts); + #endif + + p_nat->pkt_burst_cnt = 0; /* for dynamic napt */ + + uint16_t phy_port = 0; + uint16_t *src_port = NULL; + uint16_t *dst_port = NULL; + uint32_t *src_addr = NULL; + uint32_t *dst_addr = NULL; + uint8_t *protocol = NULL; + uint8_t *eth_dest = NULL; + uint8_t *eth_src = NULL; + uint16_t src_port_offset = 0; + uint16_t dst_port_offset = 0; + uint16_t src_addr_offset = 0; + uint16_t dst_addr_offset = 0; + uint16_t prot_offset = 0; + uint16_t eth_offset = 0; + int ver = 0; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4; + + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + + for (i = 0; i < n_pkts; i++) { + p_nat->receivedPktCount++; + + /* bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << i; + + /* remember this pkt as valid pkt */ + p_nat->valid_packets |= pkt_mask; + + struct rte_mbuf *pkt = pkts[i]; + + if (enable_hwlb) + if (!check_arp_icmp(pkt, pkt_mask, p_nat)) + continue; + + int ver = rte_get_pkt_ver(pkt); + + #ifdef CGNAPT_DBG_PRNT + printf("ver no. of the pkt:%d\n", ver); + #endif + + if (unlikely(ver < 0)) { + /* Not a valid pkt , ignore. */ + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount1++; + #endif + continue; + } + if (ver == 4) + prot_offset = PROT_OFST_IP4; + else + prot_offset = PROT_OFST_IP6; + protocol = + (uint8_t *) RTE_MBUF_METADATA_UINT32_PTR(pkt, + prot_offset); + if (! + (*protocol == IP_PROTOCOL_TCP + || *protocol == IP_PROTOCOL_UDP + || *protocol == IP_PROTOCOL_ICMP)) { + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + continue; + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt); + #endif + + #ifdef PCP_ENABLE + /* Handling PCP + * 1. Handel PCP for egress traffic + * 2. If PCP, then give response (send pkt) from the same port + * 3. Drop the PCP packet, should not be added in the NAPT table + */ + if (pcp_enable) { + if (*protocol == IP_PROTOCOL_UDP) { + struct udp_hdr *udp; + if (ver == 4) + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt, + IPV4_UDP_OFST); + else + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt, + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt, ver, p_nat); + p_nat->invalid_packets |= pkt_mask; + continue; + } + } + } + #endif + + if (ver == 4) { + + src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, + SRC_ADR_OFST_IP4); + dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, + DST_ADR_OFST_IP4); + + if ((*protocol == IP_PROTOCOL_TCP) + || (*protocol == IP_PROTOCOL_UDP)) { + + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + + } else if (*protocol == IP_PROTOCOL_ICMP) { + /* Identifier */ + src_port_offset = IDEN_OFST_IP4_ICMP; + /* Sequence number */ + dst_port_offset = SEQN_OFST_IP4_ICMP; + } + + src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, + src_port_offset); + dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, + dst_port_offset); + } else { + + src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, + SRC_ADR_OFST_IP6); + dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, + DST_ADR_OFST_IP6); + src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, + SRC_PRT_OFST_IP6); + dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, + DST_PRT_OFST_IP6); + } + /* need to create compacted table of pointers to + * pass to bulk lookup + */ + + compacting_map[packets_for_lookup] = i; + + //phy_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, phyport_offset); + phy_port = pkt->port; + + struct pipeline_cgnapt_entry_key key; + + memset(&key, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + key.pid = phy_port; + if (get_in_port_dir(phy_port)) { + /* Egress */ + if (ver == 4) + key.ip = rte_bswap32(*src_addr); + else + key.ip = rte_bswap32(src_addr[3]); + key.port = rte_bswap16(*src_port); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + } else { + /* Ingress */ + key.ip = rte_bswap32(*dst_addr); + + if (*protocol == IP_PROTOCOL_ICMP) { + /* common table lookupkey preparation from + * incoming ICMP Packet- Indentifier field + */ + key.port = rte_bswap16(*src_port); + } else { + key.port = rte_bswap16(*dst_port); + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + + key.pid = 0xffff; + } + + memcpy(&(p_nat->keys[packets_for_lookup]), &key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[packets_for_lookup] = + &(p_nat->keys[packets_for_lookup]); + packets_for_lookup++; + } + + if (unlikely(packets_for_lookup == 0)) { + /* no suitable packet for lookup */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return p_nat->valid_packets; + } + + /* lookup entries in the common napt table */ + + int lookup_result = rte_hash_lookup_bulk(napt_common_table, + (const void **) + &p_nat->key_ptrs, + packets_for_lookup, + &p_nat->lkup_indx[0]); + + if (unlikely(lookup_result < 0)) { + /* unknown error, just discard all packets */ + printf("Unexpected hash lookup error %d, discarding all " + "packets", lookup_result); + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return 0; + } + //struct rte_pipeline_table_entry *entries[64]; + /* Now one by one check the result of our bulk lookup */ + + for (i = 0; i < packets_for_lookup; i++) { + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[i]; + /* index into packet table of this packet */ + uint8_t pkt_index = compacting_map[i]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_index; + + struct cgnapt_table_entry *entry = NULL; + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = + pkt_miss_cgnapt(p_nat->key_ptrs[i], + pkts[pkt_index], + &table_entry, + &p_nat->valid_packets, + pkt_index, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + if (*protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkts[pkt_index]; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", + p_nat->pipeline_num); + print_key(p_nat->key_ptrs[i]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + continue; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_index] = &(entry->head); + + phy_port = pkts[pkt_index]->port; + + struct ipv6_hdr ipv6_hdr; + struct ipv4_hdr ipv4_hdr; + + ver = rte_get_pkt_ver(pkts[pkt_index]); + #ifdef CGNAPT_DEBUGGING + if (CGNAPT_DEBUG >= 1) { + printf("ver:%d\n", ver); + printf("entry->data.type:%d\n", entry->data.type); + } + #endif + if ((ver == 6) && (entry->data.type == CGNAPT_ENTRY_IPV6) + && is_phy_port_privte(phy_port)) { + convert_ipv6_to_ipv4(pkts[pkt_index], &ipv6_hdr); + + pkt_type = PKT_TYPE_IPV6to4; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) + printf("pkt_work_cganpt: " + "convert_ipv6_to_ipv4\n"); + #endif + + struct cgnapt_nsp_node *ll = nsp_ll; + int nsp = 0; + while (ll != NULL) { + if (!memcmp(&ipv6_hdr.dst_addr[0], + &ll->nsp.prefix[0], + ll->nsp.depth / 8)) { + nsp = 1; + break; + } + ll = ll->next; + } + + if (!nsp + && !memcmp(&ipv6_hdr.dst_addr[0], + &well_known_prefix[0], 12)) { + nsp = 1; + } + + if (!nsp) { + p_nat->invalid_packets |= 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount5++; + #endif + continue; + } + + } + + /* As packet is already converted into IPv4 we must not operate + * IPv6 offsets on packet + * Only perform IPv4 operations + */ + + if (ver == 6) { + + src_port_offset = SRC_PRT_OFST_IP6t4; + dst_port_offset = DST_PRT_OFST_IP6t4; + src_addr_offset = SRC_ADR_OFST_IP6t4; + dst_addr_offset = DST_ADR_OFST_IP6t4; + prot_offset = PROT_OFST_IP6t4; + eth_offset = ETH_OFST_IP6t4; + + } else { + + if ((*protocol == IP_PROTOCOL_TCP) + || (*protocol == IP_PROTOCOL_UDP)) { + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + } else if (*protocol == IP_PROTOCOL_ICMP) { + /* Identifier */ + src_port_offset = IDEN_OFST_IP4_ICMP; + /* Sequence number */ + dst_port_offset = SEQN_OFST_IP4_ICMP; + } + + src_addr_offset = SRC_ADR_OFST_IP4; + dst_addr_offset = DST_ADR_OFST_IP4; + prot_offset = PROT_OFST_IP4; + eth_offset = MBUF_HDR_ROOM; + + } + + src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkts[pkt_index], + src_addr_offset); + dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkts[pkt_index], + dst_addr_offset); + src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkts[pkt_index], + src_port_offset); + dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkts[pkt_index], + dst_port_offset); + protocol = + RTE_MBUF_METADATA_UINT8_PTR(pkts[pkt_index], + prot_offset); + + eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(pkts[pkt_index], + eth_offset); + eth_src = + RTE_MBUF_METADATA_UINT8_PTR(pkts[pkt_index], + eth_offset + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + uint8_t nh_ipv6[16]; + uint32_t nhip = 0; + + uint32_t dest_if = 0xff; + uint32_t ret; + + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkts[pkt_index], + cgnapt_meta_offset); + + if (is_phy_port_privte(phy_port)) { + + if (*protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*dst_port) == 53) { + p_nat->invalid_packets |= 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + dest_address = rte_bswap32(*dst_addr); + ret = local_get_nh_ipv4(dest_address, &dest_if, + &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, + IP_VERSION_4); + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= + 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + do_local_nh_ipv4_cache(dest_if, p_nat); + } + + *outport_id = p_nat->outport_id[dest_if]; + int ret; + ret = get_dest_mac_addr_port(dest_address, + &dest_if, &hw_addr); + + if (ret == ARP_FOUND) { + memcpy(eth_dest, &hw_addr, + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5]); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkts[pkt_index]); + #endif + + } else{ + if (ret == ARP_NOT_FOUND) { + /* Commented code may be required + * for future use, Please keep it */ + //request_arp(*outport_id, nhip, + // p_nat->p.p); + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + } + + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Egress: \tphy_port:%d\t " + "get_prv_to_pub():%d \tout_port:%d\n", + phy_port, dest_if, + *outport_id); + #endif + + /* Egress */ + *src_addr = rte_bswap32(entry->data.pub_ip); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *src_port = rte_bswap16(entry->data.pub_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + p_nat->enaptedPktCount++; + } else { + /* Ingress */ + if (*protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*src_port) == 53) { + p_nat->invalid_packets |= 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Ingress: \tphy_port:%d\t " + "get_pub_to_prv():%d \tout_port%d\n", + phy_port, dest_if, + *outport_id); + #endif + + if (entry->data.type == CGNAPT_ENTRY_IPV6) { + convert_ipv4_to_ipv6(pkts[pkt_index], + &ipv4_hdr); + pkt_type = PKT_TYPE_IPV4to6; + /* Ethernet MTU check */ + if ((rte_pktmbuf_data_len(pkts[pkt_index]) - + 14) > 1500) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + continue; + } + + eth_dest = eth_dest - 20; + eth_src = eth_src - 20; + + dst_port_offset = DST_PRT_OFST_IP4t6; + dst_addr_offset = DST_ADR_OFST_IP4t6; + dst_addr = + RTE_MBUF_METADATA_UINT32_PTR( + pkts[pkt_index], + dst_addr_offset); + dst_port = + RTE_MBUF_METADATA_UINT16_PTR( + pkts[pkt_index], + dst_port_offset); + + memcpy((uint8_t *) &dst_addr[0], + &entry->data.u.prv_ipv6[0], 16); + memset(nh_ipv6, 0, 16); + + ret = local_get_nh_ipv6((uint8_t *)&dst_addr[0], + &dest_if, &nh_ipv6[0], p_nat); + + if (!ret) { + dest_if = get_prv_to_pub_port( + &dst_addr[0], + IP_VERSION_6); + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= + 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + do_local_nh_ipv6_cache(dest_if, p_nat); + } + *outport_id = p_nat->outport_id[dest_if]; + + if (get_dest_mac_address_ipv6_port((uint8_t *) + &dst_addr[0], &dest_if, + &hw_addr, &nh_ipv6[0])){ + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, *outport_id, + hw_addr.addr_bytes[0], + hw_addr.addr_bytes[1], hw_addr.addr_bytes[2], + hw_addr.addr_bytes[3], hw_addr.addr_bytes[4], + hw_addr.addr_bytes[5]); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + memcpy(eth_dest, &hw_addr, + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr( + dest_if), + sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkts[pkt_index]); + #endif + } else { + + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = + rte_bswap16(entry->data.prv_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + } else { + *dst_addr = rte_bswap32(entry->data.u.prv_ip); + dest_address = entry->data.u.prv_ip; + ret = local_get_nh_ipv4(dest_address, &dest_if, + &nhip, p_nat); + if (!ret) { + dest_if = get_pub_to_prv_port( + &dest_address, IP_VERSION_4); + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= + 1LLU << pkt_index; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + do_local_nh_ipv4_cache(dest_if, p_nat); + }; + + *outport_id = p_nat->outport_id[dest_if]; + int ret; + ret = get_dest_mac_addr_port(dest_address, + &dest_if, &hw_addr); + + if (ret == ARP_FOUND) { + memcpy(eth_dest, &hw_addr, + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr( + dest_if), + sizeof(struct ether_addr)); + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5]); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkts[pkt_index]); + #endif + + } else { + if (ret == ARP_NOT_FOUND) { + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + } + //request_arp(*outport_id, + // nhip, p_nat->p.p); + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + + if (*protocol == IP_PROTOCOL_ICMP) { + // Query ID reverse translation done here + *src_port = + rte_bswap16(entry->data.prv_port); + } else { + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = + rte_bswap16(entry-> + data.prv_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + } + } + + p_nat->inaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkts[pkt_index], pkt_type); + else + #endif + sw_checksum(pkts[pkt_index], pkt_type); + } + + if (p_nat->invalid_packets) { + /* get rid of invalid packets */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) { + printf("valid_packets:0x%jx\n", p_nat->valid_packets); + printf("rte_valid_packets :0x%jx\n", rte_p->pkts_mask); + printf("invalid_packets:0x%jx\n", + p_nat->invalid_packets); + printf("rte_invalid_packets :0x%jx\n", + rte_p->pkts_drop_mask); + printf("Total pkts dropped :0x%jx\n", + rte_p->n_pkts_ah_drop); + } + #endif + } + + return p_nat->valid_packets; +} + +/** + * Input port handler for IPv4 private traffic + * Starting from the packet burst it filters unwanted packets, + * calculates keys, does lookup and then based on the lookup + * updates NAPT table and does packet NAPT translation. + * + * @param rte_p + * A pointer to struct rte_pipeline + * @param pkts + * A pointer to array of packets mbuf + * @param n_pkts + * Number of packets in the burst + * @param arg + * Void pointer + * + * @return + * int that is not checked by caller + */ + +static int cgnapt_in_port_ah_ipv4_prv(struct rte_pipeline *rte_p, + struct rte_mbuf **pkts, + uint32_t n_pkts, void *arg) +{ + uint32_t i, j; + struct pipeline_cgnapt_in_port_h_arg *ap = arg; + struct pipeline_cgnapt *p_nat = ap->p; + + #ifdef CGNAPT_TIMING_INST + uint64_t entry_timestamp = 0, exit_timestamp; + + if (p_nat->time_measurements_on) { + entry_timestamp = rte_get_tsc_cycles(); + /* check since exit ts not valid first time through */ + if (likely(p_nat->in_port_exit_timestamp)) + p_nat->external_time_sum += + entry_timestamp - p_nat->in_port_exit_timestamp; + } + #endif + + p_nat->pkt_burst_cnt = 0; /* for dynamic napt */ + p_nat->valid_packets = rte_p->pkts_mask; /*n_pkts; */ + p_nat->invalid_packets = 0; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("cgnapt_key hit fn: %" PRIu32 "\n", n_pkts); + #endif + + /* prefetching for mbufs should be done here */ + for (j = 0; j < n_pkts; j++) + rte_prefetch0(pkts[j]); + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_key_ipv4_prv(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_key_ipv4_prv(pkts[i], i, arg, p_nat); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + if (unlikely(p_nat->valid_packets == 0)) { + /* no suitable packet for lookup */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + return p_nat->valid_packets; + } + + /* lookup entries in the common napt table */ + + int lookup_result = rte_hash_lookup_bulk( + napt_common_table, + (const void **)&p_nat->key_ptrs, + /* should be minus num invalid pkts */ + n_pkts, + /*new pipeline data member */ + &p_nat->lkup_indx[0]); + + if (unlikely(lookup_result < 0)) { + /* unknown error, just discard all packets */ + printf("Unexpected hash lookup error %d, discarding " + "all packets", lookup_result); + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return 0; + } + + /* Now call second stage of pipeline to one by one + * check the result of our bulk lookup + */ + + /* prefetching for table entries should be done here */ + for (j = 0; j < n_pkts; j++) { + if (p_nat->lkup_indx[j] >= 0) + rte_prefetch0(&napt_hash_tbl_entries + [p_nat->lkup_indx[j]]); + } + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_ipv4_prv(pkts, i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_ipv4_prv(pkts, i, arg, p_nat); + + if (p_nat->invalid_packets) { + /* get rid of invalid packets */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) { + printf("valid_packets:0x%jx\n", p_nat->valid_packets); + printf("rte_valid_packets :0x%jx\n", rte_p->pkts_mask); + printf("invalid_packets:0x%jx\n", + p_nat->invalid_packets); + printf("rte_invalid_packets :0x%jx\n", + rte_p->pkts_drop_mask); + printf("Total pkts dropped :0x%jx\n", + rte_p->n_pkts_ah_drop); + } + #endif + } + + #ifdef CGNAPT_TIMING_INST + if (p_nat->time_measurements_on) { + exit_timestamp = rte_get_tsc_cycles(); + p_nat->in_port_exit_timestamp = exit_timestamp; + p_nat->internal_time_sum += exit_timestamp - entry_timestamp; + p_nat->time_measurements++; + if (p_nat->time_measurements == p_nat->max_time_mesurements) + p_nat->time_measurements_on = 0; + } + #endif + + return p_nat->valid_packets; +} + +/** + * Input port handler for IPv4 public traffic + * Starting from the packet burst it filters unwanted packets, + * calculates keys, does lookup and then based on the lookup + * updates NAPT table and does packet NAPT translation. + * + * @param rte_p + * A pointer to struct rte_pipeline + * @param pkts + * A pointer to array of packets mbuf + * @param n_pkts + * Number of packets in the burst + * @param arg + * Void pointer + * + * @return + * int that is not checked by caller + */ +static int cgnapt_in_port_ah_ipv4_pub(struct rte_pipeline *rte_p, + struct rte_mbuf **pkts, + uint32_t n_pkts, void *arg) +{ + uint32_t i, j; + struct pipeline_cgnapt_in_port_h_arg *ap = arg; + struct pipeline_cgnapt *p_nat = ap->p; + + #ifdef CGNAPT_TIMING_INST + uint64_t entry_timestamp = 0, exit_timestamp; + + if (p_nat->time_measurements_on) { + entry_timestamp = rte_get_tsc_cycles(); + + /* check since exit ts not valid first time through */ + if (likely(p_nat->in_port_exit_timestamp)) + p_nat->external_time_sum += + entry_timestamp - p_nat->in_port_exit_timestamp; + } + #endif + + p_nat->pkt_burst_cnt = 0; /* for dynamic napt */ + p_nat->valid_packets = rte_p->pkts_mask; /*n_pkts; */ + p_nat->invalid_packets = 0; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("cgnapt_key hit fn: %" PRIu32 "\n", n_pkts); + #endif + + /* prefetching for mbufs should be done here */ + for (j = 0; j < n_pkts; j++) + rte_prefetch0(pkts[j]); + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_key_ipv4_pub(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_key_ipv4_pub(pkts[i], i, arg, p_nat); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + if (unlikely(p_nat->valid_packets == 0)) { + /* no suitable packet for lookup */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + return p_nat->valid_packets; + } + + /* lookup entries in the common napt table */ + + int lookup_result = rte_hash_lookup_bulk( + napt_common_table, + (const void **)&p_nat->key_ptrs, + /* should be minus num invalid pkts */ + n_pkts, + /*new pipeline data member */ + &p_nat->lkup_indx[0]); + + if (unlikely(lookup_result < 0)) { + /* unknown error, just discard all packets */ + printf("Unexpected hash lookup error %d, discarding " + "all packets", lookup_result); + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return 0; + } + + /* Now call second stage of pipeline to one by one + * check the result of our bulk lookup + */ + + /* prefetching for table entries should be done here */ + for (j = 0; j < n_pkts; j++) { + if (p_nat->lkup_indx[j] >= 0) + rte_prefetch0(&napt_hash_tbl_entries + [p_nat->lkup_indx[j]]); + } + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_ipv4_pub(pkts, i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_ipv4_pub(pkts, i, arg, p_nat); + + if (p_nat->invalid_packets) { + /* get rid of invalid packets */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) { + printf("valid_packets:0x%jx\n", p_nat->valid_packets); + printf("rte_valid_packets :0x%jx\n", rte_p->pkts_mask); + printf("invalid_packets:0x%jx\n", + p_nat->invalid_packets); + printf("rte_invalid_packets :0x%jx\n", + rte_p->pkts_drop_mask); + printf("Total pkts dropped :0x%jx\n", + rte_p->n_pkts_ah_drop); + } + #endif + } + + #ifdef CGNAPT_TIMING_INST + if (p_nat->time_measurements_on) { + exit_timestamp = rte_get_tsc_cycles(); + p_nat->in_port_exit_timestamp = exit_timestamp; + + p_nat->internal_time_sum += exit_timestamp - entry_timestamp; + p_nat->time_measurements++; + if (p_nat->time_measurements == p_nat->max_time_mesurements) + p_nat->time_measurements_on = 0; + } + #endif + + return p_nat->valid_packets; +} + +/** + * NAPT key calculation function for IPv4 private traffic + * which handles 4 pkts + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_key_ipv4_prv( + struct rte_mbuf **pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + p_nat->receivedPktCount += 4; + /* bitmask representing only this packet */ + uint64_t pkt_mask0 = 1LLU << pkt_num; + uint64_t pkt_mask1 = 1LLU << (pkt_num + 1); + uint64_t pkt_mask2 = 1LLU << (pkt_num + 2); + uint64_t pkt_mask3 = 1LLU << (pkt_num + 3); + + uint8_t protocol0 = RTE_MBUF_METADATA_UINT8(pkt[0], + PROT_OFST_IP4); + uint8_t protocol1 = RTE_MBUF_METADATA_UINT8(pkt[1], + PROT_OFST_IP4); + uint8_t protocol2 = RTE_MBUF_METADATA_UINT8(pkt[2], + PROT_OFST_IP4); + uint8_t protocol3 = RTE_MBUF_METADATA_UINT8(pkt[3], + PROT_OFST_IP4); + + uint32_t src_addr0 = RTE_MBUF_METADATA_UINT32(pkt[0], + SRC_ADR_OFST_IP4); + uint32_t src_addr1 = RTE_MBUF_METADATA_UINT32(pkt[1], + SRC_ADR_OFST_IP4); + uint32_t src_addr2 = RTE_MBUF_METADATA_UINT32(pkt[2], + SRC_ADR_OFST_IP4); + uint32_t src_addr3 = RTE_MBUF_METADATA_UINT32(pkt[3], + SRC_ADR_OFST_IP4); + + uint16_t src_port_offset0; + uint16_t src_port_offset1; + uint16_t src_port_offset2; + uint16_t src_port_offset3; + + uint16_t src_port0; + uint16_t src_port1; + uint16_t src_port2; + uint16_t src_port3; + + uint16_t phy_port0 = pkt[0]->port; + uint16_t phy_port1 = pkt[1]->port; + uint16_t phy_port2 = pkt[2]->port; + uint16_t phy_port3 = pkt[3]->port; + + struct pipeline_cgnapt_entry_key key0; + struct pipeline_cgnapt_entry_key key1; + struct pipeline_cgnapt_entry_key key2; + struct pipeline_cgnapt_entry_key key3; + + memset(&key0, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key1, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key2, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key3, 0, sizeof(struct pipeline_cgnapt_entry_key)); + +/* --0-- */ + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[0]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[0], pkt_mask0, p_nat)) + goto PKT1; + } + + switch (protocol0) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[0], + IPV4_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[0], IPV4_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask0; + goto PKT1; + } + } + #endif + } + case IP_PROTOCOL_TCP: + + src_port_offset0 = SRC_PRT_OFST_IP4_TCP; + src_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + src_port_offset0); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset0 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + src_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + src_port_offset0); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask0; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT1; + } + + key0.pid = phy_port0; + key0.ip = rte_bswap32(src_addr0); + key0.port = rte_bswap16(src_port0); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key0.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key0, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; + +/* --1-- */ +PKT1: + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[1]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[1], pkt_mask1, p_nat)) + goto PKT2; + } + switch (protocol1) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[1], + IPV4_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[1], IPV4_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask1; + goto PKT2; + } + } + #endif + } + case IP_PROTOCOL_TCP: + + src_port_offset1 = SRC_PRT_OFST_IP4_TCP; + src_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + src_port_offset1); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset1 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + src_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + src_port_offset1); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask1; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT2; + } + + key1.pid = phy_port1; + key1.ip = rte_bswap32(src_addr1); + key1.port = rte_bswap16(src_port1); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key1.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 1], &key1, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 1] = &p_nat->keys[pkt_num + 1]; + +/* --2-- */ +PKT2: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[2]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[2], pkt_mask2, p_nat)) + goto PKT3; + } + + switch (protocol2) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[2], + IPV4_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[2], IPV4_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask2; + goto PKT3; + } + } + #endif + } + case IP_PROTOCOL_TCP: + + src_port_offset2 = SRC_PRT_OFST_IP4_TCP; + src_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + src_port_offset2); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset2 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + src_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + src_port_offset2); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask2; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT3; + } + + key2.pid = phy_port2; + key2.ip = rte_bswap32(src_addr2); + key2.port = rte_bswap16(src_port2); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key2.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 2], &key2, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 2] = &p_nat->keys[pkt_num + 2]; + +/* --3-- */ +PKT3: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[3]); + #endif + if (enable_hwlb) { + if (!check_arp_icmp(pkt[3], pkt_mask3, p_nat)) + return; + } + + switch (protocol3) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[3], + IPV4_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[3], IPV4_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask3; + return; + } + } + #endif + } + case IP_PROTOCOL_TCP: + + src_port_offset3 = SRC_PRT_OFST_IP4_TCP; + src_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + src_port_offset3); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset3 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + src_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + src_port_offset3); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask3; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key3.pid = phy_port3; + key3.ip = rte_bswap32(src_addr3); + key3.port = rte_bswap16(src_port3); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key3.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 3], &key3, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 3] = &p_nat->keys[pkt_num + 3]; +} + +/** + * NAPT key calculation function for IPv4 public traffic + * which handles 4 pkts + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_key_ipv4_pub( + struct rte_mbuf **pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + p_nat->receivedPktCount += 4; + /* bitmask representing only this packet */ + uint64_t pkt_mask0 = 1LLU << pkt_num; + uint64_t pkt_mask1 = 1LLU << (pkt_num + 1); + uint64_t pkt_mask2 = 1LLU << (pkt_num + 2); + uint64_t pkt_mask3 = 1LLU << (pkt_num + 3); + + uint8_t protocol0 = RTE_MBUF_METADATA_UINT8(pkt[0], + PROT_OFST_IP4); + uint8_t protocol1 = RTE_MBUF_METADATA_UINT8(pkt[1], + PROT_OFST_IP4); + uint8_t protocol2 = RTE_MBUF_METADATA_UINT8(pkt[2], + PROT_OFST_IP4); + uint8_t protocol3 = RTE_MBUF_METADATA_UINT8(pkt[3], + PROT_OFST_IP4); + + uint32_t dst_addr0 = RTE_MBUF_METADATA_UINT32(pkt[0], + DST_ADR_OFST_IP4); + uint32_t dst_addr1 = RTE_MBUF_METADATA_UINT32(pkt[1], + DST_ADR_OFST_IP4); + uint32_t dst_addr2 = RTE_MBUF_METADATA_UINT32(pkt[2], + DST_ADR_OFST_IP4); + uint32_t dst_addr3 = RTE_MBUF_METADATA_UINT32(pkt[3], + DST_ADR_OFST_IP4); + + uint16_t src_port_offset0; + uint16_t src_port_offset1; + uint16_t src_port_offset2; + uint16_t src_port_offset3; + + uint16_t dst_port_offset0; + uint16_t dst_port_offset1; + uint16_t dst_port_offset2; + uint16_t dst_port_offset3; + + uint16_t src_port0; + uint16_t src_port1; + uint16_t src_port2; + uint16_t src_port3; + + uint16_t dst_port0; + uint16_t dst_port1; + uint16_t dst_port2; + uint16_t dst_port3; + + struct pipeline_cgnapt_entry_key key0; + struct pipeline_cgnapt_entry_key key1; + struct pipeline_cgnapt_entry_key key2; + struct pipeline_cgnapt_entry_key key3; + + memset(&key0, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key1, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key2, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key3, 0, sizeof(struct pipeline_cgnapt_entry_key)); + +/* --0-- */ + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[0]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[0], pkt_mask0, p_nat)) + goto PKT1; + } + + switch (protocol0) { + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + + src_port_offset0 = SRC_PRT_OFST_IP4_TCP; + dst_port_offset0 = DST_PRT_OFST_IP4_TCP; + + src_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + src_port_offset0); + dst_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + dst_port_offset0); + + key0.port = rte_bswap16(dst_port0); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset0 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset0 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + + src_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + src_port_offset0); + dst_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + dst_port_offset0); + + key0.port = rte_bswap16(src_port0); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask0; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT1; + } + + key0.pid = 0xffff; + key0.ip = rte_bswap32(dst_addr0); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key0.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key0, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; + +/* --1-- */ +PKT1: + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[1]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[1], pkt_mask1, p_nat)) + goto PKT2; + } + + switch (protocol1) { + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + + src_port_offset1 = SRC_PRT_OFST_IP4_TCP; + dst_port_offset1 = DST_PRT_OFST_IP4_TCP; + + src_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + src_port_offset1); + dst_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + dst_port_offset1); + + key1.port = rte_bswap16(dst_port1); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset1 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset1 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + + src_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + src_port_offset1); + dst_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + dst_port_offset1); + + key1.port = rte_bswap16(src_port1); + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask1; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT2; + } + + key1.pid = 0xffff; + key1.ip = rte_bswap32(dst_addr1); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key1.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 1], &key1, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 1] = &p_nat->keys[pkt_num + 1]; + +/* --2-- */ +PKT2: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[2]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[2], pkt_mask2, p_nat)) + goto PKT3; + } + + switch (protocol2) { + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + + src_port_offset2 = SRC_PRT_OFST_IP4_TCP; + dst_port_offset2 = DST_PRT_OFST_IP4_TCP; + + src_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + src_port_offset2); + dst_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + dst_port_offset2); + + key2.port = rte_bswap16(dst_port2); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset2 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset2 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + + src_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + src_port_offset2); + dst_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + dst_port_offset2); + + key2.port = rte_bswap16(src_port2); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask2; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT3; + } + + key2.pid = 0xffff; + key2.ip = rte_bswap32(dst_addr2); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key2.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 2], &key2, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 2] = &p_nat->keys[pkt_num + 2]; + +/* --3-- */ +PKT3: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[3]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[3], pkt_mask3, p_nat)) + return; + } + + switch (protocol3) { + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + + src_port_offset3 = SRC_PRT_OFST_IP4_TCP; + dst_port_offset3 = DST_PRT_OFST_IP4_TCP; + + src_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + src_port_offset3); + dst_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + dst_port_offset3); + + key3.port = rte_bswap16(dst_port3); + + break; + + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset3 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset3 = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + + src_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + src_port_offset3); + dst_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + dst_port_offset3); + + key3.port = rte_bswap16(src_port3); + + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask3; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key3.pid = 0xffff; + key3.ip = rte_bswap32(dst_addr3); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key3.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 3], &key3, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 3] = &p_nat->keys[pkt_num + 3]; +} + +/** + * NAPT key calculation function for IPv4 private traffic + * which handles 1 pkt + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_key_ipv4_prv( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + /* Egress */ + p_nat->receivedPktCount++; + + /* bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t src_addr = RTE_MBUF_METADATA_UINT32(pkt, SRC_ADR_OFST_IP4); + + uint16_t src_port_offset; + + uint16_t src_port; + + uint16_t phy_port = pkt->port; + struct pipeline_cgnapt_entry_key key; + + memset(&key, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt, pkt_mask, p_nat)) + return; + } + + switch (protocol) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt, + IPV4_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt, IPV4_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask; + return; + } + } + #endif + } + case IP_PROTOCOL_TCP: + + src_port_offset = SRC_PRT_OFST_IP4_TCP; + src_port = RTE_MBUF_METADATA_UINT16(pkt, src_port_offset); + + key.port = rte_bswap16(src_port); + + break; + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + src_port = RTE_MBUF_METADATA_UINT16(pkt, src_port_offset); + + key.port = rte_bswap16(src_port); + + break; + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key.pid = phy_port; + key.ip = rte_bswap32(src_addr); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; +} + +/** + * NAPT key calculation function for IPv4 public traffic + * which handles 1 pkt + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_key_ipv4_pub( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + p_nat->receivedPktCount++; + + /* bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + uint32_t dst_addr = RTE_MBUF_METADATA_UINT32(pkt, DST_ADR_OFST_IP4); + uint16_t src_port_offset; + uint16_t dst_port_offset; + uint16_t src_port; + uint16_t dst_port; + struct pipeline_cgnapt_entry_key key; + memset(&key, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt, pkt_mask, p_nat)) + return; + } + + switch (protocol) { + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + + src_port = RTE_MBUF_METADATA_UINT16(pkt, src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16(pkt, dst_port_offset); + + key.port = rte_bswap16(dst_port); + break; + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + dst_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + + src_port = RTE_MBUF_METADATA_UINT16(pkt, src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16(pkt, dst_port_offset); + + /* common table lookupkey preparation from incoming + * ICMP Packet- Indentifier field + */ + key.port = rte_bswap16(src_port); + break; + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key.ip = rte_bswap32(dst_addr); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + + key.pid = 0xffff; + + memcpy(&p_nat->keys[pkt_num], &key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; +} + + +/** + * NAPT function for IPv4 private traffic which handles 1 pkt + * + * @param pkts + * A pointer to array of packet mbuf + * @param in_pkt_num + * Pkt number of pkt + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_ipv4_prv( + struct rte_mbuf **pkts, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + #ifdef CT_CGNAT + struct rte_CT_helper ct_helper; + memset(&ct_helper, 0, sizeof(struct rte_CT_helper)); + #endif + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + struct rte_mbuf *pkt = pkts[pkt_num]; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t dest_if = 0xff; /* Added for Multiport */ + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + + struct cgnapt_table_entry *entry = NULL; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], + pkt, &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for Destination + * Host unreachable + */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + return; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + uint32_t *src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, SRC_ADR_OFST_IP4); + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP4); + uint16_t src_port_offset = 0; + uint16_t dst_port_offset = 0; + uint16_t *src_port; + uint16_t *dst_port; + + switch (protocol) { + case IP_PROTOCOL_TCP: + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, dst_port_offset); + + #ifdef CT_CGNAT + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + + #ifdef ALGDBG + printf("cgnapt_ct_process: pkt_mask: % "PRIu64", " + "pkt_num: %d\n", pkt_mask, pkt_num); + #endif + + pkt_mask = cgnapt_ct_process(cgnat_cnxn_tracker, pkts, + pkt_mask, &ct_helper); + } + #endif + break; + case IP_PROTOCOL_UDP: + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, dst_port_offset); + break; + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, dst_port_offset); + break; + } + + uint8_t *eth_dest = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + + /* Egress */ + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*dst_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + dest_address = rte_bswap32(*dst_addr); + /*Multiport Changes */ + uint32_t nhip = 0; + uint32_t ret; + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, IP_VERSION_4); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + do_local_nh_ipv4_cache(dest_if, p_nat); + } + + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Egress: \tphy_port:%d\t get_prv_to_pub():%d " + "\tout_port:%d\n", pkt->port, dest_if, + *outport_id); + #endif + + if (local_dest_mac_present(dest_if)) { + memcpy(eth_dest, + get_local_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + //request_arp(*outport_id, nhip, p_nat->p.p); + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - %02x:%02x: " + "%02x:%02x:%02x:%02x\n", dest_address, + *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5]); + + printf("Dest MAC before - %02x:%02x:%02x: " + "%02x:%02x:%02x\n", eth_dest[0], eth_dest[1], + eth_dest[2], eth_dest[3], eth_dest[4], eth_dest[5]); + } + + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + link_hw_laddr_valid[dest_if] = 1; + memcpy(&link_hw_laddr[dest_if], &hw_addr, + sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - %02x:%02x:%02x:%02x:%02x" + ":%02x\n", eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Egress */ + *src_addr = rte_bswap32(entry->data.pub_ip); + + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *src_port = rte_bswap16(entry->data.pub_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + #ifdef SIP_ALG + uint16_t rtp_port = 0, rtcp_port = 0; + struct cgnapt_table_entry *entry_ptr1 = NULL, + *entry_ptr2 = NULL, *entry_ptr3 = NULL, + *entry_ptr4 = NULL; + + if (unlikely(protocol == IP_PROTOCOL_UDP + && (rte_be_to_cpu_16(*dst_port) == 5060 + || rte_be_to_cpu_16(*src_port) == 5060))) { + + int ret = natSipAlgGetAudioPorts(pkt, &rtp_port, + &rtcp_port); + /* Commented code may be required for debug + * and future use, Please keep it*/ + #if 0 + if (ret < 0) { + printf("%s: Wrong SIP ALG packet1\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + #endif + + if (ret >= 0 && rtp_port != 0) { + struct pipeline_cgnapt_entry_key rtp_key; + rtp_key.ip = entry->data.u.prv_ip; + rtp_key.port = rtp_port; + rtp_key.pid = entry->data.prv_phy_port; + + if (add_dynamic_cgnapt_entry_alg( + (struct pipeline *)p_nat, &rtp_key, + &entry_ptr1, &entry_ptr2) == 0) { + printf("%s: Wrong SIP ALG packet2\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + } + + if (ret >= 0 && rtcp_port != 0) { + struct pipeline_cgnapt_entry_key rtcp_key; + rtcp_key.ip = entry->data.u.prv_ip; + rtcp_key.port = rtcp_port; + rtcp_key.pid = entry->data.prv_phy_port; + + if (add_dynamic_cgnapt_entry_alg( + (struct pipeline *)p_nat, &rtcp_key, + &entry_ptr3, &entry_ptr4) == 0) { + printf("%s: Wrong SIP ALG packet3\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + + } + //if(entry_ptr1 != NULL && entry_ptr3 != NULL) + if (sip_alg_dpi(pkt, PRIVATE, entry->data.pub_ip, + entry->data.pub_port, entry->data.u.prv_ip, + entry->data.prv_port, (rtp_port == 0) ? 0 : + entry_ptr1->data.pub_port, + (rtcp_port == 0) ? 0 : + entry_ptr3->data.pub_port) == 0) { + + printf("%s: Wrong SIP ALG packet4\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + } + #endif /* SIP_ALG */ + + #ifdef FTP_ALG + + #ifdef ALGDBG + printf("@CGNAT-pktwork ct_position :%d, pkt_num %d pkt_mask= " + "%" PRIu64 "\n", ct_position, pkt_num, pkt_mask); + #endif + + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + + int32_t ct_position = cgnat_cnxn_tracker->positions[pkt_num]; + if (ct_position < 0){ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + return; + } + /* Commented code may be required for future usage, + * Please keep it + */ + //if (cgnat_cnxn_tracker->hash_table_entries + // [ct_position].alg_bypass_flag != BYPASS) + { + struct pipeline_cgnapt_entry_key data_channel_entry_key; + + data_channel_entry_key.ip = entry->data.pub_ip; + data_channel_entry_key.port = entry->data.pub_port; + data_channel_entry_key.pid = pkt->port; + ftp_alg_dpi(p_nat, &data_channel_entry_key, pkt, + cgnat_cnxn_tracker, ct_position, PRIVATE); + } + } + #endif /* FTP_ALG */ + + p_nat->enaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); + +} + + +/** + * NAPT function for IPv4 public traffic which handles 1 pkt + * + * @param pkts + * A pointer to array of packet mbuf + * @param in_pkt_num + * Pkt number of pkt + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_ipv4_pub( + struct rte_mbuf **pkts, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + + #ifdef CT_CGNAT + struct rte_CT_helper ct_helper; + memset(&ct_helper, 0, sizeof(struct rte_CT_helper)); + #endif + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + struct rte_mbuf *pkt = pkts[pkt_num]; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t dest_if = 0xff; /* Added for Multiport */ + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + + struct cgnapt_table_entry *entry = NULL; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], + pkt, &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + return; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP4); + uint16_t src_port_offset = 0; + uint16_t dst_port_offset = 0; + + if ((protocol == IP_PROTOCOL_TCP) || (protocol == IP_PROTOCOL_UDP)) { + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + } else if (protocol == IP_PROTOCOL_ICMP) { + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + } + + uint16_t *src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, src_port_offset); + uint16_t *dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, dst_port_offset); + + uint8_t *eth_dest = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + + /* Multiport Changes */ + uint32_t nhip = 0; + uint32_t ret; + + { + /* Ingress */ + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*src_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + dest_address = entry->data.u.prv_ip; + + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, IP_VERSION_4); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + do_local_nh_ipv4_cache(dest_if, p_nat); + } + + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Ingress: \tphy_port:%d\t get_pub_to_prv():%d " + "\tout_port%d\n", pkt->port, dest_if, *outport_id); + #endif + } + + if (local_dest_mac_present(dest_if)) { + memcpy(eth_dest, + get_local_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + /* Commented code may be required for debug + * and future use, Please keep it */ + //request_arp(*outport_id, nhip, p_nat->p.p); + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + + } + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf + ("MAC found for ip 0x%x, port %d - %02x:%02x: " + "%02x:%02x:%02x:%02x\n", dest_address, + *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5] + ); + + printf + ("Dest MAC before - %02x:%02x:%02x:%02x " + ":%02x:%02x\n", eth_dest[0], eth_dest[1], + eth_dest[2], eth_dest[3], eth_dest[4], + eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + link_hw_laddr_valid[dest_if] = 1; + memcpy(&link_hw_laddr[dest_if], &hw_addr, + sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], eth_dest[3], + eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Ingress */ + + *dst_addr = rte_bswap32(entry->data.u.prv_ip); + if (protocol == IP_PROTOCOL_ICMP) { + /* Query ID reverse translation done here */ + /* dont care sequence num */ + *src_port = rte_bswap16(entry->data.prv_port); + } else { + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = rte_bswap16(entry->data.prv_port); + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + #ifdef CT_CGNAT + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + pkt_mask = cgnapt_ct_process(cgnat_cnxn_tracker, pkts, + pkt_mask, &ct_helper); + } + #endif + } + + #ifdef SIP_ALG + uint16_t rtp_port = 0, rtcp_port = 0; + struct cgnapt_table_entry *entry_ptr1 = NULL, + *entry_ptr3 = NULL; + + /* Commented code may be required for debug + * and future use, Please keep it */ + #if 0 + struct cgnapt_table_entry *entry_ptr2 = NULL, + *entry_ptr4 = NULL; + #endif + + if (unlikely(protocol == IP_PROTOCOL_UDP + && (rte_be_to_cpu_16(*dst_port) == 5060 + || rte_be_to_cpu_16(*src_port) == 5060))) { + /* Commented code may be required for future usage, + * Please keep it + */ + #if 0 + int ret = natSipAlgGetAudioPorts(pkt, &rtp_port, + &rtcp_port); + if (ret < 0) { + printf("%s: Wrong SIP ALG packet1\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + if (rtp_port != 0) { + struct pipeline_cgnapt_entry_key rtp_key; + rtp_key.ip = entry->data.pub_ip; + rtp_key.port = rtp_port; + rtp_key.pid = 0xffff; + + if (retrieve_cgnapt_entry_alg(&rtp_key, + &entry_ptr1, &entry_ptr2) == 0) { + printf("%s: Wrong SIP ALG packet2\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + } + + if (rtcp_port != 0) { + struct pipeline_cgnapt_entry_key rtcp_key; + rtcp_key.ip = entry->data.pub_ip; + rtcp_key.port = rtcp_port; + rtcp_key.pid = 0xffff; + + if (retrieve_cgnapt_entry_alg(&rtcp_key, + &entry_ptr3, &entry_ptr4) == 0) { + printf("%s: Wrong SIP ALG packet3\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + + } + #endif + + if (sip_alg_dpi(pkt, PUBLIC, entry->data.u.prv_ip, + entry->data.prv_port, entry->data.pub_ip, + entry->data.pub_port, (rtp_port == 0) ? 0 : + entry_ptr1->data.prv_port, + (rtcp_port == 0) ? 0 : + entry_ptr3->data.prv_port) == 0) { + + printf("%s: Wrong SIP ALG packet4\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + + } + } + #endif /* SIP_ALG */ + + #ifdef FTP_ALG + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + int32_t ct_position = cgnat_cnxn_tracker-> + positions[pkt_num]; + if (ct_position < 0){ + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + return; + } + #ifdef ALGDBG + rte_hexdump(stdout, "CT Entry", &cgnat_cnxn_tracker-> + hash_table_entries[ct_position].key, 40); + #endif + + /* Commented code may be required for debug + * and future use, Please keep it*/ + //if (cgnat_cnxn_tracker->hash_table_entries + // [ct_position].alg_bypass_flag != BYPASS) + { + /*enable ALG DPI */ + struct pipeline_cgnapt_entry_key + data_channel_entry_key; + + data_channel_entry_key.ip = entry->data.pub_ip; + data_channel_entry_key.port = entry->data.pub_port; + data_channel_entry_key.pid = 0xffff; + //printf("pkt_work_pub ftp_alg_dpi\n"); + ftp_alg_dpi(p_nat, &data_channel_entry_key, pkt, + cgnat_cnxn_tracker, ct_position, PUBLIC); + + } + } + #endif + + p_nat->inaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); +} + + +/** + * NAPT function for IPv4 private traffic which handles 4 pkts + * + * @param pkts + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_ipv4_prv( + struct rte_mbuf **pkts, + uint32_t in_pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + uint32_t dest_if = 0xff; /* Added for Multiport */ + struct rte_mbuf *pkt; + uint8_t i; + uint8_t pkt_num; + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4; + + #ifdef CT_CGNAT + struct rte_CT_helper ct_helper; + memset(&ct_helper, 0, sizeof(struct rte_CT_helper)); + #endif + + for (i = 0; i < 4; i++) { + pkt_num = in_pkt_num + i; + pkt = pkts[pkt_num]; + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + + struct cgnapt_table_entry *entry = NULL; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = + pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], pkt, + &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", + p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + continue; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + uint32_t *src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, SRC_ADR_OFST_IP4); + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP4); + uint16_t src_port_offset = 0; + uint16_t dst_port_offset = 0; + uint16_t *src_port; + uint16_t *dst_port; + + #if 0 + if ((protocol == IP_PROTOCOL_TCP) + || (protocol == IP_PROTOCOL_UDP)) { + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + } else if (protocol == IP_PROTOCOL_ICMP) { + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + } + #endif + + switch (protocol) { + case IP_PROTOCOL_TCP: + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + dst_port_offset); + + #ifdef CT_CGNAT + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + + //To process CT , pkt_mask does it need + //to be complemented ?? + #ifdef ALGDBG + printf("cgnapt_ct_process: pkt_mask: " + "% "PRIu64", pkt_num: %d\n", + pkt_mask, pkt_num); + #endif + + pkt_mask = cgnapt_ct_process( + cgnat_cnxn_tracker, pkts, + pkt_mask, &ct_helper); + } + #endif + break; + case IP_PROTOCOL_UDP: + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + dst_port_offset); + break; + case IP_PROTOCOL_ICMP: + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset = MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + src_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + src_port_offset); + dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + dst_port_offset); + break; + } + + + uint8_t *eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + /*Multiport Changes */ + uint32_t nhip = 0; + uint32_t ret; + + { + + /* Egress */ + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*dst_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + dest_address = rte_bswap32(*dst_addr); + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, + IP_VERSION_4); + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + do_local_nh_ipv4_cache(dest_if, p_nat); + } + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Egress: \tphy_port:%d\t " + "get_prv_to_pub():%d \tout_port:%d\n", + pkt->port, dest_if, *outport_id); + #endif + } + + if (local_dest_mac_present(dest_if)) { + memcpy(eth_dest, + get_local_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + //request_arp(*outport_id, nhip, p_nat->p.p); + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + + } + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, + *outport_id, + hw_addr.addr_bytes[0], + hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], + hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], + hw_addr.addr_bytes[5] + ); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + link_hw_laddr_valid[dest_if] = 1; + memcpy(&link_hw_laddr[dest_if], &hw_addr, + sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Egress */ + *src_addr = rte_bswap32(entry->data.pub_ip); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *src_port = rte_bswap16(entry->data.pub_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + #ifdef SIP_ALG + uint16_t rtp_port = 0, rtcp_port = 0; + struct cgnapt_table_entry *entry_ptr1 = NULL, + *entry_ptr2 = NULL, *entry_ptr3 = NULL, + *entry_ptr4 = NULL; + + if (unlikely(protocol == IP_PROTOCOL_UDP + && (rte_be_to_cpu_16(*dst_port) == 5060 + || rte_be_to_cpu_16(*src_port) == 5060))) { + + int ret = natSipAlgGetAudioPorts(pkt, + &rtp_port, &rtcp_port); + /* Commented code may be required for future usage, + * Please keep it + */ + #if 0 + if (ret < 0) { + printf("%s: Wrong SIP ALG packet1\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + #endif + + if (ret >= 0 && rtp_port != 0) { + struct pipeline_cgnapt_entry_key rtp_key; + rtp_key.ip = entry->data.u.prv_ip; + rtp_key.port = rtp_port; + rtp_key.pid = entry->data.prv_phy_port; + + if (add_dynamic_cgnapt_entry_alg( + (struct pipeline *)p_nat, &rtp_key, + &entry_ptr1, &entry_ptr2) == 0) { + printf("%s: Wrong SIP ALG packet2\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + } + + if (ret >= 0 && rtcp_port != 0) { + struct pipeline_cgnapt_entry_key rtcp_key; + rtcp_key.ip = entry->data.u.prv_ip; + rtcp_key.port = rtcp_port; + rtcp_key.pid = entry->data.prv_phy_port; + + if (add_dynamic_cgnapt_entry_alg( + (struct pipeline *)p_nat, &rtcp_key, + &entry_ptr3, &entry_ptr4) == 0) { + + printf("%s: Wrong SIP ALG packet3\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + + } + //if(entry_ptr1 != NULL && entry_ptr3 != NULL) + if (sip_alg_dpi(pkt, PRIVATE, + entry->data.pub_ip, + entry->data.pub_port, + entry->data.u.prv_ip, + entry->data.prv_port, + (rtp_port == 0) ? 0 : + entry_ptr1->data.pub_port, + (rtcp_port == 0) ? 0 : + entry_ptr3->data.pub_port) == 0) { + + printf("%s: Wrong SIP ALG packet4\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + } + #endif /* SIP_ALG */ + + #ifdef FTP_ALG + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + + int32_t ct_position = + cgnat_cnxn_tracker->positions[pkt_num]; + #ifdef ALGDBG + printf("@CGNAT-pkt4work ct_position :%d, pkt_num %d " + "pkt_mask = %" PRIu64 "\n", ct_position, + pkt_num, pkt_mask); + #endif + + if (ct_position < 0){ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + continue; + } + if (cgnat_cnxn_tracker->hash_table_entries[ct_position]. + alg_bypass_flag != BYPASS){ + + struct pipeline_cgnapt_entry_key + data_channel_entry_key; + /*enable ALG DPI */ + data_channel_entry_key.ip = + entry->data.pub_ip; + data_channel_entry_key.port = + entry->data.pub_port; + data_channel_entry_key.pid = 0xffff; + + ftp_alg_dpi(p_nat, &data_channel_entry_key, + pkt, cgnat_cnxn_tracker, ct_position, + PRIVATE); + + } + } + #endif + p_nat->enaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); + } +} + +/** + * NAPT function for IPv4 public traffic which handles 4 pkts + * + * @param pkts + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_ipv4_pub( + struct rte_mbuf **pkts, + uint32_t in_pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + #ifdef CT_CGNAT + struct rte_CT_helper ct_helper; + memset(&ct_helper, 0, sizeof(struct rte_CT_helper)); + #endif + struct rte_mbuf *pkt; + uint8_t i; + uint8_t pkt_num; + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4; + + for (i = 0; i < 4; i++) { + pkt_num = in_pkt_num + i; + pkt = pkts[pkt_num]; + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t dest_if = 0xff; /* Added for Multiport */ + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + + struct cgnapt_table_entry *entry = NULL; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = + pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], pkt, + &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", + p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + + continue; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP4); + uint16_t src_port_offset = 0; + uint16_t dst_port_offset = 0; + + if ((protocol == IP_PROTOCOL_TCP) + || (protocol == IP_PROTOCOL_UDP)) { + src_port_offset = SRC_PRT_OFST_IP4_TCP; + dst_port_offset = DST_PRT_OFST_IP4_TCP; + } else if (protocol == IP_PROTOCOL_ICMP) { + /* Identifier */ + src_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 4; + /*Sequence number */ + dst_port_offset = MBUF_HDR_ROOM + + ETH_HDR_SIZE + + IP_HDR_SIZE + 6; + } + + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, src_port_offset); + uint16_t *dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, dst_port_offset); + + uint8_t *eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + /* Multiport Changes */ + uint32_t nhip = 0; + uint32_t ret; + + /* Ingress */ + { + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*src_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + dest_address = entry->data.u.prv_ip; + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, IP_VERSION_4); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + do_local_nh_ipv4_cache(dest_if, p_nat); + } + + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Ingress: \tphy_port:%d\t " + "get_pub_to_prv():%d \tout_port%d\n", + pkt->port, dest_if, + *outport_id); + #endif + } + + if (local_dest_mac_present(dest_if)) { + memcpy(eth_dest, + get_local_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + //request_arp(*outport_id, nhip, p_nat->p.p); + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + + } + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, *outport_id, + hw_addr.addr_bytes[0], + hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], + hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], + hw_addr.addr_bytes[5] + ); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + link_hw_laddr_valid[dest_if] = 1; + memcpy(&link_hw_laddr[dest_if], + &hw_addr, sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - %02x:%02x:%02x: " + "%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Ingress */ + + *dst_addr = rte_bswap32(entry->data.u.prv_ip); + if (protocol == IP_PROTOCOL_ICMP) { + /* Query ID reverse translation done here */ + *src_port = rte_bswap16(entry->data.prv_port); + /* dont care sequence num */ + } else { + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = + rte_bswap16(entry->data.prv_port); + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + #ifdef CT_CGNAT + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + pkt_mask = cgnapt_ct_process( + cgnat_cnxn_tracker, pkts, + pkt_mask, &ct_helper); + } + #endif + } + + #ifdef SIP_ALG + uint16_t rtp_port = 0, rtcp_port = 0; + struct cgnapt_table_entry *entry_ptr1 = NULL, + *entry_ptr3 = NULL; + /* Commented code may be required for future usage, + * Please keep it + */ + #if 0 + struct cgnapt_table_entry *entry_ptr2 = NULL, + *entry_ptr4 = NULL; + #endif + + if (unlikely(protocol == IP_PROTOCOL_UDP + && (rte_be_to_cpu_16(*dst_port) == 5060 + || rte_be_to_cpu_16(*src_port) == 5060))) { + /* Commented code may be required for future usage, + * Please keep it + */ + #if 0 + int ret = natSipAlgGetAudioPorts(pkt, + &rtp_port, &rtcp_port); + if (ret < 0) { + printf("%s: Wrong SIP ALG packet1\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + + if (rtp_port != 0) { + struct pipeline_cgnapt_entry_key rtp_key; + rtp_key.ip = entry->data.pub_ip; + rtp_key.port = rtp_port; + rtp_key.pid = 0xffff; + + if (retrieve_cgnapt_entry_alg(&rtp_key, + &entry_ptr1, &entry_ptr2) == 0) { + printf("%s: Wrong SIP ALG packet2\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + } + + if (rtcp_port != 0) { + struct pipeline_cgnapt_entry_key rtcp_key; + rtcp_key.ip = entry->data.pub_ip; + rtcp_key.port = rtcp_port; + rtcp_key.pid = 0xffff; + + if (retrieve_cgnapt_entry_alg(&rtcp_key, + &entry_ptr3, &entry_ptr4) == 0) { + printf("%s: Wrong SIP ALG packet3\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + } + + } + #endif + if (sip_alg_dpi(pkt, PUBLIC, + entry->data.u.prv_ip, + entry->data.prv_port, + entry->data.pub_ip, + entry->data.pub_port, + (rtp_port == 0) ? 0 : + entry_ptr1->data.prv_port, + (rtcp_port == 0) ? 0 : + entry_ptr3->data.prv_port) == 0) { + + printf("%s: Wrong SIP ALG packet4\n", + __func__); + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + } + } + #endif /* SIP_ALG */ + + #ifdef FTP_ALG + if ((rte_be_to_cpu_16(*src_port) == 21) || + rte_be_to_cpu_16(*dst_port) == 21) { + + int32_t ct_position = + cgnat_cnxn_tracker->positions[pkt_num]; + if (ct_position < 0){ + p_nat->invalid_packets |= pkt_mask; + + p_nat->naptDroppedPktCount++; + continue; + } + if (cgnat_cnxn_tracker->hash_table_entries + [ct_position].alg_bypass_flag != BYPASS){ + + struct pipeline_cgnapt_entry_key + data_channel_entry_key; + + /*enable ALG DPI */ + data_channel_entry_key.ip = + entry->data.pub_ip; + data_channel_entry_key.port = + entry->data.pub_port; + data_channel_entry_key.pid = 0xffff; + + ftp_alg_dpi(p_nat, &data_channel_entry_key, + pkt, cgnat_cnxn_tracker, + ct_position, PUBLIC); + + } + } + #endif + p_nat->inaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); + } +} + +/** + * NAPT key calculation function for IPv6 private traffic + * which handles 1 pkt + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_key_ipv6_prv( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + /* Egress */ + p_nat->receivedPktCount++; + + /* bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP6); + uint32_t *src_addr = RTE_MBUF_METADATA_UINT32_PTR(pkt, + SRC_ADR_OFST_IP6); + uint16_t src_port = RTE_MBUF_METADATA_UINT16(pkt, SRC_PRT_OFST_IP6); + + uint16_t phy_port = pkt->port; + struct pipeline_cgnapt_entry_key key; + + memset(&key, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt, pkt_mask, p_nat)) + return; + } + + switch (protocol) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt, + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt, IPV6_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask; + return; + } + } + #endif + } + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + printf("wrong protocol: %d\n", protocol); + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key.pid = phy_port; + key.ip = rte_bswap32(src_addr[3]); + key.port = rte_bswap16(src_port); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; +} + +/** + * NAPT key calculation function for IPv6 public traffic + * which handles 1 pkt + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_key_ipv6_pub( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + + /* Ingress */ + p_nat->receivedPktCount++; + + /* bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t *dst_addr = RTE_MBUF_METADATA_UINT32_PTR(pkt, + DST_ADR_OFST_IP4); + uint16_t dst_port = RTE_MBUF_METADATA_UINT16(pkt, + DST_PRT_OFST_IP4_TCP); + + struct pipeline_cgnapt_entry_key key; + + memset(&key, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt, pkt_mask, p_nat)) + return; + } + + switch (protocol) { + + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key.pid = 0xffff; + key.ip = rte_bswap32(dst_addr[0]); + key.port = rte_bswap16(dst_port); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; +} + +/** + * NAPT key calculation function for IPv6 private traffic + * which handles 4 pkts + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_key_ipv6_prv( + struct rte_mbuf **pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + p_nat->receivedPktCount += 4; + + /* bitmask representing only this packet */ + uint64_t pkt_mask0 = 1LLU << pkt_num; + uint64_t pkt_mask1 = 1LLU << (pkt_num + 1); + uint64_t pkt_mask2 = 1LLU << (pkt_num + 2); + uint64_t pkt_mask3 = 1LLU << (pkt_num + 3); + + uint8_t protocol0 = RTE_MBUF_METADATA_UINT8(pkt[0], + PROT_OFST_IP6); + uint8_t protocol1 = RTE_MBUF_METADATA_UINT8(pkt[1], + PROT_OFST_IP6); + uint8_t protocol2 = RTE_MBUF_METADATA_UINT8(pkt[2], + PROT_OFST_IP6); + uint8_t protocol3 = RTE_MBUF_METADATA_UINT8(pkt[3], + PROT_OFST_IP6); + + uint32_t *src_addr0 = RTE_MBUF_METADATA_UINT32_PTR(pkt[0], + SRC_ADR_OFST_IP6); + uint32_t *src_addr1 = RTE_MBUF_METADATA_UINT32_PTR(pkt[1], + SRC_ADR_OFST_IP6); + uint32_t *src_addr2 = RTE_MBUF_METADATA_UINT32_PTR(pkt[2], + SRC_ADR_OFST_IP6); + uint32_t *src_addr3 = RTE_MBUF_METADATA_UINT32_PTR(pkt[3], + SRC_ADR_OFST_IP6); + + uint16_t src_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + SRC_PRT_OFST_IP6); + uint16_t src_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + SRC_PRT_OFST_IP6); + uint16_t src_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + SRC_PRT_OFST_IP6); + uint16_t src_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + SRC_PRT_OFST_IP6); + + uint16_t phy_port0 = pkt[0]->port; + uint16_t phy_port1 = pkt[1]->port; + uint16_t phy_port2 = pkt[2]->port; + uint16_t phy_port3 = pkt[3]->port; + + struct pipeline_cgnapt_entry_key key0; + struct pipeline_cgnapt_entry_key key1; + struct pipeline_cgnapt_entry_key key2; + struct pipeline_cgnapt_entry_key key3; + + memset(&key0, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key1, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key2, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key3, 0, sizeof(struct pipeline_cgnapt_entry_key)); + + + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[0]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[0], pkt_mask0, p_nat)) + goto PKT1; + } + + switch (protocol0) { + + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[0], + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[0], IPV6_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask0; + goto PKT1; + } + } + #endif + } + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask0; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + + goto PKT1; + } + + + key0.pid = phy_port0; + key0.ip = rte_bswap32(src_addr0[3]); + key0.port = rte_bswap16(src_port0); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key0.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key0, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; + + PKT1: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[1]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[1], pkt_mask1, p_nat)) + goto PKT2; + } + + switch (protocol1) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[1], + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[1], IPV6_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask1; + goto PKT2; + } + } + #endif + } + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask1; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + + goto PKT2; + } + + key1.pid = phy_port1; + key1.ip = rte_bswap32(src_addr1[3]); + key1.port = rte_bswap16(src_port1); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key1.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 1], &key1, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 1] = &p_nat->keys[pkt_num + 1]; + + PKT2: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[2]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[2], pkt_mask2, p_nat)) + goto PKT3; + } + + switch (protocol2) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[2], + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[2], IPV6_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask2; + goto PKT3; + } + } + #endif + } + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask2; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + + goto PKT3; + } + + key2.pid = phy_port2; + key2.ip = rte_bswap32(src_addr2[3]); + key2.port = rte_bswap16(src_port2); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key2.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 2], &key2, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 2] = &p_nat->keys[pkt_num + 2]; + + PKT3: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[3]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[3], pkt_mask3, p_nat)) + return; + } + + switch (protocol3) { + case IP_PROTOCOL_UDP: + { + #ifdef PCP_ENABLE + if (pcp_enable) { + struct udp_hdr *udp; + + udp = (struct udp_hdr *) + RTE_MBUF_METADATA_UINT8_PTR(pkt[3], + IPV6_UDP_OFST); + + if (rte_bswap16(udp->dst_port) == + PCP_SERVER_PORT) { + handle_pcp_req(pkt[3], IPV6_SZ, p_nat); + p_nat->invalid_packets |= pkt_mask3; + return; + } + } + #endif + } + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask2; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + + return; + } + + key3.pid = phy_port3; + key3.ip = rte_bswap32(src_addr3[3]); + key3.port = rte_bswap16(src_port3); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key3.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 3], &key3, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 3] = &p_nat->keys[pkt_num + 3]; + + +} + +/** + * NAPT key calculation function for IPv4 public traffic + * which handles 4 pkts + * + * @param pkt + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_key_ipv6_pub( + struct rte_mbuf **pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + p_nat->receivedPktCount += 4; + + /* bitmask representing only this packet */ + uint64_t pkt_mask0 = 1LLU << pkt_num; + uint64_t pkt_mask1 = 1LLU << (pkt_num + 1); + uint64_t pkt_mask2 = 1LLU << (pkt_num + 2); + uint64_t pkt_mask3 = 1LLU << (pkt_num + 3); + + uint8_t protocol0 = RTE_MBUF_METADATA_UINT8(pkt[0], + PROT_OFST_IP4); + uint8_t protocol1 = RTE_MBUF_METADATA_UINT8(pkt[1], + PROT_OFST_IP4); + uint8_t protocol2 = RTE_MBUF_METADATA_UINT8(pkt[2], + PROT_OFST_IP4); + uint8_t protocol3 = RTE_MBUF_METADATA_UINT8(pkt[3], + PROT_OFST_IP4); + + uint32_t *dst_addr0 = RTE_MBUF_METADATA_UINT32_PTR(pkt[0], + DST_ADR_OFST_IP4); + uint32_t *dst_addr1 = RTE_MBUF_METADATA_UINT32_PTR(pkt[1], + DST_ADR_OFST_IP4); + uint32_t *dst_addr2 = RTE_MBUF_METADATA_UINT32_PTR(pkt[2], + DST_ADR_OFST_IP4); + uint32_t *dst_addr3 = RTE_MBUF_METADATA_UINT32_PTR(pkt[3], + DST_ADR_OFST_IP4); + + uint16_t dst_port0 = RTE_MBUF_METADATA_UINT16(pkt[0], + DST_PRT_OFST_IP4_TCP); + uint16_t dst_port1 = RTE_MBUF_METADATA_UINT16(pkt[1], + DST_PRT_OFST_IP4_TCP); + uint16_t dst_port2 = RTE_MBUF_METADATA_UINT16(pkt[2], + DST_PRT_OFST_IP4_TCP); + uint16_t dst_port3 = RTE_MBUF_METADATA_UINT16(pkt[3], + DST_PRT_OFST_IP4_TCP); + + struct pipeline_cgnapt_entry_key key0; + struct pipeline_cgnapt_entry_key key1; + struct pipeline_cgnapt_entry_key key2; + struct pipeline_cgnapt_entry_key key3; + + memset(&key0, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key1, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key2, 0, sizeof(struct pipeline_cgnapt_entry_key)); + memset(&key3, 0, sizeof(struct pipeline_cgnapt_entry_key)); + +/* --0-- */ + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[0]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[0], pkt_mask0, p_nat)) + goto PKT1; + } + + switch (protocol0) { + + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask0; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT1; + } + + key0.pid = 0xffff; + key0.ip = rte_bswap32(dst_addr0[0]); + key0.port = rte_bswap16(dst_port0); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key0.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num], &key0, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num] = &p_nat->keys[pkt_num]; + + +/* --1-- */ + +PKT1: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[1]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[1], pkt_mask1, p_nat)) + goto PKT2; + } + + switch (protocol1) { + + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask1; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT2; + } + + key1.pid = 0xffff; + key1.ip = rte_bswap32(dst_addr1[0]); + key1.port = rte_bswap16(dst_port1); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key1.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 1], &key1, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->key_ptrs[pkt_num + 1] = &p_nat->keys[pkt_num + 1]; + + +/* --2-- */ + +PKT2: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[2]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[2], pkt_mask2, p_nat)) + goto PKT3; + } + + switch (protocol2) { + + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask2; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + goto PKT3; + } + + key2.pid = 0xffff; + key2.ip = rte_bswap32(dst_addr2[0]); + key2.port = rte_bswap16(dst_port2); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key2.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 2], &key2, + sizeof(struct pipeline_cgnapt_entry_key)); + + p_nat->key_ptrs[pkt_num + 2] = &p_nat->keys[pkt_num + 2]; + + +/* --3-- */ + +PKT3: + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 4) + print_pkt(pkt[3]); + #endif + + if (enable_hwlb) { + if (!check_arp_icmp(pkt[3], pkt_mask3, p_nat)) + return; + } + + switch (protocol3) { + + case IP_PROTOCOL_TCP: + case IP_PROTOCOL_UDP: + case IP_PROTOCOL_ICMP: + /*we don't need icmp check in ipv6 */ + break; + + default: + /* remember invalid packets to be dropped */ + p_nat->invalid_packets |= pkt_mask3; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount2++; + #endif + return; + } + + key3.pid = 0xffff; + key3.ip = rte_bswap32(dst_addr3[0]); + key3.port = rte_bswap16(dst_port3); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + key3.port = 0xffff; + #endif + + memcpy(&p_nat->keys[pkt_num + 3], &key3, + sizeof(struct pipeline_cgnapt_entry_key)); + + p_nat->key_ptrs[pkt_num + 3] = &p_nat->keys[pkt_num + 3]; +} + +/** + * NAPT function for IPv6 private traffic which handles 1 pkt + * + * @param pkts + * A pointer to array of packet mbuf + * @param in_pkt_num + * Pkt number of pkt + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_ipv6_prv( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP6); + + /* Added for Multiport */ + uint32_t dest_if = INVALID_DESTIF; + uint16_t *outport_id = RTE_MBUF_METADATA_UINT16_PTR(pkt, + cgnapt_meta_offset); + + struct cgnapt_table_entry *entry = NULL; + enum PKT_TYPE pkt_type = PKT_TYPE_IPV6to4; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], + pkt, &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + /* Do we need this check for ipv6? */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + + return; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + struct ipv6_hdr ipv6_hdr; + + struct ether_addr hw_addr; + uint32_t dest_address = 0; + uint32_t nhip = 0; + /* Egress */ + { + + convert_ipv6_to_ipv4(pkt, &ipv6_hdr); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG == 1) + printf("pkt_work_cganpt: convert_ipv6_to_ipv4\n"); + #endif + + struct cgnapt_nsp_node *ll = nsp_ll; + int nsp = 0; + + while (ll != NULL) { + if (!memcmp + (&ipv6_hdr.dst_addr[0], &ll->nsp.prefix[0], + ll->nsp.depth / 8)) { + nsp = 1; + break; + } + ll = ll->next; + } + + if (!nsp + && !memcmp(&ipv6_hdr.dst_addr[0], &well_known_prefix[0], + 12)) { + nsp = 1; + } + + if (!nsp) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount5++; + #endif + + return; + } + + } + + /* As packet is already converted into IPv4 we must not + * operate IPv6 offsets on packet + * Only perform IPv4 operations + */ + + uint32_t *src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, SRC_ADR_OFST_IP6t4); + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP6t4); + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, SRC_PRT_OFST_IP6t4); + uint16_t *dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, DST_PRT_OFST_IP6t4); + + uint8_t *eth_dest = RTE_MBUF_METADATA_UINT8_PTR(pkt, + ETH_OFST_IP6t4); + uint8_t *eth_src = RTE_MBUF_METADATA_UINT8_PTR(pkt, + ETH_OFST_IP6t4 + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + { + /* Egress */ + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*dst_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + + return; + } + + dest_address = rte_bswap32(*dst_addr); + /*Multiport Changes */ + uint32_t nhip = 0; + uint32_t ret; + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, IP_VERSION_4); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + do_local_nh_ipv4_cache(dest_if, p_nat); + } + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Egress: \tphy_port:%d\t get_prv_to_pub():%d " + "\tout_port:%d\n", pkt->port, + dest_if, *outport_id); + #endif + } + + #ifdef CGNAPT_DBG_PRNT + static int static_count; + + if (static_count++ < 10) { + print_pkt(pkt); + my_print_entry(entry); + printf("dest-offset:%d\n", DST_ADR_OFST_IP4); + printf("dest_add:%x\n", entry->data.u.prv_ip); + printf("dest_add:%x\n", *dst_addr); + printf("DST_ADR_OFST_IP6:%d\n", DST_ADR_OFST_IP6); + } + #endif + + if (local_dest_mac_present(dest_if)) { + memcpy(eth_dest, + get_local_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + //request_arp(*outport_id, nhip, p_nat->p.p); + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + return; + + } + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - %02x:%02x: " + "%02x:%02x:%02x:%02x\n", dest_address, + *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5]); + + printf("Dest MAC before - %02x:%02x:%02x:%02x: " + "%02x:%02x\n", eth_dest[0], eth_dest[1], + eth_dest[2], eth_dest[3], + eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], eth_dest[3], + eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Egress */ + *src_addr = rte_bswap32(entry->data.pub_ip); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *src_port = rte_bswap16(entry->data.pub_port); + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + p_nat->enaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); +} + + +/** + * NAPT function for IPv6 public traffic which handles 1 pkt + * + * @param pkts + * A pointer to array of packet mbuf + * @param in_pkt_num + * Pkt number of pkt + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt_work_cgnapt_ipv6_pub( + struct rte_mbuf *pkt, + uint32_t pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + + uint32_t dest_if = INVALID_DESTIF; /* Added for Multiport */ + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + struct cgnapt_table_entry *entry = NULL; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4to6; + + if (hash_table_entry < 0) { + + /* Drop ingress initial traffic */ + + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + return; + + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + if (entry->data.type != CGNAPT_ENTRY_IPV6) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + return; + } + + struct ipv4_hdr ipv4_hdr; + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, SRC_PRT_OFST_IP4_TCP); + + uint8_t *eth_dest = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint8_t dest_addr_ipv6[16]; + uint8_t nh_ipv6[16]; + + /* Ingress */ + { + + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*src_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + memcpy(&dest_addr_ipv6[0], &entry->data.u.prv_ipv6[0], 16); + uint8_t nhipv6[16]; + int ret; + ret = local_get_nh_ipv6(&dest_addr_ipv6[0], &dest_if, + &nhipv6[0], p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port((uint32_t *) + &dest_addr_ipv6[0], + IP_VERSION_6); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + do_local_nh_ipv6_cache(dest_if, p_nat); + } + *outport_id = p_nat->outport_id[dest_if]; + } + + #ifdef CGNAPT_DEBUGGING + static int static_count; + + if (static_count++ < 10) { + print_pkt(pkt); + my_print_entry(entry); + printf("dest-offset:%d\n", DST_ADR_OFST_IP4); + printf("dest_add:%x\n", entry->data.u.prv_ip); + printf("DST_ADR_OFST_IP6:%d\n", DST_ADR_OFST_IP6); + } + #endif + + memset(nh_ipv6, 0, 16); + if (get_dest_mac_address_ipv6_port( + &dest_addr_ipv6[0], + &dest_if, + &hw_addr, + &nh_ipv6[0])) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + *((uint32_t *)dest_addr_ipv6 + 12), + *outport_id, + hw_addr.addr_bytes[0], + hw_addr.addr_bytes[1], hw_addr.addr_bytes[2], + hw_addr.addr_bytes[3], hw_addr.addr_bytes[4], + hw_addr.addr_bytes[5]); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], eth_dest[3], + eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + + return; + } + /* Ingress */ + { + + convert_ipv4_to_ipv6(pkt, &ipv4_hdr); + + /* Ethernet MTU check */ + if ((rte_pktmbuf_data_len(pkt) - 14) > 1500) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + return; + } + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP4t6); + uint16_t *dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, DST_PRT_OFST_IP4t6); + + memcpy((uint8_t *) &dst_addr[0], &entry->data.u.prv_ipv6[0], + 16); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = rte_bswap16(entry->data.prv_port); + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + p_nat->inaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); +} + + +/** + * NAPT function for IPv6 private traffic which handles 4 pkts + * + * @param pkts + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_ipv6_prv( + struct rte_mbuf **pkts, + uint32_t in_pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + struct rte_mbuf *pkt; + uint8_t i; + uint8_t pkt_num; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV6to4; + + for (i = 0; i < 4; i++) { + pkt_num = in_pkt_num + i; + pkt = pkts[i]; + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP6); + uint32_t dest_if = INVALID_DESTIF; + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + struct cgnapt_table_entry *entry = NULL; + + if (hash_table_entry < 0) { + + /* try to add new entry */ + struct rte_pipeline_table_entry *table_entry = NULL; + + uint64_t dropmask = + pkt_miss_cgnapt(p_nat->key_ptrs[pkt_num], pkt, + &table_entry, + &p_nat->valid_packets, pkt_num, + (void *)p_nat); + + if (!table_entry) { + /* ICMP Error message generation for + * Destination Host unreachable + */ + /* Do we need this check for ipv6? */ + if (protocol == IP_PROTOCOL_ICMP) { + cgnapt_icmp_pkt = pkt; + send_icmp_dest_unreachable_msg(); + } + + /* Drop packet by adding to invalid pkt mask */ + + p_nat->invalid_packets |= dropmask; + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", + p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + #endif + + continue; + } + + entry = (struct cgnapt_table_entry *)table_entry; + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + + struct ipv6_hdr ipv6_hdr; + struct ether_addr hw_addr; + uint32_t dest_address = 0; + uint8_t nh_ipv6[16]; + uint32_t nhip = 0; + + /* Egress */ + { + convert_ipv6_to_ipv4(pkt, &ipv6_hdr); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) + printf("pkt_work_cganpt: " + "convert_ipv6_to_ipv4\n"); + #endif + + struct cgnapt_nsp_node *ll = nsp_ll; + int nsp = 0; + + while (ll != NULL) { + if (!memcmp(&ipv6_hdr.dst_addr[0], + &ll->nsp.prefix[0], + ll->nsp.depth / 8)) { + nsp = 1; + break; + } + ll = ll->next; + } + + if (!nsp + && !memcmp(&ipv6_hdr.dst_addr[0], + &well_known_prefix[0], 12)) { + nsp = 1; + } + + if (!nsp) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount5++; + #endif + continue; + } + + } + + /* As packet is already converted into IPv4 we must not + * operate IPv6 offsets on packet only perform IPv4 operations + */ + + uint32_t *src_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, SRC_ADR_OFST_IP6t4); + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR(pkt, DST_ADR_OFST_IP6t4); + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, SRC_PRT_OFST_IP6t4); + uint16_t *dst_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, DST_PRT_OFST_IP6t4); + + uint8_t *eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(pkt, ETH_OFST_IP6t4); + uint8_t *eth_src = + RTE_MBUF_METADATA_UINT8_PTR(pkt, ETH_OFST_IP6t4 + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + /* Egress */ + { + + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*dst_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + dest_address = rte_bswap32(*dst_addr); + uint32_t nhip; + uint32_t ret; + ret = local_get_nh_ipv4(dest_address, &dest_if, &nhip, p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port(&dest_address, IP_VERSION_4); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + do_local_nh_ipv4_cache(dest_if, p_nat); + } + *outport_id = p_nat->outport_id[dest_if]; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("Egress: \tphy_port:%d\t" + "get_prv_to_pub():%d \tout_port:%d\n", + pkt->port, dest_if, *outport_id); + #endif + } + + #ifdef CGNAPT_DEBUGGING + static int static_count; + + if (static_count++ < 10) { + print_pkt(pkt); + my_print_entry(entry); + printf("dest-offset:%d\n", DST_ADR_OFST_IP4); + printf("dest_add:%x\n", entry->data.u.prv_ip); + printf("dest_add:%x\n", *dst_addr); + printf("DST_ADR_OFST_IP6:%d\n", DST_ADR_OFST_IP6); + } + #endif + + memset(nh_ipv6, 0, 16); + + { + int ret; + ret = get_dest_mac_addr_port(dest_address, &dest_if, &hw_addr); + + if (unlikely(ret != ARP_FOUND)) { + + if (unlikely(ret == ARP_NOT_FOUND)) { + /* Commented code may be required for debug + * and future use, Please keep it */ + //request_arp(*outport_id, nhip, p_nat->p.p); + printf("%s: ARP Not Found, nhip: %x, " + "outport_id: %d\n", __func__, nhip, + *outport_id); + } + + /* Drop the pkt */ + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + continue; + + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + dest_address, *outport_id, + hw_addr.addr_bytes[0], + hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], + hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], + hw_addr.addr_bytes[5] + ); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } + + { + /* Egress */ + *src_addr = rte_bswap32(entry->data.pub_ip); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *src_port = rte_bswap16(entry->data.pub_port); + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + p_nat->enaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); + } +} + +/** + * NAPT function for IPv6 public traffic which handles 4 pkts + * + * @param pkts + * A pointer to array of packets mbuf + * @param in_pkt_num + * Starting pkt number of pkts + * @param arg + * Void pointer + * @param p_nat + * A pointer to main CGNAPT structure + * + */ +void +pkt4_work_cgnapt_ipv6_pub( + struct rte_mbuf **pkts, + uint32_t in_pkt_num, + __rte_unused void *arg, + struct pipeline_cgnapt *p_nat) +{ + struct rte_mbuf *pkt; + uint8_t i; + uint8_t pkt_num; + + enum PKT_TYPE pkt_type = PKT_TYPE_IPV4to6; + + for (i = 0; i < 4; i++) { + pkt_num = in_pkt_num + i; + pkt = pkts[i]; + + /* index into hash table entries */ + int hash_table_entry = p_nat->lkup_indx[pkt_num]; + /*bitmask representing only this packet */ + uint64_t pkt_mask = 1LLU << pkt_num; + + uint8_t protocol = RTE_MBUF_METADATA_UINT8(pkt, PROT_OFST_IP4); + uint16_t *outport_id = + RTE_MBUF_METADATA_UINT16_PTR(pkt, cgnapt_meta_offset); + struct cgnapt_table_entry *entry = NULL; + + if (hash_table_entry < 0) { + + /* Drop ingress initial traffic */ + + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount3++; + if (p_nat->kpc2++ < 5) { + printf("in_ah Th: %d", p_nat->pipeline_num); + print_key(p_nat->key_ptrs[pkt_num]); + } + #endif + + continue; + + } else { + /* entry found for this packet */ + entry = &napt_hash_tbl_entries[hash_table_entry]; + } + + /* apply napt and mac changes */ + + p_nat->entries[pkt_num] = &(entry->head); + if (entry->data.type != CGNAPT_ENTRY_IPV6) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + continue; + } + + struct ipv4_hdr ipv4_hdr; + + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR(pkt, SRC_PRT_OFST_IP4_TCP); + + uint8_t *eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM); + uint8_t *eth_src = + RTE_MBUF_METADATA_UINT8_PTR(pkt, MBUF_HDR_ROOM + 6); + + if (entry->data.ttl == NAPT_ENTRY_STALE) + entry->data.ttl = NAPT_ENTRY_VALID; + + struct ether_addr hw_addr; + uint8_t dest_addr_ipv6[16]; + uint8_t nh_ipv6[16]; + uint32_t dest_if = INVALID_DESTIF; + /* Ingress */ + { + + if (unlikely(protocol == IP_PROTOCOL_UDP + && rte_be_to_cpu_16(*src_port) == 53)) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + continue; + } + + memcpy(&dest_addr_ipv6[0], &entry->data.u.prv_ipv6[0], + 16); + uint8_t nhipv6[16]; + int ret; + ret = local_get_nh_ipv6(&dest_addr_ipv6[0], &dest_if, + &nhipv6[0], p_nat); + if (!ret) { + dest_if = get_prv_to_pub_port((uint32_t *) + &dest_addr_ipv6[0], IP_VERSION_6); + + if (dest_if == INVALID_DESTIF) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount6++; + #endif + return; + } + + do_local_nh_ipv6_cache(dest_if, p_nat); + } + + *outport_id = p_nat->outport_id[dest_if]; + } + + #ifdef CGNAPT_DEBUGGING + static int static_count; + + if (static_count++ < 10) { + print_pkt(pkt); + my_print_entry(entry); + printf("dest-offset:%d\n", DST_ADR_OFST_IP4); + printf("dest_add:%x\n", entry->data.u.prv_ip); + printf("DST_ADR_OFST_IP6:%d\n", DST_ADR_OFST_IP6); + } + #endif + + memset(nh_ipv6, 0, 16); + if (get_dest_mac_address_ipv6 + (&dest_addr_ipv6[0], &dest_if, + &hw_addr, &nh_ipv6[0])) { + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("MAC found for ip 0x%x, port %d - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + *((uint32_t *)dest_addr_ipv6 + 12), + *outport_id, + hw_addr.addr_bytes[0], hw_addr.addr_bytes[1], + hw_addr.addr_bytes[2], hw_addr.addr_bytes[3], + hw_addr.addr_bytes[4], hw_addr.addr_bytes[5]); + + printf("Dest MAC before - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_dest, &hw_addr, sizeof(struct ether_addr)); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("Dest MAC after - " + "%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dest[0], eth_dest[1], eth_dest[2], + eth_dest[3], eth_dest[4], eth_dest[5]); + } + #endif + + memcpy(eth_src, + get_link_hw_addr(dest_if), + sizeof(struct ether_addr)); + } else { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->naptDroppedPktCount4++; + #endif + + continue; + } + + { + /* Ingress */ + + convert_ipv4_to_ipv6(pkt, &ipv4_hdr); + + /* Ethernet MTU check */ + if ((rte_pktmbuf_data_len(pkt) - 14) > 1500) { + p_nat->invalid_packets |= pkt_mask; + p_nat->naptDroppedPktCount++; + continue; + } + uint32_t *dst_addr = RTE_MBUF_METADATA_UINT32_PTR(pkt, + DST_ADR_OFST_IP4t6); + uint16_t *dst_port = RTE_MBUF_METADATA_UINT16_PTR(pkt, + DST_PRT_OFST_IP4t6); + + memcpy((uint8_t *) &dst_addr[0], + &entry->data.u.prv_ipv6[0], 16); + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + *dst_port = rte_bswap16(entry->data.prv_port); + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + p_nat->inaptedPktCount++; + } + + p_nat->naptedPktCount++; + + #ifdef HW_CHECKSUM_REQ + if (p_nat->hw_checksum_reqd) + hw_checksum(pkt, pkt_type); + else + #endif + sw_checksum(pkt, pkt_type); + } +} + +/** + * Input port handler for IPv6 private traffic + * Starting from the packet burst it filters unwanted packets, + * calculates keys, does lookup and then based on the lookup + * updates NAPT table and does packet NAPT translation. + * + * @param rte_p + * A pointer to struct rte_pipeline + * @param pkts + * A pointer to array of packets mbuf + * @param n_pkts + * Number of packets in the burst + * @param arg + * Void pointer + * + * @return + * int that is not checked by caller + */ +static int cgnapt_in_port_ah_ipv6_prv(struct rte_pipeline *rte_p, + struct rte_mbuf **pkts, + uint32_t n_pkts, void *arg) +{ + uint32_t i, j; + struct pipeline_cgnapt_in_port_h_arg *ap = arg; + struct pipeline_cgnapt *p_nat = ap->p; + + p_nat->pkt_burst_cnt = 0; /* for dynamic napt */ + p_nat->valid_packets = rte_p->pkts_mask; /*n_pkts; */ + p_nat->invalid_packets = 0; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("cgnapt_key hit fn: %" PRIu32 "\n", n_pkts); + #endif + + /* prefetching for mbufs should be done here */ + for (j = 0; j < n_pkts; j++) + rte_prefetch0(pkts[j]); + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_key_ipv6_prv(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_key_ipv6_prv(pkts[i], i, arg, p_nat); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + if (unlikely(p_nat->valid_packets == 0)) { + /* no suitable packet for lookup */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + return p_nat->valid_packets; + } + + /* lookup entries in the common napt table */ + + int lookup_result = rte_hash_lookup_bulk( + napt_common_table, + (const void **) &p_nat->key_ptrs, + /* should be minus num invalid pkts */ + n_pkts, + /*new pipeline data member */ + &p_nat->lkup_indx[0]); + + if (unlikely(lookup_result < 0)) { + /* unknown error, just discard all packets */ + printf("Unexpected hash lookup error %d, " + "discarding all packets", + lookup_result); + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return 0; + } + + /* Now call second stage of pipeline to one by one + * check the result of our bulk lookup + */ + + /* prefetching for table entries should be done here */ + for (j = 0; j < n_pkts; j++) { + if (p_nat->lkup_indx[j] >= 0) + rte_prefetch0(&napt_hash_tbl_entries + [p_nat->lkup_indx[j]]); + } + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_ipv6_prv(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_ipv6_prv(pkts[i], i, arg, p_nat); + + if (p_nat->invalid_packets) { + /* get rid of invalid packets */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) { + printf("valid_packets:0x%jx\n", p_nat->valid_packets); + printf("rte_valid_packets :0x%jx\n", rte_p->pkts_mask); + printf("invalid_packets:0x%jx\n", + p_nat->invalid_packets); + printf("rte_invalid_packets :0x%jx\n", + rte_p->pkts_drop_mask); + printf("Total pkts dropped :0x%jx\n", + rte_p->n_pkts_ah_drop); + } + #endif + } + + return p_nat->valid_packets; +} + + +/** + * Input port handler for IPv6 public traffic + * Starting from the packet burst it filters unwanted packets, + * calculates keys, does lookup and then based on the lookup + * updates NAPT table and does packet NAPT translation. + * + * @param rte_p + * A pointer to struct rte_pipeline + * @param pkts + * A pointer to array of packets mbuf + * @param n_pkts + * Number of packets in the burst + * @param arg + * Void pointer + * + * @return + * int that is not checked by caller + */ +static int cgnapt_in_port_ah_ipv6_pub(struct rte_pipeline *rte_p, + struct rte_mbuf **pkts, + uint32_t n_pkts, void *arg) +{ + uint32_t i, j; + struct pipeline_cgnapt_in_port_h_arg *ap = arg; + struct pipeline_cgnapt *p_nat = ap->p; + + p_nat->pkt_burst_cnt = 0; /* for dynamic napt */ + p_nat->valid_packets = rte_p->pkts_mask; /*n_pkts; */ + p_nat->invalid_packets = 0; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("cgnapt_key hit fn: %" PRIu32 "\n", n_pkts); + #endif + + /* prefetching for mbufs should be done here */ + for (j = 0; j < n_pkts; j++) + rte_prefetch0(pkts[j]); + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_key_ipv6_pub(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_key_ipv6_pub(pkts[i], i, arg, p_nat); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + if (unlikely(p_nat->valid_packets == 0)) { + /* no suitable packet for lookup */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + return p_nat->valid_packets; + } + + /* lookup entries in the common napt table */ + + int lookup_result = rte_hash_lookup_bulk( + napt_common_table, + (const void **) &p_nat->key_ptrs, + /* should be minus num invalid pkts */ + n_pkts, + /*new pipeline data member */ + &p_nat->lkup_indx[0]); + + if (unlikely(lookup_result < 0)) { + /* unknown error, just discard all packets */ + printf("Unexpected hash lookup error %d, " + "discarding all packets", + lookup_result); + rte_pipeline_ah_packet_drop(rte_p, p_nat->valid_packets); + return 0; + } + + /* Now call second stage of pipeline to one by one + * check the result of our bulk lookup + */ + + /* prefetching for table entries should be done here */ + for (j = 0; j < n_pkts; j++) { + if (p_nat->lkup_indx[j] >= 0) + rte_prefetch0(&napt_hash_tbl_entries + [p_nat->lkup_indx[j]]); + } + + for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) + pkt4_work_cgnapt_ipv6_pub(&pkts[i], i, arg, p_nat); + + for (; i < n_pkts; i++) + pkt_work_cgnapt_ipv6_pub(pkts[i], i, arg, p_nat); + + if (p_nat->invalid_packets) { + /* get rid of invalid packets */ + rte_pipeline_ah_packet_drop(rte_p, p_nat->invalid_packets); + + p_nat->valid_packets &= ~(p_nat->invalid_packets); + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) { + printf("valid_packets:0x%jx\n", p_nat->valid_packets); + printf("rte_valid_packets :0x%jx\n", rte_p->pkts_mask); + printf("invalid_packets:0x%jx\n", + p_nat->invalid_packets); + printf("rte_invalid_packets :0x%jx\n", + rte_p->pkts_drop_mask); + printf("Total pkts dropped :0x%jx\n", + rte_p->n_pkts_ah_drop); + } + #endif + } + + return p_nat->valid_packets; +} + +/** + * Function to send ICMP dest unreachable msg + * + */ +void send_icmp_dest_unreachable_msg(void) +{ + + struct ether_hdr *eth_h; + struct ipv4_hdr *ip_h; + struct icmp_hdr *icmp_h; + struct rte_mbuf *icmp_pkt = cgnapt_icmp_pkt; + + if (icmp_pkt == NULL) { + if (ARPICMP_DEBUG) + printf("Error allocating icmp_pkt rte_mbuf\n"); + return; + } + uint16_t port_id; + port_id = icmp_pkt->port; + + struct app_link_params *link; + link = &mylink[port_id]; + eth_h = rte_pktmbuf_mtod(icmp_pkt, struct ether_hdr *); + ip_h = (struct ipv4_hdr *)((char *)eth_h + sizeof(struct ether_hdr)); + icmp_h = (struct icmp_hdr *)((char *)ip_h + sizeof(struct ipv4_hdr)); + + struct ether_addr gw_addr; + struct ether_addr dst_addr; + ether_addr_copy(ð_h->s_addr, &dst_addr); + rte_eth_macaddr_get(port_id, &gw_addr); + ether_addr_copy(&gw_addr, ð_h->s_addr); + ether_addr_copy(&dst_addr, ð_h->d_addr); + + eth_h->ether_type = CHECK_ENDIAN_16(ETHER_TYPE_IPv4); + ip_h->version_ihl = IP_VHL_DEF; + ip_h->type_of_service = 0; + ip_h->total_length = rte_cpu_to_be_16(sizeof(struct ipv4_hdr) + + sizeof(struct icmp_hdr)); + ip_h->packet_id = 0xaabb; + ip_h->fragment_offset = 0x0000; + ip_h->time_to_live = 64; + ip_h->next_proto_id = 1; + + uint32_t *src_addr; + uint32_t src_addr_offset = + MBUF_HDR_ROOM + ETH_HDR_SIZE + IP_HDR_SRC_ADR_OFST; + src_addr = + RTE_MBUF_METADATA_UINT32_PTR(cgnapt_icmp_pkt, src_addr_offset); + + ip_h->dst_addr = *src_addr; + ip_h->src_addr = rte_bswap32(link->ip); + + ip_h->dst_addr = *src_addr; + ip_h->src_addr = rte_bswap32(link->ip); + + ip_h->hdr_checksum = 0; + ip_h->hdr_checksum = rte_ipv4_cksum(ip_h); + icmp_h->icmp_type = 3; /* Destination Unreachable */ + icmp_h->icmp_code = 13; /* Communication administratively prohibited */ + + icmp_h->icmp_cksum = ~rte_raw_cksum(icmp_h, sizeof(struct icmp_hdr)); + + icmp_pkt->pkt_len = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + + sizeof(struct icmp_hdr); + icmp_pkt->data_len = icmp_pkt->pkt_len; + if (ARPICMP_DEBUG) { + printf("Sending ICMP error message - " + "Destination Unreachable\n"); + } + rte_pipeline_port_out_packet_insert(myP, port_id, icmp_pkt); +} + +/** + * Function to add a dynamic NAPT entry pair + * + * @param p + * A pointer to struct pipeline + * @param key + * A pointer to struct pipeline_cgnapt_entry_key + * @param time_out + * expairy time of an dynamic or PCP req entry + * @param src_addr + * uint8_t pointer of source address + * + * @return + * A pointer to struct cgnapt_table_entry for added entry + */ + +struct cgnapt_table_entry *add_dynamic_cgnapt_entry( + struct pipeline *p, + struct pipeline_cgnapt_entry_key *key, + uint32_t timeout, + uint8_t pkt_type, + uint8_t *src_addr, + uint8_t *err) +{ + int port_num = 0; + void *entry_ptr, *ret_ptr; + int ret = 0, i; + + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 1) { + printf("Th%d add_dynamic_cgnapt_entry key detail Entry:" + "0x%x, %d, %d\n", p_nat->pipeline_num, key->ip, key->port, + key->pid); + } + #endif + + for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX && i < p_nat->pkt_burst_cnt; + i++) { + if (p_nat->cgnapt_dyn_ent_table[i].ip == key->ip + && p_nat->cgnapt_dyn_ent_table[i].port == key->port + && p_nat->cgnapt_dyn_ent_table[i].pid == key->pid) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("add_dynamic_cgnapt_entry:pkt_burst " + "array key matched!!!\n"); + #endif + + return &napt_hash_tbl_entries + [p_nat->cgnapt_dyn_ent_index[i]]; + } + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + + ret = increment_max_port_counter(key->ip, key->pid, p_nat); + if (ret == MAX_PORT_INC_ERROR) { + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount5++; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("add_dynamic_cgnapt_entry:" + "increment_max_port_counter-1 failed\n"); + #endif + + *err = 1; + return NULL; + } + + if (ret == MAX_PORT_INC_REACHED) { + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount6++; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("add_dynamic_cgnapt_entry:" + "increment_max_port_counter-2 failed\n"); + #endif + + *err = 1; + return NULL; + } + + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + uint32_t public_ip; + port_num = get_free_iport(p_nat, &public_ip); + + if (port_num == -1) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) { + printf("add_dynamic_cgnapt_entry: %d\n", port_num); + printf("add_dynamic_cgnapt_entry key detail:0x%x, " + "%d, %d\n", key->ip, key->port, key->pid); + } + #endif + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount7++; + #endif + + *err = 1; + return NULL; + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (!nat_only_config_flag) { + #endif + + if (ret == 2) { //MPPC_NEW_ENTRY + + /* check for max_clients_per_ip */ + if (rte_atomic16_read + (&all_public_ip + [rte_jhash(&public_ip, 4, 0) % + CGNAPT_MAX_PUB_IP].count) == + p_nat->max_clients_per_ip) { + + /* For now just bail out + * In future we can think about + * retrying getting a new iport + */ + + release_iport(port_num, public_ip, p_nat); + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount10++; + #endif + *err = 1; + return NULL; + } + + rte_atomic16_inc(&all_public_ip + [rte_jhash(&public_ip, 4, 0) % + CGNAPT_MAX_PUB_IP].count); + + #ifdef CGNAPT_DBG_PRNT + if ((rte_jhash(&public_ip, 4, 0) % + CGNAPT_MAX_PUB_IP) == 8) + printf("pub ip:%x coutn:%d\n", public_ip, + rte_atomic16_read(&all_public_ip + [rte_jhash(&public_ip, 4, 0) % + CGNAPT_MAX_PUB_IP].count)); + #endif + + } + #ifdef NAT_ONLY_CONFIG_REQ + } + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 0) { + printf("add_dynamic_cgnapt_entry: %d\n", + port_num); + printf("add_dynamic_cgnapt_entry key detail: " + "0x%x, %d, %d\n", key->ip, key->port, key->pid); + } + #endif + + struct cgnapt_table_entry entry = { + .head = { + .action = RTE_PIPELINE_ACTION_PORT, + /* made it configurable below */ + {.port_id = p->port_out_id[0]}, + }, + + .data = { + .prv_port = key->port, + .pub_ip = public_ip, + .pub_port = port_num, + .prv_phy_port = key->pid, + .pub_phy_port = get_pub_to_prv_port( + &public_ip, + IP_VERSION_4), + .ttl = 0, + /* if(timeout == -1) : static entry + * if(timeout == 0 ) : dynamic entry + * if(timeout > 0 ) : PCP requested entry + */ + .timeout = timeout > 0 ? timeout : 0, + #ifdef PCP_ENABLE + .timer = NULL, + #endif + } + }; + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + entry.data.prv_port = 0xffff; + entry.data.pub_port = 0xffff; + } + #endif + + if (pkt_type == CGNAPT_ENTRY_IPV6) { + entry.data.type = CGNAPT_ENTRY_IPV6; + memcpy(&entry.data.u.prv_ipv6[0], src_addr, 16); + } else { + entry.data.u.prv_ip = key->ip; + entry.data.type = CGNAPT_ENTRY_IPV4; + } + + //entry.head.port_id = CGNAPT_PUB_PORT_ID; /* outgoing port info */ + entry.head.port_id = entry.data.pub_phy_port; /* outgoing port info */ + + struct pipeline_cgnapt_entry_key second_key; + /* Need to add a second ingress entry */ + second_key.ip = public_ip; + second_key.port = port_num; + second_key.pid = 0xffff; + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + second_key.port = 0xffff; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("add_dynamic_cgnapt_entry second key detail:" + "0x%x, %d, %d\n", second_key.ip, second_key.port, + second_key.pid); + #endif + + int32_t position = rte_hash_add_key(napt_common_table, (void *)key); + + if (position < 0) { + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount8++; + #endif + + printf("CG-NAPT entry add failed ...returning " + "without adding ... %d\n", position); + *err = 1; + return NULL; + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG) { + printf("add_dynamic_cgnapt_entry\n"); + print_key(key); + print_cgnapt_entry(&entry); + } + #endif + + memcpy(&napt_hash_tbl_entries[position], &entry, + sizeof(struct cgnapt_table_entry)); + + /* this pointer is returned to pkt miss function */ + ret_ptr = &napt_hash_tbl_entries[position]; + + p_nat->n_cgnapt_entry_added++; + p_nat->dynCgnaptCount++; + + /* Now modify the forward port for reverse entry */ + + /* outgoing port info */ + //entry.head.port_id = CGNAPT_PRV_PORT_ID; + /* outgoing port info */ + entry.head.port_id = entry.data.prv_phy_port; + + int32_t position2 = rte_hash_add_key(napt_common_table, &second_key); + + if (position2 < 0) { + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount9++; + #endif + printf("CG-NAPT entry reverse bulk add failed ..." + "returning with fwd add ...%d\n", + position2); + *err = 1; + return NULL; + } + + memcpy(&napt_hash_tbl_entries[position2], &entry, + sizeof(struct cgnapt_table_entry)); + + entry_ptr = &napt_hash_tbl_entries[position2]; + + timer_thread_enqueue(key, &second_key, ret_ptr, + entry_ptr, (struct pipeline *)p_nat); + + p_nat->n_cgnapt_entry_added++; + p_nat->dynCgnaptCount++; + + if (p_nat->pkt_burst_cnt < RTE_PORT_IN_BURST_SIZE_MAX) { + memcpy(&p_nat->cgnapt_dyn_ent_table[p_nat->pkt_burst_cnt], key, + sizeof(struct pipeline_cgnapt_entry_key)); + p_nat->cgnapt_dyn_ent_index[p_nat->pkt_burst_cnt] = position; + p_nat->pkt_burst_cnt++; + } + return ret_ptr; +} + +int pkt_miss_cgnapt_count; +/** + * Function handle a missed NAPT entry lookup + * Will attempt to add a dynamic entry pair. + * + * @param p + * A pointer to struct pipeline + * @param key + * A pointer to struct pipeline_cgnapt_entry_key + * @param pkt + * A pointer to pkt struct rte_mbuf + * @param pkt_mask + * uint64_t pointer to pkt mask + * @param table_entry + * A pointer to struct rte_pipeline_table_entry to be created and returned + * @param pkt_num + * number of this pkt in current burst + * + * @return + * A uint64_t mask for drop packets + */ +uint64_t +pkt_miss_cgnapt(struct pipeline_cgnapt_entry_key *key, + struct rte_mbuf *pkt, + struct rte_pipeline_table_entry **table_entry, + __rte_unused uint64_t *pkts_mask, + uint32_t pkt_num, void *arg) +{ + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 0) + printf("\n pkt_miss_cgnapt\n"); + #endif + /* In egress case + * get src address + * see if get_port passes for this src address + * if passed add a new egress entry and a + * corresponding new ingress entry + * return the fwd entry to calling function using input pointer + * else if get_port fails drop packet + */ + + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)arg; + + uint32_t eth_proto_offset = MBUF_HDR_ROOM + 12; + uint32_t src_addr_offset_ipv6 = + MBUF_HDR_ROOM + ETH_HDR_SIZE + IPV6_HDR_SRC_ADR_OFST; + uint16_t phy_port = pkt->port; + + uint16_t *eth_proto = + RTE_MBUF_METADATA_UINT16_PTR(pkt, eth_proto_offset); + + uint8_t *src_addr = NULL; + uint8_t src_addr_ipv6[16]; + uint8_t pkt_type = CGNAPT_ENTRY_IPV4; + /* To drop the packet */ + uint64_t drop_mask = 0; + + if (p_nat->is_static_cgnapt) { + drop_mask |= 1LLU << pkt_num; + p_nat->missedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount1++; + #endif + return drop_mask; + } + + if (rte_be_to_cpu_16(*eth_proto) == ETHER_TYPE_IPv6) { + src_addr = + RTE_MBUF_METADATA_UINT8_PTR(pkt, src_addr_offset_ipv6); + pkt_type = CGNAPT_ENTRY_IPV6; + memcpy(src_addr_ipv6, src_addr, 16); + } + + uint8_t err = 0; + + /* some validation first */ + if (is_phy_port_privte(phy_port)) { + /* dynamic NAPT entry creation */ + *table_entry = (struct rte_pipeline_table_entry *) + add_dynamic_cgnapt_entry( + (struct pipeline *)&p_nat->p, + key, + DYNAMIC_CGNAPT_TIMEOUT, + pkt_type, + src_addr_ipv6, &err); + + if (!(*table_entry)) { + if (err) { + drop_mask |= 1LLU << pkt_num; + p_nat->missedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount2++; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("Add Dynamic NAT entry failed " + "in pkt!!!\n"); + #endif + } else { + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount11++; + #endif + } + + } + + } else if (!is_phy_port_privte(phy_port)) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 2) { + printf("Initial Ingress entry creation NOT ALLOWED " + "%d\n", phy_port); + } + #endif + + drop_mask |= 1LLU << pkt_num; + p_nat->missedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount3++; + #endif + } else { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 1) + printf("NOT a PRIVATE or PUBLIC port!!!!!\n"); + #endif + + drop_mask |= 1LLU << pkt_num; + p_nat->missedPktCount++; + + #ifdef CGNAPT_DEBUGGING + p_nat->missedpktcount4++; + #endif + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 5) + print_pkt(pkt); + #endif + + return drop_mask; +} + +int numprints; + +/** + * Function to print the contents of a packet + * + * @param pkt + * A pointer to pkt struct rte_mbuf + */ +void print_pkt(struct rte_mbuf *pkt) +{ + int i = 0, j = 0; + + printf("\nPacket Contents:\n"); + + uint8_t *rd = RTE_MBUF_METADATA_UINT8_PTR(pkt, 0); + + for (i = 0; i < 20; i++) { + for (j = 0; j < 20; j++) + printf("%02x ", rd[(20 * i) + j]); + + printf("\n"); + } +} + +rte_table_hash_op_hash cgnapt_hash_func[] = { + hash_default_key8, + hash_default_key16, + hash_default_key24, + hash_default_key32, + hash_default_key40, + hash_default_key48, + hash_default_key56, + hash_default_key64 +}; + +/** + * Function to parse incoming pipeline arguments + * Called during pipeline initialization + * + * @param p + * A pointer to struct pipeline_cgnapt + * @param params + * A pointer to struct pipeline_params + * + * @return + * 0 if success, negative if failure + */ +static int +pipeline_cgnapt_parse_args(struct pipeline_cgnapt *p, + struct pipeline_params *params) +{ + uint32_t n_flows_present = 0; + uint32_t key_offset_present = 0; + uint32_t key_size_present = 0; + uint32_t hash_offset_present = 0; + uint32_t n_entries_present = 0; + uint32_t max_port_present = 0; + uint32_t max_client_present = 0; + uint32_t public_ip_range_present = 0; + uint32_t public_ip_port_range_present = 0; + uint32_t i; + uint8_t public_ip_count = 0; + uint8_t public_ip_range_count = 0; + uint8_t dest_if_offset_present = 0; + uint8_t cgnapt_meta_offset_present = 0; + uint8_t prv_que_handler_present = 0; + uint8_t n_prv_in_port = 0; + + if (CGNAPT_DEBUG > 2) { + printf("CGNAPT pipeline_cgnapt_parse_args params->n_args: %d\n", + params->n_args); + } + for (i = 0; i < params->n_args; i++) { + char *arg_name = params->args_name[i]; + char *arg_value = params->args_value[i]; + + if (CGNAPT_DEBUG > 2) { + printf("CGNAPT args[%d]: %s %d, %s\n", i, arg_name, + atoi(arg_value), arg_value); + } + if (strcmp(arg_name, "prv_que_handler") == 0) { + + if (prv_que_handler_present) { + printf("Duplicate pktq_in_prv ..\n\n"); + return -1; + } + prv_que_handler_present = 1; + n_prv_in_port = 0; + + char *token; + int rxport = 0; + /* get the first token */ + token = strtok(arg_value, "("); + token = strtok(token, ")"); + token = strtok(token, ","); + printf("***** prv_que_handler *****\n"); + + if (token == NULL) { + printf("string is null\n"); + printf("invalid prv_que_handler value/n"); + return -1; + } + printf("string is :%s\n", token); + + /* walk through other tokens */ + while (token != NULL) { + printf(" %s\n", token); + rxport = atoi(token); + cgnapt_prv_que_port_index[n_prv_in_port++] = + rxport; + if (rxport < PIPELINE_MAX_PORT_IN) + cgnapt_in_port_egress_prv[rxport] = 1; + token = strtok(NULL, ","); + } + + if (n_prv_in_port == 0) { + printf("VNF common parse err - " + "no prv RX phy port\n"); + return -1; + } + continue; + } + + if (strcmp(arg_name, "cgnapt_meta_offset") == 0) { + if (cgnapt_meta_offset_present) { + printf("CG-NAPT parse error:"); + printf("cgnapt_meta_offset initizlized " + "mulitple times\n"); + return -1; + } + cgnapt_meta_offset_present = 1; + int temp; + temp = atoi(arg_value); + + if (temp > 256) { + printf("cgnapt_meta_offset is invalid :"); + printf("Not be more than metadata size\n"); + return -1; + } + cgnapt_meta_offset = (uint16_t) temp; + } + if (strcmp(arg_name, "vnf_set") == 0) + vnf_set_count++; + + if (strcmp(arg_name, "public_ip_range") == 0) { + public_ip_range_present = 1; + if (public_ip_port_range_present) { + printf("CG-NAPT parse error:"); + printf("public_ip_range with " + "public_ip_port_range_present\n"); + return -1; + } + + p->pub_ip_range = rte_realloc(p->pub_ip_range, + sizeof(struct + pub_ip_range), + RTE_CACHE_LINE_SIZE); + + if (!p->pub_ip_range) { + printf("Memory allocation failed for " + "pub_ip_range\n"); + return -1; + } + + uint32_t sip = 0, eip = 0; + + if (sscanf(arg_value, "(%x,%x)", &sip, &eip) != 2) { + printf("public_ip_range is invalid\n"); + return -1; + } + + if (sip <= 0 || eip <= 0 || sip >= eip) { + printf("public_ip_range is invalid %x-%x\n", + sip, eip); + return -1; + } + + printf("public_ip_range: %d-%d\n", + p->pub_ip_range[public_ip_range_count]. + start_ip = sip, + p->pub_ip_range[public_ip_range_count]. + end_ip = eip); + + p->pub_ip_range_count = ++public_ip_range_count; + continue; + } + + if (strcmp(arg_name, "public_ip_port_range") == 0) { + public_ip_port_range_present = 1; + if (nat_only_config_flag || public_ip_range_present) { + + printf("CG-NAPT parse error:"); + printf("nat_only_config_flag OR "); + printf("public_ip_range_present with " + "public_ip_port_range_present\n"); + return -1; + } + + p->pub_ip_port_set = rte_realloc( + p->pub_ip_port_set, + sizeof(struct pub_ip_port_set), + RTE_CACHE_LINE_SIZE); + + if (!p->pub_ip_port_set) { + printf("Memory allocation failed for " + "public IP\n"); + return -1; + } + + uint32_t ip = 0; + int sp = 0, ep = 0; + + if (sscanf(arg_value, "%x:(%d,%d)", + &ip, &sp, &ep) != 3) { + printf("Public IP or Port-range is invalid\n"); + return -1; + } + + if (ip <= 0 || sp <= 0 || ep <= 0 || sp > ep) { + printf("Public IP or Port-range is invalid " + "%x:%d-%d\n", ip, sp, ep); + return -1; + } + + printf("public_ip: 0x%x Range:%d-%d\n", + p->pub_ip_port_set[public_ip_count].ip = ip, + p->pub_ip_port_set[public_ip_count].start_port = sp, + p->pub_ip_port_set[public_ip_count].end_port = ep); + + napt_port_alloc_elem_count += (ep - sp + 1); + printf("parse - napt_port_alloc_elem_count :%d\n", + napt_port_alloc_elem_count); + + /* Store all public IPs of all CGNAPT threads + * in the global variable + */ + /* to revisit indexing */ + all_public_ip[rte_jhash(&ip, 4, 0) % + CGNAPT_MAX_PUB_IP].ip = ip; + p->pub_ip_count = ++public_ip_count; + printf("public_ip_count:%d hash:%d\n", public_ip_count, + rte_jhash(&ip, 4, 0) % CGNAPT_MAX_PUB_IP); + continue; + } + + /* hw_checksum_reqd */ + if (strcmp(arg_name, "hw_checksum_reqd") == 0) { + int temp; + temp = atoi(arg_value); + if ((temp != 0) && (temp != 1)) { + printf("hw_checksum_reqd is invalid\n"); + return -1; + } + p->hw_checksum_reqd = temp; + continue; + } + + /* nat_only_config_flag */ + if (strcmp(arg_name, "nat_only_config_flag") == 0) { + nat_only_config_flag = 1; + if (public_ip_port_range_present) { + + printf("CG-NAPT parse error:"); + printf("nat_only_config_flag with " + "public_ip_port_range_present\n"); + return -1; + } + continue; + } + + /* max_port_per_client */ + if (strcmp(arg_name, "max_port_per_client") == 0) { + if (max_port_present) { + printf("CG-NAPT Parse Error: " + "duplicate max_port_per_client\n"); + return -1; + } + max_port_present = 1; + + int max = 0; + max = atoi(arg_value); + if (max <= 0) { + printf("max_port_per_client is invalid !!!\n"); + return -1; + } + + p->max_port_per_client = (uint16_t) max; + + if (p->max_port_per_client <= 0) { + printf("max port per client is invalid\n"); + return -1; + } + + printf("max_port_per_client comp: %d\n", + p->max_port_per_client); + continue; + } + + /* max_clients_per_ip */ + if (strcmp(arg_name, "max_clients_per_ip") == 0) { + if (max_client_present) { + printf("CG-NAPT parse Error: duplicate " + "max_clients_per_ip\n"); + return -1; + } + max_client_present = 1; + + if (nat_only_config_flag) { + printf("CG-NAPT parse error:"); + printf("nat_only_config_flag with " + "max_clients_per_ip\n"); + return -1; + } + + int max = 0; + max = atoi(arg_value); + if (max <= 0) { + printf("max_clients_per_ip is invalid !!!\n"); + return -1; + } + + p->max_clients_per_ip = (uint16_t) max; + + if (p->max_clients_per_ip <= 0) { + printf("max_clients_per_ip is invalid\n"); + return -1; + } + + printf("max_clients_per_ip: %d\n", + p->max_clients_per_ip); + continue; + } + + /* n_entries */ + if (strcmp(arg_name, "n_entries") == 0) { + if (n_entries_present) + return -1; + n_entries_present = 1; + + p->n_entries = atoi(arg_value); + if (p->n_entries == 0) + return -1; + + continue; + } + + /* n_flows */ + if (strcmp(arg_name, "n_flows") == 0) { + if (n_flows_present) + return -1; + n_flows_present = 1; + + p->n_flows = atoi(arg_value); + if (p->n_flows == 0) + return -1; + + napt_common_table_hash_params.entries = p->n_flows; + continue; + } + /* dest_if_offset Multiport Changes */ + if (strcmp(arg_name, "dest_if_offset") == 0) { + if (dest_if_offset_present) + return -1; + //dest_if_offset_present = 1; + + dest_if_offset = atoi(arg_value); + + continue; + } + + /* key_offset */ + if (strcmp(arg_name, "key_offset") == 0) { + if (key_offset_present) + return -1; + key_offset_present = 1; + + p->key_offset = atoi(arg_value); + + continue; + } + + /* key_size */ + if (strcmp(arg_name, "key_size") == 0) { + if (key_size_present) + return -1; + key_size_present = 1; + + p->key_size = atoi(arg_value); + if ((p->key_size == 0) || + (p->key_size > PIPELINE_CGNAPT_KEY_MAX_SIZE) || + (p->key_size % 8)) + return -1; + + continue; + } + + /* hash_offset */ + if (strcmp(arg_name, "hash_offset") == 0) { + if (hash_offset_present) + return -1; + hash_offset_present = 1; + + p->hash_offset = atoi(arg_value); + + continue; + } + + /* traffic_type */ + if (strcmp(arg_name, "pkt_type") == 0) { + if (strcmp(arg_value, "ipv4") == 0) { + p->traffic_type = TRAFFIC_TYPE_IPV4; + printf("Traffic is set to IPv4\n"); + } else if (strcmp(arg_value, "ipv6") == 0) { + p->traffic_type = TRAFFIC_TYPE_IPV6; + printf("Traffic is set to IPv6\n"); + } + continue; + } + + /* cgnapt_debug */ + if (strcmp(arg_name, "cgnapt_debug") == 0) { + CGNAPT_DEBUG = atoi(arg_value); + + continue; + } + + /* any other Unknown argument return -1 */ + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + if (!public_ip_range_count) { + printf("No public_ip_range %d for NAT only config.\n", + public_ip_range_count); + printf("Running static NAT only configuration\n"); + p->is_static_cgnapt = 1; + } + } + #else + + if (!p->max_port_per_client) + p->is_static_cgnapt = 1; + #endif + + /* Check that mandatory arguments are present */ + if ((n_flows_present == 0) || + (cgnapt_meta_offset_present == 0)) + return -1; + + return 0; + +} + +/** + * Function to initialize the pipeline + * + * @param params + * A pointer to struct pipeline_params + * @param arg + * Void pointer - points to app params + * + * @return + * void pointer to the pipeline, NULL 0 if failure + */ +static void *pipeline_cgnapt_init(struct pipeline_params *params, void *arg) + /* (struct app_params *app) save it for use in port in handler */ +{ + struct pipeline *p; + struct pipeline_cgnapt *p_nat; + uint32_t size, i, in_ports_arg_size; + + /* Check input arguments */ + if ((params == NULL) || + (params->n_ports_in == 0) || (params->n_ports_out == 0)) + return NULL; + + /* Memory allocation */ + size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct pipeline_cgnapt)); + p = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE); + p_nat = (struct pipeline_cgnapt *)p; + if (p == NULL) + return NULL; + + all_pipeline_cgnapt[n_cgnapt_pipeline++] = p_nat; + + strcpy(p->name, params->name); + p->log_level = params->log_level; + + PLOG(p, HIGH, "CG-NAPT"); + /* Initialize all counters and arrays */ + + p_nat->n_cgnapt_entry_deleted = 0; + p_nat->n_cgnapt_entry_added = 0; + p_nat->naptedPktCount = 0; + p_nat->naptDroppedPktCount = 0; + p_nat->inaptedPktCount = 0; + p_nat->enaptedPktCount = 0; + p_nat->receivedPktCount = 0; + p_nat->missedPktCount = 0; + p_nat->dynCgnaptCount = 0; + p_nat->arpicmpPktCount = 0; + + p_nat->app_params_addr = (uint64_t) arg; + for (i = 0; i < PIPELINE_MAX_PORT_IN; i++) { + p_nat->links_map[i] = 0xff; + p_nat->outport_id[i] = 0xff; + cgnapt_in_port_egress_prv[i] = 0; + cgnapt_prv_que_port_index[i] = 0; + } + p_nat->pipeline_num = 0xff; + p_nat->hw_checksum_reqd = 0; + p_nat->pub_ip_port_set = NULL; + p_nat->pub_ip_count = 0; + p_nat->traffic_type = TRAFFIC_TYPE_MIX; + p_nat->vnf_set = 0xff; + + /* For every init it should be reset */ + napt_port_alloc_elem_count = 0; + + #ifdef CGNAPT_TIMING_INST + p_nat->in_port_exit_timestamp = 0; + p_nat->external_time_sum = 0; + p_nat->internal_time_sum = 0; + p_nat->time_measurements = 0; + p_nat->max_time_mesurements = 10000; + p_nat->time_measurements_on = 0; + #endif + + #ifdef CGNAPT_DEBUGGING + + p_nat->naptDebugCount = 0; + + p_nat->naptDroppedPktCount1 = 0; + p_nat->naptDroppedPktCount2 = 0; + p_nat->naptDroppedPktCount3 = 0; + p_nat->naptDroppedPktCount4 = 0; + p_nat->naptDroppedPktCount5 = 0; + p_nat->naptDroppedPktCount6 = 0; + + p_nat->missedpktcount1 = 0; + p_nat->missedpktcount2 = 0; + p_nat->missedpktcount3 = 0; + p_nat->missedpktcount4 = 0; + p_nat->missedpktcount5 = 0; + p_nat->missedpktcount6 = 0; + p_nat->missedpktcount7 = 0; + p_nat->missedpktcount8 = 0; + p_nat->missedpktcount9 = 0; + p_nat->missedpktcount10 = 0; + p_nat->missedpktcount11 = 0; + p_nat->missedpktcount12 = 0; + + p_nat->max_port_dec_err1 = 0; + p_nat->max_port_dec_err2 = 0; + p_nat->max_port_dec_err3 = 0; + p_nat->max_port_dec_success = 0; + + p_nat->pfb_err = 0; + p_nat->pfb_ret = 0; + p_nat->pfb_get = 0; + p_nat->pfb_suc = 0; + p_nat->gfp_suc = 0; + p_nat->gfp_get = 0; + p_nat->gfp_ret = 0; + p_nat->gfp_err = 0; + + p_nat->kpc2 = 0; + p_nat->kpc1 = 0; + #endif + + #ifdef SIP_ALG + static int sip_enabled; + if (!sip_enabled) + lib_sip_alg_init(); + sip_enabled = 1; + #endif /* SIP_ALG */ + + /*struct rte_pipeline_table_entry *entries[RTE_HASH_LOOKUP_BULK_MAX];*/ + /* bitmap of valid packets */ + p_nat->valid_packets = 0; + /* bitmap of invalid packets to be dropped */ + p_nat->invalid_packets = 0; + + for (i = 0; i < RTE_HASH_LOOKUP_BULK_MAX; i++) + p_nat->key_ptrs[i] = &(p_nat->keys[i]); + + p_nat->port_alloc_ring = NULL; + + /* Parse arguments */ + if (pipeline_cgnapt_parse_args(p_nat, params)) + return NULL; + + p_nat->vnf_set = vnf_set_count; + + /* Pipeline */ + { + struct rte_pipeline_params pipeline_params = { + .name = params->name, + .socket_id = params->socket_id, + .offset_port_id = cgnapt_meta_offset, + }; + + p->p = rte_pipeline_create(&pipeline_params); + if (p->p == NULL) { + rte_free(p); + return NULL; + } + myP = p->p; + } + + #ifdef PIPELINE_CGNAPT_INSTRUMENTATION + + uint32_t instr_size = + RTE_CACHE_LINE_ROUNDUP((sizeof(uint64_t)) * + (INST_ARRAY_SIZE)); + inst_start_time = + (uint64_t *) rte_zmalloc(NULL, instr_size, + RTE_CACHE_LINE_SIZE); + inst_end_time = + (uint64_t *) rte_zmalloc(NULL, instr_size, + RTE_CACHE_LINE_SIZE); + inst_diff_time = + (uint32_t *) rte_zmalloc(NULL, instr_size / 2, + RTE_CACHE_LINE_SIZE); + if ((inst_start_time == NULL) || (inst_end_time == NULL) + || (inst_diff_time == NULL)) { + printf("Inst array alloc failed .... "); + return NULL; + } + #endif + + /* Memory allocation for in_port_h_arg */ + in_ports_arg_size = RTE_CACHE_LINE_ROUNDUP( + (sizeof(struct pipeline_cgnapt_in_port_h_arg)) * + (params->n_ports_in)); + struct pipeline_cgnapt_in_port_h_arg *ap = + (struct pipeline_cgnapt_in_port_h_arg *) + rte_zmalloc(NULL, + in_ports_arg_size, + RTE_CACHE_LINE_SIZE); + if (ap == NULL) + return NULL; + + myApp = (struct app_params *) arg; + + /* Input ports */ + p->n_ports_in = params->n_ports_in; + for (i = 0; i < p->n_ports_in; i++) { + /* passing our cgnapt pipeline in call back arg */ + (ap[i]).p = p_nat; + (ap[i]).in_port_id = i; + + struct rte_pipeline_port_in_params port_params = { + .ops = + pipeline_port_in_params_get_ops(¶ms->port_in + [i]), + .arg_create = + pipeline_port_in_params_convert(¶ms->port_in + [i]), + .f_action = cgnapt_in_port_ah_mix, + .arg_ah = &(ap[i]), + .burst_size = params->port_in[i].burst_size, + }; + + #ifdef PIPELINE_CGNAPT_INSTRUMENTATION + if (i == 0) + instrumentation_port_in_arg = &(ap[i]); + #endif + + if (p_nat->traffic_type == TRAFFIC_TYPE_IPV4) { + /* Private in-port handler */ + /* Multiport changes */ + if (cgnapt_in_port_egress_prv[i]) { + port_params.f_action = + cgnapt_in_port_ah_ipv4_prv; + printf("CGNAPT port %d is IPv4 Prv\n", i); + } else{ + port_params.f_action = + cgnapt_in_port_ah_ipv4_pub; + printf("CGNAPT port %d is IPv4 Pub\n", i); + } + } + + if (p_nat->traffic_type == TRAFFIC_TYPE_IPV6) { + if (cgnapt_in_port_egress_prv[i]) { + port_params.f_action = + cgnapt_in_port_ah_ipv6_prv; + printf("CGNAPT port %d is IPv6 Prv\n", i); + } else{ + port_params.f_action = + cgnapt_in_port_ah_ipv6_pub; + printf("CGNAPT port %d is IPv6 Pub\n", i); + } + } + + int status = rte_pipeline_port_in_create(p->p, + &port_params, + &p->port_in_id[i]); + + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + + } + + /* Output ports */ + p->n_ports_out = params->n_ports_out; + for (i = 0; i < p->n_ports_out; i++) { + struct rte_pipeline_port_out_params port_params = { + .ops = pipeline_port_out_params_get_ops( + ¶ms->port_out[i]), + .arg_create = pipeline_port_out_params_convert( + ¶ms->port_out[i]), + #ifdef PIPELINE_CGNAPT_INSTRUMENTATION + .f_action = port_out_ah_cgnapt, + #else + .f_action = NULL, + #endif + .arg_ah = NULL, + }; + + int status = rte_pipeline_port_out_create(p->p, + &port_params, + &p->port_out_id[i]); + + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + } + + int pipeline_num = 0; + int ignore; + ignore = sscanf(params->name, "PIPELINE%d", &pipeline_num); + if (ignore != 1) { + printf("Not able to read pipeline number\n"); + return NULL; + } + p_nat->pipeline_num = (uint8_t) pipeline_num; + register_pipeline_Qs(p_nat->pipeline_num, p); + set_link_map(p_nat->pipeline_num, p, p_nat->links_map); + set_outport_id(p_nat->pipeline_num, p, p_nat->outport_id); + + /* Tables */ + p->n_tables = 1; + { + + if (napt_common_table == NULL) { + if (create_napt_common_table(p_nat->n_flows)) { + PLOG(p, HIGH, + "CG-NAPT create_napt_common_table failed."); + return NULL; + } + } + + struct rte_pipeline_table_params table_params = { + .ops = &rte_table_stub_ops, + .arg_create = NULL, + .f_action_hit = NULL, + .f_action_miss = NULL, + .arg_ah = NULL, + .action_data_size = 0, + }; + + int status = rte_pipeline_table_create(p->p, + &table_params, + &p->table_id[0]); + + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + struct rte_pipeline_table_entry default_entry = { + .action = RTE_PIPELINE_ACTION_PORT_META + }; + struct rte_pipeline_table_entry *default_entry_ptr; + status = rte_pipeline_table_default_entry_add( + p->p, + p->table_id[0], + &default_entry, + &default_entry_ptr); + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + } + + /* Connecting input ports to tables */ + for (i = 0; i < p->n_ports_in; i++) { + int status = rte_pipeline_port_in_connect_to_table(p->p, + p->port_in_id + [i], + p->table_id + [0]); + + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + } + + /* Enable input ports */ + for (i = 0; i < p->n_ports_in; i++) { + int status = rte_pipeline_port_in_enable(p->p, + p->port_in_id[i]); + + if (status) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + } + + /* Check pipeline consistency */ + if (rte_pipeline_check(p->p) < 0) { + rte_pipeline_free(p->p); + rte_free(p); + return NULL; + } + + /* Message queues */ + p->n_msgq = params->n_msgq; + for (i = 0; i < p->n_msgq; i++) + p->msgq_in[i] = params->msgq_in[i]; + for (i = 0; i < p->n_msgq; i++) + p->msgq_out[i] = params->msgq_out[i]; + + /* Message handlers */ + memcpy(p->handlers, handlers, sizeof(p->handlers)); + memcpy(p_nat->custom_handlers, + custom_handlers, sizeof(p_nat->custom_handlers)); + + if (!p_nat->is_static_cgnapt) { + printf("Initializing dyn napt components ... %d\n", + p_nat->pipeline_num); + if (napt_port_alloc_init(p_nat) == -1) { + printf("Error - napt_port_alloc_init failed - %d\n", + p_nat->pipeline_num); + return NULL; + } + int rc = 0; + + if (max_port_per_client_hash == NULL) { + rc = init_max_port_per_client(p_nat); + if (rc < 0) { + printf("CGNAPT Error - " + "init_max_port_per_client failed %d", rc); + return NULL; + } + } + + } + + if (!icmp_pool_init) { + icmp_pool_init = 1; + /* create the arp_icmp mbuf rx pool */ + cgnapt_icmp_pktmbuf_tx_pool = + rte_pktmbuf_pool_create("icmp_mbuf_tx_pool", 63, 32, 0, + RTE_MBUF_DEFAULT_BUF_SIZE, + rte_socket_id()); + if (cgnapt_icmp_pktmbuf_tx_pool == NULL) { + PLOG(p, HIGH, "ICMP mbuf pool create failed."); + return NULL; + } + + cgnapt_icmp_pkt = + rte_pktmbuf_alloc(cgnapt_icmp_pktmbuf_tx_pool); + + if (cgnapt_icmp_pkt == NULL) { + printf("Failed to allocate cgnapt_icmp_pkt\n"); + return NULL; + } + } + + #ifdef CT_CGNAT + + cgnat_cnxn_tracker = rte_zmalloc(NULL, rte_ct_get_cnxn_tracker_size(), + RTE_CACHE_LINE_SIZE); + + if (cgnat_cnxn_tracker == NULL) { + printf("CGNAPT CT memory not allocated\n"); + return NULL; + } + rte_ct_initialize_default_timeouts(cgnat_cnxn_tracker); + + printf("CGNAPT CT Flows %d\n", p_nat->n_flows); + int ret; + ret = rte_ct_initialize_cnxn_tracker(cgnat_cnxn_tracker, + p_nat->n_flows, + "CGNAT_CT_COMMON_TABLE"); + if (ret == -1) + return NULL; + #endif + + #ifdef FTP_ALG + lib_ftp_alg_init(); + #endif + + #ifdef PCP_ENABLE + if (pcp_init() == PCP_INIT_SUCCESS) + printf("PCP contents are initialized successfully\n"); + else + printf("Error in initializing PCP contents\n"); + #endif + + return p; +} + +/** + * Function for pipeline cleanup + * + * @param pipeline + * A void pointer to pipeline + * + * @return + * 0 + */ +static int pipeline_cgnapt_free(void *pipeline) +{ + struct pipeline *p = (struct pipeline *)pipeline; + + /* Check input arguments */ + if (p == NULL) + return -1; + + /* Free resources */ + rte_pipeline_free(p->p); + rte_free(p); + return 0; +} + +static int +pipeline_cgnapt_track(void *pipeline, __rte_unused uint32_t port_in, + uint32_t *port_out) +{ + struct pipeline *p = (struct pipeline *)pipeline; + + /* Check input arguments */ + if ((p == NULL) || (port_in >= p->n_ports_in) || (port_out == NULL)) + return -1; + + if (p->n_ports_in == 1) { + *port_out = 0; + return 0; + } + + return -1; +} + +/** + * Function for pipeline timers + * + * @param pipeline + * A void pointer to pipeline + * + * @return + * 0 + */ +static int pipeline_cgnapt_timer(void *pipeline) +{ + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)pipeline; + + pipeline_msg_req_handle(&p_nat->p); + + rte_pipeline_flush(((struct pipeline *)p_nat)->p); + + return 0; +} + +/** + * Function for pipeline custom handlers + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_custom_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + struct pipeline_custom_msg_req *req = msg; + pipeline_msg_req_handler f_handle; + + f_handle = (req->subtype < PIPELINE_CGNAPT_MSG_REQS) ? + p_nat->custom_handlers[req->subtype] : + pipeline_msg_req_invalid_handler; + + if (f_handle == NULL) + f_handle = pipeline_msg_req_invalid_handler; + + return f_handle(p, req); +} + +/** + * Function for adding NSP data + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_nsp_add_handler( + __rte_unused struct pipeline *p, + void *msg) +{ + struct pipeline_cgnapt_nsp_add_msg_req *req = msg; + struct pipeline_cgnapt_nsp_add_msg_rsp *rsp = msg; + int size = 0; + struct cgnapt_nsp_node *node = NULL, *ll = nsp_ll; + + if (! + (req->nsp.depth == 32 || req->nsp.depth == 40 + || req->nsp.depth == 48 || req->nsp.depth == 56 + || req->nsp.depth == 64 || req->nsp.depth == 96)) { + rsp->status = 0xE; + rsp->key_found = 0; + return rsp; + } + + printf("be initial cond\n"); + if (nsp_ll == NULL) { + size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct cgnapt_nsp_node)); + node = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (node == NULL) { + printf("be 1st cond\n"); + rsp->status = 0xE; + rsp->key_found = 0; + return rsp; + } + + memcpy(&node->nsp, &req->nsp, + sizeof(struct pipeline_cgnapt_nsp_t)); + node->next = NULL; + nsp_ll = node; + } else { + while (ll != NULL) { + if (!memcmp(ll->nsp.prefix, req->nsp.prefix, 16) + && ll->nsp.depth == req->nsp.depth) { + printf("be 2st cond\n"); + rsp->status = 0xE; + rsp->key_found = 1; + return rsp; + } + ll = ll->next; + } + + size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct cgnapt_nsp_node)); + node = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (node == NULL) { + printf("be 3st cond\n"); + rsp->status = 0xE; + rsp->key_found = 0; + return rsp; + } + + memcpy(&node->nsp, &req->nsp, + sizeof(struct pipeline_cgnapt_nsp_t)); + node->next = nsp_ll; + nsp_ll = node; + } + + rsp->status = 0; + rsp->key_found = 0; + + printf("be 4st cond\n"); + return rsp; +} + +/** + * Function for deleting NSP data + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_nsp_del_handler( + __rte_unused struct pipeline *p, + void *msg) +{ + struct pipeline_cgnapt_nsp_del_msg_req *req = msg; + struct pipeline_cgnapt_nsp_del_msg_rsp *rsp = msg; + struct cgnapt_nsp_node *prev = NULL, *ll = nsp_ll; + + while (ll != NULL) { + if (!memcmp(ll->nsp.prefix, req->nsp.prefix, 16) + && ll->nsp.depth == req->nsp.depth) { + if (prev != NULL) + prev->next = ll->next; + else + nsp_ll = NULL; + + rte_free(ll); + + rsp->status = 0; + rsp->key_found = 1; + + return rsp; + } + + prev = ll; + ll = ll->next; + } + + rsp->status = 0xE; + rsp->key_found = 0; + + return rsp; +} + +/** + * Function for adding NAPT entry + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_entry_add_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt_entry_add_msg_req *req = msg; + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + uint8_t type = req->data.type; + uint32_t src_ip = (type == CGNAPT_ENTRY_IPV4) ? + req->data.u.prv_ip : + rte_bswap32(req->data.u.u32_prv_ipv6[3]); + + uint8_t src_ipv6[16]; + + uint32_t dest_ip = req->data.pub_ip; + uint16_t src_port = req->data.prv_port; + uint16_t dest_port = req->data.pub_port; + uint16_t rx_port = req->data.prv_phy_port; + uint32_t ttl = req->data.ttl; + + if (type == CGNAPT_ENTRY_IPV6) + memcpy(src_ipv6, req->data.u.prv_ipv6, 16); + + printf("CG-NAPT addm - PrvIP %x, PrvPort %d,", src_ip, src_port); + printf("PubIP %x, PubPort %d,", dest_ip, dest_port); + + printf("PhyPort %d, ttl %u,", rx_port, ttl); + printf("entry_type %d\n", type); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + if (!p_nat->is_static_cgnapt) { + int i; + + for (i = 0; i < p_nat->pub_ip_range_count; i++) { + if (((dest_ip >= p_nat->pub_ip_range[i].start_ip) + && (dest_ip <= p_nat->pub_ip_range[i].end_ip))) { + printf("Error - static port cannot be in Dynamic " + "port range"); + printf("%x-%x\n", p_nat->pub_ip_range[i].start_ip, + p_nat->pub_ip_range[i].end_ip); + return msg; + } + } + } + + if (pipeline_cgnapt_msg_req_entry_addm_pair(p, msg, + src_ip, src_port, + dest_ip, dest_port, + rx_port, ttl, + type, src_ipv6)) { + printf("Error - "); + printf("pipeline_cgnapt_msg_req_entry_addm_handler\n"); + return msg; + } + + printf("Success - pipeline_cgnapt_msg_req_entry_addm_handler"); + printf("added %d rule pairs.\n", count); + + return msg; + } + #endif + + if (!p_nat->is_static_cgnapt) { + int i; + + for (i = 0; i < p_nat->pub_ip_count; i++) { + /* Check port range if same Public-IP */ + if (dest_ip != p_nat->pub_ip_port_set[i].ip) + continue; + if (((dest_port >= p_nat->pub_ip_port_set[i].start_port) && + (dest_port <= p_nat->pub_ip_port_set[i].end_port))) { + printf("Error - port cannot be in Dynamic " + "port range %d-%d\n", + p_nat->pub_ip_port_set[i].start_port, + p_nat->pub_ip_port_set[i].end_port); + return msg; + } + } + } + + if (pipeline_cgnapt_msg_req_entry_addm_pair + (p, msg, src_ip, src_port, dest_ip, dest_port, rx_port, + ttl, type, src_ipv6)) { + printf("Error - pipeline_cgnapt_msg_req_entry_add_handler\n"); + return msg; + } + + + printf("\nSuccess - pipeline_cgnapt_msg_req_entry_add_handler " + "added\n"); + + return msg; +} + +/** + * Function for adding a NAPT entry pair + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * @param src_ip + * source ip address + * @param src_port + * source port + * @param dest_ip + * destination ip address + * @param dest_port + * destination port + * @param rx_port + * Physical receive port + * @param ttl + * time to live value + * @param type + * type of entry IPv4 vs IPv6 + * @param src_ipv6[] + * uint8_t array of IPv6 address + * + * @return + * 0 if success, negative if fails + */ +int +pipeline_cgnapt_msg_req_entry_addm_pair( + struct pipeline *p, __rte_unused void *msg, + uint32_t src_ip, uint16_t src_port, + uint32_t dest_ip, uint16_t dest_port, + uint16_t rx_port, uint32_t ttl, + uint8_t type, uint8_t src_ipv6[16]) +{ + + struct pipeline_cgnapt_entry_key key; + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + + key.ip = src_ip; + key.port = src_port; + key.pid = rx_port; + + struct cgnapt_table_entry entry = { + .head = { + .action = RTE_PIPELINE_ACTION_PORT, + .port_id = CGNAPT_PUB_PORT_ID, + }, + + .data = { + /*.prv_ip = src_ip, */ + .prv_port = src_port, + .pub_ip = dest_ip, + .pub_port = dest_port, + .prv_phy_port = rx_port, + .pub_phy_port = get_prv_to_pub_port(&dest_ip, + IP_VERSION_4), + .ttl = ttl, + .timeout = STATIC_CGNAPT_TIMEOUT, + #ifdef PCP_ENABLE + .timer = NULL, + #endif + } + }; + + if (type == CGNAPT_ENTRY_IPV4) { + entry.data.type = CGNAPT_ENTRY_IPV4; + entry.data.u.prv_ip = src_ip; + } else { + entry.data.type = CGNAPT_ENTRY_IPV6; + memcpy(entry.data.u.prv_ipv6, src_ipv6, 16); + } + + /* Also need to add a paired entry on our own */ + /* + * Need to change key + * Need to change entry header + * Will keep the same entry and take care + * of translation in table hit handler + */ + struct pipeline_cgnapt_entry_key second_key; + + /* Need to add a second ingress entry */ + second_key.ip = dest_ip; + second_key.port = dest_port; + second_key.pid = 0xffff; + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + key.port = 0xffff; + entry.data.pub_port = 0xffff; + second_key.port = 0xffff; + } + #endif + + if (CGNAPT_DEBUG > 2) + printf("key.ip %x, key.port %d", key.ip, key.port); + printf("key.pid %d, in_type %d,", key.pid, type); + printf("entry_type %d\n", entry.data.type); + + int32_t position = rte_hash_add_key(napt_common_table, &key); + + if (position < 0) { + printf("CG-NAPT entry bulk add failed"); + printf(" ... returning without adding ...\n"); + return -1; + } + + memcpy(&napt_hash_tbl_entries[position], &entry, + sizeof(struct cgnapt_table_entry)); + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc1++ < 5) + print_key(&key); + #endif + + p_nat->n_cgnapt_entry_added++; + + /* Now modify the forward port for reverse entry */ + entry.head.port_id = CGNAPT_PRV_PORT_ID; + + position = rte_hash_add_key(napt_common_table, &second_key); + + if (position < 0) { + printf("CG-NAPT entry reverse bulk add failed"); + printf(" ... returning with fwd add ...%d\n", position); + return 2; + } + + memcpy(&napt_hash_tbl_entries[position], &entry, + sizeof(struct cgnapt_table_entry)); + + #ifdef CGNAPT_DEBUGGING + if (p_nat->kpc1 < 5) + print_key(&second_key); + #endif + + p_nat->n_cgnapt_entry_added++; + return 0; +} + +/** + * Function for adding multiple NAPT entries + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_entry_addm_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt_entry_addm_msg_req *req = msg; + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + uint32_t uenum = 0; + uint32_t max_ue = req->data.num_ue; + uint8_t type = req->data.type; + uint32_t src_ip = (type == CGNAPT_ENTRY_IPV4) ? + req->data.u.prv_ip : + rte_bswap32(req->data.u.u32_prv_ipv6[3]); + + uint8_t src_ipv6[16]; + + uint32_t dest_ip = req->data.pub_ip; + uint16_t src_port = req->data.prv_port; + uint16_t dest_port = req->data.pub_port; + uint16_t rx_port = req->data.prv_phy_port; + uint32_t ttl = req->data.ttl; + uint16_t max_src_port = req->data.prv_port_max; + uint16_t max_dest_port = req->data.pub_port_max; + uint32_t count = 0; + uint16_t src_port_start = src_port; + uint16_t dest_port_start = dest_port; + uint32_t src_ip_temp; + + if (type == CGNAPT_ENTRY_IPV6) + memcpy(src_ipv6, req->data.u.prv_ipv6, 16); + + printf("CG-NAPT addm - PrvIP %x, PrvPort %d,", src_ip, src_port); + printf("PubIP %x, PubPort %d,", dest_ip, dest_port); + printf("PhyPort %d, ttl %u, NumUe %d,", rx_port, ttl, max_ue); + printf("mPrvPort %d, mPubPort %d,", max_src_port, max_dest_port); + printf("entry_type %d\n", type); + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) { + if (!p_nat->is_static_cgnapt) { + int i; + + for (i = 0; i < p_nat->pub_ip_range_count; i++) { + if (((dest_ip >= p_nat->pub_ip_range[i].start_ip) + && (dest_ip <= p_nat->pub_ip_range[i].end_ip)) || + (((dest_ip + max_ue) >= + p_nat->pub_ip_range[i].start_ip) && + ((dest_ip + max_ue) <= + p_nat->pub_ip_range[i].end_ip))) { + printf("Error - static port cannot be in Dynamic " + "port range"); + printf("%x-%x\n", p_nat->pub_ip_range[i].start_ip, + p_nat->pub_ip_range[i].end_ip); + + return msg; + } + } + } + + for (uenum = 0; uenum < max_ue; uenum++) { + + if (pipeline_cgnapt_msg_req_entry_addm_pair(p, msg, + src_ip, src_port, + dest_ip, dest_port, + rx_port, ttl, + type, src_ipv6)) { + printf("Error - "); + printf("pipeline_cgnapt_msg_req_entry_addm_handler\n"); + return msg; + } + + count++; + + src_ip++; + dest_ip++; + } + + printf("Success - pipeline_cgnapt_msg_req_entry_addm_handler"); + printf("added %d rule pairs.\n", count); + + return msg; + } + #endif + + if (!p_nat->is_static_cgnapt) { + int i; + + for (i = 0; i < p_nat->pub_ip_count; i++) { + /* Check port range if same Public-IP */ + if (dest_ip != p_nat->pub_ip_port_set[i].ip) + continue; + if (((dest_port >= p_nat->pub_ip_port_set[i].start_port) && + (dest_port <= p_nat->pub_ip_port_set[i].end_port)) || + ((max_dest_port >= p_nat->pub_ip_port_set[i].start_port) + && max_dest_port <= p_nat->pub_ip_port_set[i].end_port)) { + printf("Error - port cannot be in Dynamic port range %d-%d\n", + p_nat->pub_ip_port_set[i].start_port, + p_nat->pub_ip_port_set[i].end_port); + return msg; + } + } + } + + for (uenum = 0; uenum < max_ue; uenum++) { + if (pipeline_cgnapt_msg_req_entry_addm_pair + (p, msg, src_ip, src_port, dest_ip, dest_port, rx_port, + ttl, type, src_ipv6)) { + printf("Error - pipeline_cgnapt_msg_req_entry_addm_handler\n"); + return msg; + } + + count++; + + src_port++; + if (src_port > max_src_port) { + src_port = src_port_start; + src_ip++; + if (req->data.type == CGNAPT_ENTRY_IPV6) { + src_ip_temp = rte_bswap32(src_ip); + memcpy(&src_ipv6[12], &src_ip_temp, 4); + } + } + dest_port++; + if (dest_port > max_dest_port) { + dest_port = dest_port_start; + dest_ip++; + } + } + + printf("\nSuccess - pipeline_cgnapt_msg_req_entry_addm_handler added"); + printf("%d rule pairs.\n", count); + + return msg; +} + +/** + * Function for deleting NAPT entry + * + * @param pipeline + * A void pointer to pipeline + * @param msg + * void pointer for incoming data + * + * @return + * void pointer of response + */ +void *pipeline_cgnapt_msg_req_entry_del_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt_entry_delete_msg_req *req = msg; + struct pipeline_cgnapt_entry_delete_msg_rsp *rsp = msg; + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + + if (CGNAPT_DEBUG) { + uint8_t *KeyP = (void *)(&req->key); + int i = 0; + + printf("pipeline_cgnapt_msg_req_entry_del_handler - Key: "); + for (i = 0; i < (int)sizeof(struct pipeline_cgnapt_entry_key); + i++) + printf(" %02x", KeyP[i]); + printf(" ,KeySize %u\n", + (int)sizeof(struct pipeline_cgnapt_entry_key)); + } + + struct cgnapt_table_entry entry; + + /* If ingress key */ + if (!is_phy_port_privte(req->key.pid)) + req->key.pid = 0xffff; + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + req->key.port = 0xffff; + #endif + + int32_t position; + position = rte_hash_lookup(napt_common_table, &req->key); + if (position == -ENOENT) { + printf("Entry not found\n"); + return NULL; + } + memcpy(&entry, &napt_hash_tbl_entries[position], + sizeof(struct cgnapt_table_entry)); + position = rte_hash_del_key(napt_common_table, &req->key); + p_nat->n_cgnapt_entry_deleted++; + + struct pipeline_cgnapt_entry_key second_key; + + if (is_phy_port_privte(req->key.pid)) { + /* key is for egress - make second key for ingress */ + second_key.ip = entry.data.pub_ip; + second_key.port = entry.data.pub_port; + second_key.pid = 0xffff; + + } else { + /* key is for ingress - make second key for egress */ + second_key.ip = entry.data.u.prv_ip; + second_key.port = entry.data.prv_port; + second_key.pid = entry.data.prv_phy_port; + } + + #ifdef NAT_ONLY_CONFIG_REQ + if (nat_only_config_flag) + second_key.port = 0xffff; + #endif + + position = rte_hash_del_key(napt_common_table, &second_key); + p_nat->n_cgnapt_entry_deleted++; + + return rsp; +} + +void *pipeline_cgnapt_msg_req_entry_sync_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt_entry_delete_msg_req *req = msg; + struct pipeline_cgnapt_entry_delete_msg_rsp *rsp = msg; + + rsp->status = rte_pipeline_table_entry_delete( + p->p, + p->table_id[0], + &req->key, + &rsp->key_found, NULL); + + return rsp; +} + +/** + * Function to print the NAPT key + * + * @param key + * A pointer to struct pipeline_cgnapt_entry_key + */ +void print_key(struct pipeline_cgnapt_entry_key *key) +{ + uint8_t *KeyP = (void *)(key); + int i = 0; + + printf("\nKey: "); + for (i = 0; i < (int)sizeof(struct pipeline_cgnapt_entry_key); i++) + printf(" %02x", KeyP[i]); +} + +/** + * Function to print the table entry + * + * @param entry + * A pointer to struct rte_pipeline_table_entry + */ +void print_entry1(struct rte_pipeline_table_entry *entry) +{ + uint8_t *entryP = (void *)(entry); + int i = 0; + + printf("Entry: "); + for (i = 0; i < (int)sizeof(struct rte_pipeline_table_entry); i++) + printf(" %02x", entryP[i]); +} + +/** + * Function to print the NAPT table entry + * + * @param entry + * A pointer to struct cgnapt_table_entry + */ +void print_cgnapt_entry(struct cgnapt_table_entry *entry) +{ + uint8_t *entryP = (void *)(entry); + int i = 0; + + printf("CGNAPT Entry: "); + for (i = 0; i < (int)sizeof(struct cgnapt_table_entry); i++) + printf(" %02x", entryP[i]); + printf(" size:%d\n", (int)sizeof(struct cgnapt_table_entry)); +} + +/** + * Function to get a free port + * + * @param p_nat + * A pointer to struct pipeline_cgnapt + * @param public_ip + * A uint32_t pointer to return corresponding ip address + * + * @return + * free port number, 0 if error + */ +int get_free_iport(struct pipeline_cgnapt *p_nat, uint32_t *public_ip) +{ + int port = -1; + /* If we don't have a valid napt_port_alloc_elem get one from + * port_alloc_ring + */ + if (p_nat->allocated_ports == NULL) { + void *ports; + int ret; + + ret = rte_ring_dequeue(p_nat->port_alloc_ring, &ports); + if (ret == 0) { + p_nat->allocated_ports = + (struct napt_port_alloc_elem *)ports; + + #ifdef CGNAPT_DEBUGGING + p_nat->gfp_get++; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 3) + printf("p_nat->allocated_ports %p\n", + p_nat->allocated_ports); + #endif + } else { + printf("CGNAPT Err - get_free_iport rte_ring_dequeue " + "failed"); + printf("%d, %d, %d\n", rte_ring_count( + p_nat->port_alloc_ring), rte_ring_free_count( + p_nat->port_alloc_ring), ret); + + #ifdef CGNAPT_DEBUGGING + #ifdef CGNAPT_DBG_PRNT + printf("Th%d GFP:: %" PRIu64 ", %" PRIu64 ", " + "%" PRIu64", %" PRIu64 ",\n", p_nat->pipeline_num, + p_nat->gfp_get, p_nat->gfp_ret, p_nat->gfp_suc, + p_nat->gfp_err); + + p_nat->gfp_err++; + #endif + #endif + return port; + } + } + + /* get the port from index count-1 and decrease count */ + port = p_nat->allocated_ports->ports + [p_nat->allocated_ports->count - 1]; + *public_ip = p_nat->allocated_ports->ip_addr + [p_nat->allocated_ports->count - 1]; + + p_nat->allocated_ports->count -= 1; + + /* if count is zero, return buffer to mem pool */ + if (p_nat->allocated_ports->count == 0) { + rte_mempool_put(napt_port_pool, p_nat->allocated_ports); + + #ifdef CGNAPT_DEBUGGING + p_nat->gfp_ret++; + #ifdef CGNAPT_DBG_PRNT + printf("Th%d Returned to pool p_nat->allocated_ports %p,", + p_nat->pipeline_num, p_nat->allocated_ports); + printf("%" PRIu64 ", %" PRIu64 ",", + p_nat->gfp_get, p_nat->gfp_ret); + printf("%" PRIu64 ", %" PRIu64 ",\n", + p_nat->gfp_suc, p_nat->gfp_err); + #endif + #endif + + p_nat->allocated_ports = NULL; + } + + #ifdef CGNAPT_DEBUGGING + p_nat->gfp_suc++; + #endif + + return port; +} + +/** + * Function to free a port + * + * @param port_num + * Port number to free + * @param public_ip + * Corresponding ip address + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + */ +void release_iport(uint16_t port_num, uint32_t public_ip, + struct pipeline_cgnapt *p_nat) +{ + /* If we don't have a valid napt_port_alloc_elem get one + * from mem pool + */ + if (p_nat->free_ports == NULL) { + void *ports; + + #ifdef CGNAPT_DEBUGGING + p_nat->pfb_get++; + #endif + + if (rte_mempool_get(napt_port_pool, &ports) < 0) { + #ifdef CGNAPT_DEBUGGING + p_nat->pfb_err++; + #endif + printf("CGNAPT release_iport error in getting " + "port alloc buffer\n"); + return; + } + + p_nat->free_ports = (struct napt_port_alloc_elem *)ports; + p_nat->free_ports->count = 0; + } + + /* put the port at index count and increase count */ + p_nat->free_ports->ip_addr[p_nat->free_ports->count] = public_ip; + p_nat->free_ports->ports[p_nat->free_ports->count] = port_num; + p_nat->free_ports->count += 1; + + /* if napt_port_alloc_elem is full add it to ring */ + { + + #ifdef CGNAPT_DEBUGGING + p_nat->pfb_ret++; + #endif + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 2) { + printf("CGNAPT port_alloc_ring before EnQ Cnt %d, Free %d\n", + rte_ring_count(p_nat->port_alloc_ring), + rte_ring_free_count(p_nat->port_alloc_ring)); + } + #endif + + if (rte_ring_enqueue(p_nat->port_alloc_ring, + (void *)p_nat->free_ports) != 0) { + printf("CGNAPT release_iport Enqueue error %p\n", + p_nat->free_ports); + + #ifdef CGNAPT_DEBUGGING + p_nat->pfb_err++; + #endif + } + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG >= 2) { + printf("CGNAPT port_alloc_ring after EnQ Cnt %d", + rte_ring_count(p_nat->port_alloc_ring)); + printf("Free %d\n", + rte_ring_free_count(p_nat->port_alloc_ring)); + } + #endif + + p_nat->free_ports = NULL; + } + + #ifdef CGNAPT_DEBUGGING + p_nat->pfb_suc++; + #endif +} + +/** + * Function to initialize max ports per client data structures + * Called during dynamic NAPT initialization. + * + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 if success, negative if error + */ +int init_max_port_per_client( + __rte_unused struct pipeline_cgnapt *p_nat) +{ + if (max_port_per_client_hash) + return -1; + + /*MPPC_ALREADY_EXISTS */ + + int i = 0; + + max_port_per_client_hash = + rte_hash_create(&max_port_per_client_hash_params); + if (!max_port_per_client_hash) + return -2; + + /*MPPC_HASH_CREATE_ERROR */ + + max_port_per_client_array = + rte_zmalloc(NULL, + sizeof(struct max_port_per_client) * MAX_DYN_ENTRY, + RTE_CACHE_LINE_SIZE); + if (!max_port_per_client_array) + return -3; + + /*MPPC_ARRAY_CREATE_ERROR */ + + for (i = 0; i < MAX_DYN_ENTRY; i++) { + max_port_per_client_array[i].prv_ip = 0; + max_port_per_client_array[i].prv_phy_port = 0; + max_port_per_client_array[i].max_port_cnt = 0; + } + + return 0; + /*MPPC_SUCCESS */ +} + +/** + * Function to check if max ports for a client is reached + * + * @param prv_ip_param + * A uint32_t ip address of client + * @param prv_phy_port_param + * A uint32_t physical port id of the client + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 if max port not reached, 1 if reached, -1 if error + */ +int is_max_port_per_client_reached(uint32_t prv_ip_param, + uint32_t prv_phy_port_param, + struct pipeline_cgnapt *p_nat) +{ + int index = MAX_PORT_INVALID_KEY; + + struct max_port_per_client_key key = { + .prv_ip = prv_ip_param, + .prv_phy_port = prv_phy_port_param, + }; + + index = rte_hash_lookup(max_port_per_client_hash, (const void *)&key); + + if (index < 0) + return MAX_PORT_INVALID_KEY; + + if (max_port_per_client_array[index].max_port_cnt >= + p_nat->max_port_per_client) + return MAX_PORT_REACHED; + + return MAX_PORT_NOT_REACHED; +} + +/** + * Function to increase max ports for a client + * + * @param prv_ip_param + * A uint32_t ip address of client + * @param prv_phy_port_param + * A uint32_t physical port id of the client + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 if max port reached, 1 if success, 2 if new entry, -1 if error + */ +int increment_max_port_counter(uint32_t prv_ip_param, + uint32_t prv_phy_port_param, + struct pipeline_cgnapt *p_nat) +{ + int index = MAX_PORT_INC_ERROR; + + struct max_port_per_client_key key = { + .prv_ip = prv_ip_param, + .prv_phy_port = prv_phy_port_param, + }; + + index = rte_hash_lookup(max_port_per_client_hash, (const void *)&key); + + if (index == -EINVAL) + return MAX_PORT_INC_ERROR; + + if (index == -ENOENT) { + if (max_port_per_client_add_entry(prv_ip_param, + prv_phy_port_param, + p_nat) <= 0) + return MAX_PORT_INC_ERROR; + + return 2; /*return MAX_PORT_NEW_ENTRY; */ + } + + if (CGNAPT_DEBUG > 2) + printf("%s: max_port_cnt(%d), p_nat_max(%d)\n", __func__, + max_port_per_client_array[index].max_port_cnt, + p_nat->max_port_per_client); + + if (max_port_per_client_array[index].max_port_cnt < + p_nat->max_port_per_client) { + max_port_per_client_array[index].max_port_cnt++; + return MAX_PORT_INC_SUCCESS; + } + + return MAX_PORT_INC_REACHED; +} + +/** + * Function to decrease max ports for a client + * + * @param prv_ip_param + * A uint32_t ip address of client + * @param prv_phy_port_param + * A uint32_t physical port id of the client + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 if count already 0, 1 if success, -1 if error + */ +int decrement_max_port_counter(uint32_t prv_ip_param, + uint32_t prv_phy_port_param, + struct pipeline_cgnapt *p_nat) +{ + int index = MAX_PORT_DEC_ERROR; + + struct max_port_per_client_key key = { + .prv_ip = prv_ip_param, + .prv_phy_port = prv_phy_port_param, + }; + + index = rte_hash_lookup(max_port_per_client_hash, (const void *)&key); + if (index < 0) { + + #ifdef CGNAPT_DEBUGGING + p_nat->max_port_dec_err1++; + #endif + return MAX_PORT_DEC_ERROR; + + } + + if (max_port_per_client_array[index].max_port_cnt > 0) { + /* If it is the last port,ret this info which is used for + * max_cli_per_pub_ip + */ + + max_port_per_client_array[index].max_port_cnt--; + /* Count should be atomic but we are good as we have only + * one task handling this counter at a time (core affinity) + */ + } + + if (max_port_per_client_array[index].max_port_cnt <= 0) { + if (max_port_per_client_del_entry + (prv_ip_param, prv_phy_port_param, p_nat) <= 0) { + + #ifdef CGNAPT_DEBUGGING + p_nat->max_port_dec_err2++; + #endif + return MAX_PORT_DEC_ERROR; + } + + #ifdef CGNAPT_DEBUGGING + p_nat->max_port_dec_err3++; + #endif + + return MAX_PORT_DEC_REACHED; + } + + #ifdef CGNAPT_DEBUGGING + p_nat->max_port_dec_success++; + #endif + + return MAX_PORT_DEC_SUCCESS; +} + +/** + * Function to add a max ports per client entry + * + * @param prv_ip_param + * A uint32_t ip address of client + * @param prv_phy_port_param + * A uint32_t physical port id of the client + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 no success, 1 if success, -1 if error + */ +int max_port_per_client_add_entry( + uint32_t prv_ip_param, + uint32_t prv_phy_port_param, + __rte_unused struct pipeline_cgnapt *p_nat) +{ + int index = MAX_PORT_ADD_ERROR; + + struct max_port_per_client_key key = { + .prv_ip = prv_ip_param, + .prv_phy_port = prv_phy_port_param, + }; + + index = rte_hash_lookup(max_port_per_client_hash, (const void *)&key); + if (index == -EINVAL) + return MAX_PORT_ADD_ERROR; + + if (index >= 0) + return MAX_PORT_ADD_UNSUCCESS; + + if (index == -ENOENT) { + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("max_port_per_client_add_entry fn: " + "Entry does not exist\n"); + #endif + + index = + rte_hash_add_key(max_port_per_client_hash, + (const void *)&key); + if (index == -ENOSPC) + return MAX_PORT_ADD_UNSUCCESS; + + #ifdef CGNAPT_DBG_PRNT + if (CGNAPT_DEBUG > 2) + printf("max_port_per_client_add_entry fn:" + "Add entry index(%d)\n", index); + #endif + + max_port_per_client_array[index].prv_ip = prv_ip_param; + max_port_per_client_array[index].prv_phy_port = + prv_phy_port_param; + } + + max_port_per_client_array[index].max_port_cnt++; + return MAX_PORT_ADD_SUCCESS; +} + +/** + * Function to delete a max ports per client entry + * + * @param prv_ip_param + * A uint32_t ip address of client + * @param prv_phy_port_param + * A uint32_t physical port id of the client + * @param p_nat + * A pointer to struct pipeline_cgnapt + * + * @return + * 0 no success, 1 if success, -1 if error + */ +int max_port_per_client_del_entry( + uint32_t prv_ip_param, + uint32_t prv_phy_port_param, + __rte_unused struct pipeline_cgnapt *p_nat) +{ + int index = MAX_PORT_DEL_ERROR; + + struct max_port_per_client_key key = { + .prv_ip = prv_ip_param, + .prv_phy_port = prv_phy_port_param, + }; + + index = rte_hash_lookup(max_port_per_client_hash, (const void *)&key); + + if (index == -EINVAL) + return MAX_PORT_DEL_ERROR; + + if (index == -ENOENT) + return MAX_PORT_DEL_UNSUCCESS; + + index = rte_hash_del_key(max_port_per_client_hash, (const void *)&key); + max_port_per_client_array[index].prv_ip = 0; + max_port_per_client_array[index].prv_phy_port = 0; + max_port_per_client_array[index].max_port_cnt = 0; + + return MAX_PORT_DEL_SUCCESS; +} + +/** + * Function to execute debug commands + * + * @param p + * A pointer to struct pipeline + * @param msg + * void pointer to incoming arguments + */ +void *pipeline_cgnapt_msg_req_entry_dbg_handler(struct pipeline *p, void *msg) +{ + struct pipeline_cgnapt_entry_delete_msg_rsp *rsp = msg; + uint8_t *Msg = msg; + struct pipeline_cgnapt *p_nat = (struct pipeline_cgnapt *)p; + + rsp->status = 0; + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_STATS_SHOW) { + printf("\nCG-NAPT Packet Stats:\n"); + printf("Received %" PRIu64 ",", p_nat->receivedPktCount); + printf("Missed %" PRIu64 ",", p_nat->missedPktCount); + printf("Dropped %" PRIu64 ",", p_nat->naptDroppedPktCount); + printf("Translated %" PRIu64 ",", p_nat->naptedPktCount); + printf("ingress %" PRIu64 ",", p_nat->inaptedPktCount); + printf("egress %" PRIu64 "\n", p_nat->enaptedPktCount); + printf("arp pkts %" PRIu64 "\n", p_nat->arpicmpPktCount); + + #ifdef CGNAPT_DEBUGGING + printf("\n Drop detail 1:%" PRIu64 ",", + p_nat->naptDroppedPktCount1); + printf("\n Drop detail 2:%" PRIu64 ",", + p_nat->naptDroppedPktCount2); + printf("\n Drop detail 3:%" PRIu64 ",", + p_nat->naptDroppedPktCount3); + printf("\n Drop detail 4:%" PRIu64 ",", + p_nat->naptDroppedPktCount4); + printf("\n Drop detail 5:%" PRIu64 ",", + p_nat->naptDroppedPktCount5); + printf("\n Drop detail 6:%" PRIu64 "", + p_nat->naptDroppedPktCount6); + + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount1, + p_nat->missedpktcount2); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount3, + p_nat->missedpktcount4); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount5, + p_nat->missedpktcount6); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount7, + p_nat->missedpktcount8); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount9, + p_nat->missedpktcount10); + + #endif + + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_STATS_CLEAR) { + printf("\nCG-NAPT Packet Stats:\n"); + printf("Received %" PRIu64 ",", p_nat->receivedPktCount); + printf("Missed %" PRIu64 ",", p_nat->missedPktCount); + printf("Dropped %" PRIu64 ",", p_nat->naptDroppedPktCount); + printf("Translated %" PRIu64 ",", p_nat->naptedPktCount); + printf("ingress %" PRIu64 ",", p_nat->inaptedPktCount); + printf("egress %" PRIu64 "\n", p_nat->enaptedPktCount); + printf("arp pkts %" PRIu64 "\n", p_nat->arpicmpPktCount); + + p_nat->naptedPktCount = 0; + p_nat->naptDroppedPktCount = 0; + p_nat->inaptedPktCount = 0; + p_nat->enaptedPktCount = 0; + p_nat->receivedPktCount = 0; + p_nat->missedPktCount = 0; + p_nat->arpicmpPktCount = 0; + printf("CG-NAPT Packet Stats cleared\n"); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_DBG_LEVEL) { + CGNAPT_DEBUG = Msg[CGNAPT_DBG_CMD_OFST + 1]; + printf("CG-NAPT debug level set to %d\n", CGNAPT_DEBUG); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_DBG_SHOW) { + + printf("\nNAPT entries - added %" PRIu64 ",", + p_nat->n_cgnapt_entry_added); + printf("deleted %" PRIu64 ",", p_nat->n_cgnapt_entry_deleted); + printf("current %" PRIu64 "", p_nat->n_cgnapt_entry_added - + p_nat->n_cgnapt_entry_deleted); + + printf("\nCG-NAPT Packet Stats:\n"); + printf("Received %" PRIu64 ",", p_nat->receivedPktCount); + printf("Missed %" PRIu64 ",", p_nat->missedPktCount); + printf("Dropped %" PRIu64 ",", p_nat->naptDroppedPktCount); + printf("Translated %" PRIu64 ",", p_nat->naptedPktCount); + printf("ingress %" PRIu64 ",", p_nat->inaptedPktCount); + printf("egress %" PRIu64 "\n", p_nat->enaptedPktCount); + printf("arp pkts %" PRIu64 "\n", p_nat->arpicmpPktCount); + + return rsp; + } + #ifdef PIPELINE_CGNAPT_INSTRUMENTATION + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_INSTRUMENTATION) { + if (Msg[CGNAPT_DBG_CMD_OFST1] == + CGNAPT_CMD_INSTRUMENTATION_SUB0) { + + int index = 0; + uint32_t diff_sum = 0; + + printf("CG-NAPT Instrumentation ...\n"); + printf("Instrumentation data collected for fn# %d\n", + cgnapt_num_func_to_inst); + printf("Current collection index %d\n", + cgnapt_inst_index); + + if (Msg[CGNAPT_DBG_CMD_OFST + 2] == 2) { + printf("Timer Start:\n"); + + for (index = 0; index < INST_ARRAY_SIZE; index++) { + if ((index % 5) == 0) + printf("\n"); + printf(" 0x%jx", inst_start_time[index]); + } + printf("\n\nTimer End:\n"); + + for (index = 0; index < INST_ARRAY_SIZE; index++) { + if ((index % 5) == 0) + printf("\n"); + printf(" 0x%jx", inst_end_time[index]); + } + } + + for (index = 0; index < INST_ARRAY_SIZE; index++) { + inst_diff_time[index] = (uint32_t) (inst_end_time[index] - + inst_start_time[index]); + } + + if (Msg[CGNAPT_DBG_CMD_OFST + 2] == + CGNAPT_CMD_INSTRUMENTATION_SUB1) { + printf("\n\nTimer Diff:\n"); + + for (index = 0; index < INST_ARRAY_SIZE; index++) { + if (Msg[CGNAPT_DBG_CMD_OFST + 2] == + CGNAPT_CMD_INSTRUMENTATION_SUB1) { + if ((index % 5) == 0) + printf("\n"); + printf(" 0x%08x", inst_diff_time[index]); + } + + diff_sum += inst_diff_time[index]; + } + + printf("\ndiff_sum %u, INST_ARRAY_SIZE %d, Ave Time %u\n", + diff_sum, INST_ARRAY_SIZE, (diff_sum / INST_ARRAY_SIZE)); + } else if (Msg[CGNAPT_DBG_CMD_OFST + 1] == + CGNAPT_CMD_INSTRUMENTATION_SUB1) { + /* p plid entry dbg 7 1 0 + * p plid entry dbg 7 1 1 <--- pkt_work_cgnapt + * p plid entry dbg 7 1 2 <--- pkt4_work_cgnapt + * p plid entry dbg 7 1 3 <--- pkt_work_cgnapt_key + * p plid entry dbg 7 1 4 <--- pkt4_work_cgnapt_key + * p plid entry dbg 7 1 5 <--- in port ah to out port ah + * - pkt life in the system + * p plid entry dbg 7 1 6 <--- how long this instrumentation + * itself is taking + */ + cgnapt_inst_index = 0; + cgnapt_num_func_to_inst = Msg[CGNAPT_DBG_CMD_OFST + 2]; + printf("Instrumentation data collection started for fn# %d\n", + cgnapt_num_func_to_inst); + } else if (Msg[CGNAPT_DBG_CMD_OFST + 1] == + CGNAPT_CMD_INSTRUMENTATION_SUB2) { + /* p plid entry dbg 7 2 0 + * Test all major functions by calling them multiple times + * pkt_work_cgnapt, pkt4_work_cgnapt, pkt_work_cgnapt_key, + * pkt4_work_cgnapt_key + */ + if (cgnapt_test_pktmbuf_pool == NULL) { + cgnapt_test_pktmbuf_pool = rte_pktmbuf_pool_create( + "cgnapt_test_pktmbuf_pool", 63, 32, 0, + RTE_MBUF_DEFAULT_BUF_SIZE, + rte_socket_id()); + } + + if (cgnapt_test_pktmbuf_pool == NULL) + printf("CGNAPT test mbuf pool create failed.\n"); + + struct rte_mbuf *cgnapt_test_pkt0 = + rte_pktmbuf_alloc(cgnapt_test_pktmbuf_pool); + if (cgnapt_test_pkt0 == NULL) + printf("CGNAPT test pkt 0 alloc failed."); + struct rte_mbuf *cgnapt_test_pkt1 = + rte_pktmbuf_alloc(cgnapt_test_pktmbuf_pool); + if (cgnapt_test_pkt1 == NULL) + printf("CGNAPT test pkt 1 alloc failed."); + struct rte_mbuf *cgnapt_test_pkt2 = + rte_pktmbuf_alloc(cgnapt_test_pktmbuf_pool); + if (cgnapt_test_pkt2 == NULL) + printf("CGNAPT test pkt 2 alloc failed."); + struct rte_mbuf *cgnapt_test_pkt3 = + rte_pktmbuf_alloc(cgnapt_test_pktmbuf_pool); + if (cgnapt_test_pkt3 == NULL) + printf("CGNAPT test pkt 3 alloc failed."); + + struct rte_mbuf *cgnapt_test_pkts[4]; + + cgnapt_test_pkts[0] = cgnapt_test_pkt0; + cgnapt_test_pkts[1] = cgnapt_test_pkt1; + cgnapt_test_pkts[2] = cgnapt_test_pkt2; + cgnapt_test_pkts[3] = cgnapt_test_pkt3; + + uint32_t src_addr_offset = + MBUF_HDR_ROOM + ETH_HDR_SIZE + IP_HDR_SRC_ADR_OFST; + /* header room + eth hdr size + + * src_aadr offset in ip header + */ + uint32_t dst_addr_offset = + MBUF_HDR_ROOM + ETH_HDR_SIZE + IP_HDR_DST_ADR_OFST; + /* header room + eth hdr size + + * dst_aadr offset in ip header + */ + uint32_t prot_offset = + MBUF_HDR_ROOM + ETH_HDR_SIZE + IP_HDR_PROTOCOL_OFST; + /* header room + eth hdr size + + * srprotocol char offset in ip header + */ + int pktCnt = 0, entCnt = 0, exCnt = 0; + + for (pktCnt = 0; pktCnt < 4; pktCnt++) { + uint32_t *src_addr = + RTE_MBUF_METADATA_UINT32_PTR + (cgnapt_test_pkts[pktCnt], src_addr_offset); + uint32_t *dst_addr = + RTE_MBUF_METADATA_UINT32_PTR + (cgnapt_test_pkts[pktCnt], dst_addr_offset); + uint8_t *protocol = + RTE_MBUF_METADATA_UINT8_PTR(cgnapt_test_pkts + [pktCnt], + prot_offset); + uint8_t *phy_port = + RTE_MBUF_METADATA_UINT8_PTR(cgnapt_test_pkts + [pktCnt], 70); + uint8_t *eth_dest = + RTE_MBUF_METADATA_UINT8_PTR(cgnapt_test_pkts + [pktCnt], + MBUF_HDR_ROOM); + uint8_t *eth_src = + RTE_MBUF_METADATA_UINT8_PTR( + cgnapt_test_pkts[pktCnt], + MBUF_HDR_ROOM + + 6); + uint16_t *src_port = + RTE_MBUF_METADATA_UINT16_PTR + (cgnapt_test_pkts[pktCnt], + MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE); + uint16_t *dst_port = + RTE_MBUF_METADATA_UINT16_PTR + (cgnapt_test_pkts[pktCnt], + MBUF_HDR_ROOM + ETH_HDR_SIZE + + IP_HDR_SIZE + 2); + *src_addr = 0xc0a80001; + *dst_addr = 0x90418634; + *protocol = 0x6; + *phy_port = 0; + *src_port = 1234; + *dst_port = 4000; + eth_src[0] = 0xAB; + eth_src[1] = 0xAB; + eth_src[2] = 0xAB; + eth_src[3] = 0xAB; + eth_src[4] = 0xAB; + eth_src[5] = 0xAB; + eth_dest[0] = 0x90; + eth_dest[1] = 0xE2; + eth_dest[2] = 0xba; + eth_dest[3] = 0x54; + eth_dest[4] = 0x67; + eth_dest[5] = 0xc8; + } + struct rte_pipeline_table_entry *table_entries[4]; + struct cgnapt_table_entry ctable_entries[4]; + table_entries[0] = (struct rte_pipeline_table_entry *) + &ctable_entries[0]; + table_entries[1] = (struct rte_pipeline_table_entry *) + &ctable_entries[1]; + table_entries[2] = (struct rte_pipeline_table_entry *) + &ctable_entries[2]; + table_entries[3] = (struct rte_pipeline_table_entry *) + &ctable_entries[3]; + for (entCnt = 0; entCnt < 4; entCnt++) { + ctable_entries[entCnt].head.action = + RTE_PIPELINE_ACTION_PORT; + ctable_entries[entCnt].head.port_id = 0; + + ctable_entries[entCnt].data.prv_ip = 0x01020304; + ctable_entries[entCnt].data.prv_port = 1234; + ctable_entries[entCnt].data.pub_ip = 0x0a0b0c0d; + ctable_entries[entCnt].data.pub_port = 4000; + ctable_entries[entCnt].data.prv_phy_port = 0; + ctable_entries[entCnt].data.pub_phy_port = 1; + ctable_entries[entCnt].data.ttl = 500; + } + + uint64_t time1 = rte_get_tsc_cycles(); + + for (exCnt = 0; exCnt < 1000; exCnt++) { + pkt_work_cgnapt_key(cgnapt_test_pkts[0], + instrumentation_port_in_arg); + } + uint64_t time2 = rte_get_tsc_cycles(); + + printf("times for %d times execution of " + "pkt_work_cgnapt_key 0x%jx", + exCnt, time1); + printf(", 0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000000; exCnt++) { + pkt_work_cgnapt_key(cgnapt_test_pkts[0], + instrumentation_port_in_arg); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt_work_cgnapt_key 0x%jx", exCnt, time1); + printf("0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000; exCnt++) { + pkt4_work_cgnapt_key(cgnapt_test_pkts, + instrumentation_port_in_arg); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt4_work_cgnapt_key 0x%jx", + exCnt, time1); + printf(" 0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000000; exCnt++) { + pkt4_work_cgnapt_key(cgnapt_test_pkts, + instrumentation_port_in_arg); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt4_work_cgnapt_key 0x%jx", + exCnt, time1); + printf("0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + uint64_t mask = 0xff; + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000; exCnt++) { + pkt_work_cgnapt(cgnapt_test_pkts[0], + table_entries[0], 3, &mask, + NULL); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt_work_cgnapt 0x%jx", + exCnt, time1); + printf("0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000000; exCnt++) { + pkt_work_cgnapt(cgnapt_test_pkts[0], + table_entries[0], 3, &mask, + NULL); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt_work_cgnapt 0x%jx", + exCnt, time1); + printf("0x%jx, diff %" PRIu64 "\n", time2, + time2 - time1); + + time1 = rte_get_tsc_cycles(); + for (exCnt = 0; exCnt < 1000; exCnt++) { + pkt4_work_cgnapt(cgnapt_test_pkts, + table_entries, 0, &mask, NULL); + } + time2 = rte_get_tsc_cycles(); + printf("times for %d times execution of " + "pkt4_work_cgnapt 0x%jx", + exCnt, time1); + printf("0x%jx, diff % " PRIu64 "\n", time2, + time2 - time1); + + int idummy = ctable_entries[0].data.prv_port; + + idummy++; + + } + } + return rsp; + } + #endif + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_LS_ENTRY) { + printf("CG-NAPT be entries are:\n"); + printf("Pipeline pointer %p\n", p); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_DYN) { + printf("Total Number of dynamic napt entries: %" PRIu64 "\n", + p_nat->dynCgnaptCount); + + #ifdef CGNAPT_DEBUGGING + printf("MAX PORT PER CLIENT:"); + printf("%" PRIu64 ",%" PRIu64 ",%" PRIu64 "\n", + p_nat->max_port_dec_err1, p_nat->max_port_dec_err2, + p_nat->max_port_dec_err3); + printf("MPPC success : %" PRIu64 "\n", + p_nat->max_port_dec_success); + + printf("Release port:err:%" PRIu64 ",ret::%" PRIu64 ",get::%" + PRIu64 ",suc::%" PRIu64 "\n", p_nat->pfb_err, + p_nat->pfb_ret, p_nat->pfb_get, p_nat->pfb_suc); + printf("Get port::err:%" PRIu64 ",ret::%" PRIu64 ",get::%" + PRIu64 ",suc::%" PRIu64 "\n", p_nat->gfp_err, + p_nat->gfp_ret, p_nat->gfp_get, p_nat->gfp_suc); + printf("Ring Info:\n"); + rte_ring_dump(stdout, p_nat->port_alloc_ring); + #endif + return rsp; + } + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_IPV6) { + dual_stack_enable = Msg[CGNAPT_DBG_CMD_OFST + 1]; + printf("Dual Stack option set: %x\n", dual_stack_enable); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_MAPS_INFO) { + pipelines_port_info(); + pipelines_map_info(); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_ITER_COM_TBL) { + uint32_t count = 0; + const void *key; + void *data; + uint32_t next = 0; + int32_t index = 0; + + do { + index = + rte_hash_iterate(napt_common_table, &key, &data, + &next); + + if ((index != -EINVAL) && (index != -ENOENT)) { + printf("\n%04d ", count); + rte_hexdump(stdout, "KEY", key, + sizeof(struct + pipeline_cgnapt_entry_key)); + + //print_key((struct pipeline_cgnapt_entry_key *) + // key); + int32_t position = + rte_hash_lookup(napt_common_table, + key); + print_cgnapt_entry(&napt_hash_tbl_entries + [position]); + } + + count++; + } while (index != -ENOENT); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_IF_STATS) { + + struct app_params *app = + (struct app_params *)p_nat->app_params_addr; + uint8_t cmd[2]; + + cmd[0] = Msg[CGNAPT_DBG_CMD_OFST + 1]; + cmd[1] = Msg[CGNAPT_DBG_CMD_OFST + 2]; + switch (cmd[0]) { + case CGNAPT_IF_STATS_HWQ: + printf("n_pktq_hwq_int :%d\n", app->n_pktq_hwq_in); + printf("n_pktq_hwq_out :%d\n", app->n_pktq_hwq_out); + printf("\n"); + uint8_t i, j; + + for (i = 0; i < app->n_pktq_hwq_in; i++) { + struct rte_eth_stats stats; + + rte_eth_stats_get(p_nat->links_map[i], &stats); + + if (is_phy_port_privte(i)) + printf("Private Port Stats %d\n", i); + else + printf("Public Port Stats %d\n", i); + + printf("\n\tipackets : %" PRIu64 "", + stats.ipackets); + printf("\n\topackets : %" PRIu64 "", + stats.opackets); + printf("\n\tierrors : %" PRIu64 "", + stats.ierrors); + printf("\n\toerrors : %" PRIu64 "", + stats.oerrors); + printf("\n\trx_nombuf: %" PRIu64 "", + stats.rx_nombuf); + printf("\n"); + if (is_phy_port_privte(i)) + printf("Private Q:"); + else + printf("Public Q:"); + for (j = 0; j < RTE_ETHDEV_QUEUE_STAT_CNTRS; + j++) + printf(" %" PRIu64 ", %" PRIu64 "|", + stats.q_ipackets[j], + stats.q_opackets[j]); + + printf("\n\n"); + + } + + return rsp; + + case CGNAPT_IF_STATS_SWQ: + + printf("n_pktq_swq :%d\n", app->n_pktq_swq); + + if (cmd[1] < app->n_pktq_swq) { + rte_ring_dump(stdout, app->swq[cmd[1]]); + return rsp; + } + printf("SWQ number is invalid\n"); + return rsp; + + case CGNAPT_IF_STATS_OTH: + printf("\n"); + printf("config_file:%s\n", app->config_file); + printf("script_file:%s\n", app->script_file); + printf("parser_file:%s\n", app->parser_file); + printf("output_file:%s\n", app->output_file); + printf("n_msgq :%d\n", app->n_msgq); + printf("n_pktq_tm :%d\n", app->n_pktq_tm); + printf("n_pktq_source :%d\n", app->n_pktq_source); + printf("n_pktq_sink :%d\n", app->n_pktq_sink); + printf("n_pipelines :%d\n", app->n_pipelines); + printf("\n"); + return rsp; + default: + printf("Command does not match\n\n"); + return rsp; + + } /* switch */ + + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_MAX_CLI_PER_PUB_IP) { + if (nat_only_config_flag) { + printf("Command not supported for NAT only config.\n"); + return rsp; + } + uint16_t ii; + + printf("\tPublic IP: Num Clients\n"); + for (ii = 0; ii < CGNAPT_MAX_PUB_IP; ii++) + printf("\t%x : %7d\n", all_public_ip[ii].ip, + rte_atomic16_read(&all_public_ip[ii].count)); + return rsp; + } + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_PUB_IP_LIST) { + + int i; + for (i = 0; i < p_nat->pub_ip_count; i++) + printf("%x : (%d,%d)\n", p_nat->pub_ip_port_set[i].ip, + p_nat->pub_ip_port_set[i].start_port, + p_nat->pub_ip_port_set[i].end_port); + return rsp; + } + + #ifdef CGNAPT_TIMING_INST + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_TIMING_INST) { + if (Msg[CGNAPT_DBG_CMD_OFST + 1] == 0) { + p_nat->time_measurements_on = 1; + p_nat->time_measurements = 0; + printf("CGNAPT timing instrumentation turned on.\n"); + printf("Max samples %d\n", p_nat->max_time_mesurements); + } + if (Msg[CGNAPT_DBG_CMD_OFST + 1] == 1) { + p_nat->time_measurements_on = 0; + printf("CGNAPT timing instrumentation turned off.\n"); + printf("Cur Samples %d\n", p_nat->time_measurements); + } + if (Msg[CGNAPT_DBG_CMD_OFST + 1] == 2) { + uint64_t sum = p_nat->external_time_sum + + p_nat->internal_time_sum; + uint64_t isump = (p_nat->internal_time_sum * 100) / sum; + uint64_t esump = (p_nat->external_time_sum * 100) / sum; + printf("CGNAPT timing instrumentation status ...\n"); + printf("Max Count %d, Cur Count %d, Status %d (1=ON)\n", + p_nat->max_time_mesurements, + p_nat->time_measurements, + p_nat->time_measurements_on); + printf("Internal Time Sum %" PRIu64 " , Ave %" PRIu64 + ", percent %" PRIu64 "\n", + p_nat->internal_time_sum, + (p_nat->internal_time_sum / + p_nat->time_measurements), isump); + printf("External Time Sum %" PRIu64 " , Ave %" PRIu64 + ", percent %" PRIu64 "\n", + p_nat->external_time_sum, + (p_nat->external_time_sum / + p_nat->time_measurements), esump); + } + + return rsp; + } + #endif + + if (Msg[CGNAPT_DBG_CMD_OFST] == CGNAPT_DBG_CMD_PRINT_NSP) { + struct cgnapt_nsp_node *ll = nsp_ll; + + while (ll != NULL) { + fprintf(stderr, "NSP Prefix/Depth=>%x%x:%x%x:%x%x: " + "%x%x:%x%x:%x%x:%x%x:%x%x/%d", + ll->nsp.prefix[0], ll->nsp.prefix[1], + ll->nsp.prefix[2], ll->nsp.prefix[3], + ll->nsp.prefix[4], ll->nsp.prefix[5], + ll->nsp.prefix[6], ll->nsp.prefix[7], + ll->nsp.prefix[8], ll->nsp.prefix[9], + ll->nsp.prefix[10], ll->nsp.prefix[11], + ll->nsp.prefix[12], ll->nsp.prefix[13], + ll->nsp.prefix[14], ll->nsp.prefix[15], + ll->nsp.depth); + + ll = ll->next; + } + + return rsp; + } + + printf("CG-NAPT debug handler called with wrong args %x %x\n", Msg[0], + Msg[1]); + int i = 0; + + for (i = 0; i < 20; i++) + printf("%02x ", Msg[i]); + printf("\n"); + return rsp; +} + +/** + * Function to print num of clients per IP address + * + */ +void print_num_ip_clients(void) +{ + if (nat_only_config_flag) { + printf("Command not supported for NAT only config.\n"); + return; + } + + uint16_t ii; + printf("\tPublic IP: Num Clients\n"); + for (ii = 0; ii < CGNAPT_MAX_PUB_IP; ii++) + printf("\t%08x : %7d\n", all_public_ip[ii].ip, + rte_atomic16_read(&all_public_ip[ii].count)); +} + +/** + * Function to print CGNAPT version info + * + * @param p + * An unused pointer to struct pipeline + * @param msg + * void pointer to incoming arguments + */ +void *pipeline_cgnapt_msg_req_ver_handler(__rte_unused struct pipeline *p, + void *msg) +{ + struct pipeline_cgnapt_entry_delete_msg_rsp *rsp = msg; + uint8_t *Msg = msg; + + rsp->status = 0; + + printf("CG-NAPT debug handler called with args %x %x, offset %d\n", + Msg[CGNAPT_VER_CMD_OFST], Msg[CGNAPT_VER_CMD_OFST + 1], + CGNAPT_VER_CMD_OFST); + + if (Msg[CGNAPT_VER_CMD_OFST] == CGNAPT_VER_CMD_VER) { + printf("CGNAPT Version %s\n", CGNAPT_VERSION); + return rsp; + } + printf("CG-NAPT Version handler called with wrong args %x %x\n", + Msg[0], Msg[1]); + int i = 0; + + for (i = 0; i < 20; i++) + printf("%02x ", Msg[i]); + printf("\n"); + return rsp; +} + +/** + * Function to show CGNAPT stats + * + */ +void all_cgnapt_stats(void) +{ + int i; + struct pipeline_cgnapt *p_nat; + uint64_t receivedPktCount = 0; + uint64_t missedPktCount = 0; + uint64_t naptDroppedPktCount = 0; + uint64_t naptedPktCount = 0; + uint64_t inaptedPktCount = 0; + uint64_t enaptedPktCount = 0; + uint64_t arpicmpPktCount = 0; + + printf("\nCG-NAPT Packet Stats:\n"); + for (i = 0; i < n_cgnapt_pipeline; i++) { + p_nat = all_pipeline_cgnapt[i]; + + receivedPktCount += p_nat->receivedPktCount; + missedPktCount += p_nat->missedPktCount; + naptDroppedPktCount += p_nat->naptDroppedPktCount; + naptedPktCount += p_nat->naptedPktCount; + inaptedPktCount += p_nat->inaptedPktCount; + enaptedPktCount += p_nat->enaptedPktCount; + arpicmpPktCount += p_nat->arpicmpPktCount; + + printf("pipeline %d stats:\n", p_nat->pipeline_num); + printf("Received %" PRIu64 ",", p_nat->receivedPktCount); + printf("Missed %" PRIu64 ",", p_nat->missedPktCount); + printf("Dropped %" PRIu64 ",", p_nat->naptDroppedPktCount); + printf("Translated %" PRIu64 ",", p_nat->naptedPktCount); + printf("ingress %" PRIu64 ",", p_nat->inaptedPktCount); + printf("egress %" PRIu64 "\n", p_nat->enaptedPktCount); + printf("arpicmp pkts %" PRIu64 "\n", p_nat->arpicmpPktCount); + + + #ifdef CGNAPT_DEBUGGING + printf("\n Drop detail 1:%" PRIu64 ",", + p_nat->naptDroppedPktCount1); + printf("\n Drop detail 2:%" PRIu64 ",", + p_nat->naptDroppedPktCount2); + printf("\n Drop detail 3:%" PRIu64 ",", + p_nat->naptDroppedPktCount3); + printf("\n Drop detail 4:%" PRIu64 ",", + p_nat->naptDroppedPktCount4); + printf("\n Drop detail 5:%" PRIu64 ",", + p_nat->naptDroppedPktCount5); + printf("\n Drop detail 6:%" PRIu64 "", + p_nat->naptDroppedPktCount6); + + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount1, + p_nat->missedpktcount2); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount3, + p_nat->missedpktcount4); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount5, + p_nat->missedpktcount6); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount7, + p_nat->missedpktcount8); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount9, + p_nat->missedpktcount10); + + #endif + + } + + printf("\nTotal pipeline stats:\n"); + printf("Received %" PRIu64 ",", receivedPktCount); + printf("Missed %" PRIu64 ",", missedPktCount); + printf("Dropped %" PRIu64 ",", naptDroppedPktCount); + printf("Translated %" PRIu64 ",", naptedPktCount); + printf("ingress %" PRIu64 ",", inaptedPktCount); + printf("egress %" PRIu64 "\n", enaptedPktCount); + printf("arpicmp pkts %" PRIu64 "\n", arpicmpPktCount); +} + +void all_cgnapt_clear_stats(void) +{ + int i; + struct pipeline_cgnapt *p_nat; + printf("\nCG-NAPT Packet Stats:\n"); + for (i = 0; i < n_cgnapt_pipeline; i++) { + p_nat = all_pipeline_cgnapt[i]; + + printf("pipeline %d stats:\n", p_nat->pipeline_num); + printf("Received %" PRIu64 ",", p_nat->receivedPktCount); + printf("Missed %" PRIu64 ",", p_nat->missedPktCount); + printf("Dropped %" PRIu64 ",", p_nat->naptDroppedPktCount); + printf("Translated %" PRIu64 ",", p_nat->naptedPktCount); + printf("ingress %" PRIu64 ",", p_nat->inaptedPktCount); + printf("egress %" PRIu64 "\n", p_nat->enaptedPktCount); + printf("arpicmp pkts %" PRIu64 "\n", p_nat->arpicmpPktCount); + + p_nat->receivedPktCount = 0; + p_nat->missedPktCount = 0; + p_nat->naptDroppedPktCount = 0; + p_nat->naptedPktCount = 0; + p_nat->inaptedPktCount = 0; + p_nat->enaptedPktCount = 0; + p_nat->arpicmpPktCount = 0; + + #ifdef CGNAPT_DEBUGGING + printf("\n Drop detail 1:%" PRIu64 ",", + p_nat->naptDroppedPktCount1); + printf("\n Drop detail 2:%" PRIu64 ",", + p_nat->naptDroppedPktCount2); + printf("\n Drop detail 3:%" PRIu64 ",", + p_nat->naptDroppedPktCount3); + printf("\n Drop detail 4:%" PRIu64 ",", + p_nat->naptDroppedPktCount4); + printf("\n Drop detail 5:%" PRIu64 ",", + p_nat->naptDroppedPktCount5); + printf("\n Drop detail 6:%" PRIu64 "", + p_nat->naptDroppedPktCount6); + + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount1, + p_nat->missedpktcount2); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount3, + p_nat->missedpktcount4); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount5, + p_nat->missedpktcount6); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount7, + p_nat->missedpktcount8); + printf("\nPkt_miss: %" PRIu64 " %" PRIu64 "", + p_nat->missedpktcount9, + p_nat->missedpktcount10); + + #endif + + } +} + +/** + * Function to print common CGNAPT table entries + * + */ +void print_static_cgnapt_entries(void) +{ + uint32_t count = 0; + const void *key; + void *data; + uint32_t next = 0; + int32_t index = 0; + struct cgnapt_table_entry *entry; + do { + index = rte_hash_iterate(napt_common_table, + &key, &data, &next); + + if ((index != -EINVAL) && (index != -ENOENT)) { + printf("\n%04d ", count); + rte_hexdump(stdout, "KEY", key, + sizeof(struct pipeline_cgnapt_entry_key)); + int32_t position = rte_hash_lookup( + napt_common_table, key); + entry = &napt_hash_tbl_entries[position]; + + if (entry->data.timeout == STATIC_CGNAPT_TIMEOUT) + rte_hexdump(stdout, "Entry", + (const void *)entry, + sizeof(struct cgnapt_table_entry)); + } + + count++; + } while (index != -ENOENT); +} + +/** + * Function to show CGNAPT stats + * + */ + +struct pipeline_be_ops pipeline_cgnapt_be_ops = { + .f_init = pipeline_cgnapt_init, + .f_free = pipeline_cgnapt_free, + .f_run = NULL, + .f_timer = pipeline_cgnapt_timer, + .f_track = pipeline_cgnapt_track, +}; |