/*
 *
 * (C) 2005-13 - ntop.org
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesses General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 */

#ifndef _PFRING_H_
#define _PFRING_H_

#include <sys/types.h>
#include <stdio.h>
#include <stdarg.h>

#ifndef HAVE_PCAP
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <linux/sockios.h>
#endif

#include <linux/if_packet.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <time.h>
#include <poll.h>
#include <string.h>
#include <pthread.h>
#include <linux/pf_ring.h>
#include <linux/if_ether.h>

#ifdef HAVE_REDIRECTOR
#include <librdi.h>
#endif

#define MAX_CAPLEN             65535
#define PAGE_SIZE               4096

#define DEFAULT_POLL_DURATION   500

#define POLL_SLEEP_STEP           10 /* ns = 0.1 ms */
#define POLL_SLEEP_MIN          POLL_SLEEP_STEP
#define POLL_SLEEP_MAX          1000 /* ns */
#define POLL_QUEUE_MIN_LEN       500 /* # packets */

#ifndef HAVE_RW_LOCK
#define pthread_rwlock_t       pthread_mutex_t
#define pthread_rwlock_init    pthread_mutex_init
#define pthread_rwlock_rdlock  pthread_mutex_lock
#define pthread_rwlock_wrlock  pthread_mutex_lock
#define pthread_rwlock_unlock  pthread_mutex_unlock
#define pthread_rwlock_destroy pthread_mutex_destroy
#endif

#ifndef max
#define max(a, b) (a > b ? a : b)
#endif

#define timespec_is_before(a, b) \
  ((((a)->tv_sec<(b)->tv_sec)||(((a)->tv_sec==(b)->tv_sec)&&((a)->tv_nsec<(b)->tv_nsec)))?1:0)

/* ********************************* */

#define likely(x)       __builtin_expect((x),1)
#define unlikely(x)     __builtin_expect((x),0)

/* ********************************* */

/*
  See also __builtin_prefetch
  http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
*/
#define prefetch(x) __asm volatile("prefetcht0 %0" :: "m" (*(const unsigned long *)x));

/* ********************************* */

