res_pjsip_endpoint_identifier_ip.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_cli.h"
#include "asterisk/module.h"
#include "asterisk/acl.h"
#include "asterisk/manager.h"
#include "res_pjsip/include/res_pjsip_private.h"

Include dependency graph for res_pjsip_endpoint_identifier_ip.c:

Go to the source code of this file.

Data Structures
struct	ip_identify_match
	Structure for an IP identification matching object. More...

Macros
#define	HOSTS_BUCKETS   53
	The number of buckets for storing hosts for resolution.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ao2_container *	cli_get_container (const char *regex)
static int	cli_iterator (void *container, ao2_callback_fn callback, void *args)
static int	cli_print_body (void *obj, void *arg, int flags)
static int	cli_print_header (void *obj, void *arg, int flags)
static void *	cli_retrieve_by_id (const char *id)
static struct ast_sip_endpoint *	common_identify (ao2_callback_fn *identify_match_cb, void *arg)
static int	format_ami_endpoint_identify (const struct ast_sip_endpoint *endpoint, struct ast_sip_ami *ami)
static struct ast_sip_endpoint *	header_identify (pjsip_rx_data *rdata)
static int	header_identify_match_check (void *obj, void *arg, int flags)
	Comparator function for matching an object by header.
static struct ast_sip_endpoint *	ip_identify (pjsip_rx_data *rdata)
static void *	ip_identify_alloc (const char *name)
	Allocator function for a matching object.
static int	ip_identify_apply (const struct ast_sorcery *sorcery, void *obj)
	Apply handler for identify type.
static void	ip_identify_destroy (void *obj)
	Destructor function for a matching object.
static int	ip_identify_match_check (void *obj, void *arg, int flags)
	Comparator function for matching an object by IP address.
static int	ip_identify_match_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom handler for match field.
static int	ip_identify_match_host_lookup (struct ip_identify_match *identify, const char *host)
	Helper function which performs a host lookup and adds result to identify match.
static int	ip_identify_match_srv_lookup (struct ip_identify_match *identify, const char *prefix, const char *host, int results)
	Helper function which performs an SRV lookup and then resolves the hostname.
static int	load_module (void)
static int	match_to_str (const void *obj, const intptr_t *args, char **buf)
static int	match_to_var_list (const void *obj, struct ast_variable **fields)
static void	match_to_var_list_append (struct ast_variable **head, struct ast_ha *ha)
static char *	my_cli_traverse_objects (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	reload_module (void)
static struct ast_sip_endpoint *	request_identify (pjsip_rx_data *rdata)
static int	request_identify_match_check (void *obj, void *arg, int flags)
	Comparator function for matching an object by request URI.
static int	send_identify_ami_event (void *obj, void *arg, void *data, int flags)
static int	sip_identify_to_ami (const struct ip_identify_match *identify, struct ast_str **buf)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP IP endpoint identifier" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND - 4, .requires = "res_pjsip", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_sip_cli_formatter_entry *	cli_formatter
static struct ast_cli_entry	cli_identify []
struct ast_sip_endpoint_formatter	endpoint_identify_formatter
static struct ast_sip_endpoint_identifier	header_identifier
static struct ast_sip_endpoint_identifier	ip_identifier
static struct ast_sip_endpoint_identifier	request_identifier

Macro Definition Documentation

HOSTS_BUCKETS

#define HOSTS_BUCKETS   53

The number of buckets for storing hosts for resolution.

Definition at line 162 of file res_pjsip_endpoint_identifier_ip.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1035 of file res_pjsip_endpoint_identifier_ip.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1035 of file res_pjsip_endpoint_identifier_ip.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1035 of file res_pjsip_endpoint_identifier_ip.c.

cli_get_container()

static struct ao2_container * cli_get_container ( const char *  regex )

static

Definition at line 818 of file res_pjsip_endpoint_identifier_ip.c.

{
    RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup);
    struct ao2_container *s_container;
 
    container =  ast_sorcery_retrieve_by_regex(ast_sip_get_sorcery(), "identify", regex);
    if (!container) {
        return NULL;
    }
 
    s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
        ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
    if (!s_container) {
        return NULL;
    }
 
    if (ao2_container_dup(s_container, container, 0)) {
        ao2_ref(s_container, -1);
        return NULL;
    }
 
    return s_container;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_list, ao2_container_dup(), ao2_ref, ast_sip_get_sorcery(), ast_sorcery_object_id_compare(), ast_sorcery_object_id_sort(), ast_sorcery_retrieve_by_regex(), container, NULL, RAII_VAR, and regex().

Referenced by load_module().

cli_iterator()

static int cli_iterator ( void *  container, ao2_callback_fn  callback, void *  args  )

static

Definition at line 795 of file res_pjsip_endpoint_identifier_ip.c.

{
    const struct ast_sip_endpoint *endpoint = container;
    struct ao2_container *identifies;
 
    struct ast_variable fields = {
        .name = "endpoint",
        .value = ast_sorcery_object_get_id(endpoint),
        .next = NULL,
    };
 
    identifies = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "identify",
        AST_RETRIEVE_FLAG_MULTIPLE, &fields);
    if (!identifies) {
        return -1;
    }
 
    ao2_callback(identifies, OBJ_NODATA, callback, args);
    ao2_cleanup(identifies);
 
    return 0;
}

References ao2_callback, ao2_cleanup, args, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), callback(), container, ast_variable::name, NULL, and OBJ_NODATA.

