Routines for integration with Homer using HEPv3. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
#include "asterisk/config_options.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/res_hep.h"
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <netinet/ip6.h>

Include dependency graph for res_hep.c:

Go to the source code of this file.

Data Structures
struct	hep_chunk

struct	hep_chunk_ip4

struct	hep_chunk_ip6

struct	hep_chunk_uint16

struct	hep_chunk_uint32

struct	hep_chunk_uint8

struct	hep_ctrl

struct	hep_generic

struct	hepv3_global_config
	Global configuration for the module. More...

struct	hepv3_runtime_data
	Run-time data derived from hepv3_global_config. More...

struct	module_config
	The configuration settings for this module. More...

Macros
#define	ASTERISK_VENDOR_ID 0x0004

#define	GENERIC_VENDOR_ID 0x0000

#define	INITIALIZE_GENERIC_HEP_CHUNK(hep_item, type)

#define	INITIALIZE_GENERIC_HEP_CHUNK_DATA(hep_item, type, value)

#define	INITIALIZE_GENERIC_HEP_IDS(hep_chunk, type)

#define	INITIALIZE_GENERIC_HEP_IDS_VAR(hep_chunk, type, len)

Enumerations
enum	hepv3_chunk_types { CHUNK_TYPE_IP_PROTOCOL_FAMILY = 0X0001 , CHUNK_TYPE_IP_PROTOCOL_ID = 0X0002 , CHUNK_TYPE_IPV4_SRC_ADDR = 0X0003 , CHUNK_TYPE_IPV4_DST_ADDR = 0X0004 , CHUNK_TYPE_IPV6_SRC_ADDR = 0X0005 , CHUNK_TYPE_IPV6_DST_ADDR = 0X0006 , CHUNK_TYPE_SRC_PORT = 0X0007 , CHUNK_TYPE_DST_PORT = 0X0008 , CHUNK_TYPE_TIMESTAMP_SEC = 0X0009 , CHUNK_TYPE_TIMESTAMP_USEC = 0X000A , CHUNK_TYPE_PROTOCOL_TYPE = 0X000B , CHUNK_TYPE_CAPTURE_AGENT_ID = 0X000C , CHUNK_TYPE_KEEP_ALIVE_TIMER = 0X000D , CHUNK_TYPE_AUTH_KEY = 0X000E , CHUNK_TYPE_PAYLOAD = 0X000F , CHUNK_TYPE_PAYLOAD_ZIP = 0X0010 , CHUNK_TYPE_UUID = 0X0011 , CHUNK_TYPE_CAPTURE_AGENT_NAME = 0X0013 }

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

static	AO2_GLOBAL_OBJ_STATIC (global_config)
	The module configuration container.

static	AO2_GLOBAL_OBJ_STATIC (global_data)
	Current module data.

struct ast_module *	AST_MODULE_SELF_SYM (void)

static void	capture_info_dtor (void *obj)
	Destructor for a hepv3_capture_info object.

	CONFIG_INFO_STANDARD (cfg_info, global_config, module_config_alloc,.files=ACO_FILES(&hepv3_conf),.pre_apply_config=hepv3_config_pre_apply,.post_apply_config=hepv3_config_post_apply,)
	Register information about the configs being processed by this module.

static int	hep_queue_cb (void *data)
	Callback function for the hep_queue_tp taskprocessor.

static void *	hepv3_config_alloc (void)
	HEPv3 configuration object allocation.

static void	hepv3_config_dtor (void *obj)

static void	hepv3_config_post_apply (void)
	Post-apply callback for the config framework.

static int	hepv3_config_pre_apply (void)
	Pre-apply callback for the config framework.

struct hepv3_capture_info *	hepv3_create_capture_info (const void *payload, size_t len)
	Create a hepv3_capture_info object.

static struct hepv3_runtime_data *	hepv3_data_alloc (struct hepv3_global_config *config)
	Allocate the HEPv3 run-time data.

static void	hepv3_data_dtor (void *obj)
	HEPv3 run-time data destructor.

enum hep_uuid_type	hepv3_get_uuid_type (void)
	Get the preferred UUID type.

int	hepv3_is_loaded (void)
	Return whether or not we're currently loaded and active.

int	hepv3_send_packet (struct hepv3_capture_info *capture_info)
	Send a generic packet capture to HEPv3.

static int	load_module (void)
	Load the module.

static void *	module_config_alloc (void)
	Module config constructor.

static void	module_config_dtor (void *obj)
	Configuration object destructor.

static int	reload_module (void)
	Reload the module.

static int	unload_module (void)
	Unload the module.

static int	uuid_type_handler (const struct aco_option opt, struct ast_variable var, void *obj)
	Handler for the uuid_type attribute.

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS \| AST_MODFLAG_LOAD_ORDER , .description = "HEPv3 API" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_APP_DEPEND, }

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct aco_type	global_option

struct aco_type *	global_options [] = ACO_TYPES(&global_option)

static struct ast_taskprocessor *	hep_queue_tp

