EtherLib/packet_sieve.h

#ifndef ETHERLIB_PACKET_SIEVE_H
#define ETHERLIB_PACKET_SIEVE_H

#include <stdbool.h>

#include "packet_registry.h"
#include "packet.h"

/**
 * Packet header information.
 */
typedef struct PcktHeaderElement_ {
    struct PcktHeaderElement_ * next, * prev; ///< Next and previous header in the linked list
    PcktProps props; ///< Properties (allocated to appropriate size)
} PcktHeaderElement;

/**
 * Free chain of packet header. List is auto-rewound.
 * @param hdr pointer to header chain element
 */
void pckthdr_chain_free(PcktHeaderElement * hdr);

#define ETH_PCKT_HEADER_ELEMENT_HEAD_SIZE (2 * sizeof(PcktHeaderElement *))

/**
 * @union PcktSieveFilterCondition
 * Union for storing filter conditions.
 */
typedef union {
    uint16_t uw[8];
    uint32_t u[4];
    uint64_t lu[2];
    int16_t sw[8];
    int32_t i[4];
    int64_t li[2];
    uint8_t d[16];
} PcktSieveFilterCondition;

/**
 * Function for comparing filter conditions.
 * @param c1 condition 1
 * @param c2 condition 2
 * @return true if cond1 matches cond2, otherwise false
 */
bool packfiltcond_cmp(const PcktSieveFilterCondition * c1, const PcktSieveFilterCondition * c2);

/**
 * Clear packet filter condition structure.
 * @param cond pointer to existing filter condition structure
 */
void packfiltcond_zero(PcktSieveFilterCondition * cond);

struct EthInterface_;

/**
 * Sieve filter function type.
 */
typedef bool (*SieveFilterFn)(const PcktSieveFilterCondition * filtCond, const PcktProps * contProps, const PcktProps * ownProps, struct EthInterface_ * intf);

struct PcktSieveLayer_;

typedef union {
    void * p;
    uint32_t u;
} PcktSieveLayerTag;

/**
 * Callback function type for packet sieve match.
 */
typedef int (*SieveCallBackFn)(const Pckt * pckt, PcktSieveLayerTag tag);

/**
 * Callback function for printing connblock report.
 */
struct ConnBlock_;
typedef void (*ConnBlockReportFn)(const struct ConnBlock_ * connBlock);


#define PCKT_SIEVE_INFOTAG_LEN (24)

/**
 * Packet sieve layer structure.
 */
typedef struct PcktSieveLayer_ {
    uint16_t packetClass; ///< Packet class (e.g. IP)
    PcktSieveFilterCondition filtCond; ///< Filter condition, arbitrary type (e.g. destination IP-address)
    bool matchAny; ///< Match any packet, don't test against filter condition
    SieveFilterFn filtFn; ///< Filter function pointer
    SieveCallBackFn cbFn; ///< Associated callback function
    PcktSieveLayerTag tag; ///< Layer tag (arbitrary information)
    struct PcktSieveLayer_ * parent; ///< Pointer to parent node in the sieve tree
    struct PcktSieveLayer_ * next, * prev; ///< Next and previous sieve layer on the same level
    struct PcktSieveLayer_ * nodes; ///< Subnodes in the sieve tree
    ConnBlockReportFn connBReportFn; ///< Connection block report function pointer
} PcktSieveLayer;

/**
 * Packet sieve class.
 */
typedef struct PcktSieve_ {
    PcktSieveLayer layer0; ///< Top of sieve tree
    struct EthInterface_ * intf; ///< Ethernet interface
} PcktSieve;

/**
 * Create new packet sieve.
 * @return pointer to packet sieve object or NULL on failure
 */
PcktSieve * packsieve_new();

/**
 * Process packet with packet sieve.
 * @param bottomLayer
 * @param data
 * @param size
 */
void packsieve_input(const PcktSieve *sieve, const RawPckt *rawPckt);

/**
 * Create a new sieve filter layer.
 * @param parent parent layer
 * @param filtCond filter condition passed to the filter callback function
 * @param matchAny don't test against filter criteria, accept any incoming packet (e.g. pass IP packets with any destination address)
 * @param filtFn filter callback function, returning boolean
 * @param cbFn callback function invoked, if packet has passed filter criteria
 * @param tag arbitrary tag, passed to callbacn function, when invoked
 * @param pcktClass packet class associated with current sieve layer
 * @return pointer to new layer object or NULL on failure
 */
PcktSieveLayer *packsieve_new_layer(PcktSieveLayer *parent, const PcktSieveFilterCondition *filtCond, bool matchAny, SieveFilterFn filtFn, SieveCallBackFn cbFn, PcktSieveLayerTag tag, uint16_t pcktClass);

/**
 * Remove sieve layer from packet sieve.
 * @param layer Layer to remove and deallocate
 */
bool packsieve_remove_layer(PcktSieveLayer * layer);

/**
 * Recursively report layer structure on terminal.
 * @param sieve pointer to packet sieve structure
 * @param layer pointer to existing layer
 * @param indent sub-tree indentation
 */
void packsieve_report(const PcktSieve * sieve, const PcktSieveLayer *layer, uint32_t indent);

#define packsieve_report_full(sieve) packsieve_report((sieve), &(sieve)->layer0, 0)

/**
 * Report info on given layer and its parents.
 * @param sieve pointer to packet sieve structure
 * @param layer pointer to an existing layer
 */
void packsieve_layer_info(const PcktSieve * sieve, const PcktSieveLayer * layer);

#endif //ETHERLIB_PACKET_SIEVE_H