Referenced by load_module().

cli_print_body()

static int cli_print_body ( void *  obj, void *  arg, int  flags  )

static

Definition at line 874 of file res_pjsip_endpoint_identifier_ip.c.

{
    RAII_VAR(struct ast_str *, str, ast_str_create(MAX_OBJECT_FIELD), ast_free);
    struct ip_identify_match *ident = obj;
    struct ast_sip_cli_context *context = arg;
    struct ast_ha *match;
    int indent;
 
    ast_assert(context->output_buffer != NULL);
 
    ast_str_append(&context->output_buffer, 0, "%*s:  %s/%s\n",
        CLI_INDENT_TO_SPACES(context->indent_level), "Identify",
        ast_sorcery_object_get_id(ident), ident->endpoint_name);
 
    if (context->recurse) {
        context->indent_level++;
        indent = CLI_INDENT_TO_SPACES(context->indent_level);
 
        for (match = ident->matches; match; match = match->next) {
            const char *addr;
 
            if (ast_sockaddr_port(&match->addr)) {
                addr = ast_sockaddr_stringify(&match->addr);
            } else {
                addr = ast_sockaddr_stringify_addr(&match->addr);
            }
 
            ast_str_append(&context->output_buffer, 0, "%*s: %s%s/%d\n",
                indent,
                "Match",
                match->sense == AST_SENSE_ALLOW ? "!" : "",
                addr, ast_sockaddr_cidr_bits(&match->netmask));
        }
 
        if (!ast_strlen_zero(ident->match_header)) {
            ast_str_append(&context->output_buffer, 0, "%*s: %s\n",
                indent,
                "Header",
                ident->match_header);
        }
 
        if (!ast_strlen_zero(ident->match_request_uri)) {
            ast_str_append(&context->output_buffer, 0, "%*s: %s\n",
                indent,
                "RequestURI",
                ident->match_request_uri);
        }
 
        context->indent_level--;
 
        if (context->indent_level == 0) {
            ast_str_append(&context->output_buffer, 0, "\n");
        }
    }
 
    if (context->show_details
        || (context->show_details_only_level_0 && context->indent_level == 0)) {
        ast_str_append(&context->output_buffer, 0, "\n");
        ast_sip_cli_print_sorcery_objectset(ident, context, 0);
    }
 
    return 0;
}

References ast_ha::addr, ast_assert, ast_free, AST_SENSE_ALLOW, ast_sip_cli_print_sorcery_objectset(), ast_sockaddr_cidr_bits(), ast_sockaddr_port, ast_sockaddr_stringify(), ast_sockaddr_stringify_addr(), ast_sorcery_object_get_id(), ast_str_append(), ast_str_create, ast_strlen_zero(), CLI_INDENT_TO_SPACES, ip_identify_match::endpoint_name, match(), ip_identify_match::match_header, ip_identify_match::match_request_uri, ip_identify_match::matches, MAX_OBJECT_FIELD, NULL, RAII_VAR, and str.

Referenced by load_module().

cli_print_header()

static int cli_print_header ( void *  obj, void *  arg, int  flags  )

static

Definition at line 847 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ast_sip_cli_context *context = arg;
    int indent = CLI_INDENT_TO_SPACES(context->indent_level);
    int filler = CLI_MAX_WIDTH - indent - 22;
 
    ast_assert(context->output_buffer != NULL);
 
    ast_str_append(&context->output_buffer, 0,
        "%*s:  <Identify/Endpoint%*.*s>\n",
        indent, "Identify", filler, filler, CLI_HEADER_FILLER);
 
    if (context->recurse) {
        context->indent_level++;
        indent = CLI_INDENT_TO_SPACES(context->indent_level);
        filler = CLI_LAST_TABSTOP - indent - 24;
 
        ast_str_append(&context->output_buffer, 0,
            "%*s:  <criteria%*.*s>\n",
            indent, "Match", filler, filler, CLI_HEADER_FILLER);
 
        context->indent_level--;
    }
 
    return 0;
}

References ast_assert, ast_str_append(), CLI_HEADER_FILLER, CLI_INDENT_TO_SPACES, CLI_LAST_TABSTOP, CLI_MAX_WIDTH, and NULL.

Referenced by load_module().

cli_retrieve_by_id()

static void * cli_retrieve_by_id ( const char *  id )

static

Definition at line 842 of file res_pjsip_endpoint_identifier_ip.c.

{
    return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "identify", id);
}

References ast_sip_get_sorcery(), and ast_sorcery_retrieve_by_id().

Referenced by load_module().

common_identify()

static struct ast_sip_endpoint * common_identify ( ao2_callback_fn *  identify_match_cb, void *  arg  )

static

Definition at line 349 of file res_pjsip_endpoint_identifier_ip.c.

{
    RAII_VAR(struct ao2_container *, candidates, NULL, ao2_cleanup);
    struct ip_identify_match *match;
    struct ast_sip_endpoint *endpoint;
 
    /* If no possibilities exist return early to save some time */
    candidates = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "identify",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    if (!candidates || !ao2_container_count(candidates)) {
        ast_debug(3, "No identify sections to match against\n");
        return NULL;
    }
 
    match = ao2_callback(candidates, 0, identify_match_cb, arg);
    if (!match) {
        return NULL;
    }
 
    endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
        match->endpoint_name);
    if (endpoint) {
        ast_debug(3, "Identify '%s' SIP message matched to endpoint %s\n",
            ast_sorcery_object_get_id(match), match->endpoint_name);
    } else {
        ast_log(LOG_WARNING, "Identify '%s' points to endpoint '%s' but endpoint could not be found\n",
            ast_sorcery_object_get_id(match), match->endpoint_name);
    }
 
    ao2_ref(match, -1);
    return endpoint;
}