struct aco_file	hepv3_conf

Detailed Description

Routines for integration with Homer using HEPv3.

Author: Alexandr Dubovikov alexa.nosp@m.ndr..nosp@m.dubov.nosp@m.ikov.nosp@m.@sipc.nosp@m.aptu.nosp@m.re.or.nosp@m.g; Matt Jordan mjord.nosp@m.an@d.nosp@m.igium.nosp@m..com

Definition in file res_hep.c.

Macro Definition Documentation

◆ ASTERISK_VENDOR_ID

#define ASTERISK_VENDOR_ID 0x0004

Asterisk vendor ID. Used for custom data to send to a capture node

Definition at line 129 of file res_hep.c.

◆ GENERIC_VENDOR_ID

#define GENERIC_VENDOR_ID 0x0000

Generic vendor ID. Used for HEPv3 standard packets

Definition at line 126 of file res_hep.c.

◆ INITIALIZE_GENERIC_HEP_CHUNK

#define INITIALIZE_GENERIC_HEP_CHUNK	(	hep_item,
		type
	)

Value:

    do { \
    INITIALIZE_GENERIC_HEP_IDS(&(hep_item)->chunk, (type)); \
    (hep_item)->chunk.length = htons(sizeof(*(hep_item))); \
    } while (0)

Definition at line 199 of file res_hep.c.

                                                        { \
    INITIALIZE_GENERIC_HEP_IDS(&(hep_item)->chunk, (type)); \
    (hep_item)->chunk.length = htons(sizeof(*(hep_item))); \
    } while (0)

◆ INITIALIZE_GENERIC_HEP_CHUNK_DATA

#define INITIALIZE_GENERIC_HEP_CHUNK_DATA	(	hep_item,
		type,
		value
	)

Value:

    do { \
    INITIALIZE_GENERIC_HEP_CHUNK((hep_item), (type)); \
    (hep_item)->data = (value); \
    } while (0)

Definition at line 204 of file res_hep.c.

                                                                    { \
    INITIALIZE_GENERIC_HEP_CHUNK((hep_item), (type)); \
    (hep_item)->data = (value); \
    } while (0)

◆ INITIALIZE_GENERIC_HEP_IDS

#define INITIALIZE_GENERIC_HEP_IDS	(	hep_chunk,
		type
	)

Value:

    do { \
    (hep_chunk)->vendor_id = htons(GENERIC_VENDOR_ID); \
    (hep_chunk)->type_id = htons((type)); \
    } while (0)

Definition at line 189 of file res_hep.c.

                                                       { \
    (hep_chunk)->vendor_id = htons(GENERIC_VENDOR_ID); \
    (hep_chunk)->type_id = htons((type)); \
    } while (0)

◆ INITIALIZE_GENERIC_HEP_IDS_VAR

#define INITIALIZE_GENERIC_HEP_IDS_VAR	(	hep_chunk,
		type,
		len
	)

Value:

    do { \
    INITIALIZE_GENERIC_HEP_IDS((hep_chunk), (type)); \
    (hep_chunk)->length = htons(sizeof(*(hep_chunk)) + len); \
    } while (0)

Definition at line 194 of file res_hep.c.

                                                                { \
    INITIALIZE_GENERIC_HEP_IDS((hep_chunk), (type)); \
    (hep_chunk)->length = htons(sizeof(*(hep_chunk)) + len); \
    } while (0)

Enumeration Type Documentation

◆ hepv3_chunk_types

enum hepv3_chunk_types

Chunk types from the HEPv3 Spec

Enumerator
CHUNK_TYPE_IP_PROTOCOL_FAMILY	THE IP PROTOCOL FAMILY
CHUNK_TYPE_IP_PROTOCOL_ID	THE IP PROTOCOL ID (UDP, TCP, ETC.)
CHUNK_TYPE_IPV4_SRC_ADDR	IF IPV4, THE SOURCE ADDRESS
CHUNK_TYPE_IPV4_DST_ADDR	IF IPV4, THE DESTINATION ADDRESS
CHUNK_TYPE_IPV6_SRC_ADDR	IF IPV6, THE SOURCE ADDRESS
CHUNK_TYPE_IPV6_DST_ADDR	IF IPV6, THE DESTINATION ADDRESS
CHUNK_TYPE_SRC_PORT	THE SOURCE PORT
CHUNK_TYPE_DST_PORT	THE DESTINATION PORT
CHUNK_TYPE_TIMESTAMP_SEC	THE CAPTURE TIME (SECONDS)
CHUNK_TYPE_TIMESTAMP_USEC	THE CAPTURE TIME (MICROSECONDS)
CHUNK_TYPE_PROTOCOL_TYPE	THE PROTOCOL PACKET TYPE. SEE /REF HEPV3_CAPTURE_TYPE
CHUNK_TYPE_CAPTURE_AGENT_ID	OUR CAPTURE AGENT ID
CHUNK_TYPE_KEEP_ALIVE_TIMER	A KEEP ALIVE TIMER
CHUNK_TYPE_AUTH_KEY	THE CAPTURE_PASSWORD IF DEFINED
CHUNK_TYPE_PAYLOAD	THE ONE AND ONLY PAYLOAD
CHUNK_TYPE_PAYLOAD_ZIP	THE ONE AND ONLY (ZIPPED) PAYLOAD
CHUNK_TYPE_UUID	THE UUID FOR THIS PACKET
CHUNK_TYPE_CAPTURE_AGENT_NAME	THE CAPTURE AGENT NAME

