private.h

Go to the documentation of this file.

#ifndef _FB_PRIVATE_H_
#define _FB_PRIVATE_H_
#include <fixbuf/public.h>

#if HAVE_SPREAD
#include <sp.h>
#include <pthread.h>
#endif

#ident "$Id$"

#define IPFIX_ENTERPRISE_BIT    0x8000

#define IPFIX_REVERSE_PEN       29305

#define FB_MSGLEN_MAX       65535

#if HAVE_SPREAD

typedef struct sp_groupname_st
{
    char    name[MAX_GROUP_NAME];
} sp_groupname_t;

#define FB_SPREAD_NUM_GROUPS    16
#define FB_SPREAD_MTU           8192

typedef struct fbSpreadSpec_st {
    fbSession_t     *session;
    char *          daemon;
    sp_groupname_t  *groups;
    int             num_groups;
    sp_groupname_t  *groups_to_send;
    int             num_groups_to_send;
    mailbox         mbox;
    char            privgroup[MAX_GROUP_NAME + 2];
    pthread_mutex_t write_lock;
    pthread_t       recv_thread;
    mailbox         recv_mbox;
    char            recv_privgroup[MAX_GROUP_NAME + 2];
    GError          *recv_err;
    int             recv_exit;
    int             recv_max_groups;
    int             recv_num_groups;
    sp_groupname_t  *recv_groups;
    int             recv_max;
    char            *recv_mess;
} fbSpreadSpec_t;

#endif /* HAVE_SPREAD */

typedef struct fbUDPConnSpec_st {
    fbSession_t             *session;
    void                    *ctx;
    union {
        struct sockaddr      so;
        struct sockaddr_in   ip4;
        struct sockaddr_in6  ip6;
    } peer;
    size_t                   peerlen;
    struct fbUDPConnSpec_st  *next;
    struct fbUDPConnSpec_st  *prev;
    time_t                   last_seen;
    uint32_t                 obdomain;
    gboolean                 reject;
} fbUDPConnSpec_t;


struct fbTemplate_st {
    fbInfoModel_t       *model;
    int                 ref_count;
    uint16_t            ie_count;
    uint16_t            scope_count;
    uint16_t            ie_len;
    uint16_t            ie_internal_len;
    uint16_t            tmpl_len;
    gboolean            is_varlen;
    fbInfoElement_t     **ie_ary;
    GHashTable          *indices;
    uint16_t            *off_cache;
    gboolean            active;
    void                *tmpl_ctx;
    fbTemplateCtxFree2_fn ctx_free;
    void                *app_ctx;
};

void                fBufRewind(
    fBuf_t              *fbuf);

gboolean            fBufAppendTemplate(
    fBuf_t              *fbuf,
    uint16_t            tmpl_id,
    fbTemplate_t        *tmpl,
    gboolean            revoked,
    GError              **err);

#if HAVE_SPREAD

void                fBufSetExportGroups(
    fBuf_t              *fbuf,
    char                **groups,
    int                 num_groups,
    GError              **err);


#endif

void fBufRemoveTemplateTcplan(
    fBuf_t         *fbuf,
    fbTemplate_t   *tmpl);

void         fBufSetSession(
    fBuf_t          *fbuf,
    fbSession_t     *session);


uint32_t            fbInfoElementHash(
    fbInfoElement_t     *ie);

gboolean            fbInfoElementEqual(
    const fbInfoElement_t   *a,
    const fbInfoElement_t   *b);

void                fbInfoElementDebug(
    gboolean            tmpl,
    fbInfoElement_t     *ie);

const fbInfoElement_t     *fbInfoModelGetElement(
    fbInfoModel_t       *model,
    fbInfoElement_t     *ex_ie);

gboolean            fbInfoElementCopyToTemplate(
    fbInfoModel_t       *model,
    fbInfoElement_t     *ex_ie,
    fbInfoElement_t     *tmpl_ie);

gboolean            fbInfoElementCopyToTemplateByName(
    fbInfoModel_t       *model,
    const char          *name,
    uint16_t            len_override,
    fbInfoElement_t     *tmpl_ie);

const fbInfoElement_t     *fbInfoModelAddAlienElement(
    fbInfoModel_t       *model,
    fbInfoElement_t     *ex_ie);

void                fbTemplateRetain(
    fbTemplate_t        *tmpl);

void                fbTemplateRelease(
    fbTemplate_t        *tmpl);

void                fbTemplateFree(
    fbTemplate_t        *tmpl);

void                fbTemplateDebug(
    const char          *label,
    uint16_t            tid,
    fbTemplate_t        *tmpl);

fbNewTemplateCallback_fn fbSessionTemplateCallback(
    fbSession_t     *session);

fbTemplateCtxCallback2_fn fbSessionTemplateCtxCallback(
    fbSession_t *session);