References ao2_callback, ao2_cleanup, ao2_container_count(), ao2_ref, ast_debug, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), ast_sorcery_retrieve_by_id(), LOG_WARNING, match(), NULL, and RAII_VAR.

Referenced by header_identify(), ip_identify(), and request_identify().

format_ami_endpoint_identify()

static int format_ami_endpoint_identify ( const struct ast_sip_endpoint *  endpoint, struct ast_sip_ami *  ami  )

static

Definition at line 766 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ao2_container *identifies;
    struct ast_variable fields = {
        .name = "endpoint",
        .value = ast_sorcery_object_get_id(endpoint),
    };
 
    identifies = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "identify",
        AST_RETRIEVE_FLAG_MULTIPLE, &fields);
    if (!identifies) {
        return -1;
    }
 
    /* Build and send any found identify object's AMI IdentifyDetail event. */
    ao2_callback_data(identifies, OBJ_MULTIPLE | OBJ_NODATA,
        send_identify_ami_event,
        (void *) ast_sorcery_object_get_id(endpoint),
        ami);
 
    ao2_ref(identifies, -1);
    return 0;
}

References ao2_callback_data, ao2_ref, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), ast_variable::name, OBJ_MULTIPLE, OBJ_NODATA, and send_identify_ami_event().

header_identify()

static struct ast_sip_endpoint * header_identify ( pjsip_rx_data *  rdata )

static

Definition at line 396 of file res_pjsip_endpoint_identifier_ip.c.

{
    return common_identify(header_identify_match_check, rdata);
}

References common_identify(), and header_identify_match_check().

header_identify_match_check()

static int header_identify_match_check ( void *  obj, void *  arg, int  flags  )

static

Comparator function for matching an object by header.

Definition at line 227 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    struct pjsip_rx_data *rdata = arg;
    pjsip_hdr *header;
    pj_str_t pj_header_name;
    int header_present;
 
    if (ast_strlen_zero(identify->match_header)) {
        return 0;
    }
 
    pj_header_name = pj_str((void *) identify->match_header_name);
 
    /* Check all headers of the given name for a match. */
    header_present = 0;
    for (header = NULL;
        (header = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &pj_header_name, header));
        header = header->next) {
        char *pos;
        int len;
        char buf[PATH_MAX];
 
        header_present = 1;
 
        /* Print header line to buf */
        len = pjsip_hdr_print_on(header, buf, sizeof(buf) - 1);
        if (len < 0) {
            /* Buffer not large enough or no header vptr! */
            ast_assert(0);
            continue;
        }
        buf[len] = '\0';
 
        /* Remove header name from pj_buf and trim blanks. */
        pos = strchr(buf, ':');
        if (!pos) {
            /* No header name?  Bug in PJPROJECT if so. */
            ast_assert(0);
            continue;
        }
        pos = ast_strip(pos + 1);
 
        /* Does header value match what we are looking for? */
        if (identify->is_header_regex) {
            if (!regexec(&identify->regex_header_buf, pos, 0, NULL, 0)) {
                return CMP_MATCH;
            }
        } else if (!strcmp(identify->match_header_value, pos)) {
            return CMP_MATCH;
        }
 
        ast_debug(3, "Identify '%s': SIP message has '%s' header but value '%s' does not match '%s'.\n",
            ast_sorcery_object_get_id(identify),
            identify->match_header_name,
            pos,
            identify->match_header_value);
    }
    if (!header_present) {
        ast_debug(3, "Identify '%s': SIP message does not have '%s' header.\n",
            ast_sorcery_object_get_id(identify),
            identify->match_header_name);
    }
    return 0;
}

References ast_assert, ast_debug, ast_sorcery_object_get_id(), ast_strip(), ast_strlen_zero(), buf, CMP_MATCH, ip_identify_match::is_header_regex, len(), ip_identify_match::match_header, ip_identify_match::match_header_name, ip_identify_match::match_header_value, header::next, NULL, PATH_MAX, and ip_identify_match::regex_header_buf.

Referenced by header_identify().

ip_identify()

static struct ast_sip_endpoint * ip_identify ( pjsip_rx_data *  rdata )

static

Definition at line 382 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ast_sockaddr addr = { { 0, } };
 
    ast_sockaddr_parse(&addr, rdata->pkt_info.src_name, PARSE_PORT_FORBID);
    ast_sockaddr_set_port(&addr, rdata->pkt_info.src_port);
 
    return common_identify(ip_identify_match_check, &addr);
}

References ast_sockaddr_parse(), ast_sockaddr_set_port, common_identify(), ip_identify_match_check(), and PARSE_PORT_FORBID.

ip_identify_alloc()

static void * ip_identify_alloc ( const char *  name )

static

Allocator function for a matching object.

Definition at line 214 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = ast_sorcery_generic_alloc(sizeof(*identify), ip_identify_destroy);
 
    if (!identify || ast_string_field_init(identify, 256)) {
        ao2_cleanup(identify);
        return NULL;
    }
 
    return identify;
}

