redirect.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include "asterisk/linkedlists.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_redirect.h"

Include dependency graph for redirect.c:

Go to the source code of this file.

Data Structures
struct	ast_sip_redirect_state
	Redirect state structure. More...
struct	redirect_contact
struct	redirect_contact_list
	List of redirect contacts. More...
struct	redirect_method_map
	Mapping of SIP method names to their corresponding redirect flags. More...
struct	visited_uri

Functions
static int	add_visited_uri (struct ast_sip_redirect_state *state, const char *uri)
int	ast_sip_redirect_check_loop (const struct ast_sip_redirect_state *state, const char *uri)
	Check if a URI would create a redirect loop.
struct ast_sip_endpoint *	ast_sip_redirect_get_endpoint (const struct ast_sip_redirect_state *state)
	Get the endpoint from the redirect state.
int	ast_sip_redirect_get_hop_count (const struct ast_sip_redirect_state *state)
	Get the current hop count.
int	ast_sip_redirect_get_next_uri (struct ast_sip_redirect_state *state, char **uri_out)
	Get the next redirect URI to try.
int	ast_sip_redirect_parse_3xx (pjsip_rx_data *rdata, struct ast_sip_redirect_state *state)
	Parse a 3xx redirect response and extract contacts.
struct ast_sip_redirect_state *	ast_sip_redirect_state_create (struct ast_sip_endpoint *endpoint, const char *initial_uri)
	Create a new redirect state.
void	ast_sip_redirect_state_destroy (struct ast_sip_redirect_state *state)
	Destroy a redirect state and free all resources.