Definition at line 132 of file res_hep.c.

                       {
 
    /*! THE IP PROTOCOL FAMILY */
    CHUNK_TYPE_IP_PROTOCOL_FAMILY = 0X0001,
 
    /*! THE IP PROTOCOL ID (UDP, TCP, ETC.) */
    CHUNK_TYPE_IP_PROTOCOL_ID = 0X0002,
 
    /*! IF IPV4, THE SOURCE ADDRESS */
    CHUNK_TYPE_IPV4_SRC_ADDR = 0X0003,
 
    /*! IF IPV4, THE DESTINATION ADDRESS */
    CHUNK_TYPE_IPV4_DST_ADDR = 0X0004,
 
    /*! IF IPV6, THE SOURCE ADDRESS */
    CHUNK_TYPE_IPV6_SRC_ADDR = 0X0005,
 
    /*! IF IPV6, THE DESTINATION ADDRESS */
    CHUNK_TYPE_IPV6_DST_ADDR = 0X0006,
 
    /*! THE SOURCE PORT */
    CHUNK_TYPE_SRC_PORT = 0X0007,
 
    /*! THE DESTINATION PORT */
    CHUNK_TYPE_DST_PORT = 0X0008,
 
    /*! THE CAPTURE TIME (SECONDS) */
    CHUNK_TYPE_TIMESTAMP_SEC = 0X0009,
 
    /*! THE CAPTURE TIME (MICROSECONDS) */
    CHUNK_TYPE_TIMESTAMP_USEC = 0X000A,
 
    /*! THE PROTOCOL PACKET TYPE. SEE /REF HEPV3_CAPTURE_TYPE */
    CHUNK_TYPE_PROTOCOL_TYPE = 0X000B,
 
    /*! OUR CAPTURE AGENT ID */
    CHUNK_TYPE_CAPTURE_AGENT_ID = 0X000C,
 
    /*! A KEEP ALIVE TIMER */
    CHUNK_TYPE_KEEP_ALIVE_TIMER = 0X000D,
 
    /*! THE CAPTURE_PASSWORD IF DEFINED */
    CHUNK_TYPE_AUTH_KEY = 0X000E,
 
    /*! THE ONE AND ONLY PAYLOAD */
    CHUNK_TYPE_PAYLOAD = 0X000F,
 
    /*! THE ONE AND ONLY (ZIPPED) PAYLOAD */
    CHUNK_TYPE_PAYLOAD_ZIP = 0X0010,
 
    /*! THE UUID FOR THIS PACKET */
    CHUNK_TYPE_UUID = 0X0011,
 
    /*! THE CAPTURE AGENT NAME */
    CHUNK_TYPE_CAPTURE_AGENT_NAME = 0X0013,
};

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 746 of file res_hep.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 746 of file res_hep.c.

◆ AO2_GLOBAL_OBJ_STATIC() [1/2]

static AO2_GLOBAL_OBJ_STATIC ( global_config )

static

The module configuration container.

◆ AO2_GLOBAL_OBJ_STATIC() [2/2]

static AO2_GLOBAL_OBJ_STATIC ( global_data )

static

Current module data.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 746 of file res_hep.c.

◆ capture_info_dtor()

static void capture_info_dtor ( void * obj )

static

Destructor for a hepv3_capture_info object.

Definition at line 431 of file res_hep.c.

{
    struct hepv3_capture_info *info = obj;
 
    ast_free(info->uuid);
    ast_free(info->payload);
}

References ast_free.

Referenced by hepv3_create_capture_info().

◆ CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		global_config	,
		module_config_alloc	,
		.	files = `ACO_FILES(&hepv3_conf)`,
		.	pre_apply_config = `hepv3_config_pre_apply`,
		.	post_apply_config = `hepv3_config_post_apply`
	)

Register information about the configs being processed by this module.

◆ hep_queue_cb()

static int hep_queue_cb ( void * data )

static

Callback function for the hep_queue_tp taskprocessor.

Definition at line 482 of file res_hep.c.

