public.h

Go to the documentation of this file.

/*
 *  Copyright 2006-2024 Carnegie Mellon University
 *  See license information in LICENSE.txt.
 */
/*
 *  ------------------------------------------------------------------------
 *  Authors: Brian Trammell, Dan Ruef
 *  ------------------------------------------------------------------------
 *  @DISTRIBUTION_STATEMENT_BEGIN@
 *  libfixbuf 2.5
 *
 *  Copyright 2024 Carnegie Mellon University.
 *
 *  NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING
 *  INSTITUTE MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON
 *  UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESSED OR
 *  IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF
 *  FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS
 *  OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT
 *  MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT,
 *  TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 *
 *  Licensed under a GNU-Lesser GPL 3.0-style license, please see
 *  LICENSE.txt or contact permission@sei.cmu.edu for full terms.
 *
 *  [DISTRIBUTION STATEMENT A] This material has been approved for public
 *  release and unlimited distribution.  Please see Copyright notice for
 *  non-US Government use and distribution.
 *
 *  This Software includes and/or makes use of Third-Party Software each
 *  subject to its own license.
 *
 *  DM24-1020
 *  @DISTRIBUTION_STATEMENT_END@
 *  ------------------------------------------------------------------------
 */
 
#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_)\
    { {(const struct fbInfoElement_st*)_name_}, 0, _ent_, _num_, _len_, _flags_, _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
 
#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
 
#define FB_IE_VARLEN                            65535
 
#define FB_IE_BASIC_LIST                        291
#define FB_IE_SUBTEMPLATE_LIST                  292
#define FB_IE_SUBTEMPLATE_MULTILIST             293
 
#define FB_IE_PEN_REVERSE                       29305
 
#define FB_IE_VENDOR_BIT_REVERSE                0x4000
 
#define FB_CISCO_GENERIC                       9999
#define FB_CISCO_ASA_EVENT_ID                  9998
#define FB_CISCO_ASA_EVENT_XTRA                9997
#define FB_IE_REVERSE_STR                       "reverse"
 
#define FB_IE_REVERSE_STRLEN                    7
 
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 fbInfoElement_st {
    union {
        const struct fbInfoElement_st *canon;
        const char                    *name;
    }  ref;
 
    uint32_t            midx;
    uint32_t            ent;
    uint16_t            num;
    uint16_t            len;
    uint32_t            flags;
    uint64_t            min;
    uint64_t            max;
    uint8_t             type;
    const char          *description;
} fbInfoElement_t;
 
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
 
typedef struct fbTemplate_st fbTemplate_t;
 
#define FB_IESPEC_NULL { NULL, 0, 0 }
 
typedef struct fbInfoElementSpec_st {
    char                *name;
    uint16_t            len_override;
    uint32_t            flags;
} fbInfoElementSpec_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;
 
#define FB_CONNSPEC_INIT { FB_SCTP, NULL, NULL,         \
                           NULL, NULL, NULL, NULL,      \
                           NULL, NULL }
 
#if HAVE_SPREAD
 
#define FB_SPREADPARAMS_INIT { 0, 0, 0 }
 
typedef struct fbSpreadParams_st {
    fbSession_t * session;
    char *          daemon;
    char **         groups;
} fbSpreadParams_t;
 
#endif /* HAVE_SPREAD */
 
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);
 
 
#define FB_LIST_SEM_UNDEFINED       0xFF
#define FB_LIST_SEM_NONE_OF         0x00
#define FB_LIST_SEM_EXACTLY_ONE_OF  0x01
#define FB_LIST_SEM_ONE_OR_MORE_OF  0x02
#define FB_LIST_SEM_ALL_OF          0x03
#define FB_LIST_SEM_ORDERED         0x04
 
gboolean fbListValidSemantic(
    uint8_t semantic);
 
/****** BASICLIST FUNCTIONS AND STRUCTS *******/
typedef struct fbBasicList_st {
    const fbInfoElement_t   *infoElement;
    uint8_t                 *dataPtr;
    uint16_t                numElements;
    uint16_t                dataLength;
    uint8_t                 semantic;
} fbBasicList_t;
 
 
fbBasicList_t*  fbBasicListAlloc(
    void);
 
void* fbBasicListInit(
    fbBasicList_t          *basicList,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                numElements);
 
