public.h

Go to the documentation of this file.

/*
 *  Copyright 2006-2023 Carnegie Mellon University
 *  See license information in LICENSE.txt.
 */
/*
 *  ------------------------------------------------------------------------
 *  Authors: Brian Trammell, Dan Ruef
 *  ------------------------------------------------------------------------
 */
 
#ifndef _FB_PUBLIC_H_
#define _FB_PUBLIC_H_
 
#include <fixbuf/autoinc.h>
#include <fixbuf/version.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#define FIXBUF_CHECK_VERSION(major, minor, release)                         \
    (FIXBUF_VERSION_MAJOR > (major) ||                                      \
     (FIXBUF_VERSION_MAJOR == (major) && FIXBUF_VERSION_MINOR > (minor)) || \
     (FIXBUF_VERSION_MAJOR == (major) && FIXBUF_VERSION_MINOR == (minor) && \
      FIXBUF_VERSION_RELEASE >= (release)))
 
/*
 *  Error Handling Definitions
 */
 
#define FB_ERROR_DOMAIN             g_quark_from_string("fixbufError")
#define FB_ERROR_TMPL               1
#define FB_ERROR_EOM                2
#define FB_ERROR_EOF                3
#define FB_ERROR_IPFIX              4
#define FB_ERROR_BUFSZ              5
#define FB_ERROR_IMPL               6
#define FB_ERROR_IO                 7
#define FB_ERROR_NLREAD             8
#define FB_ERROR_NLWRITE            9
#define FB_ERROR_NOELEMENT          10
#define FB_ERROR_CONN               11
#define FB_ERROR_NETFLOWV9          12
#define FB_ERROR_TRANSMISC          13
#define FB_ERROR_SFLOW              14
#define FB_ERROR_SETUP              15
#define FB_ERROR_LAXSIZE            16
 
/*
 *  Public Datatypes and Constants
 */
 
typedef struct fBuf_st fBuf_t;
 
typedef struct fbVarfield_st {
    size_t    len;
    uint8_t  *buf;
} fbVarfield_t;
 
 
typedef struct fbInfoModel_st fbInfoModel_t;
 
typedef GHashTableIter fbInfoModelIter_t;
 
#define FB_IE_INIT_FULL(_name_, _ent_, _num_, _len_, _flags_, \
                        _min_, _max_, _type_, _desc_)         \
    { _ent_, _num_, _len_, _flags_, _type_, _min_, _max_, _name_, _desc_ }
 
#define FB_IE_INIT_FULL_SPLIT(_name_, _ent_, _num_, _len_,           \
                              _rev_, _endian_, _semantics_, _units_, \
                              _min_, _max_, _type_, _desc_)          \
    FB_IE_INIT_FULL(_name_, _ent_, _num_, _len_,                     \
                    (((_rev_) ? FB_IE_F_REVERSIBLE : 0) |            \
                     ((_endian_) ? FB_IE_F_ENDIAN : 0) |             \
                     (((_semantic) & 0xFF) << 8) |                   \
                     (((_units_) & 0xFFFF) << 16)),                  \
                    _min_, _max_, _type_, _desc_)
 
#define FB_IE_INIT(_name_, _ent_, _num_, _len_, _flags_) \
    FB_IE_INIT_FULL(_name_, _ent_, _num_, _len_, _flags_, 0, 0, 0, (char *)NULL)
 
 
#define FB_IE_NULL FB_IE_INIT(NULL, 0, 0, 0, 0)
 
#define FB_IE_SEMANTIC(flags) ((flags & 0x0000ff00) >> 8)
 
#define FB_IE_UNITS(flags) ((flags & 0xFFFF0000) >> 16)
 
#define FB_IE_F_NONE                            0x00000000
 
#define FB_IE_F_ENDIAN                          0x00000001
 
#define FB_IE_F_REVERSIBLE                      0x00000040
 
#define FB_IE_F_ALIEN                           0x00000080
 
#define FB_IE_QUANTITY                          0x00000100
 
#define FB_IE_TOTALCOUNTER                      0x00000200
 
#define FB_IE_DELTACOUNTER                      0x00000300
 
#define FB_IE_IDENTIFIER                        0x00000400
 
#define FB_IE_FLAGS                             0x00000500
 
#define FB_IE_LIST                              0x00000600
 
#define FB_IE_SNMPCOUNTER                       0x00000700
 
#define FB_IE_SNMPGAUGE                         0x00000800
 
#define FB_IE_DEFAULT                           0x00000000
 
 
typedef enum fbInfoElementSemantics_en {
    FB_IE_SEM_DEFAULT = 0,
    FB_IE_SEM_QUANTITY = 1,
    FB_IE_SEM_TOTALCOUNTER = 2,
    FB_IE_SEM_DELTACOUNTER = 3,
    FB_IE_SEM_IDENTIFIER = 4,
    FB_IE_SEM_FLAGS = 5,
    FB_IE_SEM_LIST = 6,
    FB_IE_SEM_SNMPCOUNTER = 7,
    FB_IE_SEM_SNMPGAUGE = 8
} fbInfoElementSemantics_t;
 
 
#define FB_UNITS_BITS                           0x00010000
#define FB_UNITS_OCTETS                         0x00020000
#define FB_UNITS_PACKETS                        0x00030000
#define FB_UNITS_FLOWS                          0x00040000
#define FB_UNITS_SECONDS                        0x00050000
#define FB_UNITS_MILLISECONDS                   0x00060000
#define FB_UNITS_MICROSECONDS                   0x00070000
#define FB_UNITS_NANOSECONDS                    0x00080000
#define FB_UNITS_WORDS                          0x00090000
#define FB_UNITS_MESSAGES                       0x000A0000
#define FB_UNITS_HOPS                           0x000B0000
#define FB_UNITS_ENTRIES                        0x000C0000
#define FB_UNITS_FRAMES                         0x000D0000
#define FB_UNITS_PORTS                          0x000E0000
#define FB_UNITS_INFERRED                       0x000F0000
 
typedef enum fbInfoElementUnits_en {
    FB_IE_UNITS_NONE = 0,
    FB_IE_UNITS_BITS = 1,
    FB_IE_UNITS_OCTETS = 2,
    FB_IE_UNITS_PACKETS = 3,
    FB_IE_UNITS_FLOWS = 4,
    FB_IE_UNITS_SECONDS = 5,
    FB_IE_UNITS_MILLISECONDS = 6,
    FB_IE_UNITS_MICROSECONDS = 7,
    FB_IE_UNITS_NANOSECONDS = 8,
    FB_IE_UNITS_WORDS = 9,
    FB_IE_UNITS_MESSAGES = 10,
    FB_IE_UNITS_HOPS = 11,
    FB_IE_UNITS_ENTRIES = 12,
    FB_IE_UNITS_FRAMES = 13,
    FB_IE_UNITS_PORTS = 14,
    FB_IE_UNITS_INFERRED = 15
} fbInfoElementUnits_t;
 
