public.h

Go to the documentation of this file.

/*
 ** public.h
 ** fixbuf IPFIX Implementation Public Interface
 **
 ** ------------------------------------------------------------------------
 ** Copyright (C) 2006-2015 Carnegie Mellon University. All Rights Reserved.
 ** ------------------------------------------------------------------------
 ** Authors: Brian Trammell, Dan Ruef
 ** ------------------------------------------------------------------------
 ** Use of the libfixbuf system and related source code is subject to the terms
 ** of the following licenses:
 **
 ** GNU Lesser GPL (LGPL) Rights pursuant to Version 2.1, February 1999
 ** Government Purpose License Rights (GPLR) pursuant to DFARS 252.227.7013
 **
 ** NO WARRANTY
 **
 ** ANY INFORMATION, MATERIALS, SERVICES, INTELLECTUAL PROPERTY OR OTHER
 ** PROPERTY OR RIGHTS GRANTED OR PROVIDED BY CARNEGIE MELLON UNIVERSITY
 ** PURSUANT TO THIS LICENSE (HEREINAFTER THE "DELIVERABLES") ARE ON AN
 ** "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY
 ** KIND, EITHER EXPRESS OR IMPLIED AS TO ANY MATTER INCLUDING, BUT NOT
 ** LIMITED TO, WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE,
 ** MERCHANTABILITY, INFORMATIONAL CONTENT, NONINFRINGEMENT, OR ERROR-FREE
 ** OPERATION. CARNEGIE MELLON UNIVERSITY SHALL NOT BE LIABLE FOR INDIRECT,
 ** SPECIAL OR CONSEQUENTIAL DAMAGES, SUCH AS LOSS OF PROFITS OR INABILITY
 ** TO USE SAID INTELLECTUAL PROPERTY, UNDER THIS LICENSE, REGARDLESS OF
 ** WHETHER SUCH PARTY WAS AWARE OF THE POSSIBILITY OF SUCH DAMAGES.
 ** LICENSEE AGREES THAT IT WILL NOT MAKE ANY WARRANTY ON BEHALF OF
 ** CARNEGIE MELLON UNIVERSITY, EXPRESS OR IMPLIED, TO ANY PERSON
 ** CONCERNING THE APPLICATION OF OR THE RESULTS TO BE OBTAINED WITH THE
 ** DELIVERABLES UNDER THIS LICENSE.
 **
 ** Licensee hereby agrees to defend, indemnify, and hold harmless Carnegie
 ** Mellon University, its trustees, officers, employees, and agents from
 ** all claims or demands made against them (and any related losses,
 ** expenses, or attorney's fees) arising out of, or relating to Licensee's
 ** and/or its sub licensees' negligent use or willful misuse of or
 ** negligent conduct or willful misconduct regarding the Software,
 ** facilities, or other rights or assistance granted by Carnegie Mellon
 ** University under this License, including, but not limited to, any
 ** claims of product liability, personal injury, death, damage to
 ** property, or violation of any laws or regulations.
 **
 ** Carnegie Mellon University Software Engineering Institute authored
 ** documents are sponsored by the U.S. Department of Defense under
 ** Contract FA8721-05-C-0003. Carnegie Mellon University retains
 ** copyrights in all material produced under this contract. The U.S.
 ** Government retains a non-exclusive, royalty-free license to publish or
 ** reproduce these documents, or allow others to do so, for U.S.
 ** Government purposes only pursuant to the copyright license under the
 ** contract clause at 252.227.7013.
 **
 ** ------------------------------------------------------------------------
 */

#ifndef _FB_PUBLIC_H_
#define _FB_PUBLIC_H_
#include <fixbuf/autoinc.h>