{
    RAII_VAR(struct module_config *, config, ao2_global_obj_ref(global_config), ao2_cleanup);
    RAII_VAR(struct hepv3_runtime_data *, hepv3_data, ao2_global_obj_ref(global_data), ao2_cleanup);
    RAII_VAR(struct hepv3_capture_info *, capture_info, data, ao2_cleanup);
    struct hep_generic hg_pkt;
    unsigned int packet_len = 0, sock_buffer_len;
    struct hep_chunk_ip4 ipv4_src, ipv4_dst;
    struct hep_chunk_ip6 ipv6_src, ipv6_dst;
    struct hep_chunk auth_key, payload, uuid, capturename;
    void *sock_buffer;
    int res;
 
    if (!capture_info || !config || !hepv3_data) {
        return 0;
    }
 
    if (ast_sockaddr_is_ipv4(&capture_info->src_addr) != ast_sockaddr_is_ipv4(&capture_info->dst_addr)) {
        ast_log(AST_LOG_NOTICE, "Unable to send packet: Address Family mismatch between source/destination\n");
        return -1;
    }
 
    packet_len = sizeof(hg_pkt);
 
    /* Build HEPv3 header, capture info, and calculate the total packet size */
    memcpy(hg_pkt.header.id, "\x48\x45\x50\x33", 4);
 
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.ip_proto, CHUNK_TYPE_IP_PROTOCOL_ID, capture_info->protocol_id);
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.src_port, CHUNK_TYPE_SRC_PORT, htons(ast_sockaddr_port(&capture_info->src_addr)));
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.dst_port, CHUNK_TYPE_DST_PORT, htons(ast_sockaddr_port(&capture_info->dst_addr)));
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.time_sec, CHUNK_TYPE_TIMESTAMP_SEC, htonl(capture_info->capture_time.tv_sec));
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.time_usec, CHUNK_TYPE_TIMESTAMP_USEC, htonl(capture_info->capture_time.tv_usec));
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.proto_t, CHUNK_TYPE_PROTOCOL_TYPE, capture_info->capture_type);
    INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.capt_id, CHUNK_TYPE_CAPTURE_AGENT_ID, htonl(config->general->capture_id));
 
    if (ast_sockaddr_is_ipv4(&capture_info->src_addr)) {
        INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.ip_family,
            CHUNK_TYPE_IP_PROTOCOL_FAMILY, AF_INET);
 
        INITIALIZE_GENERIC_HEP_CHUNK(&ipv4_src, CHUNK_TYPE_IPV4_SRC_ADDR);
        inet_pton(AF_INET, ast_sockaddr_stringify_addr(&capture_info->src_addr), &ipv4_src.data);
 
        INITIALIZE_GENERIC_HEP_CHUNK(&ipv4_dst, CHUNK_TYPE_IPV4_DST_ADDR);
        inet_pton(AF_INET, ast_sockaddr_stringify_addr(&capture_info->dst_addr), &ipv4_dst.data);
 
        packet_len += (sizeof(ipv4_src) + sizeof(ipv4_dst));
    } else {
        INITIALIZE_GENERIC_HEP_CHUNK_DATA(&hg_pkt.ip_family,
            CHUNK_TYPE_IP_PROTOCOL_FAMILY, AF_INET6);
 
        INITIALIZE_GENERIC_HEP_CHUNK(&ipv6_src, CHUNK_TYPE_IPV6_SRC_ADDR);
        inet_pton(AF_INET6, ast_sockaddr_stringify_addr(&capture_info->src_addr), &ipv6_src.data);
 
        INITIALIZE_GENERIC_HEP_CHUNK(&ipv6_dst, CHUNK_TYPE_IPV6_DST_ADDR);
        inet_pton(AF_INET6, ast_sockaddr_stringify_addr(&capture_info->dst_addr), &ipv6_dst.data);
 
        packet_len += (sizeof(ipv6_src) + sizeof(ipv6_dst));
    }
 
    if (!ast_strlen_zero(config->general->capture_password))  {
        INITIALIZE_GENERIC_HEP_IDS_VAR(&auth_key, CHUNK_TYPE_AUTH_KEY, strlen(config->general->capture_password));
        packet_len += (sizeof(auth_key) + strlen(config->general->capture_password));
    }
    if (!ast_strlen_zero(config->general->capture_name))  {
        INITIALIZE_GENERIC_HEP_IDS_VAR(&capturename, CHUNK_TYPE_CAPTURE_AGENT_NAME, strlen(config->general->capture_name));
        packet_len += (sizeof(capturename) + strlen(config->general->capture_name));
    }
    INITIALIZE_GENERIC_HEP_IDS_VAR(&uuid, CHUNK_TYPE_UUID, strlen(capture_info->uuid));
    packet_len += (sizeof(uuid) + strlen(capture_info->uuid));
    INITIALIZE_GENERIC_HEP_IDS_VAR(&payload,
        capture_info->zipped ? CHUNK_TYPE_PAYLOAD_ZIP : CHUNK_TYPE_PAYLOAD, capture_info->len);
    packet_len += (sizeof(payload) + capture_info->len);
    hg_pkt.header.length = htons(packet_len);
 
    /* Build the buffer to send */
    sock_buffer = ast_malloc(packet_len);
    if (!sock_buffer) {
        return -1;
    }
 
    /* Copy in the header */
    memcpy(sock_buffer, &hg_pkt, sizeof(hg_pkt));
    sock_buffer_len = sizeof(hg_pkt);
 
    /* Addresses */
    if (ast_sockaddr_is_ipv4(&capture_info->src_addr)) {
        memcpy(sock_buffer + sock_buffer_len, &ipv4_src, sizeof(ipv4_src));
        sock_buffer_len += sizeof(ipv4_src);
        memcpy(sock_buffer + sock_buffer_len, &ipv4_dst, sizeof(ipv4_dst));
        sock_buffer_len += sizeof(ipv4_dst);
    } else {
        memcpy(sock_buffer + sock_buffer_len, &ipv6_src, sizeof(ipv6_src));
        sock_buffer_len += sizeof(ipv6_src);
        memcpy(sock_buffer + sock_buffer_len, &ipv6_dst, sizeof(ipv6_dst));
        sock_buffer_len += sizeof(ipv6_dst);
    }
 
    /* Auth Key */
    if (!ast_strlen_zero(config->general->capture_password)) {
        memcpy(sock_buffer + sock_buffer_len, &auth_key, sizeof(auth_key));
        sock_buffer_len += sizeof(auth_key);
        memcpy(sock_buffer + sock_buffer_len, config->general->capture_password, strlen(config->general->capture_password));
        sock_buffer_len += strlen(config->general->capture_password);
    }
 
    /* UUID */
    memcpy(sock_buffer + sock_buffer_len, &uuid, sizeof(uuid));
    sock_buffer_len += sizeof(uuid);
    memcpy(sock_buffer + sock_buffer_len, capture_info->uuid, strlen(capture_info->uuid));
    sock_buffer_len += strlen(capture_info->uuid);
 
    /* Capture Agent Name */
    if (!ast_strlen_zero(config->general->capture_name)) {
        memcpy(sock_buffer + sock_buffer_len, &capturename, sizeof(capturename));
        sock_buffer_len += sizeof(capturename);
        memcpy(sock_buffer + sock_buffer_len, config->general->capture_name, strlen(config->general->capture_name));
        sock_buffer_len += strlen(config->general->capture_name);
    }
 
    /* Packet! */
    memcpy(sock_buffer + sock_buffer_len, &payload, sizeof(payload));
    sock_buffer_len += sizeof(payload);
    memcpy(sock_buffer + sock_buffer_len, capture_info->payload, capture_info->len);
    sock_buffer_len += capture_info->len;
 
    ast_assert(sock_buffer_len == packet_len);
 
    res = ast_sendto(hepv3_data->sockfd, sock_buffer, sock_buffer_len, 0, &hepv3_data->remote_addr);
    if (res < 0) {
        ast_log(AST_LOG_ERROR, "Error [%d] while sending packet to HEPv3 server: %s\n",
            errno, strerror(errno));
    } else if (res != sock_buffer_len) {
        ast_log(AST_LOG_WARNING, "Failed to send complete packet to HEPv3 server: %d of %u sent\n",
            res, sock_buffer_len);
        res = -1;
    }
 
    ast_free(sock_buffer);
    return res;
}