#define FB_IE_VARLEN                            65535
 
#define FB_IE_PEN_REVERSE                       29305
 
#define FB_IE_VENDOR_BIT_REVERSE                0x4000
 
#define FB_IE_REVERSE_STR                       "reverse"
 
#define FB_IE_REVERSE_STRLEN                    7
 
#define FB_CISCO_GENERIC                       9999
#define FB_CISCO_ASA_EVENT_ID                  9998
#define FB_CISCO_ASA_EVENT_XTRA                9997
 
 
typedef enum fbInfoElementDataType_en {
    FB_OCTET_ARRAY,
    FB_UINT_8,
    FB_UINT_16,
    FB_UINT_32,
    FB_UINT_64,
    FB_INT_8,
    FB_INT_16,
    FB_INT_32,
    FB_INT_64,
    FB_FLOAT_32,
    FB_FLOAT_64,
    FB_BOOL,
    FB_MAC_ADDR,
    FB_STRING,
    FB_DT_SEC,
    FB_DT_MILSEC,
    FB_DT_MICROSEC,
    FB_DT_NANOSEC,
    FB_IP4_ADDR,
    FB_IP6_ADDR,
    FB_BASIC_LIST,
    FB_SUB_TMPL_LIST,
    FB_SUB_TMPL_MULTI_LIST
} fbInfoElementDataType_t;
 
typedef struct fbTemplate_st fbTemplate_t;
 
typedef struct fbInfoElement_st {
    uint32_t     ent;
    uint16_t     num;
    uint16_t     len;
    uint32_t     flags;
    uint8_t      type;
    uint64_t     min;
    uint64_t     max;
    const char  *name;
    const char  *description;
} fbInfoElement_t;
 
 
#define  fbInfoElementCheckIdent(_ie, _enterpriseNumber, _elementId) \
    ((_elementId) == (_ie)->num && (_enterpriseNumber) == (_ie)->ent)
 
#define  fbInfoElementGetDescription(_ie)   ((_ie)->description)
 
#define  fbInfoElementGetId(_ie)        ((_ie)->num)
 
#define  fbInfoElementGetLen(_ie)       ((_ie)->len)
 
#define  fbInfoElementGetMax(_ie)       ((_ie)->max)
 
#define  fbInfoElementGetMin(_ie)       ((_ie)->min)
 
#define  fbInfoElementGetName(_ie)      ((_ie)->name)
 
#define  fbInfoElementGetPEN(_ie)       ((_ie)->ent)
 
#define  fbInfoElementGetSemantics(_ie)                         \
    ((fbInfoElementSemantics_t)(FB_IE_SEMANTIC((_ie)->flags)))
 
#define  fbInfoElementGetType(_ie)              \
    ((fbInfoElementDataType_t)((_ie)->type))
 
#define  fbInfoElementGetUnits(_ie)                     \
    ((fbInfoElementUnits_t)(FB_IE_UNITS((_ie)->units)))
 
#define  fbInfoElementIsAlien(_ie)      (!!((_ie)->flags & FB_IE_F_ALIEN))
 
#define  fbInfoElementIsEndian(_ie)     (!!((_ie)->flags & FB_IE_F_ENDIAN))
 
#define  fbInfoElementIsReversible(_ie) (!!((_ie)->flags & FB_IE_F_REVERSIBLE))
 
#define  fbInfoElementIsUnsigned(_ie) \
    ((_ie)->type >= FB_UINT_8 && (_ie)->type <= FB_UINT_64)
 
#define  fbInfoElementIsSigned(_ie) \
    ((_ie)->type >= FB_INT_8 && (_ie)->type <= FB_INT_64)
 
#define  fbInfoElementIsInteger(_ie) \
    ((_ie)->type >= FB_UINT_8 && (_ie)->type <= FB_INT_64)
 
#define  fbInfoElementIsFloat(_ie) \
    ((_ie)->type >= FB_FLOAT_32 && (_ie)->type <= FB_FLOAT_64)
 
#define  fbInfoElementIsNumber(_ie) \
    ((_ie)->type >= FB_UINT_8 && (_ie)->type <= FB_FLOAT_64)
 
#define  fbInfoElementIsIPAddress(_ie) \
    ((_ie)->type >= FB_IP4_ADDR && (_ie)->type <= FB_IP6_ADDR)
 
#define  fbInfoElementIsDatetime(_ie) \
    ((_ie)->type >= FB_DT_SEC && (_ie)->type <= FB_DT_NANOSEC)
 
#define  fbInfoElementIsList(_ie) \
    ((_ie)->type >= FB_BASIC_LIST && (_ie)->type <= FB_SUB_TMPL_MULTI_LIST)
 
#define  fbInfoElementIsPadding(_ie)    (210 == (_ie)->num && 0 == (_ie)->ent)
 
 
typedef struct fbTemplateField_st {
    const fbInfoElement_t  *canon;
    uint16_t                midx;
    uint16_t                len;
    uint16_t                offset;
    /*uint16_t                memsize; */
    /*uint16_t                position; */
    fbTemplate_t  *tmpl;
} fbTemplateField_t;
 
 
#define FB_TEMPLATEFIELD_INIT  {NULL, 0, 0, 0, NULL}
 
 
#define  fbTemplateFieldCheckIdent(_field, _enterpriseNumber, _elementId) \
    ((_elementId) == (_field)->canon->num &&                              \
     (_enterpriseNumber) == (_field)->canon->ent)
 
#define  fbTemplateFieldGetIE(_field)       ((_field)->canon)
 
#define  fbTemplateFieldGetId(_field)       ((_field)->canon->num)
 
#define  fbTemplateFieldGetLen(_field)      ((_field)->len)
 
#define  fbTemplateFieldGetMemsize(_field)                      \
    ((FB_IE_VARLEN != (_field)->len)                            \
     ? (_field)->len                                            \
     : ((FB_BASIC_LIST == (_field)->canon->type)                \
        ? sizeof(fbBasicList_t)                                 \
        : ((FB_SUB_TMPL_LIST == (_field)->canon->type)          \
           ? sizeof(fbSubTemplateList_t)                        \
           : ((FB_SUB_TMPL_MULTI_LIST == (_field)->canon->type) \
              ? sizeof(fbSubTemplateMultiList_t)                \
              : sizeof(fbVarfield_t)))))
 
#define  fbTemplateFieldGetName(_field)   ((_field)->canon->name)
 
#define  fbTemplateFieldGetOffset(_field)   ((_field)->offset)
 
#define  fbTemplateFieldGetPEN(_field)      ((_field)->canon->ent)
 
