/*
// Copyright (c) 2010-2020 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.
*/

#ifndef _TASK_INIT_H_
#define _TASK_INIT_H_

#include <sys/queue.h>

#include <rte_common.h>
#include <rte_sched.h>
#include <rte_ether.h>
#include "prox_compat.h"
#include "task_base.h"
#include "prox_globals.h"
#include "ip6_addr.h"
#include "flow_iter.h"
#include "parse_utils.h"
#include "prox_compat.h"

struct rte_mbuf;
struct lcore_cfg;

#if MAX_RINGS_PER_TASK < PROX_MAX_PORTS
#error MAX_RINGS_PER_TASK < PROX_MAX_PORTS
#endif

#define TASK_ARG_DROP           0x01
#define TASK_ARG_RX_RING        0x02
#define TASK_ARG_RTE_TABLE      0x08
#define TASK_ARG_LOCAL_LPM      0x10
#define TASK_ARG_QINQ_ACL       0x20
#define TASK_ARG_CTRL_RINGS_P   0x40
#define TASK_ARG_DST_MAC_SET	0x80
#define TASK_ARG_SRC_MAC_SET	0x100
#define	TASK_ARG_DO_NOT_SET_SRC_MAC 0x200
#define	TASK_ARG_DO_NOT_SET_DST_MAC 0x400
#define	TASK_ARG_HW_SRC_MAC 	0x800
#define TASK_ARG_L3		0x1000
#define TASK_ARG_NDP		0x2000
#define TASK_ARG_SEND_NA_AT_STARTUP		0x4000

#define PROX_MODE_LEN	32

enum protocols {IPV4, ARP, IPV6};

struct qos_cfg {
	struct rte_sched_port_params port_params;
	struct rte_sched_subport_params subport_params[1];
	struct rte_sched_pipe_params pipe_params[1];
};

enum task_mode {NOT_SET, MASTER, QINQ_DECAP4, QINQ_DECAP6,
		QINQ_ENCAP4, QINQ_ENCAP6, GRE_DECAP, GRE_ENCAP,CGNAT, ESP_ENC, ESP_DEC, QOS, POLICE
};

struct task_args;

struct task_init {
	enum task_mode mode;
	char mode_str[PROX_MODE_LEN];
	char sub_mode_str[PROX_MODE_LEN];
	void (*early_init)(struct task_args *targ);
	void (*init)(struct task_base *tbase, struct task_args *targ);
	int (*handle)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts);
	void (*start)(struct task_base *tbase);
	void (*stop)(struct task_base *tbase);
	void (*start_first)(struct task_base *tbase);
	void (*stop_last)(struct task_base *tbase);
	int (*thread_x)(struct lcore_cfg* lconf);
	struct flow_iter flow_iter;
	size_t size;
	uint16_t     flag_req_data; /* flags from prox_shared.h */
	uint64_t     flag_features;
	LIST_ENTRY(task_init) entries;
};

static int task_init_flag_set(struct task_init *task_init, uint64_t flag)
{
	return !!(task_init->flag_features & flag);
}

enum police_action {
        ACT_GREEN = RTE_COLOR_GREEN,
        ACT_YELLOW = RTE_COLOR_YELLOW,
        ACT_RED = RTE_COLOR_RED,
        ACT_DROP = 3,
	ACT_INVALID = 4
};

struct range {
	uint32_t min;
	uint32_t value;
	uint32_t max;
	uint32_t offset;
	uint8_t range_len;
};