void* fbBasicListInitWithOwnBuffer(
    fbBasicList_t          *basicList,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                numElements,
    uint16_t                dataLength,
    uint8_t                *dataPtr);
 
void fbBasicListCollectorInit(
    fbBasicList_t  *basicList);
 
uint16_t fbBasicListCountElements(
    const fbBasicList_t    *basicList);
 
uint8_t fbBasicListGetSemantic(
    fbBasicList_t  *basicList);
 
void fbBasicListSetSemantic(
    fbBasicList_t  *basicList,
    uint8_t         semantic);
 
const fbInfoElement_t*  fbBasicListGetInfoElement(
     fbBasicList_t  *basicList);
 
void* fbBasicListGetDataPtr(
    fbBasicList_t   *basicList);
 
void* fbBasicListGetIndexedDataPtr(
    fbBasicList_t   *basicList,
    uint16_t         index);
 
void* fbBasicListGetNextPtr(
    fbBasicList_t   *basicList,
    void            *currentPtr);
 
void* fbBasicListRealloc(
    fbBasicList_t  *basicList,
    uint16_t        newNumElements);
 
void* fbBasicListAddNewElements(
    fbBasicList_t  *basicList,
    uint16_t        numNewElements);
 
void fbBasicListClear(
    fbBasicList_t  *basicList);
 
void fbBasicListClearWithoutFree(
    fbBasicList_t  *basicList);
 
void fbBasicListFree(
    fbBasicList_t  *basicList);
 
 
/******* END OF BASICLIST ********/
 
 
 
/******* SUBTEMPLATELIST FUNCTIONS ****/
 
typedef struct fbSubTemplateList_st {
    union {
        size_t          length;
        uint64_t        extra;
    } dataLength;
    const fbTemplate_t  *tmpl;
    uint8_t             *dataPtr;
    uint16_t            tmplID;
    uint16_t            numElements;
    uint8_t             semantic;
} fbSubTemplateList_t;
 
fbSubTemplateList_t* fbSubTemplateListAlloc(
    void);
 
void* fbSubTemplateListInit(
    fbSubTemplateList_t    *sTL,
    uint8_t                 semantic,
    uint16_t                tmplID,
    const fbTemplate_t     *tmpl,
    uint16_t                numElements);
 
void* fbSubTemplateListInitWithOwnBuffer(
    fbSubTemplateList_t    *subTemplateList,
    uint8_t                 semantic,
    uint16_t                tmplID,
    const fbTemplate_t     *tmpl,
    uint16_t                numElements,
    uint16_t                dataLength,
    uint8_t                *dataPtr);
 
void fbSubTemplateListCollectorInit(
    fbSubTemplateList_t    *STL);
 
void* fbSubTemplateListGetDataPtr(
    const fbSubTemplateList_t  *subTemplateList);
 
void* fbSubTemplateListGetIndexedDataPtr(
    const fbSubTemplateList_t  *subTemplateList,
    uint16_t                    index);
 
void* fbSubTemplateListGetNextPtr(
    const fbSubTemplateList_t  *subTemplateList,
    void                       *currentPtr);
 
uint16_t fbSubTemplateListCountElements(
    const fbSubTemplateList_t  *subTemplateList);
 
void fbSubTemplateListSetSemantic(
    fbSubTemplateList_t    *subTemplateList,
    uint8_t                 semantic);
 
uint8_t fbSubTemplateListGetSemantic(
    fbSubTemplateList_t    *subTemplateList);
 
const fbTemplate_t* fbSubTemplateListGetTemplate(
    fbSubTemplateList_t    *subTemplateList);
 
uint16_t fbSubTemplateListGetTemplateID(
    fbSubTemplateList_t    *subTemplateList);
 
void* fbSubTemplateListRealloc(
    fbSubTemplateList_t    *subTemplateList,
    uint16_t                newNumElements);
 
void* fbSubTemplateListAddNewElements(
    fbSubTemplateList_t    *subTemplateList,
    uint16_t                numNewElements);
 
void fbSubTemplateListClear(
    fbSubTemplateList_t    *subTemplateList);
 
void fbSubTemplateListClearWithoutFree(
    fbSubTemplateList_t    *subTemplateList);
 
void fbSubTemplateListFree(
    fbSubTemplateList_t    *subTemplateList);
 
/********* END OF SUBTEMPLATELIST **********/
typedef struct fbSubTemplateMultiListEntry_st {
    fbTemplate_t   *tmpl;
    uint8_t        *dataPtr;
    size_t          dataLength;
    uint16_t        tmplID;
    uint16_t        numElements;
} fbSubTemplateMultiListEntry_t;
 