#define  fbTemplateFieldGetType(_field)                 \
    ((fbInfoElementDataType_t)((_field)->canon->type))
 
#define  fbTemplateFieldGetRepeat(_field)   ((_field)->midx)
 
typedef struct fbTemplateIter_st {
    const fbTemplate_t  *tmpl;
    uint16_t             pos;
} fbTemplateIter_t;
 
#define FB_TEMPLATE_ITER_NULL  {NULL, UINT16_MAX}
 
void
fbTemplateIterInit(
    fbTemplateIter_t    *iter,
    const fbTemplate_t  *tmpl);
 
const fbTemplateField_t *
fbTemplateIterGetField(
    const fbTemplateIter_t  *iter);
 
uint16_t
fbTemplateIterGetPosition(
    const fbTemplateIter_t  *iter);
 
const fbTemplate_t *
fbTemplateIterGetTemplate(
    const fbTemplateIter_t  *iter);
 
const fbTemplateField_t *
fbTemplateIterNext(
    fbTemplateIter_t  *iter);
 
 
typedef struct fbBasicList_st fbBasicList_t;
 
typedef struct fbSubTemplateList_st fbSubTemplateList_t;
 
typedef struct fbSubTemplateMultiList_st fbSubTemplateMultiList_t;
 
 
typedef struct fbRecord_st {
    const fbTemplate_t  *tmpl;
    uint8_t             *rec;
    size_t               reccapacity;
    size_t               recsize;
    uint16_t             tid;
} fbRecord_t;
 
 
#define FB_RECORD_INIT  {NULL, NULL, 0, 0, 0}
 
 
typedef struct fbRecordValue_st {
    const fbInfoElement_t  *ie;
    GString                *stringbuf;
    union v_un {
        uint8_t                          ip6[16];
        const fbBasicList_t             *bl;
        const fbSubTemplateList_t       *stl;
        const fbSubTemplateMultiList_t  *stml;
        fbVarfield_t                     varfield;
        struct timespec                  dt;
        uint32_t                         ip4;
        uint64_t                         u64;
        int64_t                          s64;
        double                           dbl;
        uint8_t                          mac[6];
    } v;
} fbRecordValue_t;
 
 
#define FB_RECORD_VALUE_INIT \
    { NULL, NULL, { {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} } }
 
 
typedef struct fbInfoElementOptRec_st {
    uint32_t       ie_pen;
    uint16_t       ie_id;
    uint8_t        ie_type;
    uint8_t        ie_semantic;
    uint16_t       ie_units;
    uint8_t        padding[6];
    uint64_t       ie_range_begin;
    uint64_t       ie_range_end;
    fbVarfield_t   ie_name;
    fbVarfield_t   ie_desc;
} fbInfoElementOptRec_t;
 
 
#define FB_TID_AUTO         0
 
#define FB_TID_TS           2
 
#define FB_TID_OTS          3
 
#define FB_TID_MIN_DATA     256
 
#define FB_IESPEC_NULL { NULL, 0, 0 }
 
typedef struct fbInfoElementSpec_st {
    const char  *name;
    uint16_t   len_override;
    uint32_t   flags;
} fbInfoElementSpec_t;
 
#define FB_IESPECID_NULL { {0, 0}, 0, 0 }
 
typedef struct fbInfoElementSpecId_st {
    struct fbInfoElementSpecIdIdent_st {
        uint32_t   enterprise_id;
        uint16_t   element_id;
    } ident;
    uint16_t   len_override;
    uint32_t   flags;
} fbInfoElementSpecId_t;
 
typedef struct fbSession_st fbSession_t;
 
typedef enum fbTransport_en {
    FB_SCTP,
    FB_TCP,
    FB_UDP,
    FB_DTLS_SCTP,
    FB_TLS_TCP,
    FB_DTLS_UDP
} fbTransport_t;
 
typedef struct fbConnSpec_st {
    fbTransport_t   transport;
    char           *host;
    char           *svc;
    char           *ssl_ca_file;
    char           *ssl_cert_file;
    char           *ssl_key_file;
    char           *ssl_key_pass;
    void           *vai;
    void           *vssl_ctx;
} fbConnSpec_t;
 
 
typedef struct fbTemplateInfo_st fbTemplateInfo_t;
 
typedef struct fbBasicListInfo_st fbBasicListInfo_t;
 
fbTemplateInfo_t *
fbTemplateInfoAlloc(
    void);
 
void
fbTemplateInfoFree(
    fbTemplateInfo_t  *tmplInfo);
 
fbTemplateInfo_t *
fbTemplateInfoCopy(
    const fbTemplateInfo_t  *tmplInfo);
 
gboolean
fbTemplateInfoInit(
    fbTemplateInfo_t  *tmplInfo,
    const char        *name,
    const char        *description,
    uint16_t           appLabel,
    uint16_t           parentTid);
 
#define  FB_TMPL_MD_LEVEL_0    0
#define  FB_TMPL_MD_LEVEL_1    1
#define  FB_TMPL_MD_LEVEL_NA   0xFF
 
void
fbTemplateInfoAddBasicList(
    fbTemplateInfo_t  *tmplInfo,
    uint32_t           blEnt,
    uint16_t           blNum,
    uint32_t           contentEnt,
    uint16_t           contentNum);
 
uint16_t
fbTemplateInfoGetApplabel(
    const fbTemplateInfo_t  *tmplInfo);
 
uint16_t
fbTemplateInfoGetParentTid(
    const fbTemplateInfo_t  *tmplInfo);
 
const char *
fbTemplateInfoGetName(
    const fbTemplateInfo_t  *tmplInfo);
 
const char *
fbTemplateInfoGetDescription(
    const fbTemplateInfo_t  *tmplInfo);
 
uint16_t
fbTemplateInfoGetTemplateId(
    const fbTemplateInfo_t  *tmplInfo);
 
const fbBasicListInfo_t *
fbTemplateInfoGetNextBasicList(
    const fbTemplateInfo_t   *tmplInfo,
    const fbBasicListInfo_t  *blInfo);
 
uint16_t
fbBasicListInfoGetListIdent(
    const fbBasicListInfo_t  *blInfo,
    uint32_t                 *pen);
 
uint16_t
fbBasicListInfoGetContentIdent(
    const fbBasicListInfo_t  *blInfo,
    uint32_t                 *pen);
 
 
const fbTemplateInfo_t *
fbSessionGetTemplateInfo(
    const fbSession_t  *session,
    uint16_t            tid);
 
 
uint16_t
fbSessionGetTemplatePath(
    const fbSession_t       *session,
    const fbTemplateInfo_t  *tmplInfo,
    uint16_t                 path[],
    uint16_t                 path_size,
    GError                 **err);
 
 