References ao2_cleanup, ast_sorcery_generic_alloc(), ast_string_field_init, ip_identify_destroy(), and NULL.

Referenced by load_module().

ip_identify_apply()

static int ip_identify_apply ( const struct ast_sorcery *  sorcery, void *  obj  )

static

Apply handler for identify type.

Definition at line 536 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    char *current_string;
    struct ao2_iterator i;
 
    /* Validate the identify object configuration */
    if (ast_strlen_zero(identify->endpoint_name)) {
        ast_log(LOG_ERROR, "Identify '%s' missing required endpoint name.\n",
            ast_sorcery_object_get_id(identify));
        return -1;
    }
    if (ast_strlen_zero(identify->match_header) /* No header to match */
        && ast_strlen_zero(identify->match_request_uri) /* and no request to match */
        /* and no static IP addresses with a mask */
        && !identify->matches
        /* and no addresses to resolve */
        && (!identify->hosts || !ao2_container_count(identify->hosts))) {
        ast_log(LOG_ERROR, "Identify '%s' is not configured to match anything.\n",
            ast_sorcery_object_get_id(identify));
        return -1;
    }
 
    if (!ast_strlen_zero(identify->match_header)) {
        char *c_header;
        char *c_value;
        int len;
 
        /* Split the header name and value */
        c_header = ast_strdupa(identify->match_header);
        c_value = strchr(c_header, ':');
        if (!c_value) {
            ast_log(LOG_ERROR, "Identify '%s' missing ':' separator in match_header '%s'.\n",
                ast_sorcery_object_get_id(identify), identify->match_header);
            return -1;
        }
        *c_value = '\0';
        c_value = ast_strip(c_value + 1);
        c_header = ast_strip(c_header);
 
        if (ast_strlen_zero(c_header)) {
            ast_log(LOG_ERROR, "Identify '%s' has no SIP header to match in match_header '%s'.\n",
                ast_sorcery_object_get_id(identify), identify->match_header);
            return -1;
        }
 
        if (!strcmp(c_value, "//")) {
            /* An empty regex is the same as an empty literal string. */
            c_value = "";
        }
 
        if (ast_string_field_set(identify, match_header_name, c_header)
            || ast_string_field_set(identify, match_header_value, c_value)) {
            return -1;
        }
 
        len = strlen(c_value);
        if (2 < len && c_value[0] == '/' && c_value[len - 1] == '/') {
            /* Make "/regex/" into "regex" */
            c_value[len - 1] = '\0';
            ++c_value;
 
            if (regcomp(&identify->regex_header_buf, c_value, REG_EXTENDED | REG_NOSUB)) {
                ast_log(LOG_ERROR, "Identify '%s' failed to compile match_request_uri regex '%s'.\n",
                    ast_sorcery_object_get_id(identify), c_value);
                return -1;
            }
            identify->is_header_regex = 1;
        }
    }
 
    if (!ast_strlen_zero(identify->match_request_uri)) {
        char *c_string;
        int len;
 
        len = strlen(identify->match_request_uri);
        c_string = ast_strdupa(identify->match_request_uri);
 
        if (!strcmp(c_string, "//")) {
            /* An empty regex is the same as an empty literal string. */
            c_string = "";
        }
 
        if (2 < len && c_string[0] == '/' && c_string[len - 1] == '/') {
            /* Make "/regex/" into "regex" */
            c_string[len - 1] = '\0';
            ++c_string;
 
            if (regcomp(&identify->regex_request_uri_buf, c_string, REG_EXTENDED | REG_NOSUB)) {
                ast_log(LOG_ERROR, "Identify '%s' failed to compile match_header regex '%s'.\n",
                    ast_sorcery_object_get_id(identify), c_string);
                return -1;
            }
            identify->is_request_uri_regex = 1;
        }
    }
 
    if (!identify->hosts) {
        /* No match addresses to resolve */
        return 0;
    }
 
    /* Hosts can produce dynamic content, so mark the identify as such */
    ast_sorcery_object_set_has_dynamic_contents(obj);
 
    /* Resolve the match addresses now */
    i = ao2_iterator_init(identify->hosts, 0);
    while ((current_string = ao2_iterator_next(&i))) {
        int results = 0;
        char *colon = strrchr(current_string, ':');
 
        /* We skip SRV lookup if a colon is present, assuming a port was specified */
        if (!colon) {
            /* No port, and we know this is not an IP address, so perform SRV resolution on it */
            if (identify->srv_lookups) {
                results = ip_identify_match_srv_lookup(identify, "_sip._udp", current_string,
                    results);
                if (results != -1) {
                    results = ip_identify_match_srv_lookup(identify, "_sip._tcp",
                        current_string, results);
                }
                if (results != -1) {
                    results = ip_identify_match_srv_lookup(identify, "_sips._tcp",
                        current_string, results);
                }
            }
        }
 
        /* If SRV fails fall back to a normal lookup on the host itself */
        if (!results) {
            results = ip_identify_match_host_lookup(identify, current_string);
        }
 
        if (results == 0) {
            ast_log(LOG_WARNING, "Identify '%s' provided address '%s' did not resolve to any address\n",
                ast_sorcery_object_get_id(identify), current_string);
        } else if (results == -1) {
            ast_log(LOG_ERROR, "Identify '%s' failed when adding resolution results of '%s'\n",
                ast_sorcery_object_get_id(identify), current_string);
            ao2_ref(current_string, -1);
            ao2_iterator_destroy(&i);
            return -1;
        }
 
        ao2_ref(current_string, -1);
    }
    ao2_iterator_destroy(&i);
 
    ao2_ref(identify->hosts, -1);
    identify->hosts = NULL;
 
    return 0;
}

References ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, ast_sorcery_object_get_id(), ast_sorcery_object_set_has_dynamic_contents(), ast_strdupa, ast_string_field_set, ast_strip(), ast_strlen_zero(), ip_identify_match::endpoint_name, ip_identify_match::hosts, ip_identify_match_host_lookup(), ip_identify_match_srv_lookup(), ip_identify_match::is_header_regex, ip_identify_match::is_request_uri_regex, len(), LOG_ERROR, LOG_WARNING, ip_identify_match::match_header, ip_identify_match::match_request_uri, ip_identify_match::matches, NULL, ip_identify_match::regex_header_buf, ip_identify_match::regex_request_uri_buf, and ip_identify_match::srv_lookups.

Referenced by load_module().

ip_identify_destroy()

static void ip_identify_destroy ( void *  obj )

static

Destructor function for a matching object.

Definition at line 198 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
 
    ast_string_field_free_memory(identify);
    ast_free_ha(identify->matches);
    ao2_cleanup(identify->hosts);
    if (identify->is_header_regex) {
        regfree(&identify->regex_header_buf);
    }
    if (identify->is_request_uri_regex) {
        regfree(&identify->regex_request_uri_buf);
    }
}

References ao2_cleanup, ast_free_ha(), ast_string_field_free_memory, ip_identify_match::hosts, ip_identify_match::is_header_regex, ip_identify_match::is_request_uri_regex, ip_identify_match::matches, ip_identify_match::regex_header_buf, and ip_identify_match::regex_request_uri_buf.

Referenced by ip_identify_alloc().

ip_identify_match_check()

static int ip_identify_match_check ( void *  obj, void *  arg, int  flags  )

static

Comparator function for matching an object by IP address.

Definition at line 329 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    struct ast_sockaddr *addr = arg;
    int sense;
 
    sense = ast_apply_ha(identify->matches, addr);
    if (sense != AST_SENSE_ALLOW) {
        ast_debug(3, "Source address %s matches identify '%s'\n",
                ast_sockaddr_stringify(addr),
                ast_sorcery_object_get_id(identify));
        return CMP_MATCH;
    } else {
        ast_debug(3, "Source address %s does not match identify '%s'\n",
                ast_sockaddr_stringify(addr),
                ast_sorcery_object_get_id(identify));
        return 0;
    }
}

References ast_apply_ha(), ast_debug, AST_SENSE_ALLOW, ast_sockaddr_stringify(), ast_sorcery_object_get_id(), CMP_MATCH, and ip_identify_match::matches.

Referenced by ip_identify().

ip_identify_match_handler()

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

static

Custom handler for match field.

Definition at line 480 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    char *input_string = ast_strdupa(var->value);
    char *current_string;
 
    if (ast_strlen_zero(var->value)) {
        return 0;
    }
 
    while ((current_string = ast_strip(strsep(&input_string, ",")))) {
        char *mask;
        struct ast_sockaddr address;
        int error = 0;
 
        if (ast_strlen_zero(current_string)) {
            continue;
        }
 
        mask = strrchr(current_string, '/');
 
        /* If it looks like a netmask is present, or we can immediately parse as an IP,
         * hand things off to the ACL */
        if (mask || ast_sockaddr_parse(&address, current_string, 0)) {
            identify->matches = ast_append_ha_with_port("d", current_string, identify->matches, &error);
 
            if (!identify->matches || error) {
                ast_log(LOG_ERROR, "Failed to add address '%s' to ip endpoint identifier '%s'\n",
                    current_string, ast_sorcery_object_get_id(obj));
                return -1;
            }
 
            continue;
        }
 
        if (!identify->hosts) {
            identify->hosts = ast_str_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, HOSTS_BUCKETS);
            if (!identify->hosts) {
                ast_log(LOG_ERROR, "Failed to create container to store hosts on ip endpoint identifier '%s'\n",
                    ast_sorcery_object_get_id(obj));
                return -1;
            }
        }
 
        error = ast_str_container_add(identify->hosts, current_string);
        if (error) {
            ast_log(LOG_ERROR, "Failed to store host '%s' for resolution on ip endpoint identifier '%s'\n",
                current_string, ast_sorcery_object_get_id(obj));
            return -1;
        }
    }
 
    return 0;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ast_append_ha_with_port(), ast_log, ast_sockaddr_parse(), ast_sorcery_object_get_id(), ast_str_container_add(), ast_str_container_alloc_options(), ast_strdupa, ast_strip(), ast_strlen_zero(), error(), ip_identify_match::hosts, HOSTS_BUCKETS, LOG_ERROR, ip_identify_match::matches, strsep(), and var.

Referenced by load_module().

ip_identify_match_host_lookup()

static int ip_identify_match_host_lookup ( struct ip_identify_match *  identify, const char *  host  )

static

Helper function which performs a host lookup and adds result to identify match.

