public.h

Go to the documentation of this file.

/*
 *  Copyright 2006-2025 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@
 *  ------------------------------------------------------------------------
 */
 
/*  Tell uncrustify to ignore the next part of the file */
/*  *INDENT-OFF* */
 
/*  Reenable uncrustify */
/*  *INDENT-ON* */
 
#ifndef _FB_PUBLIC_H_
#define _FB_PUBLIC_H_
#include <fixbuf/autoinc.h>
#include <fixbuf/version.h>
 
/* Hide from uncrustify */
/* *INDENT-OFF* */
#ifdef __cplusplus
extern "C" {
#endif
/* *INDENT-ON* */
 
 
#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);
 
 
/* Hide this from uncrustify */
/* *INDENT-OFF* */
#ifdef __cplusplus
} /* extern "C" */
#endif
/* *INDENT-ON* */
 
#endif /* _FB_PUBLIC_H_ */