References ao2_cleanup, ao2_global_obj_ref, ast_assert, ast_free, ast_log, AST_LOG_ERROR, AST_LOG_NOTICE, AST_LOG_WARNING, ast_malloc, ast_sendto(), ast_sockaddr_is_ipv4(), ast_sockaddr_port, ast_sockaddr_stringify_addr(), ast_strlen_zero(), hep_generic::capt_id, CHUNK_TYPE_AUTH_KEY, CHUNK_TYPE_CAPTURE_AGENT_ID, CHUNK_TYPE_CAPTURE_AGENT_NAME, CHUNK_TYPE_DST_PORT, CHUNK_TYPE_IP_PROTOCOL_FAMILY, CHUNK_TYPE_IP_PROTOCOL_ID, CHUNK_TYPE_IPV4_DST_ADDR, CHUNK_TYPE_IPV4_SRC_ADDR, CHUNK_TYPE_IPV6_DST_ADDR, CHUNK_TYPE_IPV6_SRC_ADDR, CHUNK_TYPE_PAYLOAD, CHUNK_TYPE_PAYLOAD_ZIP, CHUNK_TYPE_PROTOCOL_TYPE, CHUNK_TYPE_SRC_PORT, CHUNK_TYPE_TIMESTAMP_SEC, CHUNK_TYPE_TIMESTAMP_USEC, CHUNK_TYPE_UUID, config, hep_chunk_ip4::data, hep_chunk_ip6::data, hep_generic::dst_port, errno, hep_generic::header, hep_ctrl::id, INITIALIZE_GENERIC_HEP_CHUNK, INITIALIZE_GENERIC_HEP_CHUNK_DATA, INITIALIZE_GENERIC_HEP_IDS_VAR, hep_generic::ip_family, hep_generic::ip_proto, hep_ctrl::length, hep_generic::proto_t, RAII_VAR, hep_generic::src_port, hep_generic::time_sec, hep_generic::time_usec, and uuid().

Referenced by hepv3_send_packet().

◆ hepv3_config_alloc()