Definition at line 415 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ast_sockaddr *addrs;
    int num_addrs = 0, error = 0, i;
    int results = 0;
 
    num_addrs = ast_sockaddr_resolve(&addrs, host, 0, AST_AF_UNSPEC);
    if (!num_addrs) {
        return -1;
    }
 
    for (i = 0; i < num_addrs; ++i) {
        /* Check if the address is already in the list, if so don't add it again */
        if (identify->matches && (ast_apply_ha(identify->matches, &addrs[i]) != AST_SENSE_ALLOW)) {
            continue;
        }
 
        /* We deny what we actually want to match because there is an implicit permit all rule for ACLs */
        identify->matches = ast_append_ha_with_port("d", ast_sockaddr_stringify(&addrs[i]), identify->matches, &error);
 
        if (!identify->matches || error) {
            results = -1;
            break;
        }
 
        results += 1;
    }
 
    ast_free(addrs);
 
    return results;
}

References AST_AF_UNSPEC, ast_append_ha_with_port(), ast_apply_ha(), ast_free, AST_SENSE_ALLOW, ast_sockaddr_resolve(), ast_sockaddr_stringify(), error(), and ip_identify_match::matches.

Referenced by ip_identify_apply(), and ip_identify_match_srv_lookup().

ip_identify_match_srv_lookup()

static int ip_identify_match_srv_lookup ( struct ip_identify_match *  identify, const char *  prefix, const char *  host, int  results  )

static

Helper function which performs an SRV lookup and then resolves the hostname.

Definition at line 449 of file res_pjsip_endpoint_identifier_ip.c.

{
    char service[NI_MAXHOST];
    struct srv_context *context = NULL;
    int srv_ret;
    const char *srvhost;
    unsigned short srvport;
 
    snprintf(service, sizeof(service), "%s.%s", prefix, host);
 
    while (!(srv_ret = ast_srv_lookup(&context, service, &srvhost, &srvport))) {
        int hosts;
 
        /* In the case of the SRV lookup we don't care if it fails, we will output a log message
         * when we fallback to a normal lookup.
         */
        hosts = ip_identify_match_host_lookup(identify, srvhost);
        if (hosts == -1) {
            results = -1;
            break;
        } else {
            results += hosts;
        }
    }
 
    ast_srv_cleanup(&context);
 
    return results;
}

References ast_srv_cleanup(), ast_srv_lookup(), ip_identify_match_host_lookup(), NULL, prefix, and service.

Referenced by ip_identify_apply().

load_module()

static int load_module ( void  )

static

Definition at line 968 of file res_pjsip_endpoint_identifier_ip.c.

{
    ast_sorcery_apply_config(ast_sip_get_sorcery(), "res_pjsip_endpoint_identifier_ip");
    ast_sorcery_apply_default(ast_sip_get_sorcery(), "identify", "config", "pjsip.conf,criteria=type=identify");
 
    if (ast_sorcery_object_register(ast_sip_get_sorcery(), "identify", ip_identify_alloc, NULL, ip_identify_apply)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "type", "", OPT_NOOP_T, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "endpoint", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, endpoint_name));
    ast_sorcery_object_field_register_custom(ast_sip_get_sorcery(), "identify", "match", "", ip_identify_match_handler, match_to_str, match_to_var_list, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "match_header", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, match_header));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "match_request_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, match_request_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "srv_lookups", "yes", OPT_BOOL_T, 1, FLDSET(struct ip_identify_match, srv_lookups));
    ast_sorcery_load_object(ast_sip_get_sorcery(), "identify");
 
    ast_sip_register_endpoint_identifier_with_name(&ip_identifier, "ip");
    ast_sip_register_endpoint_identifier_with_name(&header_identifier, "header");
    ast_sip_register_endpoint_identifier_with_name(&request_identifier, "request_uri");
    ast_sip_register_endpoint_formatter(&endpoint_identify_formatter);
 
    cli_formatter = ao2_alloc(sizeof(struct ast_sip_cli_formatter_entry), NULL);
    if (!cli_formatter) {
        ast_log(LOG_ERROR, "Unable to allocate memory for cli formatter\n");
        return AST_MODULE_LOAD_DECLINE;
    }
    cli_formatter->name = "identify";
    cli_formatter->print_header = cli_print_header;
    cli_formatter->print_body = cli_print_body;
    cli_formatter->get_container = cli_get_container;
    cli_formatter->iterate = cli_iterator;
    cli_formatter->get_id = ast_sorcery_object_get_id;
    cli_formatter->retrieve_by_id = cli_retrieve_by_id;
 
    ast_sip_register_cli_formatter(cli_formatter);
    ast_cli_register_multiple(cli_identify, ARRAY_LEN(cli_identify));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ao2_alloc, ARRAY_LEN, ast_cli_register_multiple, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_sip_get_sorcery(), ast_sip_register_cli_formatter(), ast_sip_register_endpoint_formatter(), ast_sip_register_endpoint_identifier_with_name(), ast_sorcery_apply_config, ast_sorcery_apply_default, ast_sorcery_load_object(), ast_sorcery_object_field_register, ast_sorcery_object_field_register_custom, ast_sorcery_object_get_id(), ast_sorcery_object_register, cli_formatter, cli_get_container(), cli_identify, cli_iterator(), cli_print_body(), cli_print_header(), cli_retrieve_by_id(), endpoint_identify_formatter, FLDSET, ast_sip_cli_formatter_entry::get_container, ast_sip_cli_formatter_entry::get_id, header_identifier, ip_identifier, ip_identify_alloc(), ip_identify_apply(), ip_identify_match_handler(), ast_sip_cli_formatter_entry::iterate, LOG_ERROR, match_to_str(), match_to_var_list(), ast_sip_cli_formatter_entry::name, NULL, OPT_BOOL_T, OPT_NOOP_T, OPT_STRINGFIELD_T, ast_sip_cli_formatter_entry::print_body, ast_sip_cli_formatter_entry::print_header, request_identifier, ast_sip_cli_formatter_entry::retrieve_by_id, and STRFLDSET.