#ifdef  __cplusplus
extern "C" {
#endif

#ifdef SAFE_RING_MODE
  static char staticBucket[2048];
#endif

  typedef void (*pfringProcesssPacket)(const struct pfring_pkthdr *h, const u_char *p, const u_char *user_bytes);

  /* ********************************* */

  typedef struct __pfring pfring; /* Forward declaration */

  /* ********************************* */

#define MAX_NUM_BUNDLE_ELEMENTS 32
  
  typedef enum {
    pick_round_robin = 0,
    pick_fifo
  } bundle_read_policy;

  typedef struct {
    bundle_read_policy policy;
    u_int16_t num_sockets, last_read_socket;
    pfring *sockets[MAX_NUM_BUNDLE_ELEMENTS];
    struct pollfd pfd[MAX_NUM_BUNDLE_ELEMENTS];
  } pfring_bundle;

  /* ********************************* */

  typedef struct {
    u_int64_t recv, drop, droppedbyfilter;
  } pfring_stat;

  /* ********************************* */

  typedef enum {
    hardware_and_software = 0,
    hardware_only,
    software_only
  } filtering_mode;

  /* ********************************* */

  typedef void pfring_pkt_buff;
  
  /* ********************************* */
  
  struct __pfring {
    u_int8_t initialized, enabled, long_header, rss_mode, force_timestamp, strip_hw_timestamp, 
             disable_parsing, disable_timestamp;
    packet_direction direction; /* Specify the capture direction for packets */
    socket_mode mode;

    /* Hardware Timestamp */
    struct {
      u_int8_t force_timestamp, is_silicom_hw_timestamp_card, enable_hw_timestamp;
      u_int32_t last_hw_timestamp_sec, last_hw_timestamp_nsec;
    } hw_ts;

    struct {
      u_int8_t enabled_rx_packet_send;
      struct pfring_pkthdr *last_received_hdr; /*
						 Header of the past packet
						 that has been received on this socket
					       */
    } tx;

    /* TODO these fields should be moved in ->priv_data */
    /* DNA (Direct NIC Access) */
    struct {
      u_int8_t dna_mapped_device;
      u_int32_t sampling_counter;
      u_int16_t num_rx_pkts_before_dna_sync, num_tx_pkts_before_dna_sync; 
      u_int16_t dna_rx_sync_watermark, dna_tx_sync_watermark;
      u_int64_t tot_dna_read_pkts, tot_dna_lost_pkts;
      u_int32_t rx_reg, tx_reg, last_rx_slot_read;
      u_int32_t num_rx_slots_per_chunk, num_tx_slots_per_chunk;
      
      dna_device dna_dev;    
      dna_indexes *indexes_ptr;
      u_int32_t *rx_reg_ptr, *tx_reg_ptr, *mpc_reg_ptr, *qprdc_reg_ptr, 
	*rnbc_reg_ptr, *rqdpc_reg_ptr, *gorc_reg_ptr;
      dna_device_operation last_dna_operation;
    } dna;

    void       *priv_data; /* module private data */

    void      (*close)                        (pfring *);
    int	      (*stats)                        (pfring *, pfring_stat *);
    int       (*recv)                         (pfring *, u_char**, u_int, struct pfring_pkthdr *, u_int8_t);
    int       (*set_poll_watermark)           (pfring *, u_int16_t);
    int       (*set_poll_duration)            (pfring *, u_int);
    int       (*set_tx_watermark)             (pfring *, u_int16_t);
    int       (*set_channel_id)               (pfring *, u_int32_t);
    int       (*set_channel_mask)             (pfring *, u_int32_t);
    int       (*set_application_name)         (pfring *, char *);
    int       (*set_application_stats)        (pfring *, char *);
    char*     (*get_appl_stats_file_name)     (pfring *ring, char *path, u_int path_len);
    int       (*bind)                         (pfring *, char *);
    int       (*send)                         (pfring *, char *, u_int, u_int8_t);
    int       (*send_ifindex)                 (pfring *, char *, u_int, u_int8_t, int);
    int       (*send_parsed)                  (pfring *, char *, struct pfring_pkthdr *, u_int8_t);
    int       (*send_get_time)                (pfring *, char *, u_int, struct timespec *);
    u_int8_t  (*get_num_rx_channels)          (pfring *);
    int       (*set_sampling_rate)            (pfring *, u_int32_t);
    int       (*get_selectable_fd)            (pfring *);
    int       (*set_direction)                (pfring *, packet_direction);
    int       (*set_socket_mode)              (pfring *, socket_mode);
    int       (*set_cluster)                  (pfring *, u_int, cluster_type);
    int       (*remove_from_cluster)          (pfring *);
    int       (*set_master_id)                (pfring *, u_int32_t);
    int       (*set_master)                   (pfring *, pfring *);
    u_int16_t (*get_ring_id)                  (pfring *);
    u_int32_t (*get_num_queued_pkts)          (pfring *);
    u_int8_t  (*get_packet_consumer_mode)     (pfring *);
    int       (*set_packet_consumer_mode)     (pfring *, u_int8_t, char *, u_int);
    int       (*get_hash_filtering_rule_stats)(pfring *, hash_filtering_rule *, char *, u_int *);
    int       (*handle_hash_filtering_rule)   (pfring *, hash_filtering_rule *, u_char);
    int       (*purge_idle_hash_rules)        (pfring *, u_int16_t);
    int       (*add_filtering_rule)           (pfring *, filtering_rule *);
    int       (*remove_filtering_rule)        (pfring *, u_int16_t);
    int       (*purge_idle_rules)             (pfring *, u_int16_t);
    int       (*get_filtering_rule_stats)     (pfring *, u_int16_t, char *, u_int *);
    int       (*toggle_filtering_policy)      (pfring *, u_int8_t);
    int       (*enable_rss_rehash)            (pfring *);
    int       (*poll)                         (pfring *, u_int);
    int       (*is_pkt_available)             (pfring *);
    int       (*next_pkt_time)                (pfring *, struct timespec *);
    int       (*next_pkt_raw_timestamp)       (pfring *, u_int64_t *ts);
    int       (*version)                      (pfring *, u_int32_t *);
    int       (*get_bound_device_address)     (pfring *, u_char [6]);
    int       (*get_bound_device_ifindex)     (pfring *, int *);
    int       (*get_device_ifindex)           (pfring *, char *, int *);
    u_int16_t (*get_slot_header_len)          (pfring *);
    int       (*set_virtual_device)           (pfring *, virtual_filtering_device_info *);
    int       (*add_hw_rule)                  (pfring *, hw_filtering_rule *);
    int       (*remove_hw_rule)               (pfring *, u_int16_t);
    int       (*loopback_test)                (pfring *, char *, u_int, u_int);
    int       (*enable_ring)                  (pfring *);
    int       (*disable_ring)                 (pfring *);
    void      (*shutdown)                     (pfring *);
    int       (*set_bpf_filter)               (pfring *, char *);
    int       (*remove_bpf_filter)            (pfring *);
    int       (*get_device_clock)             (pfring *, struct timespec *);
    int       (*set_device_clock)             (pfring *, struct timespec *);
    int       (*adjust_device_clock)          (pfring *, struct timespec *, int8_t);
    void      (*sync_indexes_with_kernel)     (pfring *);
    int       (*send_last_rx_packet)          (pfring *, int);
    u_char*   (*get_pkt_buff_data)            (pfring *, pfring_pkt_buff *);
    int       (*set_pkt_buff_len)             (pfring *, pfring_pkt_buff *, u_int32_t);
    int       (*set_pkt_buff_ifindex)         (pfring *, pfring_pkt_buff *, int);
    int       (*add_pkt_buff_ifindex)         (pfring *, pfring_pkt_buff *, int);
    pfring_pkt_buff* (*alloc_pkt_buff)        (pfring *);
    void      (*release_pkt_buff)             (pfring *, pfring_pkt_buff *);
    int       (*recv_pkt_buff)                (pfring *, pfring_pkt_buff *, struct pfring_pkthdr *, u_int8_t);
    int       (*send_pkt_buff)                (pfring *, pfring_pkt_buff *, u_int8_t);
    void      (*flush_tx_packets)             (pfring *);
    int       (*register_zerocopy_tx_ring)    (pfring *, pfring *);

    /* DNA only */
    int      (*dna_init)             (pfring *);
    void     (*dna_term)             (pfring *);   
    int      (*dna_enable)           (pfring *);
    u_int8_t (*dna_check_packet_to_read) (pfring *, u_int8_t);
    u_char*  (*dna_next_packet)      (pfring *, u_char **, u_int, struct pfring_pkthdr *);

    u_int    (*dna_get_num_tx_slots)(pfring* ring);
    u_int    (*dna_get_num_rx_slots)(pfring* ring);
    u_int    (*dna_get_next_free_tx_slot)(pfring* ring);
    int      (*dna_copy_tx_packet_into_slot)(pfring* ring, u_int32_t tx_slot_id, char* buffer, u_int len);

    /* Silicom Redirector Only */
    struct {
      int8_t device_id, port_id;
    } rdi;

    filtering_mode ft_mode;
    pfring_device_type ft_device_type;
    void *qat; /* Intel QAT PM */

    /* All devices */
    char *buffer, *slots, *device_name;
    u_int32_t caplen;
    u_int16_t slot_header_len, mtu_len /* 0 = unknown */;
    u_int32_t sampling_rate;
    u_int8_t kernel_packet_consumer, is_shutting_down, socket_default_accept_policy;
    int fd;
    FlowSlotInfo *slots_info;
    u_int poll_sleep;
    u_int16_t poll_duration;
    u_int8_t promisc, clear_promisc, reentrant, break_recv_loop;
    u_long num_poll_calls;
    pthread_rwlock_t rx_lock, tx_lock;

    struct sockaddr_ll sock_tx;

    /* Reflector socket (copy RX packets onto it) */
    pfring *reflector_socket;
  };

  /* ********************************* */

  #define PF_RING_DNA_SYMMETRIC_RSS    1 << 0
  #define PF_RING_REENTRANT            1 << 1
  #define PF_RING_LONG_HEADER          1 << 2
  #define PF_RING_PROMISC              1 << 3
  #define PF_RING_TIMESTAMP            1 << 4
  #define PF_RING_HW_TIMESTAMP         1 << 5
  #define PF_RING_RX_PACKET_BOUNCE     1 << 6
  #define PF_RING_DNA_FIXED_RSS_Q_0    1 << 7
  #define PF_RING_STRIP_HW_TIMESTAMP   1 << 8
  #define PF_RING_DO_NOT_PARSE         1 << 9  /* parsing already disabled in zero-copy */
  #define PF_RING_DO_NOT_TIMESTAMP     1 << 10 /* sw timestamp already disabled in zero-copy */

  /* ********************************* */

  pfring* pfring_open(const char *device_name, u_int32_t caplen, u_int32_t flags);
  pfring* pfring_open_consumer(const char *device_name, u_int32_t caplen, u_int32_t flags,
			       u_int8_t consumer_plugin_id,
			       char* consumer_data, u_int consumer_data_len);
  u_int8_t pfring_open_multichannel(const char *device_name, u_int32_t caplen, 
				    u_int32_t flags, pfring* ring[MAX_NUM_RX_CHANNELS]);

  void pfring_shutdown(pfring *ring);
  void pfring_config(u_short cpu_percentage);
  int  pfring_loop(pfring *ring, pfringProcesssPacket looper, 
		   const u_char *user_bytes, u_int8_t wait_for_packet);
  void pfring_breakloop(pfring *);
  
  void pfring_close(pfring *ring);
  int pfring_stats(pfring *ring, pfring_stat *stats);
  int pfring_recv(pfring *ring, u_char** buffer, u_int buffer_len,
		  struct pfring_pkthdr *hdr, u_int8_t wait_for_incoming_packet);
  int pfring_recv_parsed(pfring *ring, u_char** buffer, u_int buffer_len,
		  struct pfring_pkthdr *hdr, u_int8_t wait_for_incoming_packet,
		  u_int8_t level /* 1..4 */, u_int8_t add_timestamp, u_int8_t add_hash);
  int pfring_set_poll_watermark(pfring *ring, u_int16_t watermark);
  int pfring_set_poll_duration(pfring *ring, u_int duration);
  int pfring_set_tx_watermark(pfring *ring, u_int16_t watermark);
  int pfring_add_hw_rule(pfring *ring, hw_filtering_rule *rule);
  int pfring_remove_hw_rule(pfring *ring, u_int16_t rule_id);
  int pfring_set_channel_id(pfring *ring, u_int32_t channel_id);
  int pfring_set_channel_mask(pfring *ring, u_int32_t channel_mask);
  int pfring_set_application_name(pfring *ring, char *name);
  int pfring_set_application_stats(pfring *ring, char *stats);
  char* pfring_get_appl_stats_file_name(pfring *ring, char *path, u_int path_len);
  int pfring_bind(pfring *ring, char *device_name);
  int pfring_send(pfring *ring, char *pkt, u_int pkt_len, u_int8_t flush_packet);
  int pfring_send_ifindex(pfring *ring, char *pkt, u_int pkt_len, u_int8_t flush_packet, int if_index);
  int pfring_send_parsed(pfring *ring, char *pkt, struct pfring_pkthdr *hdr, u_int8_t flush_packet);
  int pfring_send_get_time(pfring *ring, char *pkt, u_int pkt_len, struct timespec *ts);
  u_int8_t pfring_get_num_rx_channels(pfring *ring);
  int pfring_set_sampling_rate(pfring *ring, u_int32_t rate /* 1 = no sampling */);
  int pfring_get_selectable_fd(pfring *ring);
  int pfring_set_direction(pfring *ring, packet_direction direction);
  int pfring_set_socket_mode(pfring *ring, socket_mode mode);
  int pfring_set_cluster(pfring *ring, u_int clusterId, cluster_type the_type);
  int pfring_remove_from_cluster(pfring *ring);
  int pfring_set_master_id(pfring *ring, u_int32_t master_id);
  int pfring_set_master(pfring *ring, pfring *master);
  u_int16_t pfring_get_ring_id(pfring *ring);
  u_int32_t pfring_get_num_queued_pkts(pfring *ring);
  u_int8_t pfring_get_packet_consumer_mode(pfring *ring);
  int pfring_set_packet_consumer_mode(pfring *ring, u_int8_t plugin_id,
				      char *plugin_data, u_int plugin_data_len);
  int pfring_handle_hash_filtering_rule(pfring *ring,
					hash_filtering_rule* rule_to_add,
					u_char add_rule);
  int pfring_add_filtering_rule(pfring *ring, filtering_rule* rule_to_add);
  int pfring_remove_filtering_rule(pfring *ring, u_int16_t rule_id);
  int pfring_purge_idle_hash_rules(pfring *ring, u_int16_t inactivity_sec);
  int pfring_purge_idle_rules(pfring *ring, u_int16_t inactivity_sec);
  int pfring_get_hash_filtering_rule_stats(pfring *ring,
					   hash_filtering_rule* rule,
					   char* stats, u_int *stats_len);
  int pfring_get_filtering_rule_stats(pfring *ring, u_int16_t rule_id,
				      char* stats, u_int *stats_len);
  int pfring_toggle_filtering_policy(pfring *ring, u_int8_t rules_default_accept_policy);
  int pfring_enable_rss_rehash(pfring *ring);
  int pfring_poll(pfring *ring, u_int wait_duration);
  int pfring_is_pkt_available(pfring *ring);
  int pfring_next_pkt_time(pfring *ring, struct timespec *ts);
  int pfring_next_pkt_raw_timestamp(pfring *ring, u_int64_t *timestamp_ns);
  int pfring_version(pfring *ring, u_int32_t *version);
  int pfring_set_reflector_device(pfring *ring, char *device_name);
  int pfring_get_bound_device_address(pfring *ring, u_char mac_address[6]);
  u_int16_t pfring_get_slot_header_len(pfring *ring);
  int pfring_get_bound_device_ifindex(pfring *ring, int *if_index);
  int pfring_get_device_ifindex(pfring *ring, char *device_name, int *if_index);
  int pfring_set_virtual_device(pfring *ring, virtual_filtering_device_info *info);
  int pfring_loopback_test(pfring *ring, char *buffer, u_int buffer_len, u_int test_len);
  int pfring_enable_ring(pfring *ring);
  int pfring_disable_ring(pfring *ring);
  int pfring_set_bpf_filter(pfring *ring, char *filter_buffer);
  int pfring_remove_bpf_filter(pfring *ring);
  int pfring_set_filtering_mode(pfring *ring, filtering_mode mode);
  int pfring_get_device_clock(pfring *ring, struct timespec *ts);
  int pfring_set_device_clock(pfring *ring, struct timespec *ts);
  int pfring_adjust_device_clock(pfring *ring, struct timespec *offset, int8_t sign);
  void pfring_sync_indexes_with_kernel(pfring *ring);
  int pfring_send_last_rx_packet(pfring *ring, int tx_interface_id);

  u_int pfring_get_num_tx_slots(pfring* ring);
  u_int pfring_get_num_rx_slots(pfring* ring);
  int   pfring_copy_tx_packet_into_slot(pfring* ring, u_int16_t tx_slot_id, char* buffer, u_int len);

  u_char* pfring_get_pkt_buff_data(pfring *ring, pfring_pkt_buff *pkt_handle);
  int pfring_set_pkt_buff_len(pfring *ring, pfring_pkt_buff *pkt_handle, u_int32_t len);
  int pfring_set_pkt_buff_ifindex(pfring *ring, pfring_pkt_buff *pkt_handle, int if_index);
  int pfring_add_pkt_buff_ifindex(pfring *ring, pfring_pkt_buff *pkt_handle, int if_index);
  pfring_pkt_buff* pfring_alloc_pkt_buff(pfring *ring);
  void pfring_release_pkt_buff(pfring *ring, pfring_pkt_buff *pkt_handle);
  int pfring_recv_pkt_buff(pfring *ring, pfring_pkt_buff *pkt_handle, struct pfring_pkthdr *hdr, u_int8_t wait_for_incoming_packet); /* Note: this function fills the buffer pointed by pkt_handle */
  int pfring_send_pkt_buff(pfring *ring, pfring_pkt_buff *pkt_handle, u_int8_t flush_packet); /* Note: this function reset the buffer pointed by pkt_handle */
  int pfring_flush_tx_packets(pfring *ring);
  int pfring_search_payload(pfring *ring, char *string_to_search);
  int pfring_register_zerocopy_tx_ring(pfring *ring, pfring *tx_ring);

  /* PF_RING Socket bundle */
  void pfring_bundle_init(pfring_bundle *bundle, bundle_read_policy p);
  int pfring_bundle_add(pfring_bundle *bundle, pfring *ring);
  int pfring_bundle_poll(pfring_bundle *bundle, u_int wait_duration);
  int pfring_bundle_read(pfring_bundle *bundle, 
			 u_char** buffer, u_int buffer_len,
			 struct pfring_pkthdr *hdr,
			 u_int8_t wait_for_incoming_packet);
  void pfring_bundle_destroy(pfring_bundle *bundle);
  void pfring_bundle_close(pfring_bundle *bundle);  

  /* Utils (defined in pfring_utils.c) */
  int pfring_parse_pkt(u_char *pkt, struct pfring_pkthdr *hdr, u_int8_t level /* 2..4 */, 
		       u_int8_t add_timestamp /* 0,1 */, u_int8_t add_hash /* 0,1 */);
  int pfring_set_if_promisc(const char *device, int set_promisc);
  char* pfring_format_numbers(double val, char *buf, u_int buf_len, u_int8_t add_decimals);
  int pfring_enable_hw_timestamp(pfring* ring, char *device_name, u_int8_t enable_rx, u_int8_t enable_tx);
  int pfring_get_mtu_size(pfring* ring);

  /* ********************************* */

  typedef struct {
    char   *name;
    int   (*open)  (pfring *);
  } pfring_module_info;

#ifdef HAVE_ZERO
#include "pfring_zero.h"
#endif

#ifdef  __cplusplus
}
#endif

#endif /* _PFRING_H_ */