static void * hepv3_config_alloc ( void )

static

HEPv3 configuration object allocation.

Definition at line 329 of file res_hep.c.

{
    struct hepv3_global_config *config;
 
    config = ao2_alloc(sizeof(*config), hepv3_config_dtor);
    if (!config || ast_string_field_init(config, 32)) {
        return NULL;
    }
 
    return config;
}

References ao2_alloc, ast_string_field_init, config, hepv3_config_dtor(), and NULL.

Referenced by module_config_alloc().

◆ hepv3_config_dtor()

static void hepv3_config_dtor ( void * obj )

static

Definition at line 321 of file res_hep.c.

{
    struct hepv3_global_config *config = obj;
 
    ast_string_field_free_memory(config);
}

References ast_string_field_free_memory, and config.

Referenced by hepv3_config_alloc().

◆ hepv3_config_post_apply()

static void hepv3_config_post_apply ( void )

static

Post-apply callback for the config framework.

This will create the run-time information from the supplied configuration.

Definition at line 669 of file res_hep.c.

{
    RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(global_config), ao2_cleanup);
    struct hepv3_runtime_data *data;
 
    data = hepv3_data_alloc(mod_cfg->general);
    if (!data) {
        return;
    }
 
    ao2_global_obj_replace_unref(global_data, data);
    ao2_ref(data, -1);
}

References ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_replace_unref, ao2_ref, hepv3_data_alloc(), and RAII_VAR.

◆ hepv3_config_pre_apply()

static int hepv3_config_pre_apply ( void )

static

Pre-apply callback for the config framework.

This validates that required fields exist and are populated.

Definition at line 646 of file res_hep.c.

{
    struct module_config *config = aco_pending_config(&cfg_info);
 
    if (!config->general->enabled) {
        /* If we're not enabled, we don't care about anything else */
        return 0;
    }
 
    if (ast_strlen_zero(config->general->capture_address)) {
        ast_log(AST_LOG_ERROR, "Missing required configuration option 'capture_address'\n");
        return -1;
    }
 
    return 0;
}

References aco_pending_config(), ast_log, AST_LOG_ERROR, ast_strlen_zero(), and config.

◆ hepv3_create_capture_info()

struct hepv3_capture_info * hepv3_create_capture_info	(	const void *	payload,
		size_t	len
	)

Create a hepv3_capture_info object.

This returned object is an ao2 reference counted object.

Any attribute in the returned hepv3_capture_info that is a pointer should point to something that is allocated on the heap, as it will be free'd when the hepv3_capture_info object is reclaimed.

Parameters

payload	The payload to send to the HEP capture node
len	Length of `payload`

Returns: A hepv3_capture_info ref counted object on success

Return values

NULL on error

Definition at line 458 of file res_hep.c.

{
    struct hepv3_capture_info *info;
 
    info = ao2_alloc(sizeof(*info), capture_info_dtor);
    if (!info) {
        return NULL;
    }
 
    info->payload = ast_malloc(len);
    if (!info->payload) {
        ao2_ref(info, -1);
        return NULL;
    }
    memcpy(info->payload, payload, len);
    info->len = len;
 
    /* Set a reasonable default */
    info->protocol_id = IPPROTO_UDP;
 
    return info;
}

References ao2_alloc, ao2_ref, ast_malloc, capture_info_dtor(), len(), NULL, and hepv3_capture_info::payload.

Referenced by logging_on_rx_msg(), logging_on_tx_msg(), and rtcp_message_handler().

◆ hepv3_data_alloc()

static struct hepv3_runtime_data * hepv3_data_alloc ( struct hepv3_global_config * config )

static

Allocate the HEPv3 run-time data.

Definition at line 401 of file res_hep.c.

{
    struct hepv3_runtime_data *data;
 
    data = ao2_alloc(sizeof(*data), hepv3_data_dtor);
    if (!data) {
        return NULL;
    }
 
    data->sockfd = -1;
 
    if (ast_sockaddr_resolve_first_af(&data->remote_addr, config->capture_address, PARSE_PORT_REQUIRE, AST_AF_UNSPEC)) {
        ast_log(AST_LOG_WARNING, "Failed to create address from %s\n", config->capture_address);
        ao2_ref(data, -1);
        return NULL;
 
    }
 
    data->sockfd = socket(ast_sockaddr_is_ipv6(&data->remote_addr) ? AF_INET6 : AF_INET, SOCK_DGRAM, 0);
    if (data->sockfd < 0) {
        ast_log(AST_LOG_WARNING, "Failed to create socket for address %s: %s\n",
                config->capture_address, strerror(errno));
        ao2_ref(data, -1);
        return NULL;
    }
 
    return data;
}

References ao2_alloc, ao2_ref, AST_AF_UNSPEC, ast_log, AST_LOG_WARNING, ast_sockaddr_is_ipv6(), ast_sockaddr_resolve_first_af(), config, errno, hepv3_data_dtor(), NULL, PARSE_PORT_REQUIRE, hepv3_runtime_data::remote_addr, and hepv3_runtime_data::sockfd.