match_to_str()

static int match_to_str ( const void *  obj, const intptr_t *  args, char **  buf  )

static

Definition at line 690 of file res_pjsip_endpoint_identifier_ip.c.

{
    RAII_VAR(struct ast_str *, str, ast_str_create(MAX_OBJECT_FIELD), ast_free);
    const struct ip_identify_match *identify = obj;
 
    ast_ha_join(identify->matches, &str);
    *buf = ast_strdup(ast_str_buffer(str));
    return 0;
}

References ast_free, ast_ha_join(), ast_str_buffer(), ast_str_create, ast_strdup, buf, ip_identify_match::matches, MAX_OBJECT_FIELD, RAII_VAR, and str.

Referenced by load_module().

match_to_var_list()

static int match_to_var_list ( const void *  obj, struct ast_variable **  fields  )

static

Definition at line 717 of file res_pjsip_endpoint_identifier_ip.c.

{
    const struct ip_identify_match *identify = obj;
    struct ast_variable *head = NULL;
    struct ast_ha *ha = identify->matches;
 
    for (; ha; ha = ha->next) {
        match_to_var_list_append(&head, ha);
    }
 
    if (head) {
        *fields = head;
    }
 
    return 0;
}

References match_to_var_list_append(), ip_identify_match::matches, ast_ha::next, and NULL.

Referenced by load_module().

match_to_var_list_append()

static void match_to_var_list_append ( struct ast_variable **  head, struct ast_ha *  ha  )

static

Definition at line 700 of file res_pjsip_endpoint_identifier_ip.c.

{
    char str[MAX_OBJECT_FIELD];
    const char *addr;
 
    if (ast_sockaddr_port(&ha->addr)) {
        addr = ast_strdupa(ast_sockaddr_stringify(&ha->addr));
    } else {
        addr = ast_strdupa(ast_sockaddr_stringify_addr(&ha->addr));
    }
 
    snprintf(str, MAX_OBJECT_FIELD, "%s%s/%s", ha->sense == AST_SENSE_ALLOW ? "!" : "",
             addr, ast_sockaddr_stringify_addr(&ha->netmask));
 
    ast_variable_list_append(head, ast_variable_new("match", str, ""));
}

References ast_ha::addr, AST_SENSE_ALLOW, ast_sockaddr_port, ast_sockaddr_stringify(), ast_sockaddr_stringify_addr(), ast_strdupa, ast_variable_list_append, ast_variable_new, MAX_OBJECT_FIELD, ast_ha::netmask, ast_ha::sense, and str.

Referenced by match_to_var_list().

my_cli_traverse_objects()

static char * my_cli_traverse_objects ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 943 of file res_pjsip_endpoint_identifier_ip.c.

{
    return ast_sip_cli_traverse_objects(e, cmd, a);
}

References a, and ast_sip_cli_traverse_objects().

reload_module()

static int reload_module ( void  )

static

Definition at line 1009 of file res_pjsip_endpoint_identifier_ip.c.

{
    ast_sorcery_reload_object(ast_sip_get_sorcery(), "identify");
 
    return 0;
}

References ast_sip_get_sorcery(), and ast_sorcery_reload_object().

request_identify()

static struct ast_sip_endpoint * request_identify ( pjsip_rx_data *  rdata )

static

Definition at line 401 of file res_pjsip_endpoint_identifier_ip.c.

{
    return common_identify(request_identify_match_check, rdata);
}

References common_identify(), and request_identify_match_check().

request_identify_match_check()

static int request_identify_match_check ( void *  obj, void *  arg, int  flags  )

static

Comparator function for matching an object by request URI.

Definition at line 294 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    struct pjsip_rx_data *rdata = arg;
    int len;
    char buf[PJSIP_MAX_URL_SIZE];
 
    if (ast_strlen_zero(identify->match_request_uri)) {
        return 0;
    }
 
    /* Print request URI to req_buf */
    len = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, rdata->msg_info.msg->line.req.uri, buf, sizeof(buf) - 1);
    if (len < 0) {
        /* Buffer not large enough or no pj uri vptr! */
        ast_assert(0);
    } else {
        /* Terminate the pj_str */
        buf[len] = '\0';
        /* Does request URI match what we are looking for? */
        if (identify->is_request_uri_regex) {
            if (!regexec(&identify->regex_request_uri_buf, buf, 0, NULL, 0)) {
                return CMP_MATCH;
            }
        } else if (!strcmp(identify->match_request_uri, buf)) {
            return CMP_MATCH;
        }
        ast_debug(3, "Identify '%s': request URI not match '%s' (value='%s').\n",
            ast_sorcery_object_get_id(identify), identify->match_request_uri, buf);
    }
 
    return 0;
}

References ast_assert, ast_debug, ast_sorcery_object_get_id(), ast_strlen_zero(), buf, CMP_MATCH, ip_identify_match::is_request_uri_regex, len(), ip_identify_match::match_request_uri, NULL, and ip_identify_match::regex_request_uri_buf.

