private.h

Go to the documentation of this file.

/*
 *  Copyright 2006-2024 Carnegie Mellon University
 *  See license information in LICENSE.txt.
 */
/*
 *  ------------------------------------------------------------------------
 *  Authors: Brian Trammell
 *  ------------------------------------------------------------------------
 *  @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_PRIVATE_H_
#define _FB_PRIVATE_H_
#include <fixbuf/public.h>
 
#if HAVE_SPREAD
#include <sp.h>
#include <pthread.h>
#endif
 
 
#define IPFIX_ENTERPRISE_BIT    0x8000
 
#define FB_MSGLEN_MAX       65535
 
#define FB_SSL_ERR_BUFSIZ   512
 
#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;
 
 
#ifdef DEFINE_TEMPLATE_METADATA_SPEC
/* Template metadata template */
static fbInfoElementSpec_t template_metadata_spec[] = {
    {(char *)"templateId",                     2, 0 },
    {(char *)"paddingOctets",                  6, 1 },
    {(char *)"templateName",                   FB_IE_VARLEN, 0 },
    {(char *)"templateDescription",            FB_IE_VARLEN, 0 },
    /* {"templateInformationElementList",         FB_IE_VARLEN, 0 }, */
    FB_IESPEC_NULL
};
#endif
 
typedef struct fbTemplateOptRec_st {
    uint16_t       template_id;
    uint8_t        template_padding[6];
    fbVarfield_t   template_name;
    fbVarfield_t   template_description;
    /* fbSubTemplateList_t info_element_list; */
} fbTemplateOptRec_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;
    gboolean            default_length;
 
    fbTemplateOptRec_t  *metadata_rec;
    void                *tmpl_ctx;
    fbTemplateCtxFree_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);
 
uint16_t        fBufGetExportTemplate(
    fBuf_t          *fbuf);
 
 
uint16_t       fBufGetInternalTemplate(
    fBuf_t         *fbuf);
 
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,
    GError             **err);
 
gboolean            fbInfoElementCopyToTemplateByName(
    fbInfoModel_t       *model,
    const char          *name,
    uint16_t            len_override,
    fbInfoElement_t     *tmpl_ie,
    GError             **err);
 
const fbInfoElement_t     *fbInfoModelAddAlienElement(
    fbInfoModel_t       *model,
    fbInfoElement_t     *ex_ie);
 
fbTemplate_t        *fbInfoElementAllocTypeTemplate2(
    fbInfoModel_t       *model,
    gboolean            internal,
    GError              **err);
 
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);
 
fbTemplate_t        *fbTemplateAllocTemplateMetadataTmpl(
    fbInfoModel_t      *model,
    gboolean            internal,
    GError            **err);
 
void                fbTemplateAddMetadataRecord(
    fbTemplate_t        *tmpl,
    uint16_t             tid,
    const char          *name,
    const char          *description);
 
fbNewTemplateCallback_fn fbSessionNewTemplateCallback(
    fbSession_t     *session);
 
void *fbSessionNewTemplateCallbackAppCtx(
    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,
    unsigned 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,
    GError              **err);
 
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