void *fbSessionTemplateCtxCallbackAppCtx(
    fbSession_t *session);

fbSession_t         *fbSessionClone(
    fbSession_t         *base);

uint32_t            fbSessionGetSequence(
    fbSession_t         *session);

void                fbSessionSetSequence(
    fbSession_t         *session,
    uint32_t            sequence);

void                fbSessionSetTemplateBuffer(
    fbSession_t         *session,
    fBuf_t              *fbuf);

void fbSessionSetCollector(
    fbSession_t        *session,
    fbCollector_t      *collector);

#if HAVE_SPREAD

void fbSessionSetGroupParams(
    fbSession_t     *session,
    sp_groupname_t  *groups,
    int              num_groups);

void fbSessionSetPrivateGroup(
    fbSession_t       *session,
    char              *group,
    char              *privgroup);

void                fbSessionSetGroup(
    fbSession_t         *session,
    char                *group);

unsigned int fbSessionGetGroupOffset(
    fbSession_t     *session,
    char            *group);

unsigned int       fbSessionGetGroup(
    fbSession_t      *session);
#endif

void fbSessionClearIntTmplTableFlag(
    fbSession_t        *session);

void fbSessionClearExtTmplTableFlag(
    fbSession_t        *session);

int fbSessionIntTmplTableFlagIsSet(
    fbSession_t        *session);

int fbSessionExtTmplTableFlagIsSet(
    fbSession_t        *session);
gboolean            fbConnSpecLookupAI(
    fbConnSpec_t        *spec,
    gboolean            passive,
    GError              **err);

gboolean            fbConnSpecInitTLS(
    fbConnSpec_t        *spec,
    gboolean            passive,
    GError              **err);

fbConnSpec_t        *fbConnSpecCopy(
    fbConnSpec_t        *spec);

void                fbConnSpecFree(
    fbConnSpec_t        *spec);

#if HAVE_SPREAD

fbSpreadSpec_t        *fbConnSpreadCopy(
    fbSpreadParams_t        *spec);

void                fbConnSpreadFree(
    fbSpreadSpec_t        *spec);

const char * fbConnSpreadError(
    int err );


void fbExporterSetGroupsToSend(
    fbExporter_t      *exporter,
    char              **groups,
    int               num_groups);


gboolean fbExporterCheckGroups(
    fbExporter_t      *exporter,
    char              **groups,
    int                num_groups);


#endif /* HAVE_SPREAD */

uint16_t            fbExporterGetMTU(
    fbExporter_t        *exporter);

gboolean            fbExportMessage(
    fbExporter_t        *exporter,
    uint8_t             *msgbase,
    size_t              msglen,
    GError              **err);

void                fbExporterFree(
    fbExporter_t       *exporter);

void fbCollectorRemoveListenerLastBuf(
    fBuf_t             *fbuf,
    fbCollector_t      *collector);

fbCollector_t       *fbCollectorAllocSocket(
    fbListener_t        *listener,
    void                *ctx,
    int                 fd,
    struct sockaddr     *peer,
    size_t              peerlen);

fbCollector_t       *fbCollectorAllocTLS(
    fbListener_t        *listener,
    void                *ctx,
    int                 fd,
    struct sockaddr     *peer,
    size_t              peerlen,
    GError              **err);

gboolean            fbCollectMessage(
    fbCollector_t       *collector,
    uint8_t             *msgbase,
    size_t              *msglen,
    GError              **err);

int                 fbCollectorGetFD(
    fbCollector_t       *collector);

void             fbCollectorSetFD(
    fbCollector_t   *collector,
    int              fd);

void                fbCollectorFree(
    fbCollector_t       *collector);

gboolean        fbCollectorHasTranslator(
    fbCollector_t   *collector);


gboolean fbCollectMessageBuffer(
    uint8_t                     *hdr,
    size_t                      b_len,
    size_t                      *m_len,
    GError                      **err);


#if HAVE_SPREAD

gboolean       fbCollectorTestGroupMembership(
    fbCollector_t       *collector,
    int                 group_offset);

#endif

void fbListenerAppFree(
    fbListener_t   *listener,
    void           *ctx);

void fbListenerRemoveLastBuf(
    fBuf_t         *fbuf,
    fbListener_t   *listener);

void fbListenerRemove(
    fbListener_t        *listener,
    int                 fd);

fbConnSpec_t        *fbListenerGetConnSpec(
    fbListener_t        *listener);

void fbCollectorInterruptSocket(
    fbCollector_t   *collector);

gboolean fbListenerCallAppInit(
    fbListener_t       *listener,
    fbUDPConnSpec_t    *spec,
    GError             **err);

fbSession_t *fbListenerSetPeerSession(
    fbListener_t        *listener,
    fbSession_t         *session);

#endif