int	ast_sip_should_redirect (struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
	Check if redirect should be followed based on endpoint configuration.
static float	extract_q_value (const pjsip_contact_hdr *contact)
static void	insert_contact_sorted (struct redirect_contact_list *list, struct redirect_contact *new_contact)
static int	is_uri_visited (const struct ast_sip_redirect_state *state, const char *uri)
static int	method_allowed_for_redirect (struct ast_sip_endpoint *endpoint, const pj_str_t *method_name)
static int	parse_redirect_contacts (pjsip_rx_data *rdata, struct redirect_contact_list *contacts, const struct ast_sip_redirect_state *state)

Variables
static const struct redirect_method_map	redirect_methods []

Function Documentation

add_visited_uri()

static int add_visited_uri ( struct ast_sip_redirect_state *  state, const char *  uri  )

static

Definition at line 190 of file redirect.c.

{
    struct visited_uri *visited;
 
    visited = ast_calloc(1, sizeof(*visited));
    if (!visited) {
        return -1;
    }
 
    ast_copy_string(visited->uri, uri, sizeof(visited->uri));
    AST_LIST_INSERT_TAIL(&state->visited_uris, visited, list);
 
    return 0;
}

References ast_calloc, ast_copy_string(), AST_LIST_INSERT_TAIL, visited_uri::list, and visited_uri::uri.

Referenced by ast_sip_redirect_get_next_uri().

ast_sip_redirect_check_loop()

int ast_sip_redirect_check_loop	(	const struct ast_sip_redirect_state *	state,
		const char *	uri
	)

Check if a URI would create a redirect loop.

Parameters

state	The redirect state
uri	The URI to check

Return values

0	if URI is safe (not visited)
1	if URI would create a loop (already visited)

Definition at line 429 of file redirect.c.

{
    return is_uri_visited(state, uri);
}

References is_uri_visited(), and redirect_contact::uri.

ast_sip_redirect_get_endpoint()

struct ast_sip_endpoint * ast_sip_redirect_get_endpoint

(

const struct ast_sip_redirect_state *

state

)

Get the endpoint from the redirect state.

Parameters

state

The redirect state

Returns

The endpoint (borrowed reference, do not cleanup)

Definition at line 439 of file redirect.c.

{
    return state->endpoint;
}

Referenced by handle_message_redirect(), msg_response_callback(), and send_message_to_uri().

ast_sip_redirect_get_hop_count()

int ast_sip_redirect_get_hop_count

(

const struct ast_sip_redirect_state *

state

)

Get the current hop count.

Parameters

state

The redirect state

Returns

The current hop count

Definition at line 434 of file redirect.c.

{
    return state->hop_count;
}

Referenced by handle_message_redirect(), and send_message_to_uri().

ast_sip_redirect_get_next_uri()

int ast_sip_redirect_get_next_uri	(	struct ast_sip_redirect_state *	state,
		char **	uri_out
	)

Get the next redirect URI to try.

This function returns the next contact URI from the redirect response, ordered by q-value (highest first). It also marks the URI as visited to prevent loops on subsequent redirects.

Parameters

state	The redirect state
uri_out	Pointer to store the URI string (caller must free)

Return values

-1	if no more URIs available
0	on success

Note

The caller must ast_free() the returned URI string

Definition at line 398 of file redirect.c.

{
    struct redirect_contact *contact;
 
    if (!uri_out) {
        return -1;
    }
 
    /* Get the first contact from the pending list */
    contact = AST_LIST_REMOVE_HEAD(&state->pending_contacts, list);
    if (!contact) {
        return -1;
    }
 
    /* Allocate and return the URI string */
    *uri_out = ast_strdup(contact->uri);
    if (!*uri_out) {
        ast_free(contact);
        return -1;
    }
 
    /* Add to visited list to prevent loops */
    if (add_visited_uri(state, contact->uri)) {
        ast_log(LOG_WARNING, "Failed to add URI to visited list for endpoint '%s'. Loop detection may be impaired.\n",
          ast_sorcery_object_get_id(state->endpoint));
    }
 
    ast_free(contact);
    return 0;
}

References add_visited_uri(), ast_free, AST_LIST_REMOVE_HEAD, ast_log, ast_sorcery_object_get_id(), ast_strdup, redirect_contact::list, LOG_WARNING, and redirect_contact::uri.

Referenced by handle_message_redirect(), and msg_response_callback().

ast_sip_redirect_parse_3xx()

int ast_sip_redirect_parse_3xx	(	pjsip_rx_data *	rdata,
		struct ast_sip_redirect_state *	state
	)

Parse a 3xx redirect response and extract contacts.

This function parses all Contact headers from a 3xx response, extracts q-values, sorts contacts by priority (highest q-value first), and filters out URIs that would create loops.

Parameters

rdata	The redirect response data
state	The redirect state

Return values

-1	on failure (hop limit reached, no valid contacts, etc.)
0	on success (at least one valid contact available)

Note

After calling this, use ast_sip_redirect_get_next_uri() to retrieve URIs

Definition at line 338 of file redirect.c.

{
    struct redirect_contact_list redirect_contacts;
    struct redirect_contact *contact;
    int contact_count;
    int status_code = rdata->msg_info.msg->line.status.code;
 
    ast_debug(1, "Received %d redirect response on endpoint '%s'.\n", status_code, ast_sorcery_object_get_id(state->endpoint));
 
    /* Check if redirect should be followed based on endpoint configuration */
    if (!ast_sip_should_redirect(state->endpoint, rdata)) {
        return -1;
    }
 
    /* Check hop limit */
    if (state->hop_count >= AST_SIP_MAX_REDIRECT_HOPS) {
        ast_log(LOG_WARNING, "Redirect hop limit (%d) reached for endpoint '%s'. Not following redirect.\n",
          AST_SIP_MAX_REDIRECT_HOPS, ast_sorcery_object_get_id(state->endpoint));
        return -1;
    }
 
    /* Parse all Contact headers and sort by q-value */
    AST_LIST_HEAD_INIT_NOLOCK(&redirect_contacts);
    contact_count = parse_redirect_contacts(rdata, &redirect_contacts, state);
 
    if (contact_count == 0) {
        ast_log(LOG_WARNING, "Received %d redirect without valid Contact headers for endpoint '%s'. Cannot follow redirect.\n",
            status_code, ast_sorcery_object_get_id(state->endpoint));
        return -1;
    }
 
    /* Filter out contacts that would create loops */
    AST_LIST_TRAVERSE_SAFE_BEGIN(&redirect_contacts, contact, list) {
        if (is_uri_visited(state, contact->uri)) {
            ast_log(LOG_WARNING, "Redirect: skipping Contact '%s' for endpoint '%s' (would create loop)\n", contact->uri,
                ast_sorcery_object_get_id(state->endpoint));
            AST_LIST_REMOVE_CURRENT(list);
            ast_free(contact);
            contact_count--;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (contact_count == 0) {
        ast_log(LOG_WARNING, "Redirect: all Contact URIs would create loops for endpoint '%s'. Not following redirect.\n",
            ast_sorcery_object_get_id(state->endpoint));
        return -1;
    }
 
    /* Move all contacts to pending_contacts list */
    while ((contact = AST_LIST_REMOVE_HEAD(&redirect_contacts, list))) {
        AST_LIST_INSERT_TAIL(&state->pending_contacts, contact, list);
    }
 
    /* Increment hop count */
    state->hop_count++;
 
    return 0;
}

References ast_debug, ast_free, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, AST_SIP_MAX_REDIRECT_HOPS, ast_sip_should_redirect(), ast_sorcery_object_get_id(), is_uri_visited(), redirect_contact::list, LOG_WARNING, parse_redirect_contacts(), and redirect_contact::uri.

Referenced by handle_message_redirect().

ast_sip_redirect_state_create()

struct ast_sip_redirect_state * ast_sip_redirect_state_create	(	struct ast_sip_endpoint *	endpoint,
		const char *	initial_uri
	)

Create a new redirect state.

Parameters

endpoint	The SIP endpoint
initial_uri	The initial URI being contacted (for loop detection)

Return values

NULL	on failure
A	new redirect state on success

Note

The caller must call ast_sip_redirect_state_destroy() when done

Definition at line 59 of file redirect.c.

{
    struct ast_sip_redirect_state *state;
    struct visited_uri *visited;
 
    state = ast_calloc(1, sizeof(*state));
    if (!state) {
        return NULL;
    }
 
    state->endpoint = ao2_bump(endpoint);
    state->hop_count = 0;
    AST_LIST_HEAD_INIT_NOLOCK(&state->visited_uris);
    AST_LIST_HEAD_INIT_NOLOCK(&state->pending_contacts);
 
    /* Add the initial URI to visited list */
    if (initial_uri) {
        visited = ast_calloc(1, sizeof(*visited));
        if (visited) {
            ast_copy_string(visited->uri, initial_uri, sizeof(visited->uri));
            AST_LIST_INSERT_HEAD(&state->visited_uris, visited, list);
        } else {
            ast_log(LOG_WARNING, "Redirect: Memory allocation failed for endpoint '%s'. "
                "Redirect loop detection may be impaired.\n", ast_sorcery_object_get_id(state->endpoint));
        }
    }
 
    return state;
}

References ao2_bump, ast_calloc, ast_copy_string(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_HEAD, ast_log, ast_sorcery_object_get_id(), visited_uri::list, LOG_WARNING, NULL, and visited_uri::uri.

Referenced by message_response_data_create().

ast_sip_redirect_state_destroy()

void ast_sip_redirect_state_destroy

(

struct ast_sip_redirect_state *

state

)

Destroy a redirect state and free all resources.

Parameters

state

The redirect state to destroy

Definition at line 444 of file redirect.c.

{
    struct visited_uri *visited;
    struct redirect_contact *contact;
 
    if (!state) {
        return;
    }
 
    ao2_cleanup(state->endpoint);
 
    while ((visited = AST_LIST_REMOVE_HEAD(&state->visited_uris, list))) {
        ast_free(visited);
    }
 
    while ((contact = AST_LIST_REMOVE_HEAD(&state->pending_contacts, list))) {
        ast_free(contact);
    }
 
    ast_free(state);
}

References ao2_cleanup, ast_free, AST_LIST_REMOVE_HEAD, and redirect_contact::list.

Referenced by message_response_data_destroy().

ast_sip_should_redirect()

int ast_sip_should_redirect	(	struct ast_sip_endpoint *	endpoint,
		pjsip_rx_data *	rdata
	)

Check if redirect should be followed based on endpoint configuration.

Parameters

endpoint	The SIP endpoint
rdata	The redirect response data containing the 3xx response

Return values

0	if redirect should not be followed
1	if redirect should be followed

Note

This checks if the status code is 3xx and if the SIP method (extracted from the CSeq header) is allowed to follow redirects based on the endpoint's follow_redirect_methods configuration

Definition at line 140 of file redirect.c.

{
    pjsip_msg *msg;
    pjsip_cseq_hdr *cseq;
    int status_code;
 
    if (!rdata || !rdata->msg_info.msg || rdata->msg_info.msg->type != PJSIP_RESPONSE_MSG) {
        return 0;
    }
 
    msg = rdata->msg_info.msg;
    status_code = msg->line.status.code;
 
    /* Check if it's a 3xx response */
    if (!PJSIP_IS_STATUS_IN_CLASS(status_code, 300)) {
        return 0;
    }
 
    /* Extract the method from the CSeq header */
    cseq = rdata->msg_info.cseq;
    if (!cseq) {
        ast_log(LOG_WARNING, "Received %d redirect for endpoint '%s', but no CSeq header found\n",
            status_code, ast_sorcery_object_get_id(endpoint));
        return 0;
    }
 
    /* Check if this method is allowed to follow redirects */
    return method_allowed_for_redirect(endpoint, &cseq->method.name);
}

References ast_log, ast_sorcery_object_get_id(), LOG_WARNING, and method_allowed_for_redirect().

Referenced by ast_sip_redirect_parse_3xx().

extract_q_value()

static float extract_q_value ( const pjsip_contact_hdr *  contact )

static

Definition at line 212 of file redirect.c.

{
    pjsip_param *param;
    static const pj_str_t Q_STR = { "q", 1 };
 
    /* Search for q parameter in the contact header */
    param = pjsip_param_find(&contact->other_param, &Q_STR);
    if (!param) {
        /* No q parameter, use default */
        return 1.0f;
    }
 
    /* Parse the q value */
    if (param->value.slen > 0) {
        char q_buf[16];
        float q_val;
        int len = param->value.slen < sizeof(q_buf) - 1 ? param->value.slen : sizeof(q_buf) - 1;
        memcpy(q_buf, param->value.ptr, len);
        q_buf[len] = '\0';
 
        q_val = ast_sip_parse_qvalue(q_buf);
 
        return q_val < 0.0f ? 1.0f : q_val;
    }
 
    /* Invalid q value, use default */
    return 1.0f;
}

References ast_sip_parse_qvalue(), and len().

Referenced by parse_redirect_contacts().

insert_contact_sorted()

static void insert_contact_sorted ( struct redirect_contact_list *  list, struct redirect_contact *  new_contact  )

static

Definition at line 248 of file redirect.c.

{
    struct redirect_contact *contact;
 
    /* Find the insertion point - contacts with higher q values come first */
    AST_LIST_TRAVERSE_SAFE_BEGIN(list, contact, list) {
        if (new_contact->q_value > contact->q_value) {
            /* Insert before this contact */
            AST_LIST_INSERT_BEFORE_CURRENT(new_contact, list);
            return;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    /* If we get here, insert at the end */
    AST_LIST_INSERT_TAIL(list, new_contact, list);
}

References AST_LIST_INSERT_BEFORE_CURRENT, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, redirect_contact::list, and redirect_contact::q_value.

Referenced by parse_redirect_contacts().

is_uri_visited()

static int is_uri_visited ( const struct ast_sip_redirect_state *  state, const char *  uri  )

static

Definition at line 174 of file redirect.c.

{
    struct visited_uri *visited;
 
    AST_LIST_TRAVERSE(&state->visited_uris, visited, list) {
        if (!strcmp(visited->uri, uri)) {
            return 1;
        }
    }
    return 0;
}

References AST_LIST_TRAVERSE, visited_uri::list, and visited_uri::uri.

Referenced by ast_sip_redirect_check_loop(), and ast_sip_redirect_parse_3xx().

method_allowed_for_redirect()

static int method_allowed_for_redirect ( struct ast_sip_endpoint *  endpoint, const pj_str_t *  method_name  )

static

Definition at line 113 of file redirect.c.

{
    int i;
 
    /* Look up the method in our mapping table */
    for (i = 0; i < ARRAY_LEN(redirect_methods); i++) {
        if (pj_stricmp2(method_name, redirect_methods[i].method_name) == 0) {
            /* Method is recognized, check if it's allowed */
            if (ast_test_flag(&endpoint->follow_redirect_methods, redirect_methods[i].flag)) {
                return 1;
            } else {
                ast_log(LOG_NOTICE, "Received redirect for %s to endpoint '%s', "
                    "but %s is not in follow_redirect_methods. Not following redirect.\n",
                    redirect_methods[i].method_name,
                    ast_sorcery_object_get_id(endpoint), redirect_methods[i].method_name);
                return 0;
            }
        }
    }
 
    /* Method not recognized/supported for redirects */
    ast_log(LOG_NOTICE, "Received redirect for method %.*s to endpoint '%s', "
        "but this method is not supported in follow_redirect_methods. Not following redirect.\n",
        (int)method_name->slen, method_name->ptr, ast_sorcery_object_get_id(endpoint));
    return 0;
}

References ARRAY_LEN, ast_log, ast_sorcery_object_get_id(), ast_test_flag, redirect_method_map::flag, ast_sip_endpoint::follow_redirect_methods, LOG_NOTICE, redirect_method_map::method_name, and redirect_methods.

Referenced by ast_sip_should_redirect().

parse_redirect_contacts()

static int parse_redirect_contacts ( pjsip_rx_data *  rdata, struct redirect_contact_list *  contacts, const struct ast_sip_redirect_state *  state  )

static

Definition at line 274 of file redirect.c.

{
    pjsip_contact_hdr *contact_hdr;
    pjsip_uri *contact_uri;
    int count = 0;
    void *start = NULL;
 
    /* Iterate through all Contact headers */
    while ((contact_hdr = (pjsip_contact_hdr *) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, start))) {
        struct redirect_contact *redirect_contact;
        int len;
 
        start = contact_hdr->next;
 
        /* Enforce maximum contact limit to prevent resource exhaustion */
        if (count >= AST_SIP_MAX_REDIRECT_CONTACTS) {
            ast_log(LOG_WARNING, "Redirect: maximum Contact header limit (%d) reached for endpoint '%s'. Ignoring additional contacts\n",
                AST_SIP_MAX_REDIRECT_CONTACTS, ast_sorcery_object_get_id(state->endpoint));
            break;
        }
 
        if (!contact_hdr->uri) {
            continue;
        }
 
        contact_uri = (pjsip_uri *)pjsip_uri_get_uri(contact_hdr->uri);
 
        /* Verify it's a SIP URI */
        if (!PJSIP_URI_SCHEME_IS_SIP(contact_uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact_uri)) {
            ast_debug(1, "Skipping non-SIP/SIPS Contact URI in redirect for endpoint '%s'\n", ast_sorcery_object_get_id(state->endpoint));
            continue;
        }
 
        /* Allocate a new redirect_contact structure */
        redirect_contact = ast_calloc(1, sizeof(*redirect_contact));
        if (!redirect_contact) {
            ast_log(LOG_ERROR, "Failed to allocate memory for redirect contact for endpoint '%s'.\n", ast_sorcery_object_get_id(state->endpoint));
            continue;
        }
 
        /* Print the URI */
        len = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, contact_uri,
            redirect_contact->uri, sizeof(redirect_contact->uri) - 1);
        if (len < 1) {
            ast_debug(1, "Contact URI too long for redirect on endpoint '%s'. Skipping.\n", ast_sorcery_object_get_id(state->endpoint));
            ast_free(redirect_contact);
            continue;
        }
        redirect_contact->uri[len] = '\0';
 
        /* Extract q-value */
        redirect_contact->q_value = extract_q_value(contact_hdr);
 
        ast_debug(1, "Found redirect Contact: %s (q=%f) for endpoint '%s'.\n", redirect_contact->uri, redirect_contact->q_value,
            ast_sorcery_object_get_id(state->endpoint));
 
        /* Insert into sorted list */
        insert_contact_sorted(contacts, redirect_contact);
        count++;
    }
 
    return count;
}

References ast_calloc, ast_debug, ast_free, ast_log, AST_SIP_MAX_REDIRECT_CONTACTS, ast_sorcery_object_get_id(), extract_q_value(), insert_contact_sorted(), len(), LOG_ERROR, LOG_WARNING, redirect_contact::next, NULL, redirect_contact::q_value, and redirect_contact::uri.

Referenced by ast_sip_redirect_parse_3xx().

Variable Documentation

redirect_methods

const struct redirect_method_map redirect_methods[]

static

Initial value:

= {
    { "MESSAGE", AST_SIP_REDIRECT_METHOD_MESSAGE },
}

Definition at line 99 of file redirect.c.

                                                             {
    { "MESSAGE", AST_SIP_REDIRECT_METHOD_MESSAGE },
};

Referenced by method_allowed_for_redirect().