typedef struct fbSubTemplateMultiList_st {
    fbSubTemplateMultiListEntry_t  *firstEntry;
    uint16_t                        numElements;
    uint8_t                         semantic;
} fbSubTemplateMultiList_t;
 
 
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(
    fbSubTemplateMultiList_t   *STML);
 
void fbSubTemplateMultiListClear(
    fbSubTemplateMultiList_t   *STML);
 
void fbSubTemplateMultiListClearEntries(
    fbSubTemplateMultiList_t   *STML);
 
void fbSubTemplateMultiListFree(
    fbSubTemplateMultiList_t   *STML);
 
fbSubTemplateMultiListEntry_t* fbSubTemplateMultiListRealloc(
    fbSubTemplateMultiList_t   *STML,
    uint16_t                    newNumEntries);
 
fbSubTemplateMultiListEntry_t* fbSubTemplateMultiListAddNewEntries(
    fbSubTemplateMultiList_t   *STML,
    uint16_t                    numNewEntries);
 
fbSubTemplateMultiListEntry_t* fbSubTemplateMultiListGetFirstEntry(
    fbSubTemplateMultiList_t   *STML);
 
fbSubTemplateMultiListEntry_t* fbSubTemplateMultiListGetIndexedEntry(
    fbSubTemplateMultiList_t   *STML,
    uint16_t                    index);
 
fbSubTemplateMultiListEntry_t* fbSubTemplateMultiListGetNextEntry(
    fbSubTemplateMultiList_t       *STML,
    fbSubTemplateMultiListEntry_t  *currentEntry);
 
void* fbSubTemplateMultiListEntryInit(
    fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                        tmplID,
    fbTemplate_t                   *tmpl,
    uint16_t                        numElements);
 
void* fbSubTemplateMultiListEntryRealloc(
    fbSubTemplateMultiListEntry_t  *entry,
    uint16_t                        newNumElements);
 
void* fbSubTemplateMultiListEntryAddNewElements(
    fbSubTemplateMultiListEntry_t   *entry,
    uint16_t                         numNewElements);
 
void fbSubTemplateMultiListEntryClear(
    fbSubTemplateMultiListEntry_t   *entry);
 
void* fbSubTemplateMultiListEntryGetDataPtr(
    fbSubTemplateMultiListEntry_t   *entry);
 
void* fbSubTemplateMultiListEntryNextDataPtr(
    fbSubTemplateMultiListEntry_t   *entry,
    void                            *currentPtr);
 
void* fbSubTemplateMultiListEntryGetIndexedPtr(
    fbSubTemplateMultiListEntry_t   *entry,
    uint16_t                         index);
 
uint16_t fbSubTemplateMultiListEntryCountElements(
    const fbSubTemplateMultiListEntry_t  *entry);
 
const fbTemplate_t* fbSubTemplateMultiListEntryGetTemplate(
    fbSubTemplateMultiListEntry_t   *entry);
 
uint16_t fbSubTemplateMultiListEntryGetTemplateID(
    fbSubTemplateMultiListEntry_t   *entry);
 
/************** END OF STML FUNCTIONS *********** */
 
void fBufListFree(
    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);
 
/*
 * Public Function Calls. These calls will remain available and retain
 * their functionality in all subsequent versions of libfixbuf.
 */
 
 
gboolean            fBufSetInternalTemplate(
    fBuf_t              *fbuf,
    uint16_t            int_tid,
    GError              **err);
 
gboolean            fBufSetExportTemplate(
    fBuf_t              *fbuf,
    uint16_t            ext_tid,
    GError              **err);
 
#if HAVE_SPREAD
void                 fBufSetSpreadExportGroup(
    fBuf_t             *fbuf,
    char               **groups,
    int                num_groups,
    GError             **err);
#endif  /* HAVE_SPREAD */
 
void                fBufSetAutomaticMode(
    fBuf_t              *fbuf,
    gboolean            automatic);
 
gboolean         fBufSetAutomaticInsert(
    fBuf_t             *fbuf,
    GError             **err);
 
 
fbSession_t         *fBufGetSession(
    fBuf_t              *fbuf);
 
void                fBufFree(
    fBuf_t              *fbuf);
 
