private.h

Go to the documentation of this file.

/*
 *  Copyright 2006-2025 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 /* ifdef DEFINE_TEMPLATE_METADATA_SPEC */
 
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 /* if HAVE_SPREAD */
 
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 /* if HAVE_SPREAD */
 
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 /* if HAVE_SPREAD */
 
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 /* ifndef _FB_PRIVATE_H_ */