Referenced by request_identify().

send_identify_ami_event()

static int send_identify_ami_event ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 740 of file res_pjsip_endpoint_identifier_ip.c.

{
    struct ip_identify_match *identify = obj;
    const char *endpoint_name = arg;
    struct ast_sip_ami *ami = data;
    struct ast_str *buf;
 
    /* Build AMI event */
    buf = ast_sip_create_ami_event("IdentifyDetail", ami);
    if (!buf) {
        return CMP_STOP;
    }
    if (sip_identify_to_ami(identify, &buf)) {
        ast_free(buf);
        return CMP_STOP;
    }
    ast_str_append(&buf, 0, "EndpointName: %s\r\n", endpoint_name);
 
    /* Send AMI event */
    astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
    ++ami->count;
 
    ast_free(buf);
    return 0;
}

References ast_free, ast_sip_create_ami_event(), ast_str_append(), ast_str_buffer(), astman_append(), buf, CMP_STOP, ast_sip_ami::count, ip_identify_match::endpoint_name, ast_sip_ami::s, and sip_identify_to_ami().

Referenced by format_ami_endpoint_identify().

sip_identify_to_ami()

static int sip_identify_to_ami ( const struct ip_identify_match *  identify, struct ast_str **  buf  )

static

Definition at line 734 of file res_pjsip_endpoint_identifier_ip.c.

{
    return ast_sip_sorcery_object_to_ami(identify, buf);
}

References ast_sip_sorcery_object_to_ami(), and buf.

Referenced by send_identify_ami_event().

unload_module()

static int unload_module ( void  )

static

Definition at line 1016 of file res_pjsip_endpoint_identifier_ip.c.

{
    ast_cli_unregister_multiple(cli_identify, ARRAY_LEN(cli_identify));
    ast_sip_unregister_cli_formatter(cli_formatter);
    ast_sip_unregister_endpoint_formatter(&endpoint_identify_formatter);
    ast_sip_unregister_endpoint_identifier(&header_identifier);
    ast_sip_unregister_endpoint_identifier(&request_identifier);
    ast_sip_unregister_endpoint_identifier(&ip_identifier);
 
    return 0;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_sip_unregister_cli_formatter(), ast_sip_unregister_endpoint_formatter(), ast_sip_unregister_endpoint_identifier(), cli_formatter, cli_identify, endpoint_identify_formatter, header_identifier, ip_identifier, and request_identifier.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP IP endpoint identifier" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND - 4, .requires = "res_pjsip", }

static

Definition at line 1035 of file res_pjsip_endpoint_identifier_ip.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1035 of file res_pjsip_endpoint_identifier_ip.c.

cli_formatter

struct ast_sip_cli_formatter_entry* cli_formatter

static

Definition at line 966 of file res_pjsip_endpoint_identifier_ip.c.

Referenced by load_module(), and unload_module().

cli_identify

struct ast_cli_entry cli_identify[]

static

Definition at line 949 of file res_pjsip_endpoint_identifier_ip.c.

                                             {
AST_CLI_DEFINE(my_cli_traverse_objects, "List PJSIP Identifies",
    .command = "pjsip list identifies",
    .usage = "Usage: pjsip list identifies [ like <pattern> ]\n"
    "       List the configured PJSIP Identifies\n"
    "       Optional regular expression pattern is used to filter the list.\n"),
AST_CLI_DEFINE(my_cli_traverse_objects, "Show PJSIP Identifies",
    .command = "pjsip show identifies",
    .usage = "Usage: pjsip show identifies [ like <pattern> ]\n"
    "       Show the configured PJSIP Identifies\n"
    "       Optional regular expression pattern is used to filter the list.\n"),
AST_CLI_DEFINE(my_cli_traverse_objects, "Show PJSIP Identify",
    .command = "pjsip show identify",
    .usage = "Usage: pjsip show identify <id>\n"
    "       Show the configured PJSIP Identify\n"),
};

Referenced by load_module(), and unload_module().

endpoint_identify_formatter

struct ast_sip_endpoint_formatter endpoint_identify_formatter

Initial value:

= {
    .format_ami = format_ami_endpoint_identify
}

Definition at line 791 of file res_pjsip_endpoint_identifier_ip.c.

                                                                {
    .format_ami = format_ami_endpoint_identify
};

Referenced by load_module(), and unload_module().

header_identifier

struct ast_sip_endpoint_identifier header_identifier

static

Initial value:

= {
    .identify_endpoint = header_identify,
}

Definition at line 406 of file res_pjsip_endpoint_identifier_ip.c.

                                                              {
    .identify_endpoint = header_identify,
};

Referenced by load_module(), and unload_module().

ip_identifier

struct ast_sip_endpoint_identifier ip_identifier

static

Initial value:

= {
    .identify_endpoint = ip_identify,
}

Definition at line 392 of file res_pjsip_endpoint_identifier_ip.c.

                                                          {
    .identify_endpoint = ip_identify,
};

Referenced by load_module(), and unload_module().

request_identifier

struct ast_sip_endpoint_identifier request_identifier

static

Initial value:

= {
    .identify_endpoint = request_identify,
}

Definition at line 410 of file res_pjsip_endpoint_identifier_ip.c.

                                                               {
    .identify_endpoint = request_identify,
};

Referenced by load_module(), and unload_module().