fBuf_t              *fBufAllocForExport(
    fbSession_t         *session,
    fbExporter_t        *exporter);
 
fbExporter_t        *fBufGetExporter(
    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(
    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            fBufNextMessage(
    fBuf_t              *fbuf,
    GError              **err);
 
uint32_t            fBufGetExportTime(
    fBuf_t              *fbuf);
 
fbTemplate_t    *fBufGetCollectionTemplate(
    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,
    fbInfoElement_t     *ie);
 
void                fbInfoModelAddElementArray(
    fbInfoModel_t       *model,
    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(
    fbInfoModel_t       *model,
    const char          *name);
 
const fbInfoElement_t    *fbInfoModelGetElementByID(
    fbInfoModel_t       *model,
    uint16_t            id,
    uint32_t            ent);
 
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,
    fbInfoElementOptRec_t   *rec);
 
gboolean fbInfoModelTypeInfoRecord(
    fbTemplate_t            *tmpl);
 
fbTemplate_t        *fbTemplateAlloc(
    fbInfoModel_t       *model);
 
gboolean            fbTemplateAppend(
    fbTemplate_t        *tmpl,
    fbInfoElement_t     *ex_ie,
    GError              **err);
 
gboolean            fbTemplateAppendSpec(
    fbTemplate_t        *tmpl,
    fbInfoElementSpec_t *spec,
    uint32_t            flags,
    GError              **err);
 
gboolean            fbTemplateAppendSpecArray(
    fbTemplate_t        *tmpl,
    fbInfoElementSpec_t *spec,
    uint32_t            flags,
    GError              **err);
 
uint32_t            fbTemplateCountElements(
    fbTemplate_t        *tmpl);
 
void                fbTemplateSetOptionsScope(
    fbTemplate_t        *tmpl,
    uint16_t            scope_count);
 
uint32_t            fbTemplateGetOptionsScope(
    fbTemplate_t        *tmpl);
 
gboolean           fbTemplateContainsElement(
    fbTemplate_t            *tmpl,
    const fbInfoElement_t   *ex_ie);
 
gboolean           fbTemplateContainsElementByName(
    fbTemplate_t        *tmpl,
    fbInfoElementSpec_t *spec);
 
gboolean           fbTemplateContainsAllElementsByName(
    fbTemplate_t        *tmpl,
    fbInfoElementSpec_t *spec);
 
gboolean            fbTemplateContainsAllFlaggedElementsByName(
    fbTemplate_t        *tmpl,
    fbInfoElementSpec_t *spec,
    uint32_t             flags);
 
fbInfoElement_t*    fbTemplateGetIndexedIE(
    fbTemplate_t       *tmpl,
    uint32_t            IEindex);
 
 
fbInfoModel_t *     fbTemplateGetInfoModel(
    fbTemplate_t        *tmpl);
 
void                fbTemplateFreeUnused(
    fbTemplate_t        *tmpl);
 
void               *fbTemplateGetContext(
    fbTemplate_t         *tmpl);
 
uint16_t            fbTemplateGetIELenOfMemBuffer(
    fbTemplate_t         *tmpl);
 
fbSession_t         *fbSessionAlloc(
    fbInfoModel_t       *model);
 
gboolean fbSessionEnableTypeMetadata(
    fbSession_t                *session,
    gboolean                    enabled,
    GError                    **err);
 
uint16_t fbSessionSetMetadataExportElements(
    fbSession_t                *session,
    gboolean                    enabled,
    uint16_t                    tid,
    GError                    **err);
 
gboolean fbSessionEnableTemplateMetadata(
    fbSession_t                *session,
    gboolean                    enabled,
    GError                    **err);
 
uint16_t fbSessionSetMetadataExportTemplates(
    fbSession_t                *session,
    gboolean                    enabled,
    uint16_t                    tid,
    GError                    **err);
 
uint16_t fbSessionAddTemplateWithMetadata(
    fbSession_t         *session,
    gboolean             internal,
    uint16_t             tid,
    fbTemplate_t        *tmpl,
    const char          *name,
    const char          *description,
    GError              **err);
 
fbInfoModel_t       *fbSessionGetInfoModel(
    fbSession_t         *session);
 
void fbSessionAddNewTemplateCallback(
    fbSession_t               *session,
    fbNewTemplateCallback_fn   callback,
    void                      *app_ctx);
 
void fbSessionAddTemplatePair(
    fbSession_t    *session,
    uint16_t        ent_tid,
    uint16_t        int_tid);
 
void fbSessionRemoveTemplatePair(
    fbSession_t    *session,
    uint16_t        ext_tid);
 
uint16_t    fbSessionLookupTemplatePair(
    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(
    fbSession_t         *session);
 
uint16_t            fbSessionGetLargestInternalTemplateSize(
    fbSession_t        *session);
 
fbCollector_t *fbSessionGetCollector(
    fbSession_t        *session);
 
#if HAVE_SPREAD
uint16_t        fbSessionAddTemplatesMulticast(
    fbSession_t      *session,
    char             **groups,
    gboolean         internal,
    uint16_t         tid,
    fbTemplate_t     *tmpl,
    GError           **err);
 
uint16_t fbSessionAddTemplatesMulticastWithMetadata(
    fbSession_t      *session,
    char             **groups,
    gboolean         internal,
    uint16_t         tid,
    fbTemplate_t     *tmpl,
    char             *name,
    char             *description,
    GError           **err);
 
 
gboolean fbSessionSpreadEnableTemplateMetadata(
    fbSession_t                *session,
    char                       **groups,
    gboolean                   enabled,
    GError                     **err);
 
uint16_t fbSessionSpreadSetMetadataExportTemplates(
    fbSession_t                *session,
    char                       **groups,
    gboolean                   enabled,
    uint16_t                   tid,
    GError                     **err);
 
gboolean fbSessionSpreadEnableTypeMetadata(
    fbSession_t                *session,
    char                       **groups,
    gboolean                   enabled,
    GError                     **err);
 
uint16_t fbSessionSpreadSetMetadataExportElements(
    fbSession_t                *session,
    char                       **groups,
    gboolean                   enabled,
    uint16_t                   tid,
    GError                     **err);
#endif  /* HAVE_SPREAD */
 
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,
    GError              **err);
 
gboolean            fbSessionRemoveTemplate(
    fbSession_t         *session,
    gboolean            internal,
    uint16_t            tid,
    GError              **err);
 
fbTemplate_t        *fbSessionGetTemplate(
    fbSession_t         *session,
    gboolean            internal,
    uint16_t            tid,
    GError              **err);
 
fbExporter_t        *fbExporterAllocNet(
    fbConnSpec_t        *spec);
 
#if HAVE_SPREAD
int fbCollectorGetSpreadReturnGroups(
    fbCollector_t *collector,
    char *groups[]);
 
fbExporter_t        *fbExporterAllocSpread(
    fbSpreadParams_t      *params);
 
#endif /* HAVE_SPREAD */
 
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(
    fbExporter_t   *exporter);
 
void fbExporterAddSourceIP(
    fbExporter_t   *exporter,
    const char     *source_ip_v4);
 
void fbExporterAddSourceIP6(
    fbExporter_t   *exporter,
    const char     *source_ip_v6);
 
fbCollector_t       *fbCollectorAllocFile(
    void                *ctx,
    const char          *path,
    GError              **err);
 
fbCollector_t       *fbCollectorAllocFP(
    void                *ctx,
    FILE                *fp);
 
 
#if HAVE_SPREAD
fbCollector_t       *fbCollectorAllocSpread(
    void                *ctx,
    fbSpreadParams_t    *params,
    GError              **err);
 
#endif /* HAVE_SPREAD */
 
void                *fbCollectorGetContext(
    fbCollector_t       *collector);
 
void                fbCollectorClose(
    fbCollector_t       *collector);
 
 
void                fbCollectorSetAcceptOnly(
    fbCollector_t       *collector,
    struct sockaddr     *address,
    size_t              address_length);
 
fbListener_t        *fbListenerAlloc(
    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(
    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(
    fbCollector_t         *collector,
    struct sockaddr       *peer,
    size_t                 peerlen,
    uint32_t               obdomain);
 
uint32_t fbCollectorGetSFlowMissed(
    fbCollector_t         *collector,
    struct sockaddr       *peer,
    size_t                 peerlen,
    uint32_t               obdomain);
 
struct sockaddr* fbCollectorGetPeer(
    fbCollector_t   *collector);
 
uint32_t fbCollectorGetObservationDomain(
    fbCollector_t  *collector);
 
void fbCollectorSetUDPMultiSession(
    fbCollector_t *collector,
    gboolean       multi_session);
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* _FB_PUBLIC_H_ */