#ifdef __cplusplus
extern "C" {
#endif

#ident "$Id$"

/*
 * 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


/*
 * Public Datatypes and Constants
 */

struct fBuf_st;
typedef struct fBuf_st fBuf_t;

typedef struct fbVarfield_st {
    size_t      len;
    uint8_t     *buf;
} fbVarfield_t;


struct fbInfoModel_st;
typedef struct fbInfoModel_st fbInfoModel_t;

typedef struct fbInfoModelIter_st {
    const fbInfoModel_t *model;
    guint                index;
} 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_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_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 {
    uint64_t       ie_range_begin;
    uint64_t       ie_range_end;
    uint32_t       ie_pen;
    uint16_t       ie_units;
    uint16_t       ie_id;
    uint8_t        ie_type;
    uint8_t        ie_semantic;
    uint8_t        padding[6];
    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

struct fbTemplate_st;
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;

struct fbSession_st;
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 */

struct fbExporter_st;
typedef struct fbExporter_st fbExporter_t;

struct fbCollector_st;
typedef struct fbCollector_st fbCollector_t;

struct fbListener_st;
typedef struct fbListener_st fbListener_t;

typedef struct fbListenerEntry_st fbListenerEntry_t;

struct fbListenerEntry_st
{
    fbListenerEntry_t  *next;
    fbListenerEntry_t  *prev;
    fbListener_t       *listener;
};

typedef struct fbListenerGroupResult_st fbListenerGroupResult_t;

struct fbListenerGroupResult_st
{
    fbListenerGroupResult_t *next;
    fbListener_t    *listener;
    fBuf_t          *fbuf;
};

struct fbListenerGroup_st;
typedef struct fbListenerGroup_st fbListenerGroup_t;

typedef void (*fbNewTemplateCallback_fn) (
    fbSession_t    *session,
    uint16_t        tid,
    fbTemplate_t   *tmpl);

typedef void (*fbTemplateCtxFree_fn)(
    void           *ctx);

typedef void (*fbTemplateCtxFree2_fn)(
    void           *tmpl_ctx,
    void           *app_ctx);


typedef void (*fbTemplateCtxCallback_fn) (
    fbSession_t          *session,
    uint16_t             tid,
    fbTemplate_t         *tmpl,
    void                 **ctx,
    fbTemplateCtxFree_fn *fn);

typedef void (*fbTemplateCtxCallback2_fn) (
    fbSession_t           *session,
    uint16_t              tid,
    fbTemplate_t          *tmpl,
    void                  *app_ctx,
    void                  **tmpl_ctx,
    fbTemplateCtxFree2_fn *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          *basicListPtr,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                numElements);

void* fbBasicListInitWithOwnBuffer(
    fbBasicList_t          *basicListPtr,
    uint8_t                 semantic,
    const fbInfoElement_t  *infoElement,
    uint16_t                numElements,
    uint16_t                dataLength,
    uint8_t                *dataPtr);

void fbBasicListCollectorInit(
    fbBasicList_t  *basicListPtr);


uint8_t fbBasicListGetSemantic(
    fbBasicList_t  *basicListPtr);

void fbBasicListSetSemantic(
    fbBasicList_t  *basicListPtr,
    uint8_t         semantic);


const fbInfoElement_t*  fbBasicListGetInfoElement(
     fbBasicList_t  *basicListPtr);

void* fbBasicListGetDataPtr(
    fbBasicList_t   *basicListPtr);

void* fbBasicListGetIndexedDataPtr(
    fbBasicList_t   *basicListPtr,
    uint16_t         bl_index);

void* fbBasicListGetNextPtr(
    fbBasicList_t   *basicListPtr,
    void            *currentPtr);

void* fbBasicListRealloc(
    fbBasicList_t  *basicList,
    uint16_t        newNumElements);

void* fbBasicListAddNewElements(
    fbBasicList_t  *basicList,
    uint16_t        numNewElements);

void fbBasicListClear(
    fbBasicList_t  *basicListPtr);

void fbBasicListClearWithoutFree(
    fbBasicList_t  *basicList);

void fbBasicListFree(
    fbBasicList_t  *basicListPtr);


/******* 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  *subTemplateListPtr);

void* fbSubTemplateListGetIndexedDataPtr(
    const fbSubTemplateList_t  *subTemplateListPtr,
    uint16_t                    index);

void* fbSubTemplateListGetNextPtr(
    const fbSubTemplateList_t  *subTemplateListPtr,
    void                       *currentPtr);

void fbSubTemplateListSetSemantic(
    fbSubTemplateList_t    *subTemplateListPtr,
    uint8_t                 semantic);

uint8_t fbSubTemplateListGetSemantic(
    fbSubTemplateList_t    *subTemplateListPtr);

const fbTemplate_t* fbSubTemplateListGetTemplate(
    fbSubTemplateList_t    *subTemplateListPtr);

uint16_t fbSubTemplateListGetTemplateID(
    fbSubTemplateList_t    *subTemplateListPtr);

void* fbSubTemplateListRealloc(
    fbSubTemplateList_t    *subTemplateList,
    uint16_t                newNumElements);

void* fbSubTemplateListAddNewElements(
    fbSubTemplateList_t    *subTemplateList,
    uint16_t                numNewElements);

void fbSubTemplateListClear(
    fbSubTemplateList_t    *subTemplateListPtr);

void fbSubTemplateListClearWithoutFree(
    fbSubTemplateList_t    *subTemplateListPtr);

void fbSubTemplateListFree(
    fbSubTemplateList_t    *subTemplateListPtr);

/********* 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);

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);

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

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);

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                tid,
    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);

void                fbTemplateFreeUnused(
    fbTemplate_t        *tmpl);

void               *fbTemplateGetContext(
    fbTemplate_t         *tmpl);

fbSession_t         *fbSessionAlloc(
    fbInfoModel_t       *model);

fbInfoModel_t       *fbSessionGetInfoModel(
    fbSession_t         *session);


void fbSessionAddTemplateCallback(
    fbSession_t                *session,
    fbNewTemplateCallback_fn    callback);

void fbSessionAddTemplateCtxCallback(
    fbSession_t               *session,
    fbTemplateCtxCallback_fn  callback);

void fbSessionAddTemplateCtxCallback2(
    fbSession_t               *session,
    fbTemplateCtxCallback2_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);

fbCollector_t *fbSessionGetCollector(
    fbSession_t        *session);

#if HAVE_SPREAD

gboolean        fbSessionAddTemplatesMulticast(
    fbSession_t      *session,
    char             **groups,
    gboolean         internal,
    uint16_t         tid,
    fbTemplate_t     *tmpl,
    GError           **err);

#endif

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);

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);

void fbCollectorManageUDPStreamByPort(
    fbCollector_t *collector,
    gboolean       manage_port);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif