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 }

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 103 of file res_hep.c.

GENERIC_VENDOR_ID

#define GENERIC_VENDOR_ID   0x0000

Generic vendor ID. Used for HEPv3 standard packets

Definition at line 100 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 170 of file res_hep.c.

Referenced by hep_queue_cb().

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 175 of file res_hep.c.

Referenced by hep_queue_cb().

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 160 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 165 of file res_hep.c.

Referenced by hep_queue_cb().

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

Definition at line 106 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 \REF 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,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 703 of file res_hep.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 703 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 703 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 401 of file res_hep.c.

References ast_free, sip_to_pjsip::info(), hepv3_capture_info::payload, and hepv3_capture_info::uuid.

Referenced by hepv3_create_capture_info().

{
   struct hepv3_capture_info *info = obj;

   ast_free(info->uuid);
   ast_free(info->payload);
}

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 452 of file res_hep.c.

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_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_ip6::data, hep_chunk_ip4::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, and hep_generic::time_usec.

Referenced by hepv3_send_packet().

{
   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;
   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));
   }
   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);

   /* 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;
}

hepv3_config_alloc()

static void* hepv3_config_alloc ( void  )

static

HEPv3 configuration object allocation.

Definition at line 299 of file res_hep.c.

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

Referenced by module_config_alloc().

{
   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;
}

hepv3_config_dtor()

static void hepv3_config_dtor ( void *  obj )

static

Definition at line 291 of file res_hep.c.

References ast_string_field_free_memory, and config.

Referenced by hepv3_config_alloc().

{
   struct hepv3_global_config *config = obj;

   ast_string_field_free_memory(config);
}

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 627 of file res_hep.c.

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

{
   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);
}

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 604 of file res_hep.c.

References aco_pending_config(), ast_log, AST_LOG_ERROR, ast_strlen_zero, config, and module_config::general.

{
   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;
}

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

Return values

A	hepv3_capture_info ref counted object on success
NULL	on error

Definition at line 428 of file res_hep.c.

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

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

{
   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;
}

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 371 of file res_hep.c.

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

Referenced by hepv3_config_post_apply().

{
   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;
}

hepv3_data_dtor()

static void hepv3_data_dtor ( void *  obj )

static

HEPv3 run-time data destructor.

Definition at line 360 of file res_hep.c.

References hepv3_runtime_data::sockfd.

Referenced by hepv3_data_alloc().

{
   struct hepv3_runtime_data *data = obj;

   if (data->sockfd > -1) {
      close(data->sockfd);
      data->sockfd = -1;
   }
}

hepv3_get_uuid_type()

enum hep_uuid_type hepv3_get_uuid_type

(

void

)

Get the preferred UUID type.

Since

13.10.0

Return values

The	type of UUID the packet should use

Definition at line 409 of file res_hep.c.

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

Referenced by assign_uuid().

{
   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;
}

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 421 of file res_hep.c.

References ao2_cleanup, ao2_global_obj_ref, config, and RAII_VAR.

Referenced by load_module().

{
   RAII_VAR(struct module_config *, config, ao2_global_obj_ref(global_config), ao2_cleanup);

   return config && config->general->enabled;
}

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 581 of file res_hep.c.

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

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

{
   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;
}

load_module()

static int load_module ( void  )

static

Load the module.

Definition at line 669 of file res_hep.c.

References ACO_EXACT, aco_info_destroy(), aco_info_init(), aco_option_register, aco_option_register_custom, aco_process_config(), ACO_PROCESS_ERROR, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_APP_DEPEND, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_MODULE_SUPPORT_EXTENDED, ast_taskprocessor_get(), ASTERISK_GPL_KEY, error(), FLDSET, OPT_BOOL_T, OPT_STRINGFIELD_T, OPT_UINT_T, reload(), reload_module(), STRFLDSET, TPS_REF_DEFAULT, unload_module(), and uuid_type_handler().

{
   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_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;
}

module_config_alloc()

static void * module_config_alloc ( void  )

static

Module config constructor.

Definition at line 322 of file res_hep.c.

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

{
   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;
}

module_config_dtor()

static void module_config_dtor ( void *  obj )

static

Configuration object destructor.

Definition at line 312 of file res_hep.c.

References ao2_ref, config, and module_config::general.

Referenced by module_config_alloc().

{
   struct module_config *config = obj;

   if (config->general) {
      ao2_ref(config->general, -1);
   }
}

reload_module()

static int reload_module ( void  )

static

Reload the module.

Definition at line 644 of file res_hep.c.

References aco_process_config(), and ACO_PROCESS_ERROR.

Referenced by load_module().

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

unload_module()

static int unload_module ( void  )

static

Unload the module.

Definition at line 655 of file res_hep.c.

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

Referenced by load_module().

{
   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;
}

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 341 of file res_hep.c.

References HEP_UUID_TYPE_CALL_ID, HEP_UUID_TYPE_CHANNEL, ast_variable::name, hepv3_global_config::uuid_type, and ast_variable::value.

Referenced by load_module().

{
   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;
}

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 703 of file res_hep.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 703 of file res_hep.c.

global_option

struct aco_type global_option

static

Definition at line 257 of file res_hep.c.

global_options

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

Definition at line 265 of file res_hep.c.

hep_queue_tp

struct ast_taskprocessor* hep_queue_tp

static

Definition at line 278 of file res_hep.c.

hepv3_conf

struct aco_file hepv3_conf

Initial value:

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

Definition at line 267 of file res_hep.c.