/* Configuration for task that is only used during startup. */
struct task_args {
	struct task_base       *tbase;
	struct task_init*       task_init;
	struct rte_mempool     *pool;
	char		       pool_name[MAX_NAME_SIZE];
	struct lcore_cfg       *lconf;
	uint32_t               nb_mbuf;
	uint32_t               mbuf_size;
	uint32_t               nb_cache_mbuf;
	uint8_t                nb_slave_threads;
	uint8_t		       nb_worker_threads;
	uint8_t		       worker_thread_id;
	uint8_t		       task;
	uint32_t               id;
	struct core_task_set   core_task_set[MAX_PROTOCOLS];
	struct task_args       *prev_tasks[MAX_RINGS_PER_TASK];
	uint32_t               n_prev_tasks;
	uint32_t               ring_size; /* default is RX_RING_SIZE */
	struct qos_cfg         qos_conf;
	uint32_t               flags;
	uint32_t               runtime_flags;
	uint8_t                nb_txports;
	uint8_t                nb_txrings;
	uint8_t                nb_rxrings;
	uint8_t                tot_rxrings;
	uint8_t                nb_rxports;
	uint32_t               byte_offset;
	uint32_t               ipv6_router;
	uint32_t               gateway_ipv4;
	uint32_t               local_ipv4;
	uint32_t               remote_ipv4;
	uint32_t               local_prefix;
	uint32_t               reachable_timeout;
	uint32_t               arp_ndp_retransmit_timeout;
	struct ipv6_addr       local_ipv6;    /* For IPv6 Tunnel, it's the local tunnel endpoint address */
	struct ipv6_addr       global_ipv6;
	struct ipv6_addr       gateway_ipv6;
	struct ipv6_addr       router_prefix;
	struct rte_ring        *rx_rings[MAX_RINGS_PER_TASK];
	struct rte_ring        *tx_rings[MAX_RINGS_PER_TASK];
	struct rte_ring        *ctrl_plane_ring;
	uint32_t               tot_n_txrings_inited;
	prox_rte_ether_addr      edaddr;
	prox_rte_ether_addr      esaddr;
	struct port_queue      tx_port_queue[PROX_MAX_PORTS];
	struct port_queue      rx_port_queue[PROX_MAX_PORTS];
	/* Used to set up actual task at initialization time. */
	enum task_mode         mode;
	/* Destination output position in hw or sw when using mac learned dest port. */
	uint8_t                mapping[PROX_MAX_PORTS];
	struct rte_table_hash  *cpe_table;
	struct rte_table_hash  *qinq_gre_table;
	struct rte_hash        *cpe_gre_hash;
	struct rte_hash        *qinq_gre_hash;
	struct cpe_data        *cpe_data;
	struct cpe_gre_data    *cpe_gre_data;
	struct qinq_gre_data   *qinq_gre_data;
	uint8_t                tx_opt_ring;
	struct task_args       *tx_opt_ring_task;
	uint32_t               qinq_tag;

#ifdef ENABLE_EXTRA_USER_STATISTICS
	uint32_t               n_users;	// Number of users in user table.
#endif
	uint32_t               n_flows;	// Number of flows used in policing
	uint32_t               cir;
	uint32_t               cbs;
	uint32_t               ebs;
	uint32_t               pir;
	uint32_t               pbs;
	uint32_t               overhead;
	enum police_action     police_act[3][3];
	uint32_t               marking[4];
	uint32_t               n_max_rules;
	uint32_t               random_delay_us;
	uint32_t               delay_us;
	uint32_t               cpe_table_timeout_ms;
	uint32_t               etype;
#ifdef GRE_TP
	uint32_t tb_rate;                /**< Pipe token bucket rate (measured in bytes per second) */
	uint32_t tb_size;                /**< Pipe token bucket size (measured in credits) */
#endif
	uint8_t                tunnel_hop_limit;  /* IPv6 Tunnel - Hop limit */
        uint16_t               lookup_port_mask;  /* Ipv6 Tunnel - Mask applied to UDP/TCP port before lookup */
	uint32_t               ctrl_freq;
	uint8_t                lb_friend_core;
	uint8_t                lb_friend_task;
	/* gen related*/
	uint64_t               rate_bps;
	uint32_t               n_rand_str;
	uint32_t               n_ranges;
	uint32_t               rand_offset[64];
	char                   rand_str[64][64];
	struct range           range[64];
	char                   pcap_file[256];
	uint32_t               accur_pos;
	uint32_t               flow_id_pos;
	uint32_t               packet_id_in_flow_pos;
	uint32_t               flow_count;
	uint32_t               sig_pos;
	uint32_t               sig;
	uint32_t               lat_pos;
	uint32_t               packet_id_pos;
	uint32_t               latency_buffer_size;
	uint32_t               bucket_size;
	uint32_t               lat_enabled;
	uint32_t               pkt_size;
	uint8_t                pkt_inline[MAX_PKT_SIZE];
	uint32_t               probability_no_drop;
	uint32_t               probability_duplicate;
	uint32_t               probability_delay;
	char                   nat_table[256];
	uint32_t               use_src;
	char                   route_table[256];
	char                   rules[256];
	char                   dscp[256];
	char                   tun_bindings[256];
	char                   cpe_table_name[256];
	char                   user_table[256];
	uint32_t               n_concur_conn;
	char                   streams[256];
	uint32_t               min_bulk_size;
	uint32_t               max_bulk_size;
	uint32_t               max_setup_rate;
	uint32_t               n_pkts;
	uint32_t               loop;
	uint32_t               flow_table_size;
	char                   dpi_engine_path[256];
	char                   dpi_engine_args[16][256];
	uint32_t               n_dpi_engine_args;
	uint32_t               generator_id;
	uint32_t               accuracy_limit_nsec;
	/* cgnat related */
	uint32_t                     public_ip_count;
	struct public_ip_config_info *public_ip_config_info;
	struct public_entry          *public_entries;
	struct private_flow_entry    *private_flow_entries;
	struct rte_hash              *public_ip_port_hash;
	struct rte_hash              *private_ip_port_hash;
	struct rte_hash              *private_ip_hash;
	struct private_ip_info       *private_ip_info;
	struct rte_ring			**ctrl_rx_rings;
	struct rte_ring			**ctrl_tx_rings;
	int				n_ctrl_rings;
	uint				irq_debug;
	struct task_base *tmaster;
	char sub_mode_str[PROX_MODE_LEN];
	uint32_t               igmp_address;
	uint32_t		imix_nb_pkts;
	uint32_t 		imix_pkt_sizes[MAX_IMIX_PKTS];
	uint32_t        multiplier;
	uint32_t        mirror_size;
	uint32_t store_max;
	uint32_t loss_buffer_size;
};

/* Return the first port that is reachable through the task. If the
   task itself does not send directly to a port, the function will
   search reachable tasks through each outgoing ring */
struct task_args *find_reachable_task_sending_to_port(struct task_args *from);
struct prox_port_cfg *find_reachable_port(struct task_args *from);

struct task_base *init_task_struct(struct task_args *targ);
struct task_init *to_task_init(const char *mode_str, const char *sub_mode_str);
void tasks_list(void);
int task_is_master(struct task_args *targ);

void reg_task(struct task_init* t);

#endif /* _TASK_INIT_H_ */