#define FB_CONNSPEC_INIT \
    { FB_SCTP, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
 
typedef struct fbExporter_st fbExporter_t;
 
typedef struct fbCollector_st fbCollector_t;
 
typedef struct fbListener_st fbListener_t;
 
/*
 *  ListenerGroup and associated data type definitions
 */
 
typedef struct fbListenerGroup_st fbListenerGroup_t;
 
typedef struct fbListenerEntry_st {
    struct fbListenerEntry_st  *next;
    struct fbListenerEntry_st  *prev;
    fbListener_t               *listener;
} fbListenerEntry_t;
 
typedef struct fbListenerGroupResult_st {
    struct fbListenerGroupResult_st  *next;
    fbListener_t                     *listener;
    fBuf_t                           *fbuf;
} fbListenerGroupResult_t;
 
typedef void (*fbTemplateCtxFree_fn)(
    void  *tmpl_ctx,
    void  *app_ctx);
 
typedef void (*fbNewTemplateCallback_fn)(
    fbSession_t           *session,
    uint16_t               tid,
    fbTemplate_t          *tmpl,
    void                  *app_ctx,
    void                 **tmpl_ctx,
    fbTemplateCtxFree_fn  *tmpl_ctx_free_fn);
 
 
typedef enum fbListSemantics_en {
    FB_LIST_SEM_UNDEFINED = 0xFF,
    FB_LIST_SEM_NONE_OF = 0,
    FB_LIST_SEM_EXACTLY_ONE_OF = 1,
    FB_LIST_SEM_ONE_OR_MORE_OF = 2,
    FB_LIST_SEM_ALL_OF = 3,
    FB_LIST_SEM_ORDERED = 4
} fbListSemantics_t;
 
gboolean
fbListSemanticsIsValid(
    uint8_t   semantic);
 
 
/****** BASICLIST FUNCTIONS AND STRUCTS *******/
 
/* typedef struct fbBasicList_st fbBasicList_t; */
struct fbBasicList_st {
    uint8_t            *dataPtr;
    fbTemplateField_t   field;
    uint16_t            numElements;
    uint16_t            dataLength;
    uint8_t             semantic;
};
 
 
fbBasicList_t *
fbBasicListAlloc(
    void);
 
void *
fbBasicListInit(
    fbBasicList_t          *basicList,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                numElements);
 
 
void *
fbBasicListInitWithLength(
    fbBasicList_t          *basicList,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                elementLength,
    uint16_t                numElements);
 
void
fbBasicListCollectorInit(
    fbBasicList_t  *basicList);
 
uint16_t
fbBasicListGetElementLength(
    const fbBasicList_t  *basicList);
 
uint16_t
fbBasicListCountElements(
    const fbBasicList_t  *basicList);
 
uint8_t
fbBasicListGetSemantic(
    const fbBasicList_t  *basicList);
 
void
fbBasicListSetSemantic(
    fbBasicList_t  *basicList,
    uint8_t         semantic);
 
const fbInfoElement_t *
fbBasicListGetInfoElement(
    const fbBasicList_t  *basicList);
 
uint16_t
fbBasicListGetElementIdent(
    const fbBasicList_t  *basicList,
    uint32_t             *pen);
 
const fbTemplateField_t *
fbBasicListGetTemplateField(
    const fbBasicList_t  *basicList);
 
void *
fbBasicListGetDataPtr(
    const fbBasicList_t  *basicList);
 
void *
fbBasicListGetIndexedDataPtr(
    const fbBasicList_t  *basicList,
    uint16_t              index);
 
gboolean
fbBasicListGetIndexedRecordValue(
    const fbBasicList_t  *basicList,
    uint16_t              index,
    fbRecordValue_t      *value);
 
void *
fbBasicListGetNextPtr(
    const fbBasicList_t  *basicList,
    const void           *currentPtr);
 
#define fbBLNext(type, basicList, current) \
    ((type *)(fbBasicListGetNextPtr((basicList), (current))))
 
void *
fbBasicListResize(
    fbBasicList_t  *basicList,
    uint16_t        newCount);
 
void *
fbBasicListAddNewElements(
    fbBasicList_t  *basicList,
    uint16_t        additional);
 
void
fbBasicListClear(
    fbBasicList_t  *basicList);
 
void
fbBasicListClearWithoutFree(
    fbBasicList_t  *basicList);
 
void
fbBasicListFree(
    fbBasicList_t  *basicList);
 
 
/******* END OF BASICLIST ********/
 
 
 
/******* SUBTEMPLATELIST FUNCTIONS ****/
 
 
struct fbSubTemplateList_st {
    const fbTemplate_t  *tmpl;
    uint8_t             *dataPtr;
    uint32_t             dataLength;
    uint32_t             recordLength;
    uint16_t             numElements;
    uint16_t             tmplID;
    uint8_t              semantic;
};
 
fbSubTemplateList_t *
fbSubTemplateListAlloc(
    void);
 
void *
fbSubTemplateListInit(
    fbSubTemplateList_t  *stl,
    uint8_t               semantic,
    uint16_t              tmplID,
    const fbTemplate_t   *tmpl,
    uint16_t              numElements);
 
void
fbSubTemplateListCollectorInit(
    fbSubTemplateList_t  *subTemplateList);
 
void *
fbSubTemplateListGetDataPtr(
    const fbSubTemplateList_t  *subTemplateList);
 
void *
fbSubTemplateListGetIndexedDataPtr(
    const fbSubTemplateList_t  *subTemplateList,
    uint16_t                    index);
 
void *
fbSubTemplateListGetNextPtr(
    const fbSubTemplateList_t  *subTemplateList,
    const void                 *currentPtr);
 
 
#define fbSTLNext(type, subTemplateList, current) \
    ((type *)(fbSubTemplateListGetNextPtr((subTemplateList), (current))))
 
uint16_t
fbSubTemplateListCountElements(
    const fbSubTemplateList_t  *subTemplateList);
 
void
fbSubTemplateListSetSemantic(
    fbSubTemplateList_t  *subTemplateList,
    uint8_t               semantic);
 
uint8_t
fbSubTemplateListGetSemantic(
    const fbSubTemplateList_t  *subTemplateList);
 
const fbTemplate_t *
fbSubTemplateListGetTemplate(
    const fbSubTemplateList_t  *subTemplateList);
 
uint16_t
fbSubTemplateListGetTemplateID(
    const fbSubTemplateList_t  *subTemplateList);
 
void *
fbSubTemplateListResize(
    fbSubTemplateList_t  *subTemplateList,
    uint16_t              newCount);
 
void *
fbSubTemplateListAddNewElements(
    fbSubTemplateList_t  *subTemplateList,
    uint16_t              additional);
 
void
fbSubTemplateListClear(
    fbSubTemplateList_t  *subTemplateList);
 
void
fbSubTemplateListClearWithoutFree(
    fbSubTemplateList_t  *subTemplateList);
 
void
fbSubTemplateListFree(
    fbSubTemplateList_t  *subTemplateList);
 
/********* END OF SUBTEMPLATELIST **********/
 
 
 
/******* SUBTEMPLATEMULTILIST FUNCTIONS ****/
 
typedef struct fbSubTemplateMultiListEntry_st fbSubTemplateMultiListEntry_t;
 
 
/* typedef struct fbSubTemplateMultiList_st fbSubTemplateMultiList_t; */
struct fbSubTemplateMultiList_st {
    fbSubTemplateMultiListEntry_t  *firstEntry;
    uint16_t                        numElements;
    uint8_t                         semantic;
};
 
 
struct fbSubTemplateMultiListEntry_st {
    const fbTemplate_t  *tmpl;
    uint8_t             *dataPtr;
    uint32_t             dataLength;
    uint32_t             recordLength;
    uint16_t             numElements;
    uint16_t             tmplID;
};
 
 
fbSubTemplateMultiList_t *
fbSubTemplateMultiListAlloc(
    void);
 
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListInit(
    fbSubTemplateMultiList_t  *STML,
    uint8_t                    semantic,
    uint16_t                   numElements);
 
uint16_t
fbSubTemplateMultiListCountElements(
    const fbSubTemplateMultiList_t  *STML);
 
void
fbSubTemplateMultiListSetSemantic(
    fbSubTemplateMultiList_t  *STML,
    uint8_t                    semantic);
 
uint8_t
fbSubTemplateMultiListGetSemantic(
    const fbSubTemplateMultiList_t  *STML);
 
void
fbSubTemplateMultiListClear(
    fbSubTemplateMultiList_t  *STML);
 
void
fbSubTemplateMultiListClearEntries(
    fbSubTemplateMultiList_t  *STML);
 
void
fbSubTemplateMultiListFree(
    fbSubTemplateMultiList_t  *STML);
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListResize(
    fbSubTemplateMultiList_t  *STML,
    uint16_t                   newCount);
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListAddNewEntries(
    fbSubTemplateMultiList_t  *STML,
    uint16_t                   additional);
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListGetFirstEntry(
    const fbSubTemplateMultiList_t  *STML);
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListGetIndexedEntry(
    const fbSubTemplateMultiList_t  *STML,
    uint16_t                         index);
 
fbSubTemplateMultiListEntry_t *
fbSubTemplateMultiListGetNextEntry(
    const fbSubTemplateMultiList_t       *STML,
    const fbSubTemplateMultiListEntry_t  *currentEntry);
 
#define fbSTMLNext(subTemplateMultiList, current) \
    fbSubTemplateMultiListGetNextEntry((subTemplateMultiList), (current))
 
void *
fbSubTemplateMultiListEntryInit(
    fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                        tmplID,
    const fbTemplate_t             *tmpl,
    uint16_t                        numElements);
 
void *
fbSubTemplateMultiListEntryResize(
    fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                        newCount);
 
void *
fbSubTemplateMultiListEntryAddNewElements(
    fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                        additional);
 
void
fbSubTemplateMultiListEntryClear(
    fbSubTemplateMultiListEntry_t  *entry);
 
void *
fbSubTemplateMultiListEntryGetDataPtr(
    const fbSubTemplateMultiListEntry_t  *entry);
 
void *
fbSubTemplateMultiListEntryNextDataPtr(
    const fbSubTemplateMultiListEntry_t  *entry,
    const void                           *currentPtr);
 
 
#define fbSTMLEntryNext(type, subTemplateMultiListEntry, current) \
    ((type *)(fbSubTemplateMultiListEntryNextDataPtr(             \
                  (subTemplateMultiListEntry), (current))))
 
void *
fbSubTemplateMultiListEntryGetIndexedPtr(
    const fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                              index);
 
uint16_t
fbSubTemplateMultiListEntryCountElements(
    const fbSubTemplateMultiListEntry_t  *entry);
 
const fbTemplate_t *
fbSubTemplateMultiListEntryGetTemplate(
    const fbSubTemplateMultiListEntry_t  *entry);
 
uint16_t
fbSubTemplateMultiListEntryGetTemplateID(
    const fbSubTemplateMultiListEntry_t  *entry);
 
/************** END OF STML FUNCTIONS *********** */
 
void
fBufListFree(
    const fbTemplate_t  *tmpl,
    uint8_t             *record);
 
 
fbListenerGroup_t *
fbListenerGroupAlloc(
    void);
 
void
fbListenerGroupFree(
    fbListenerGroup_t  *group);
 
int
fbListenerGroupAddListener(
    fbListenerGroup_t   *group,
    const fbListener_t  *listener);
 
int
fbListenerGroupDeleteListener(
    fbListenerGroup_t   *group,
    const fbListener_t  *listener);
 
fbListenerGroupResult_t *
fbListenerGroupWait(
    fbListenerGroup_t  *group,
    GError            **err);
 
void
fbListenerFreeGroupResult(
    fbListenerGroupResult_t  *result);
 
fBuf_t *
fbListenerOwnSocketCollectorTCP(
    fbListener_t  *listener,
    int            sock,
    GError       **err);
 
fBuf_t *
fbListenerOwnSocketCollectorTLS(
    fbListener_t  *listener,
    int            sock,
    GError       **err);
 
void
fBufInterruptSocket(
    fBuf_t  *fbuf);
 
 
typedef gboolean (*fbListenerAppInit_fn)(
    fbListener_t     *listener,
    void            **ctx,
    int               fd,
    struct sockaddr  *peer,
    size_t            peerlen,
    GError          **err);
 
typedef void (*fbListenerAppFree_fn)(
    void  *ctx);
 
gboolean
fBufSetInternalTemplate(
    fBuf_t    *fbuf,
    uint16_t   int_tid,
    GError   **err);
 
gboolean
fBufSetExportTemplate(
    fBuf_t    *fbuf,
    uint16_t   ext_tid,
    GError   **err);
 
gboolean
fBufSetTemplatesForExport(
    fBuf_t    *fbuf,
    uint16_t   tid,
    GError   **err);
 
void
fBufSetAutomaticNextMessage(
    fBuf_t    *fbuf,
    gboolean   automatic);
 
 
void
fBufSetAutomaticMode(
    fBuf_t    *fbuf,
    gboolean   automatic);
 
 
gboolean
fBufSetAutomaticElementInsert(
    fBuf_t  *fbuf,
    GError **err);
 
gboolean
fBufSetAutomaticInsert(
    fBuf_t  *fbuf,
    GError **err);
 
gboolean
fBufSetAutomaticMetadataAttach(
    fBuf_t  *fbuf,
    GError **err);
 
 
fbSession_t *
fBufGetSession(
    const fBuf_t  *fbuf);
 
void
fBufFree(
    fBuf_t  *fbuf);
 
fBuf_t *
fBufAllocForExport(
    fbSession_t   *session,
    fbExporter_t  *exporter);
 
fbExporter_t *
fBufGetExporter(
    const fBuf_t  *fbuf);
 
void
fBufSetExporter(
    fBuf_t        *fbuf,
    fbExporter_t  *exporter);
 
 
size_t
fBufRemaining(
    fBuf_t  *fbuf);
 
 
void
fBufSetBuffer(
    fBuf_t   *fbuf,
    uint8_t  *buf,
    size_t    buflen);
 
 
gboolean
fBufAppend(
    fBuf_t   *fbuf,
    uint8_t  *recbase,
    size_t    recsize,
    GError  **err);
 
gboolean
fBufEmit(
    fBuf_t  *fbuf,
    GError **err);
 
void
fBufSetExportTime(
    fBuf_t    *fbuf,
    uint32_t   extime);
 
fBuf_t *
fBufAllocForCollection(
    fbSession_t    *session,
    fbCollector_t  *collector);
 
fbCollector_t *
fBufGetCollector(
    const fBuf_t  *fbuf);
 
void
fBufSetCollector(
    fBuf_t         *fbuf,
    fbCollector_t  *collector);
 
gboolean
fBufNext(
    fBuf_t   *fbuf,
    uint8_t  *recbase,
    size_t   *recsize,
    GError  **err);
 
gboolean
fBufNextRecord(
    fBuf_t      *fbuf,
    fbRecord_t  *record,
    GError     **err);
 
gboolean
fBufNextMessage(
    fBuf_t  *fbuf,
    GError **err);
 
uint32_t
fBufGetExportTime(
    const fBuf_t  *fbuf);
 
fbTemplate_t *
fBufGetCollectionTemplate(
    const fBuf_t  *fbuf,
    uint16_t      *ext_tid);
 
fbTemplate_t *
fBufNextCollectionTemplate(
    fBuf_t    *fbuf,
    uint16_t  *ext_tid,
    GError   **err);
 
fbInfoModel_t *
fbInfoModelAlloc(
    void);
 
void
fbInfoModelFree(
    fbInfoModel_t  *model);
 
void
fbInfoModelAddElement(
    fbInfoModel_t          *model,
    const fbInfoElement_t  *ie);
 
void
fbInfoModelAddElementArray(
    fbInfoModel_t          *model,
    const fbInfoElement_t  *ie);
 
gboolean
fbInfoModelReadXMLFile(
    fbInfoModel_t  *model,
    const gchar    *filename,
    GError        **err);
 
gboolean
fbInfoModelReadXMLData(
    fbInfoModel_t  *model,
    const gchar    *xml_data,
    gssize          xml_data_len,
    GError        **err);
 
const fbInfoElement_t *
fbInfoModelGetElementByName(
    const fbInfoModel_t  *model,
    const char           *name);
 
const fbInfoElement_t *
fbInfoModelGetElementByID(
    const fbInfoModel_t  *model,
    uint16_t              id,
    uint32_t              ent);
 
gboolean
fbInfoModelContainsElement(
    const fbInfoModel_t    *model,
    const fbInfoElement_t  *element);
 
 
guint
fbInfoModelCountElements(
    const fbInfoModel_t  *model);
 
void
fbInfoModelIterInit(
    fbInfoModelIter_t    *iter,
    const fbInfoModel_t  *model);
 
const fbInfoElement_t *
fbInfoModelIterNext(
    fbInfoModelIter_t  *iter);
 
fbTemplate_t *
fbInfoElementAllocTypeTemplate(
    fbInfoModel_t  *model,
    GError        **err);
 
gboolean
fbInfoElementWriteOptionsRecord(
    fBuf_t                 *fbuf,
    const fbInfoElement_t  *model_ie,
    uint16_t                itid,
    uint16_t                etid,
    GError                **err);
 
gboolean
fbInfoElementAddOptRecElement(
    fbInfoModel_t                *model,
    const fbInfoElementOptRec_t  *rec);
 
gboolean
fbTemplateIsMetadata(
    const fbTemplate_t  *tmpl,
    uint32_t             tests);
 
#define FB_TMPL_IS_OPTIONS          (1u << 0)
 
#define FB_TMPL_IS_META_ELEMENT     (1u << 1)
 
#define FB_TMPL_IS_META_TEMPLATE_V1 (1u << 2)
 
#define FB_TMPL_IS_META_TEMPLATE_V3 (1u << 3)
 
#define FB_TMPL_IS_META_BASICLIST   (1u << 4)
 
#define FB_TMPL_IS_META_TMPL_ANY   \
    (FB_TMPL_IS_OPTIONS |          \
     FB_TMPL_IS_META_TEMPLATE_V1 | \
     FB_TMPL_IS_META_BASICLIST)
 
#define FB_TMPL_IS_META_ANY     \
    (FB_TMPL_IS_OPTIONS |       \
     FB_TMPL_IS_META_TMPL_ANY | \
     FB_TMPL_IS_META_ELEMENT)
 
fbTemplate_t *
fbTemplateAlloc(
    fbInfoModel_t  *model);
 
gboolean
fbTemplateAppend(
    fbTemplate_t           *tmpl,
    const fbInfoElement_t  *ex_ie,
    GError                **err);
 
gboolean
fbTemplateAppendSpec(
    fbTemplate_t               *tmpl,
    const fbInfoElementSpec_t  *spec,
    uint32_t                    wantedFlags,
    GError                    **err);
 
gboolean
fbTemplateAppendSpecArray(
    fbTemplate_t               *tmpl,
    const fbInfoElementSpec_t  *spec,
    uint32_t                    wantedFlags,
    GError                    **err);
 
gboolean
fbTemplateAppendSpecId(
    fbTemplate_t                 *tmpl,
    const fbInfoElementSpecId_t  *spec,
    uint32_t                      wantedFlags,
    GError                      **err);
 
gboolean
fbTemplateAppendArraySpecId(
    fbTemplate_t                 *tmpl,
    const fbInfoElementSpecId_t  *spec,
    uint32_t                      wantedFlags,
    GError                      **err);
 
 
#define FB_TMPL_COPY_REMOVE_PADDING     0x01u
 
#define FB_TMPL_COPY_IGNORE_SCOPE       0x04u
 
 
fbTemplate_t *
fbTemplateCopy(
    const fbTemplate_t  *tmpl,
    uint32_t             flags);
 
 
uint16_t
fbTemplateCountElements(
    const fbTemplate_t  *tmpl);
 
gboolean
fbTemplateSetOptionsScope(
    fbTemplate_t  *tmpl,
    uint16_t       scope_count);
 
uint16_t
fbTemplateGetOptionsScope(
    const fbTemplate_t  *tmpl);
 
gboolean
fbTemplateContainsElement(
    const fbTemplate_t     *tmpl,
    const fbInfoElement_t  *element);
 
const fbTemplateField_t *
fbTemplateFindFieldByElement(
    const fbTemplate_t     *tmpl,
    const fbInfoElement_t  *ie,
    uint16_t               *position,
    uint16_t                skip);
 
 
const fbTemplateField_t *
fbTemplateFindFieldByIdent(
    const fbTemplate_t  *tmpl,
    uint32_t             ent,
    uint16_t             num,
    uint16_t            *position,
    uint16_t             skip);
 
 
const fbTemplateField_t *
fbTemplateFindFieldByDataType(
    const fbTemplate_t       *tmpl,
    fbInfoElementDataType_t   datatype,
    uint16_t                 *position,
    uint16_t                  skip);
 
 
gboolean
fbTemplateContainsElementByName(
    const fbTemplate_t         *tmpl,
    const fbInfoElementSpec_t  *spec);
 
gboolean
fbTemplateContainsAllElementsByName(
    const fbTemplate_t         *tmpl,
    const fbInfoElementSpec_t  *spec);
 
gboolean
fbTemplateContainsAllFlaggedElementsByName(
    const fbTemplate_t         *tmpl,
    const fbInfoElementSpec_t  *spec,
    uint32_t                    wantedFlags);
 
gboolean
fbTemplateContainsSpecId(
    const fbTemplate_t           *tmpl,
    const fbInfoElementSpecId_t  *spec);
 
gboolean
fbTemplateContainsAllArraySpecId(
    const fbTemplate_t           *tmpl,
    const fbInfoElementSpecId_t  *spec);
 
gboolean
fbTemplateContainsAllFlaggedArraySpecId(
    const fbTemplate_t           *tmpl,
    const fbInfoElementSpecId_t  *spec,
    uint32_t                      wantedFlags);
 
const fbTemplateField_t *
fbTemplateGetFieldByPosition(
    const fbTemplate_t  *tmpl,
    uint16_t             position);
 
const fbTemplateField_t *
fbTemplateGetIndexedIE(
    const fbTemplate_t  *tmpl,
    uint16_t             position)
__attribute__((__deprecated__));
 
fbInfoModel_t *
fbTemplateGetInfoModel(
    const fbTemplate_t  *tmpl);
 
void
fbTemplateFreeUnused(
    fbTemplate_t  *tmpl);
 
void *
fbTemplateGetContext(
    const fbTemplate_t  *tmpl);
 
 
void
fbTemplateSetContext(
    fbTemplate_t          *tmpl,
    void                  *tmpl_ctx,
    void                  *app_ctx,
    fbTemplateCtxFree_fn   ctx_free);
 
uint16_t
fbTemplateGetIELenOfMemBuffer(
    const fbTemplate_t  *tmpl);
 
gboolean
fbTemplatesAreEqual(
    const fbTemplate_t  *tmpl1,
    const fbTemplate_t  *tmpl2);
 
 
int
fbTemplatesCompare(
    const fbTemplate_t  *tmpl1,
    const fbTemplate_t  *tmpl2,
    unsigned int         flags);
 
 
typedef enum fbTemplateSetCompareStatus_en {
    FB_TMPL_SETCMP_SUBSET = 1,
    FB_TMPL_SETCMP_EQUAL = 2,
    FB_TMPL_SETCMP_SUPERSET = 3,
    FB_TMPL_SETCMP_COMMON = 4,
    FB_TMPL_SETCMP_DISJOINT = 8
} fbTemplatesSetCompareStatus_t;
 
fbTemplatesSetCompareStatus_t
fbTemplatesSetCompare(
    const fbTemplate_t  *tmpl1,
    const fbTemplate_t  *tmpl2,
    uint16_t            *matching_fields,
    unsigned int         flags);
 
#define FB_TMPL_CMP_IGNORE_PADDING      0x01u
 
#define FB_TMPL_CMP_IGNORE_LENGTHS      0x02u
 
#define FB_TMPL_CMP_IGNORE_SCOPE        0x04u
 
 
uint16_t
fbRecordGetFieldCount(
    const fbRecord_t  *record);
 
void
fbRecordFreeLists(
    fbRecord_t  *record);
 
 
void
fbRecordValueClear(
    fbRecordValue_t  *value);
 
fbRecordValue_t *
fbRecordValueCopy(
    fbRecordValue_t        *dstValue,
    const fbRecordValue_t  *srcValue);
 
gchar *
fbRecordValueTakeVarfieldBuf(
    fbRecordValue_t  *value);
 
 
gboolean
fbRecordGetValueForField(
    const fbRecord_t         *record,
    const fbTemplateField_t  *field,
    fbRecordValue_t          *value);
 
gboolean
fbRecordCopyFieldValue(
    const fbRecord_t         *record,
    const fbTemplateField_t  *field,
    void                     *dest,
    size_t                    destlen);
 
 
gboolean
fbRecordFindValueForInfoElement(
    const fbRecord_t       *record,
    const fbInfoElement_t  *ie,
    fbRecordValue_t        *value,
    uint16_t               *position,
    uint16_t                skip);
 
const fbBasicList_t *
fbRecordFindBasicListOfIE(
    const fbRecord_t       *record,
    const fbInfoElement_t  *contentsElement,
    uint16_t               *position,
    uint16_t                skip);
 
 
const fbSubTemplateList_t *
fbRecordFindStlOfTemplate(
    const fbRecord_t    *record,
    const fbTemplate_t  *tmpl,
    uint16_t            *position,
    uint16_t             skip);
 
 
typedef int (*fbRecordValueCallback_fn)(
    const fbRecord_t       *parent_record,
    const fbBasicList_t    *parent_bl,
    const fbInfoElement_t  *field,
    const fbRecordValue_t  *value,
    void                   *ctx);
 
int
fbRecordFindAllElementValues(
    const fbRecord_t          *record,
    const fbInfoElement_t     *ie,
    unsigned int               flags,
    fbRecordValueCallback_fn   callback,
    void                      *ctx);
 
 
typedef int (*fbRecordSubRecordCallback_fn)(
    const fbRecord_t  *record,
    void              *ctx);
 
 
int
fbRecordFindAllSubRecords(
    const fbRecord_t              *record,
    uint16_t                       tid,
    unsigned int                   flags,
    fbRecordSubRecordCallback_fn   callback,
    void                          *ctx);
 
 
gboolean
fbRecordCopyToTemplate(
    const fbRecord_t    *srcRec,
    fbRecord_t          *dstRec,
    const fbTemplate_t  *tmpl,
    uint16_t             tid,
    GError             **err);
 
 
 
fbSession_t *
fbSessionAlloc(
    fbInfoModel_t  *model);
 
 
uint16_t
fbSessionSetMetadataExportElements(
    fbSession_t  *session,
    gboolean      enabled,
    uint16_t      tid,
    GError      **err);
 
uint16_t
fbSessionSetMetadataExportTemplates(
    fbSession_t  *session,
    gboolean      enabled,
    uint16_t      tmplInfoTid,
    uint16_t      blInfoTid,
    GError      **err);
 
fbInfoModel_t *
fbSessionGetInfoModel(
    const fbSession_t  *session);
 
void
fbSessionAddNewTemplateCallback(
    fbSession_t               *session,
    fbNewTemplateCallback_fn   callback,
    void                      *app_ctx);
 
 
void
fbSessionSetCallbackCopyTemplates(
    fbSession_t  *incomingSession,
    fbSession_t  *exportSession);
 
 
void
fbSessionCopyIncomingTemplatesCallback(
    fbSession_t           *incomingSession,
    uint16_t               tid,
    fbTemplate_t          *tmpl,
    void                  *exportSession,
    void                 **tmpl_ctx,
    fbTemplateCtxFree_fn  *tmpl_ctx_free_fn);
 
void
fbSessionAddTemplatePair(
    fbSession_t  *session,
    uint16_t      ext_tid,
    uint16_t      int_tid);
 
void
fbSessionRemoveTemplatePair(
    fbSession_t  *session,
    uint16_t      ext_tid);
 
uint16_t
fbSessionLookupTemplatePair(
    const fbSession_t  *session,
    uint16_t            ext_tid);
 
void
fbSessionFree(
    fbSession_t  *session);
 
void
fbSessionResetExternal(
    fbSession_t  *session);
 
void
fbSessionSetDomain(
    fbSession_t  *session,
    uint32_t      domain);
 
uint32_t
fbSessionGetDomain(
    const fbSession_t  *session);
 
uint16_t
fbSessionGetLargestInternalTemplateSize(
    fbSession_t  *session);
 
fbCollector_t *
fbSessionGetCollector(
    const fbSession_t  *session);
 
gboolean
fbSessionExportTemplate(
    fbSession_t  *session,
    uint16_t      tid,
    GError      **err);
 
gboolean
fbSessionExportTemplates(
    fbSession_t  *session,
    GError      **err);
 
uint16_t
fbSessionAddTemplate(
    fbSession_t       *session,
    gboolean           internal,
    uint16_t           tid,
    fbTemplate_t      *tmpl,
    fbTemplateInfo_t  *tmplInfo,
    GError           **err);
 
 
uint16_t
fbSessionAddTemplatesForExport(
    fbSession_t       *session,
    uint16_t           tid,
    fbTemplate_t      *tmpl,
    fbTemplateInfo_t  *tmplInfo,
    GError           **err);
 
 
gboolean
fbSessionRemoveTemplate(
    fbSession_t  *session,
    gboolean      internal,
    uint16_t      tid,
    GError      **err);
 
fbTemplate_t *
fbSessionGetTemplate(
    const fbSession_t  *session,
    gboolean            internal,
    uint16_t            tid,
    GError            **err);
 
fbExporter_t *
fbExporterAllocNet(
    const fbConnSpec_t  *spec);
 
fbExporter_t *
fbExporterAllocFile(
    const char  *path);
 
fbExporter_t *
fbExporterAllocBuffer(
    uint8_t   *buf,
    uint16_t   bufsize);
 
 
fbExporter_t *
fbExporterAllocFP(
    FILE  *fp);
 
 
void
fbExporterSetStream(
    fbExporter_t  *exporter,
    int            sctp_stream);
 
void
fbExporterAutoStream(
    fbExporter_t  *exporter);
 
void
fbExporterClose(
    fbExporter_t  *exporter);
 
size_t
fbExporterGetMsgLen(
    const fbExporter_t  *exporter);
 
size_t
fbExporterGetOctetCount(
    const fbExporter_t  *exporter);
 
size_t
fbExporterGetOctetCountAndReset(
    fbExporter_t  *exporter);
 
void
fbExporterResetOctetCount(
    fbExporter_t  *exporter);
 
fbCollector_t *
fbCollectorAllocFile(
    void        *ctx,
    const char  *path,
    GError     **err);
 
fbCollector_t *
fbCollectorAllocFP(
    void  *ctx,
    FILE  *fp);
 
 
void *
fbCollectorGetContext(
    const fbCollector_t  *collector);
 
void
fbCollectorClose(
    fbCollector_t  *collector);
 
 
void
fbCollectorSetAcceptOnly(
    fbCollector_t    *collector,
    struct sockaddr  *address,
    size_t            address_length);
 
fbListener_t *
fbListenerAlloc(
    const fbConnSpec_t    *spec,
    fbSession_t           *session,
    fbListenerAppInit_fn   appinit,
    fbListenerAppFree_fn   appfree,
    GError               **err);
 
void
fbListenerFree(
    fbListener_t  *listener);
 
fBuf_t *
fbListenerWait(
    fbListener_t  *listener,
    GError       **err);
 
fBuf_t *
fbListenerWaitNoCollectors(
    fbListener_t  *listener,
    GError       **err);
 
void
fbListenerInterrupt(
    fbListener_t  *listener);
 
 
gboolean
fbListenerGetCollector(
    const fbListener_t  *listener,
    fbCollector_t      **collector,
    GError             **err);
 
 
 
gboolean
fbCollectorClearTranslator(
    fbCollector_t  *collector,
    GError        **err);
 
 
gboolean
fbCollectorSetNetflowV9Translator(
    fbCollector_t  *collector,
    GError        **err);
 
 
gboolean
fbCollectorSetSFlowTranslator(
    fbCollector_t  *collector,
    GError        **err);
 
uint32_t
fbCollectorGetNetflowMissed(
    const fbCollector_t    *collector,
    const struct sockaddr  *peer,
    size_t                  peerlen,
    uint32_t                obdomain);
 
uint32_t
fbCollectorGetSFlowMissed(
    const fbCollector_t    *collector,
    const struct sockaddr  *peer,
    size_t                  peerlen,
    uint32_t                obdomain);
 
const struct sockaddr *
fbCollectorGetPeer(
    const fbCollector_t  *collector);
 
uint32_t
fbCollectorGetObservationDomain(
    const fbCollector_t  *collector);
 
void
fbCollectorSetUDPMultiSession(
    fbCollector_t  *collector,
    gboolean        multi_session);
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* _FB_PUBLIC_H_ */
 
/*
 *  @DISTRIBUTION_STATEMENT_BEGIN@
 *  @DISTRIBUTION_STATEMENT_END@
 */