Referenced by hepv3_config_post_apply().

◆ hepv3_data_dtor()

static void hepv3_data_dtor ( void * obj )

static

HEPv3 run-time data destructor.

Definition at line 390 of file res_hep.c.

{
    struct hepv3_runtime_data *data = obj;
 
    if (data->sockfd > -1) {
        close(data->sockfd);
        data->sockfd = -1;
    }
}

References hepv3_runtime_data::sockfd.

Referenced by hepv3_data_alloc().

◆ hepv3_get_uuid_type()

enum hep_uuid_type hepv3_get_uuid_type ( void )

Get the preferred UUID type.

Since: 13.10.0

Returns: The type of UUID the packet should use

Definition at line 439 of file res_hep.c.

{
    RAII_VAR(struct module_config *, config, ao2_global_obj_ref(global_config), ao2_cleanup);
 
    if (!config) {
        /* Well, that's unfortunate. Return something. */
        return HEP_UUID_TYPE_CALL_ID;
    }
 
    return config->general->uuid_type;
}

References ao2_cleanup, ao2_global_obj_ref, config, HEP_UUID_TYPE_CALL_ID, and RAII_VAR.

Referenced by assign_uuid(), and assign_uuid().

◆ hepv3_is_loaded()

int hepv3_is_loaded ( void )

Return whether or not we're currently loaded and active.

Return values

0	The module is not loaded
1	The module is loaded

Definition at line 451 of file res_hep.c.

{
    RAII_VAR(struct module_config *, config, ao2_global_obj_ref(global_config), ao2_cleanup);
 
    return config && config->general->enabled;
}

References ao2_cleanup, ao2_global_obj_ref, config, and RAII_VAR.

Referenced by load_module(), and load_module().

◆ hepv3_send_packet()

int hepv3_send_packet ( struct hepv3_capture_info * capture_info )

Send a generic packet capture to HEPv3.

Parameters

capture_info Information describing the packet. This should be a reference counted object, created via hepv3_create_capture_info.

Once this function is called, it assumes ownership of the capture_info object and steals the reference of the object. Regardless of success or failure, the calling function should assumed that this function will own the object.

Return values

0	on success
-1	on error

Definition at line 623 of file res_hep.c.

{
    RAII_VAR(struct module_config *, config, ao2_global_obj_ref(global_config), ao2_cleanup);
    int res;
 
    if (!config || !config->general->enabled) {
        ao2_ref(capture_info, -1);
        return 0;
    }
 
    res = ast_taskprocessor_push(hep_queue_tp, hep_queue_cb, capture_info);
    if (res == -1) {
        ao2_ref(capture_info, -1);
    }
 
    return res;
}

References ao2_cleanup, ao2_global_obj_ref, ao2_ref, ast_taskprocessor_push(), config, hep_queue_cb(), hep_queue_tp, and RAII_VAR.

Referenced by logging_on_rx_msg(), logging_on_tx_msg(), and rtcp_message_handler().

◆ load_module()

static int load_module ( void )

static

Load the module.

Definition at line 711 of file res_hep.c.

{
    if (aco_info_init(&cfg_info)) {
        goto error;
    }
 
    hep_queue_tp = ast_taskprocessor_get("hep_queue_tp", TPS_REF_DEFAULT);
    if (!hep_queue_tp) {
        goto error;
    }
 
    aco_option_register(&cfg_info, "enabled", ACO_EXACT, global_options, "yes", OPT_BOOL_T, 1, FLDSET(struct hepv3_global_config, enabled));
    aco_option_register(&cfg_info, "capture_address", ACO_EXACT, global_options, "", OPT_STRINGFIELD_T, 1, STRFLDSET(struct hepv3_global_config, capture_address));
    aco_option_register(&cfg_info, "capture_password", ACO_EXACT, global_options, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct hepv3_global_config, capture_password));
    aco_option_register(&cfg_info, "capture_id", ACO_EXACT, global_options, "0", OPT_UINT_T, 0, STRFLDSET(struct hepv3_global_config, capture_id));
    aco_option_register(&cfg_info, "capture_name", ACO_EXACT, global_options, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct hepv3_global_config, capture_name));
    aco_option_register_custom(&cfg_info, "uuid_type", ACO_EXACT, global_options, "call-id", uuid_type_handler, 0);
 
    if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
        goto error;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
 
error:
    aco_info_destroy(&cfg_info);
    return AST_MODULE_LOAD_DECLINE;
}

References ACO_EXACT, aco_info_destroy(), aco_info_init(), aco_option_register, aco_option_register_custom, aco_process_config(), ACO_PROCESS_ERROR, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_taskprocessor_get(), enabled, error(), FLDSET, global_options, hep_queue_tp, OPT_BOOL_T, OPT_STRINGFIELD_T, OPT_UINT_T, STRFLDSET, TPS_REF_DEFAULT, and uuid_type_handler().

◆ module_config_alloc()

static void * module_config_alloc ( void )

