res_hep.c File Reference

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. More...
static	AO2_GLOBAL_OBJ_STATIC (global_data)
	Current module data. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	capture_info_dtor (void *obj)
	Destructor for a hepv3_capture_info object. More...
	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. More...
static int	hep_queue_cb (void *data)
	Callback function for the hep_queue_tp taskprocessor. More...
static void *	hepv3_config_alloc (void)
	HEPv3 configuration object allocation. More...
static void	hepv3_config_dtor (void *obj)
static void	hepv3_config_post_apply (void)
	Post-apply callback for the config framework. More...
static int	hepv3_config_pre_apply (void)
	Pre-apply callback for the config framework. More...
struct hepv3_capture_info *	hepv3_create_capture_info (const void *payload, size_t len)
	Create a hepv3_capture_info object. More...
static struct hepv3_runtime_data *	hepv3_data_alloc (struct hepv3_global_config *config)
	Allocate the HEPv3 run-time data. More...
static void	hepv3_data_dtor (void *obj)
	HEPv3 run-time data destructor. More...
enum hep_uuid_type	hepv3_get_uuid_type (void)
	Get the preferred UUID type. More...
int	hepv3_is_loaded (void)
	Return whether or not we're currently loaded and active. More...
int	hepv3_send_packet (struct hepv3_capture_info *capture_info)
	Send a generic packet capture to HEPv3. More...
static int	load_module (void)
	Load the module. More...
static void *	module_config_alloc (void)
	Module config constructor. More...
static void	module_config_dtor (void *obj)
	Configuration object destructor. More...
static int	reload_module (void)
	Reload the module. More...
static int	unload_module (void)
	Unload the module. More...
static int	uuid_type_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Handler for the uuid_type attribute. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "HEPv3 API" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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_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_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.

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.

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, and sip_to_pjsip::info().

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(), sip_to_pjsip::info(), 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().

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().

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

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.