static

Module config constructor.

Definition at line 352 of file res_hep.c.

{
    struct module_config *config;
 
    config = ao2_alloc(sizeof(*config), module_config_dtor);
    if (!config) {
        return NULL;
    }
 
    config->general = hepv3_config_alloc();
    if (!config->general) {
        ao2_ref(config, -1);
        config = NULL;
    }
 
    return config;
}

References ao2_alloc, ao2_ref, config, hepv3_config_alloc(), module_config_dtor(), and NULL.

◆ module_config_dtor()

static void module_config_dtor ( void * obj )

static

Configuration object destructor.

Definition at line 342 of file res_hep.c.

{
    struct module_config *config = obj;
 
    if (config->general) {
        ao2_ref(config->general, -1);
    }
}

References ao2_ref, and config.

Referenced by module_config_alloc().

◆ reload_module()

static int reload_module ( void )

static

Reload the module.

Definition at line 686 of file res_hep.c.

{
    if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
        return -1;
    }
    return 0;
}

References aco_process_config(), and ACO_PROCESS_ERROR.

◆ unload_module()

static int unload_module ( void )

static

Unload the module.

Definition at line 697 of file res_hep.c.

{
    hep_queue_tp = ast_taskprocessor_unreference(hep_queue_tp);
 
    ao2_global_obj_release(global_config);
    ao2_global_obj_release(global_data);
    aco_info_destroy(&cfg_info);
 
    return 0;
}

References aco_info_destroy(), ao2_global_obj_release, ast_taskprocessor_unreference(), and hep_queue_tp.

◆ uuid_type_handler()

static int uuid_type_handler	(	const struct aco_option *	opt,
		struct ast_variable *	var,
		void *	obj
	)

static

Handler for the uuid_type attribute.

Definition at line 371 of file res_hep.c.

{
    struct hepv3_global_config *global_config = obj;
 
    if (strcasecmp(var->name, "uuid_type")) {
        return -1;
    }
 
    if (!strcasecmp(var->value, "channel")) {
        global_config->uuid_type = HEP_UUID_TYPE_CHANNEL;
    } else if (!strcasecmp(var->value, "call-id")) {
        global_config->uuid_type = HEP_UUID_TYPE_CALL_ID;
    } else {
        return -1;
    }
    return 0;
}

References HEP_UUID_TYPE_CALL_ID, HEP_UUID_TYPE_CHANNEL, and var.

Referenced by load_module().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "HEPv3 API" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_APP_DEPEND, }

static

Definition at line 746 of file res_hep.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 746 of file res_hep.c.

◆ global_option

struct aco_type global_option

static

Definition at line 287 of file res_hep.c.

                                       {
    .type = ACO_GLOBAL,
    .name = "general",
    .item_offset = offsetof(struct module_config, general),
    .category_match = ACO_WHITELIST_EXACT,
    .category = "general",
};

◆ global_options

struct aco_type* global_options[] = ACO_TYPES(&global_option)

Definition at line 295 of file res_hep.c.

Referenced by load_module().

◆ hep_queue_tp

struct ast_taskprocessor* hep_queue_tp

static

Definition at line 308 of file res_hep.c.

Referenced by hepv3_send_packet(), load_module(), and unload_module().

◆ hepv3_conf

struct aco_file hepv3_conf

Initial value:

= {
    .filename = "hep.conf",
    .types = ACO_TYPES(&global_option),
}

Definition at line 297 of file res_hep.c.

                             {
    .filename = "hep.conf",
    .types = ACO_TYPES(&global_option),
};

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ASTERISK_VENDOR_ID

◆ GENERIC_VENDOR_ID

◆ INITIALIZE_GENERIC_HEP_CHUNK

◆ INITIALIZE_GENERIC_HEP_CHUNK_DATA

◆ INITIALIZE_GENERIC_HEP_IDS

◆ INITIALIZE_GENERIC_HEP_IDS_VAR

Enumeration Type Documentation

◆ hepv3_chunk_types

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AO2_GLOBAL_OBJ_STATIC() [1/2]

◆ AO2_GLOBAL_OBJ_STATIC() [2/2]

◆ AST_MODULE_SELF_SYM()

◆ capture_info_dtor()

◆ CONFIG_INFO_STANDARD()

◆ hep_queue_cb()

◆ hepv3_config_alloc()

◆ hepv3_config_dtor()

◆ hepv3_config_post_apply()

◆ hepv3_config_pre_apply()

◆ hepv3_create_capture_info()

◆ hepv3_data_alloc()

◆ hepv3_data_dtor()

◆ hepv3_get_uuid_type()

◆ hepv3_is_loaded()

◆ hepv3_send_packet()

◆ load_module()

◆ module_config_alloc()

◆ module_config_dtor()

◆ reload_module()

◆ unload_module()

◆ uuid_type_handler()

Variable Documentation

◆ __mod_info

◆ ast_module_info

◆ global_option

◆ global_options

◆ hep_queue_tp

◆ hepv3_conf