#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include <pjlib.h>
#include <pjmedia.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/res_pjsip_session_caps.h"
#include "asterisk/callerid.h"
#include "asterisk/datastore.h"
#include "asterisk/module.h"
#include "asterisk/logger.h"
#include "asterisk/astobj2.h"
#include "asterisk/lock.h"
#include "asterisk/uuid.h"
#include "asterisk/pbx.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/taskpool.h"
#include "asterisk/causes.h"
#include "asterisk/sdp_srtp.h"
#include "asterisk/dsp.h"
#include "asterisk/acl.h"
#include "asterisk/features_config.h"
#include "asterisk/pickup.h"
#include "asterisk/test.h"
#include "asterisk/stream.h"
#include "asterisk/vector.h"
#include "res_pjsip_session/pjsip_session.h"

Include dependency graph for res_pjsip_session.c:

Data Structures
struct	ast_sip_session_delayed_request
	Structure used for sending delayed requests. More...

struct	new_invite

struct	sdp_handler_list

struct	sip_session_media_bundle_group
	Bundle group building structure. More...

Macros
#define	DATASTORE_BUCKETS 53

#define	DEFAULT_NUM_SESSION_MEDIA 2

#define	GET_STREAM_NAME_SAFE(_stream) (_stream ? ast_stream_get_name(_stream) : "")

#define	GET_STREAM_SAFE(_topology, _i) (_i < ast_stream_topology_get_count(_topology) ? ast_stream_topology_get_stream(_topology, _i) : NULL)

#define	GET_STREAM_STATE_SAFE(_stream) (_stream ? ast_stream_get_state(_stream) : AST_STREAM_STATE_END)

#define	MEDIA_BUCKETS 7

#define	MOD_DATA_ON_RESPONSE "on_response"

#define	print_debug_details(inv, tsx, e) __print_debug_details(__PRETTY_FUNCTION__, (inv), (tsx), (e))

#define	SDP_HANDLER_BUCKETS 11

#define	STATE_NONE(_stream_state) (_stream_state == AST_STREAM_STATE_END)

#define	STATE_REMOVED(_stream_state) (_stream_state == AST_STREAM_STATE_REMOVED)

#define	STREAM_REMOVED(_stream) (ast_stream_get_state(_stream) == AST_STREAM_STATE_REMOVED)

Enumerations
enum	delayed_method { DELAYED_METHOD_INVITE , DELAYED_METHOD_UPDATE , DELAYED_METHOD_BYE }

enum	sip_get_destination_result { SIP_GET_DEST_EXTEN_FOUND , SIP_GET_DEST_EXTEN_NOT_FOUND , SIP_GET_DEST_EXTEN_PARTIAL , SIP_GET_DEST_UNSUPPORTED_URI }

Functions
static void	__print_debug_details (const char function, pjsip_inv_session inv, pjsip_transaction tsx, pjsip_event e)

static void	__reg_module (void)

static void	__unreg_module (void)

static int	add_bundle_groups (struct ast_sip_session session, pj_pool_t pool, pjmedia_sdp_session *answer)

static int	add_sdp_streams (struct ast_sip_session_media session_media, struct ast_sip_session session, pjmedia_sdp_session answer, const struct pjmedia_sdp_session remote, struct ast_stream *stream)

struct ast_module *	AST_MODULE_SELF_SYM (void)

int	ast_sip_can_present_connected_id (const struct ast_sip_session session, const struct ast_party_id id)
	Determines if the Connected Line info can be presented for this session.

struct ast_sip_channel_pvt *	ast_sip_channel_pvt_alloc (void pvt, struct ast_sip_session session)
	Allocate a new SIP channel pvt structure.

struct ast_sip_session *	ast_sip_dialog_get_session (pjsip_dialog *dlg)
	Retrieves a session from a dialog.

int	ast_sip_session_add_datastore (struct ast_sip_session session, struct ast_datastore datastore)
	Add a datastore to a SIP session.

struct ast_sip_session *	ast_sip_session_alloc (struct ast_sip_endpoint endpoint, struct ast_sip_contact contact, pjsip_inv_session inv_session, pjsip_rx_data rdata)
	Allocate a new SIP session.

struct ast_datastore *	ast_sip_session_alloc_datastore (const struct ast_datastore_info info, const char uid)
	Alternative for ast_datastore_alloc()

int	ast_sip_session_create_invite (struct ast_sip_session session, pjsip_tx_data *tdata)
	Creates an INVITE request.

struct ast_sip_session *	ast_sip_session_create_outgoing (struct ast_sip_endpoint endpoint, struct ast_sip_contact contact, const char location, const char request_user, struct ast_stream_topology *req_topology)
	Create a new outgoing SIP session.

int	ast_sip_session_defer_termination (struct ast_sip_session *session)
	Defer local termination of a session until remote side terminates, or an amount of time passes.

void	ast_sip_session_defer_termination_cancel (struct ast_sip_session *session)
	Cancel a pending deferred termination.

void	ast_sip_session_end_if_deferred (struct ast_sip_session *session)
	End the session if it had been previously deferred.

struct ast_datastore *	ast_sip_session_get_datastore (struct ast_sip_session session, const char name)
	Retrieve a session datastore.

pjsip_dialog *	ast_sip_session_get_dialog (const struct ast_sip_session *session)
	Retrieves a dialog from a session.

const char *	ast_sip_session_get_name (const struct ast_sip_session *session)
	Get the channel or endpoint name associated with the session.

pjsip_inv_state	ast_sip_session_get_pjsip_inv_state (const struct ast_sip_session *session)
	Retrieves the pjsip_inv_state from a session.

int	ast_sip_session_is_pending_stream_default (const struct ast_sip_session session, const struct ast_stream stream)
	Determines if a provided pending stream will be the default stream or not.

int	ast_sip_session_media_add_read_callback (struct ast_sip_session session, struct ast_sip_session_media session_media, int fd, ast_sip_session_media_read_cb callback)
	Set a read callback for a media session with a specific file descriptor.

struct ast_sip_session_media *	ast_sip_session_media_get_transport (struct ast_sip_session session, struct ast_sip_session_media session_media)
	Retrieve the underlying media session that is acting as transport for a media session.

int	ast_sip_session_media_set_write_callback (struct ast_sip_session session, struct ast_sip_session_media session_media, ast_sip_session_media_write_cb callback)
	Set a write callback for a media session.

struct ast_sip_session_media *	ast_sip_session_media_state_add (struct ast_sip_session session, struct ast_sip_session_media_state media_state, enum ast_media_type type, int position)
	Allocate an ast_session_media and add it to the media state's vector.

struct ast_sip_session_media_state *	ast_sip_session_media_state_alloc (void)
	Allocate a session media state structure.

struct ast_sip_session_media_state *	ast_sip_session_media_state_clone (const struct ast_sip_session_media_state *media_state)
	Clone a media state.

void	ast_sip_session_media_state_free (struct ast_sip_session_media_state *media_state)
	Free a session media state structure.

void	ast_sip_session_media_state_reset (struct ast_sip_session_media_state *media_state)
	Reset a media state to a clean state.

void	ast_sip_session_media_stats_save (struct ast_sip_session sip_session, struct ast_sip_session_media_state media_state)
	Save a media stats.

int	ast_sip_session_refresh (struct ast_sip_session session, ast_sip_session_request_creation_cb on_request_creation, ast_sip_session_sdp_creation_cb on_sdp_creation, ast_sip_session_response_cb on_response, enum ast_sip_session_refresh_method method, int generate_new_sdp, struct ast_sip_session_media_state media_state)
	Send a reinvite or UPDATE on a session.

int	ast_sip_session_regenerate_answer (struct ast_sip_session *session, ast_sip_session_sdp_creation_cb on_sdp_creation)
	Regenerate SDP Answer.

int	ast_sip_session_register_sdp_handler (struct ast_sip_session_sdp_handler handler, const char stream_type)
	Register an SDP handler.

void	ast_sip_session_remove_datastore (struct ast_sip_session session, const char name)
	Remove a session datastore from the session.

void	ast_sip_session_resume_reinvite (struct ast_sip_session *session)
	Resumes processing of a deferred incoming re-invite.

void	ast_sip_session_send_request (struct ast_sip_session session, pjsip_tx_data tdata)
	Send a SIP request.

void	ast_sip_session_send_request_with_cb (struct ast_sip_session session, pjsip_tx_data tdata, ast_sip_session_response_cb on_response)
	Send a SIP request and get called back when a response is received.

void	ast_sip_session_send_response (struct ast_sip_session session, pjsip_tx_data tdata)
	Send a SIP response.

void	ast_sip_session_suspend (struct ast_sip_session *session)
	Request and wait for the session serializer to be suspended.

void	ast_sip_session_terminate (struct ast_sip_session *session, int response)
	Terminate a session and, if possible, send the provided response code.

void	ast_sip_session_unregister_sdp_handler (struct ast_sip_session_sdp_handler handler, const char stream_type)
	Unregister an SDP handler.

void	ast_sip_session_unsuspend (struct ast_sip_session *session)
	Request the session serializer be unsuspended.

static int	check_content_disposition (pjsip_rx_data *rdata)

static int	check_content_disposition_in_multipart (pjsip_multipart_part *part)

static void	check_delayed_requests (struct ast_sip_session session, int(cb)(void *vsession))

static int	check_request_status (pjsip_inv_session inv, pjsip_event e)

static int	check_sdp_content_type_supported (pjsip_media_type *content_type)

static struct pjmedia_sdp_session *	create_local_sdp (pjsip_inv_session inv, struct ast_sip_session session, const pjmedia_sdp_session *offer, const unsigned int ignore_active_stream_topology)

static int	datastore_cmp (void obj, void arg, int flags)

static int	datastore_hash (const void *obj, int flags)

static int	delay_request (struct ast_sip_session session, ast_sip_session_request_creation_cb on_request, ast_sip_session_sdp_creation_cb on_sdp_creation, ast_sip_session_response_cb on_response, int generate_new_sdp, enum delayed_method method, struct ast_sip_session_media_state pending_media_state, struct ast_sip_session_media_state *active_media_state, int queue_head)

static const char *	delayed_method2str (enum delayed_method method)

static struct ast_sip_session_delayed_request *	delayed_request_alloc (enum delayed_method method, ast_sip_session_request_creation_cb on_request_creation, ast_sip_session_sdp_creation_cb on_sdp_creation, ast_sip_session_response_cb on_response, int generate_new_sdp, struct ast_sip_session_media_state pending_media_state, struct ast_sip_session_media_state active_media_state)

static void	delayed_request_free (struct ast_sip_session_delayed_request *delay)

static pj_bool_t	does_method_match (const pj_str_t message_method, const char supplement_method)

static int	fetch_callerid_num (struct ast_sip_session session, pjsip_rx_data rdata, char *buf, size_t len)
	Fetch just the Caller ID number in order of PAI, RPID, From.

static void	flush_delayed_requests (struct ast_sip_session *session)

static pjmedia_sdp_session *	generate_session_refresh_sdp (struct ast_sip_session *session)

static enum sip_get_destination_result	get_destination (struct ast_sip_session session, pjsip_rx_data rdata)
	Determine where in the dialplan a call should go.

static int	get_mid_bundle_group (const pjmedia_sdp_session sdp, const char mid)

static int	handle_incoming (struct ast_sip_session session, pjsip_rx_data rdata, enum ast_sip_session_response_priority response_priority)

static void	handle_incoming_before_media (pjsip_inv_session inv, struct ast_sip_session session, pjsip_rx_data *rdata)

static void	handle_incoming_request (struct ast_sip_session session, pjsip_rx_data rdata)

static void	handle_incoming_response (struct ast_sip_session session, pjsip_rx_data rdata, enum ast_sip_session_response_priority response_priority)

static int	handle_incoming_sdp (struct ast_sip_session session, const pjmedia_sdp_session sdp)

static int	handle_negotiated_sdp (struct ast_sip_session session, const pjmedia_sdp_session local, const pjmedia_sdp_session *remote)

static int	handle_negotiated_sdp_session_media (struct ast_sip_session_media session_media, struct ast_sip_session session, const pjmedia_sdp_session local, const pjmedia_sdp_session remote, int index, struct ast_stream *asterisk_stream)

static void	handle_new_invite_request (pjsip_rx_data *rdata)

static void	handle_outgoing_request (struct ast_sip_session session, pjsip_tx_data tdata)

static void	handle_outgoing_response (struct ast_sip_session session, pjsip_tx_data tdata)

static void	handle_session_begin (struct ast_sip_session *session)

static void	handle_session_destroy (struct ast_sip_session *session)

static void	handle_session_end (struct ast_sip_session *session)

static pj_bool_t	has_supplement (const struct ast_sip_session session, const pjsip_rx_data rdata)

static struct ast_sip_session_media_state *	internal_sip_session_media_state_alloc (size_t sessions, size_t read_callbacks)

static int	invite_collision_timeout (void *vsession)

static int	invite_proceeding (void *vsession)

static int	invite_terminated (void *vsession)

static int	is_bundle_only_stream (const struct ast_sip_session_media session_media, const struct pjmedia_sdp_media stream)
	Determine whether a zero-port stream is offered for BUNDLE-only use.

static int	is_media_state_valid (const char session_name, struct ast_sip_session_media_state state)

static int	is_stream_limitation_reached (enum ast_media_type type, const struct ast_sip_endpoint endpoint, int type_streams)

static int	load_module (void)

static int	media_stats_local_ssrc_cmp (const struct ast_rtp_instance_stats vec_elem, const struct ast_rtp_instance_stats srch)

static int	new_invite (struct new_invite *invite)

static int	new_invite_initial_answer (pjsip_inv_session inv_session, pjsip_rx_data rdata, int answer_code, int terminate_code, pj_bool_t notify)

static pj_bool_t	outbound_invite_auth (pjsip_rx_data *rdata)

static pjsip_inv_session *	pre_session_setup (pjsip_rx_data rdata, const struct ast_sip_endpoint endpoint)

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

static void	remove_stream_from_bundle (struct ast_sip_session_media session_media, struct ast_stream stream)

static void	reschedule_reinvite (struct ast_sip_session *session, ast_sip_session_response_cb on_response)

static void	resend_reinvite (pj_timer_heap_t timer, pj_timer_entry entry)

static struct ast_sip_session_media_state *	resolve_refresh_media_states (const char session_name, struct ast_sip_session_media_state delayed_pending_state, struct ast_sip_session_media_state delayed_active_state, struct ast_sip_session_media_state current_active_state, int run_post_validation)

static int	sdp_handler_list_cmp (void obj, void arg, int flags)

static int	sdp_handler_list_hash (const void *obj, int flags)

static int	sdp_requires_deferral (struct ast_sip_session session, const pjmedia_sdp_session sdp)
	Determine whether the SDP provided requires deferral of negotiating or not.

static int	send_delayed_request (struct ast_sip_session session, struct ast_sip_session_delayed_request delay)

static void	session_datastore_destroy (void *obj)

static void	session_destructor (void *obj)

static int	session_end (void *vsession)

static int	session_end_completion (void *vsession)

static int	session_end_if_disconnected (int id, pjsip_inv_session *inv)

static void	session_inv_on_create_offer (pjsip_inv_session inv, pjmedia_sdp_session *p_offer)

static void	session_inv_on_media_update (pjsip_inv_session *inv, pj_status_t status)

static void	session_inv_on_new_session (pjsip_inv_session inv, pjsip_event e)

static pjsip_redirect_op	session_inv_on_redirected (pjsip_inv_session inv, const pjsip_uri target, const pjsip_event *e)

static void	session_inv_on_rx_offer (pjsip_inv_session inv, const pjmedia_sdp_session offer)

static void	session_inv_on_state_changed (pjsip_inv_session inv, pjsip_event e)

static void	session_inv_on_tsx_state_changed (pjsip_inv_session inv, pjsip_transaction tsx, pjsip_event *e)

static void	session_media_dtor (void *obj)

static void	session_media_set_handler (struct ast_sip_session_media session_media, struct ast_sip_session_sdp_handler handler)
	Set an SDP stream handler for a corresponding session media.

static pj_bool_t	session_on_rx_request (pjsip_rx_data *rdata)
	Called when a new SIP request comes into PJSIP.

static pj_bool_t	session_on_rx_response (pjsip_rx_data *rdata)

static void	session_on_tsx_state (pjsip_transaction tsx, pjsip_event e)

static pj_status_t	session_on_tx_response (pjsip_tx_data *tdata)

static void	session_outgoing_nat_hook (pjsip_tx_data tdata, struct ast_sip_transport transport)
	Hook for modifying outgoing messages with SDP to contain the proper address information.

static pj_bool_t	session_reinvite_on_rx_request (pjsip_rx_data *rdata)

static void	session_termination_cb (pj_timer_heap_t timer_heap, struct pj_timer_entry entry)

static int	session_termination_task (void *data)

static void	set_from_header (struct ast_sip_session *session)

static int	set_mid_and_bundle_group (struct ast_sip_session session, struct ast_sip_session_media session_media, const pjmedia_sdp_session sdp, const struct pjmedia_sdp_media stream)

static int	set_outstanding_invite_timeout (struct ast_sip_session *session)

static void	set_remote_mslabel_and_stream_group (struct ast_sip_session session, struct ast_sip_session_media session_media, const pjmedia_sdp_session sdp, const struct pjmedia_sdp_media stream, struct ast_stream *asterisk_stream)

static int	setup_outbound_invite_auth (pjsip_dialog *dlg)

static void	sip_channel_destroy (void *obj)
	Destructor for SIP channel.

static void	sip_session_defer_termination_stop_timer (struct ast_sip_session *session)

static int	sip_session_refresh (struct ast_sip_session session, ast_sip_session_request_creation_cb on_request_creation, ast_sip_session_sdp_creation_cb on_sdp_creation, ast_sip_session_response_cb on_response, enum ast_sip_session_refresh_method method, int generate_new_sdp, struct ast_sip_session_media_state pending_media_state, struct ast_sip_session_media_state *active_media_state, int queued)

static int	stream_destroy (void obj, void arg, int flags)

static int	uac_invite_tsx_terminates_dialog (pjsip_transaction *tsx)

static int	unload_module (void)

static int	update_completed (void *vsession)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS \| AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Session resource" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", }

static const struct ast_module_info *	ast_module_info = &__mod_info

static pjsip_inv_callback	inv_callback

static struct ast_sip_nat_hook *	nat_hook
	NAT hook for modifying outgoing messages with SDP.

static pjsip_module	outbound_invite_auth_module

static struct ao2_container *	sdp_handlers
	Registered SDP stream handlers.

static pjsip_module	session_module

static pjsip_module	session_reinvite_module

Macro Definition Documentation

◆ DATASTORE_BUCKETS

#define DATASTORE_BUCKETS 53

Definition at line 1272 of file res_pjsip_session.c.

◆ DEFAULT_NUM_SESSION_MEDIA

#define DEFAULT_NUM_SESSION_MEDIA 2

Definition at line 63 of file res_pjsip_session.c.

◆ GET_STREAM_NAME_SAFE

#define GET_STREAM_NAME_SAFE ( _stream ) (_stream ? ast_stream_get_name(_stream) : "")

Definition at line 1851 of file res_pjsip_session.c.

◆ GET_STREAM_SAFE

#define GET_STREAM_SAFE	(	_topology,
		_i
	)	(_i < ast_stream_topology_get_count(_topology) ? ast_stream_topology_get_stream(_topology, _i) : NULL)

Definition at line 1849 of file res_pjsip_session.c.

◆ GET_STREAM_STATE_SAFE

#define GET_STREAM_STATE_SAFE ( _stream ) (_stream ? ast_stream_get_state(_stream) : AST_STREAM_STATE_END)

Definition at line 1850 of file res_pjsip_session.c.

◆ MEDIA_BUCKETS

#define MEDIA_BUCKETS 7

Definition at line 1273 of file res_pjsip_session.c.

◆ MOD_DATA_ON_RESPONSE

#define MOD_DATA_ON_RESPONSE "on_response"

Definition at line 60 of file res_pjsip_session.c.

◆ print_debug_details

#define print_debug_details	(	inv,
		tsx,
		e
	)	__print_debug_details(__PRETTY_FUNCTION__, (inv), (tsx), (e))

Definition at line 4505 of file res_pjsip_session.c.

◆ SDP_HANDLER_BUCKETS

#define SDP_HANDLER_BUCKETS 11

Definition at line 58 of file res_pjsip_session.c.

◆ STATE_NONE

#define STATE_NONE ( _stream_state ) (_stream_state == AST_STREAM_STATE_END)

Definition at line 1848 of file res_pjsip_session.c.

◆ STATE_REMOVED

#define STATE_REMOVED ( _stream_state ) (_stream_state == AST_STREAM_STATE_REMOVED)

Definition at line 1847 of file res_pjsip_session.c.

◆ STREAM_REMOVED

#define STREAM_REMOVED ( _stream ) (ast_stream_get_state(_stream) == AST_STREAM_STATE_REMOVED)

Definition at line 1846 of file res_pjsip_session.c.

Enumeration Type Documentation

◆ delayed_method

enum delayed_method

Enumerator
DELAYED_METHOD_INVITE
DELAYED_METHOD_UPDATE
DELAYED_METHOD_BYE

Definition at line 1341 of file res_pjsip_session.c.

                    {
    DELAYED_METHOD_INVITE,
    DELAYED_METHOD_UPDATE,
    DELAYED_METHOD_BYE,
};

◆ sip_get_destination_result

enum sip_get_destination_result

Enumerator
SIP_GET_DEST_EXTEN_FOUND	The extension was successfully found
SIP_GET_DEST_EXTEN_NOT_FOUND	The extension specified in the RURI was not found
SIP_GET_DEST_EXTEN_PARTIAL	The extension specified in the RURI was a partial match
SIP_GET_DEST_UNSUPPORTED_URI	The RURI is of an unsupported scheme

Definition at line 3715 of file res_pjsip_session.c.

                                {
    /*! The extension was successfully found */
    SIP_GET_DEST_EXTEN_FOUND,
    /*! The extension specified in the RURI was not found */
    SIP_GET_DEST_EXTEN_NOT_FOUND,
    /*! The extension specified in the RURI was a partial match */
    SIP_GET_DEST_EXTEN_PARTIAL,
    /*! The RURI is of an unsupported scheme */
    SIP_GET_DEST_UNSUPPORTED_URI,
};

Function Documentation

◆ __print_debug_details()

static void __print_debug_details	(	const char *	function,
		pjsip_inv_session *	inv,
		pjsip_transaction *	tsx,
		pjsip_event *	e
	)

static

Definition at line 4456 of file res_pjsip_session.c.

{
    int id = session_module.id;
    struct ast_sip_session *session = NULL;
 
    if (!DEBUG_ATLEAST(5)) {
        /* Debug not spamy enough */
        return;
    }
 
    ast_log(LOG_DEBUG, "Function %s called on event %s\n",
        function, pjsip_event_str(e->type));
    if (!inv) {
        ast_log(LOG_DEBUG, "Transaction %p does not belong to an inv_session?\n", tsx);
        ast_log(LOG_DEBUG, "The transaction state is %s\n",
            pjsip_tsx_state_str(tsx->state));
        return;
    }
    if (id > -1) {
        session = inv->mod_data[session_module.id];
    }
    if (!session) {
        ast_log(LOG_DEBUG, "inv_session %p has no ast session\n", inv);
    } else {
        ast_log(LOG_DEBUG, "The state change pertains to the endpoint '%s(%s)'\n",
            ast_sorcery_object_get_id(session->endpoint),
            session->channel ? ast_channel_name(session->channel) : "");
    }
    if (inv->invite_tsx) {
        ast_log(LOG_DEBUG, "The inv session still has an invite_tsx (%p)\n",
            inv->invite_tsx);
    } else {
        ast_log(LOG_DEBUG, "The inv session does NOT have an invite_tsx\n");
    }
    if (tsx) {
        ast_log(LOG_DEBUG, "The %s %.*s transaction involved in this state change is %p\n",
            pjsip_role_name(tsx->role),
            (int) pj_strlen(&tsx->method.name), pj_strbuf(&tsx->method.name),
            tsx);
        ast_log(LOG_DEBUG, "The current transaction state is %s\n",
            pjsip_tsx_state_str(tsx->state));
        ast_log(LOG_DEBUG, "The transaction state change event is %s\n",
            pjsip_event_str(e->body.tsx_state.type));
    } else {
        ast_log(LOG_DEBUG, "There is no transaction involved in this state change\n");
    }
    ast_log(LOG_DEBUG, "The current inv state is %s\n", pjsip_inv_state_name(inv->state));
}

References ast_channel_name(), ast_log, ast_sorcery_object_get_id(), DEBUG_ATLEAST, LOG_DEBUG, NULL, session, and session_module.

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 6300 of file res_pjsip_session.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 6300 of file res_pjsip_session.c.

◆ add_bundle_groups()

static int add_bundle_groups	(	struct ast_sip_session *	session,
		pj_pool_t *	pool,
		pjmedia_sdp_session *	answer
	)

static

Definition at line 5136 of file res_pjsip_session.c.

{
    pj_str_t stmp;
    pjmedia_sdp_attr *attr;
    struct sip_session_media_bundle_group bundle_groups[PJMEDIA_MAX_SDP_MEDIA];
    int index, mid_id;
    struct sip_session_media_bundle_group *bundle_group;
 
    if (session->endpoint->media.webrtc) {
        attr = pjmedia_sdp_attr_create(pool, "msid-semantic", pj_cstr(&stmp, "WMS *"));
        pjmedia_sdp_attr_add(&answer->attr_count, answer->attr, attr);
    }
 
    if (!session->endpoint->media.bundle) {
        return 0;
    }
 
    memset(bundle_groups, 0, sizeof(bundle_groups));
 
    /* Build the bundle group layout so we can then add it to the SDP */
    for (index = 0; index < AST_VECTOR_SIZE(&session->pending_media_state->sessions); ++index) {
        struct ast_sip_session_media *session_media = AST_VECTOR_GET(&session->pending_media_state->sessions, index);
 
        /* If this stream is not part of a bundle group we can't add it */
        if (session_media->bundle_group == -1) {
            continue;
        }
 
        bundle_group = &bundle_groups[session_media->bundle_group];
 
        /* If this is the first mid then we need to allocate the attribute string and place BUNDLE in front */
        if (!bundle_group->mids[0]) {
            bundle_group->mids[0] = session_media->mid;
            bundle_group->attr_string = ast_str_create(64);
            if (!bundle_group->attr_string) {
                continue;
            }
 
            ast_str_set(&bundle_group->attr_string, 0, "BUNDLE %s", session_media->mid);
            continue;
        }
 
        for (mid_id = 1; mid_id < PJMEDIA_MAX_SDP_MEDIA; ++mid_id) {
            if (!bundle_group->mids[mid_id]) {
                bundle_group->mids[mid_id] = session_media->mid;
                ast_str_append(&bundle_group->attr_string, 0, " %s", session_media->mid);
                break;
            } else if (!strcmp(bundle_group->mids[mid_id], session_media->mid)) {
                break;
            }
        }
    }
 
    /* Add all bundle groups that have mids to the SDP */
    for (index = 0; index < PJMEDIA_MAX_SDP_MEDIA; ++index) {
        bundle_group = &bundle_groups[index];
 
        if (!bundle_group->attr_string) {
            continue;
        }
 
        attr = pjmedia_sdp_attr_create(pool, "group", pj_cstr(&stmp, ast_str_buffer(bundle_group->attr_string)));
        pjmedia_sdp_attr_add(&answer->attr_count, answer->attr, attr);
 
        ast_free(bundle_group->attr_string);
    }
 
    return 0;
}

References answer(), ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_sip_session_media::bundle_group, ast_sip_session_media::mid, sip_session_media_bundle_group::mids, and session.

Referenced by create_local_sdp().

◆ add_sdp_streams()

static int add_sdp_streams	(	struct ast_sip_session_media *	session_media,
		struct ast_sip_session *	session,
		pjmedia_sdp_session *	answer,
		const struct pjmedia_sdp_session *	remote,
		struct ast_stream *	stream
	)

static

Definition at line 5082 of file res_pjsip_session.c.

{
    struct ast_sip_session_sdp_handler *handler = session_media->handler;
    RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
    int res = 0;
    SCOPE_ENTER(1, "%s Stream: %s\n", ast_sip_session_get_name(session),
        ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
 
    if (handler) {
        /* if an already assigned handler reports a catastrophic error, fail */
        res = handler->create_outgoing_sdp_stream(session, session_media, answer, remote, stream);
        if (res < 0) {
            SCOPE_EXIT_RTN_VALUE(-1, "Coudn't create sdp stream\n");
        }
        SCOPE_EXIT_RTN_VALUE(0, "Had handler\n");
    }
 
    handler_list = ao2_find(sdp_handlers, ast_codec_media_type2str(session_media->type), OBJ_KEY);
    if (!handler_list) {
        SCOPE_EXIT_RTN_VALUE(0, "No handlers\n");
    }
 
    /* no handler for this stream type and we have a list to search */
    AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
        if (handler == session_media->handler) {
            continue;
        }
        res = handler->create_outgoing_sdp_stream(session, session_media, answer, remote, stream);
        if (res < 0) {
            /* catastrophic error */
            SCOPE_EXIT_RTN_VALUE(-1, "Coudn't create sdp stream\n");
        }
        if (res > 0) {
            /* Handled by this handler. Move to the next stream */
            session_media_set_handler(session_media, handler);
            SCOPE_EXIT_RTN_VALUE(0, "Handled\n");
        }
    }
 
    /* streams that weren't handled won't be included in generated outbound SDP */
    SCOPE_EXIT_RTN_VALUE(0, "Not handled\n");
}

References answer(), ao2_cleanup, ao2_find, ast_codec_media_type2str(), AST_LIST_TRAVERSE, ast_sip_session_get_name(), ast_str_tmp, ast_stream_to_str(), ast_sip_session_media::handler, handler(), ast_sip_session_sdp_handler::next, NULL, OBJ_KEY, RAII_VAR, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, sdp_handlers, session, session_media_set_handler(), and ast_sip_session_media::type.

Referenced by create_local_sdp().

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 6300 of file res_pjsip_session.c.

◆ ast_sip_can_present_connected_id()

int ast_sip_can_present_connected_id	(	const struct ast_sip_session *	session,
		const struct ast_party_id *	id
	)

Determines if the Connected Line info can be presented for this session.

Parameters

session	The session
id	The Connected Line info to evaluate

Return values

1	The Connected Line info can be presented
0	The Connected Line info cannot be presented

Definition at line 131 of file res_pjsip_session.c.

{
    return id->number.valid
        && (session->endpoint->id.trust_outbound
           || (ast_party_id_presentation(id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED);
}

References ast_party_id_presentation(), AST_PRES_ALLOWED, AST_PRES_RESTRICTION, and session.

Referenced by add_id_headers(), and stir_shaken_outgoing_request().

◆ ast_sip_channel_pvt_alloc()

struct ast_sip_channel_pvt * ast_sip_channel_pvt_alloc	(	void *	pvt,
		struct ast_sip_session *	session
	)

Allocate a new SIP channel pvt structure.

Parameters

pvt	Pointer to channel specific information
session	Pointer to SIP session

Return values

non-NULL	success
NULL	failure

Definition at line 3092 of file res_pjsip_session.c.

{
    struct ast_sip_channel_pvt *channel = ao2_alloc(sizeof(*channel), sip_channel_destroy);
 
    if (!channel) {
        return NULL;
    }
 
    ao2_ref(pvt, +1);
    channel->pvt = pvt;
    ao2_ref(session, +1);
    channel->session = session;
 
    return channel;
}

References ao2_alloc, ao2_ref, NULL, ast_sip_channel_pvt::pvt, ast_sip_channel_pvt::session, session, and sip_channel_destroy().

Referenced by chan_pjsip_new().

◆ ast_sip_dialog_get_session()

struct ast_sip_session * ast_sip_dialog_get_session ( pjsip_dialog * dlg )

Retrieves a session from a dialog.

Parameters

dlg	The dialog to retrieve the session from

Return values

non-NULL	if session exists
NULL	if no session

Note: The reference count of the session is increased when returned; This function must be called with the dialog locked

Definition at line 3663 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = pjsip_dlg_get_inv_session(dlg);
    struct ast_sip_session *session;
 
    if (!inv_session ||
        !(session = inv_session->mod_data[session_module.id])) {
        return NULL;
    }
 
    ao2_ref(session, +1);
 
    return session;
}

References ao2_ref, ast_sip_session::inv_session, NULL, session, and session_module.

Referenced by assign_uuid(), ast_sip_session_send_response(), refer_incoming_ari_request(), refer_incoming_attended_request(), refer_incoming_invite_request(), session_on_tx_response(), session_outgoing_nat_hook(), session_reinvite_on_rx_request(), and transport_info_on_tx_request().

◆ ast_sip_session_add_datastore()

int ast_sip_session_add_datastore	(	struct ast_sip_session *	session,
		struct ast_datastore *	datastore
	)

Add a datastore to a SIP session.

Note that SIP uses reference counted datastores. The datastore passed into this function must have been allocated using ao2_alloc() or there will be serious problems.

Parameters

session	The session to add the datastore to
datastore	The datastore to be added to the session

Return values

0	Success
-1	Failure

Definition at line 1319 of file res_pjsip_session.c.

{
    ast_assert(datastore != NULL);
    ast_assert(datastore->info != NULL);
    ast_assert(ast_strlen_zero(datastore->uid) == 0);
 
    if (!ao2_link(session->datastores, datastore)) {
        return -1;
    }
    return 0;
}

References ao2_link, ast_assert, ast_strlen_zero(), ast_datastore::info, NULL, session, and ast_datastore::uid.

Referenced by add_header(), aoc_send_as_xml(), ast_sip_session_add_reason_header(), chan_pjsip_incoming_request(), chan_pjsip_session_begin(), handle_incoming_request(), incoming_request(), incoming_response(), outgoing_request(), rfc3329_incoming_response(), session_refresh_state_get_or_alloc(), t38_state_get_or_alloc(), and transport_info_on_tx_request().

◆ ast_sip_session_alloc()

struct ast_sip_session * ast_sip_session_alloc	(	struct ast_sip_endpoint *	endpoint,
		struct ast_sip_contact *	contact,
		pjsip_inv_session *	inv,
		pjsip_rx_data *	rdata
	)

Allocate a new SIP session.

This will take care of allocating the datastores container on the session as well as placing all registered supplements onto the session.

The endpoint that is passed in will have its reference count increased by one since the session will be keeping a reference to the endpoint. The session will relinquish this reference when the session is destroyed.

Parameters

endpoint	The endpoint that this session communicates with
contact	The contact associated with this session
inv	The PJSIP INVITE session data
rdata	INVITE request received (NULL if for outgoing allocation)

Definition at line 3108 of file res_pjsip_session.c.

{
    RAII_VAR(struct ast_sip_session *, session, NULL, ao2_cleanup);
    struct ast_sip_session *ret_session;
    int dsp_features = 0;
 
    session = ao2_alloc(sizeof(*session), session_destructor);
    if (!session) {
        return NULL;
    }
 
    AST_LIST_HEAD_INIT(&session->supplements);
    AST_LIST_HEAD_INIT_NOLOCK(&session->delayed_requests);
    ast_party_id_init(&session->id);
 
    session->direct_media_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!session->direct_media_cap) {
        return NULL;
    }
    session->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp);
    if (!session->datastores) {
        return NULL;
    }
    session->active_media_state = ast_sip_session_media_state_alloc();
    if (!session->active_media_state) {
        return NULL;
    }
    session->pending_media_state = ast_sip_session_media_state_alloc();
    if (!session->pending_media_state) {
        return NULL;
    }
    if (AST_VECTOR_INIT(&session->media_stats, 1) < 0) {
        return NULL;
    }
 
    if (endpoint->dtmf == AST_SIP_DTMF_INBAND || endpoint->dtmf == AST_SIP_DTMF_AUTO) {
        dsp_features |= DSP_FEATURE_DIGIT_DETECT;
    }
    if (endpoint->faxdetect) {
        dsp_features |= DSP_FEATURE_FAX_DETECT;
    }
    if (dsp_features) {
        session->dsp = ast_dsp_new();
        if (!session->dsp) {
            return NULL;
        }
 
        ast_dsp_set_features(session->dsp, dsp_features);
    }
 
    session->endpoint = ao2_bump(endpoint);
 
    if (rdata) {
        /*
         * We must continue using the serializer that the original
         * INVITE came in on for the dialog.  There may be
         * retransmissions already enqueued in the original
         * serializer that can result in reentrancy and message
         * sequencing problems.
         */
        session->serializer = ast_sip_get_distributor_serializer(rdata);
    } else {
        /*
         * This is an outgoing session, so we can just choose a serializer
         * from the distributor pool based on the dialog.
         */
        session->serializer = ast_sip_get_distributor_serializer_dialog(inv_session->dlg);
    }
    if (!session->serializer) {
        return NULL;
    }
    ast_sip_dialog_set_serializer(inv_session->dlg, session->serializer);
    ast_sip_dialog_set_endpoint(inv_session->dlg, endpoint);
 
    /* When a PJSIP INVITE session is created it is created with a reference
     * count of 1, with that reference being managed by the underlying state
     * of the INVITE session itself. When the INVITE session transitions to
     * a DISCONNECTED state that reference is released. This means we can not
     * rely on that reference to ensure the INVITE session remains for the
     * lifetime of our session. To ensure it does we add our own reference
     * and release it when our own session goes away, ensuring that the INVITE
     * session remains for the lifetime of session.
     */
 
#ifdef HAVE_PJSIP_INV_SESSION_REF
    if (pjsip_inv_add_ref(inv_session) != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Can't increase the session reference counter\n");
        return NULL;
    }
#endif
 
    pjsip_dlg_inc_session(inv_session->dlg, &session_module);
    inv_session->mod_data[session_module.id] = ao2_bump(session);
    session->contact = ao2_bump(contact);
    session->inv_session = inv_session;
 
    session->dtmf = endpoint->dtmf;
    session->moh_passthrough = endpoint->moh_passthrough;
 
    if (ast_sip_session_add_supplements(session)) {
        /* Release the ref held by session->inv_session */
        ao2_ref(session, -1);
        return NULL;
    }
 
    session->authentication_challenge_count = 0;
 
    /* Fire session begin handlers */
    handle_session_begin(session);
 
    /* Avoid unnecessary ref manipulation to return a session */
    ret_session = session;
    session = NULL;
    return ret_session;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_bump, ao2_cleanup, ao2_container_alloc_hash, ao2_ref, ast_dsp_new(), ast_dsp_set_features(), ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, AST_LIST_HEAD_INIT, AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_party_id_init(), ast_sip_dialog_set_endpoint(), ast_sip_dialog_set_serializer(), AST_SIP_DTMF_AUTO, AST_SIP_DTMF_INBAND, ast_sip_get_distributor_serializer(), ast_sip_get_distributor_serializer_dialog(), ast_sip_session_add_supplements(), ast_sip_session_media_state_alloc(), AST_VECTOR_INIT, ast_sip_session::contact, DATASTORE_BUCKETS, datastore_cmp(), datastore_hash(), DSP_FEATURE_DIGIT_DETECT, DSP_FEATURE_FAX_DETECT, ast_sip_endpoint::dtmf, ast_sip_session::endpoint, ast_sip_endpoint::faxdetect, handle_session_begin(), ast_sip_session::inv_session, LOG_ERROR, ast_sip_endpoint::moh_passthrough, NULL, RAII_VAR, session, session_destructor(), and session_module.

Referenced by ast_sip_session_create_outgoing(), and handle_new_invite_request().

◆ ast_sip_session_alloc_datastore()

struct ast_datastore * ast_sip_session_alloc_datastore	(	const struct ast_datastore_info *	info,
		const char *	uid
	)

Alternative for ast_datastore_alloc()

There are two major differences between this and ast_datastore_alloc() 1) This allocates a refcounted object 2) This will fill in a uid if one is not provided

DO NOT call ast_datastore_free() on a datastore allocated in this way since that function will attempt to free the datastore rather than play nicely with its refcount.

Parameters

info	Callbacks for datastore
uid	Identifier for datastore

Return values

NULL	Failed to allocate datastore
non-NULL	Newly allocated datastore

Definition at line 1289 of file res_pjsip_session.c.

{
    RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
    char uuid_buf[AST_UUID_STR_LEN];
    const char *uid_ptr = uid;
 
    if (!info) {
        return NULL;
    }
 
    datastore = ao2_alloc(sizeof(*datastore), session_datastore_destroy);
    if (!datastore) {
        return NULL;
    }
 
    datastore->info = info;
    if (ast_strlen_zero(uid)) {
        /* They didn't provide an ID so we'll provide one ourself */
        uid_ptr = ast_uuid_generate_str(uuid_buf, sizeof(uuid_buf));
    }
 
    datastore->uid = ast_strdup(uid_ptr);
    if (!datastore->uid) {
        return NULL;
    }
 
    ao2_ref(datastore, +1);
    return datastore;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_strdup, ast_strlen_zero(), ast_uuid_generate_str(), AST_UUID_STR_LEN, ast_datastore::info, NULL, RAII_VAR, session_datastore_destroy(), and ast_datastore::uid.

Referenced by add_header(), aoc_send_as_xml(), ast_sip_session_add_reason_header(), chan_pjsip_incoming_request(), chan_pjsip_session_begin(), handle_incoming_request(), incoming_request(), incoming_response(), outgoing_request(), rfc3329_incoming_response(), session_refresh_state_get_or_alloc(), t38_state_get_or_alloc(), and transport_info_on_tx_request().

◆ ast_sip_session_create_invite()

int ast_sip_session_create_invite	(	struct ast_sip_session *	session,
		pjsip_tx_data **	tdata
	)

Creates an INVITE request.

Parameters

session	Starting session for the INVITE
tdata	The created request.

Definition at line 2968 of file res_pjsip_session.c.

{
    pjmedia_sdp_session *offer;
    SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
 
    if (!(offer = create_local_sdp(session->inv_session, session, NULL, 0))) {
        pjsip_inv_terminate(session->inv_session, 500, PJ_FALSE);
        SCOPE_EXIT_RTN_VALUE(-1, "Couldn't create offer\n");
    }
 
    pjsip_inv_set_local_sdp(session->inv_session, offer);
    pjmedia_sdp_neg_set_prefer_remote_codec_order(session->inv_session->neg, PJ_FALSE);
#ifdef PJMEDIA_SDP_NEG_ANSWER_MULTIPLE_CODECS
    if (!session->endpoint->preferred_codec_only) {
        pjmedia_sdp_neg_set_answer_multiple_codecs(session->inv_session->neg, PJ_TRUE);
    }
#endif
 
    /*
     * We MUST call set_from_header() before pjsip_inv_invite.  If we don't, the
     * From in the initial INVITE will be wrong but the rest of the messages will be OK.
     */
    set_from_header(session);
 
    if (pjsip_inv_invite(session->inv_session, tdata) != PJ_SUCCESS) {
        SCOPE_EXIT_RTN_VALUE(-1, "pjsip_inv_invite failed\n");
    }
 
    SCOPE_EXIT_RTN_VALUE(0);
}

References ast_sip_session_get_name(), create_local_sdp(), NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, and set_from_header().

Referenced by call().

◆ ast_sip_session_create_outgoing()

struct ast_sip_session * ast_sip_session_create_outgoing	(	struct ast_sip_endpoint *	endpoint,
		struct ast_sip_contact *	contact,
		const char *	location,
		const char *	request_user,
		struct ast_stream_topology *	req_topology
	)

Create a new outgoing SIP session.

The endpoint that is passed in will have its reference count increased by one since the session will be keeping a reference to the endpoint. The session will relinquish this reference when the session is destroyed.

Parameters

endpoint	The endpoint that this session uses for settings
contact	The contact that this session will communicate with
location	Name of the location to call, be it named location or explicit URI. Overrides contact if present.
request_user	Optional request user to place in the request URI if permitted
req_topology	The requested capabilities

Definition at line 3332 of file res_pjsip_session.c.

{
    const char *uri = NULL;
    RAII_VAR(struct ast_sip_aor *, found_aor, NULL, ao2_cleanup);
    RAII_VAR(struct ast_sip_contact *, found_contact, NULL, ao2_cleanup);
    pjsip_timer_setting timer;
    pjsip_dialog *dlg;
    struct pjsip_inv_session *inv_session;
    RAII_VAR(struct ast_sip_session *, session, NULL, ao2_cleanup);
    struct ast_sip_session *ret_session;
    SCOPE_ENTER(1, "%s %s Topology: %s\n", ast_sorcery_object_get_id(endpoint), request_user,
        ast_str_tmp(256, ast_stream_topology_to_str(req_topology, &STR_TMP)));
 
    if (ast_sip_session_check_supplement_create(endpoint, contact, location,
            request_user, req_topology)) {
        SCOPE_EXIT_RTN_VALUE(NULL, "%s: Session creation blocked by supplement\n",
            ast_sorcery_object_get_id(endpoint));
    }
 
    /* If no location has been provided use the AOR list from the endpoint itself */
    if (location || !contact) {
        location = S_OR(location, endpoint->aors);
 
        ast_sip_location_retrieve_contact_and_aor_from_list_filtered(location, AST_SIP_CONTACT_FILTER_REACHABLE,
            &found_aor, &found_contact);
        if (!found_contact || ast_strlen_zero(found_contact->uri)) {
            uri = location;
        } else {
            uri = found_contact->uri;
        }
    } else {
        uri = contact->uri;
    }
 
    /* If we still have no URI to dial fail to create the session */
    if (ast_strlen_zero(uri)) {
        ast_log(LOG_ERROR, "Endpoint '%s': No URI available.  Is endpoint registered?\n",
            ast_sorcery_object_get_id(endpoint));
        SCOPE_EXIT_RTN_VALUE(NULL, "No URI\n");
    }
 
    if (!(dlg = ast_sip_create_dialog_uac(endpoint, uri, request_user))) {
        SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create dialog\n");
    }
 
    if (setup_outbound_invite_auth(dlg)) {
        pjsip_dlg_terminate(dlg);
        SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't setup auth\n");
    }
 
    if (pjsip_inv_create_uac(dlg, NULL, endpoint->extensions.flags, &inv_session) != PJ_SUCCESS) {
        pjsip_dlg_terminate(dlg);
        SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create uac\n");
    }
#if defined(HAVE_PJSIP_REPLACE_MEDIA_STREAM) || defined(PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE)
    inv_session->sdp_neg_flags = PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE;
#endif
 
    pjsip_timer_setting_default(&timer);
    timer.min_se = endpoint->extensions.timer.min_se;
    timer.sess_expires = endpoint->extensions.timer.sess_expires;
    pjsip_timer_init_session(inv_session, &timer);
 
    session = ast_sip_session_alloc(endpoint, found_contact ? found_contact : contact,
        inv_session, NULL);
    if (!session) {
        pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
        return NULL;
    }
    session->aor = ao2_bump(found_aor);
    session->call_direction = AST_SIP_SESSION_OUTGOING_CALL;
 
    ast_party_id_copy(&session->id, &endpoint->id.self);
 
    if (ast_stream_topology_get_count(req_topology) > 0) {
        /* get joint caps between req_topology and endpoint topology */
        int i;
 
        for (i = 0; i < ast_stream_topology_get_count(req_topology); ++i) {
            struct ast_stream *req_stream;
            struct ast_stream *clone_stream;
 
            req_stream = ast_stream_topology_get_stream(req_topology, i);
 
            if (ast_stream_get_state(req_stream) == AST_STREAM_STATE_REMOVED) {
                continue;
            }
 
            clone_stream = ast_sip_session_create_joint_call_stream(session, req_stream);
            if (!clone_stream || ast_stream_get_format_count(clone_stream) == 0) {
                ast_stream_free(clone_stream);
                continue;
            }
 
            if (!session->pending_media_state->topology) {
                session->pending_media_state->topology = ast_stream_topology_alloc();
                if (!session->pending_media_state->topology) {
                    pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
                    ao2_ref(session, -1);
                    SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create topology\n");
                }
            }
 
            if (ast_stream_topology_append_stream(session->pending_media_state->topology, clone_stream) < 0) {
                ast_stream_free(clone_stream);
                continue;
            }
        }
    }
 
    if (!session->pending_media_state->topology) {
        /* Use the configured topology on the endpoint as the pending one */
        session->pending_media_state->topology = ast_stream_topology_clone(endpoint->media.topology);
        if (!session->pending_media_state->topology) {
            pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
            ao2_ref(session, -1);
            SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't clone topology\n");
        }
    }
 
    if (pjsip_dlg_add_usage(dlg, &session_module, NULL) != PJ_SUCCESS) {
        pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
        /* Since we are not notifying ourselves that the INVITE session is being terminated
         * we need to manually drop its reference to session
         */
        ao2_ref(session, -1);
        SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't add usage\n");
    }
 
    /* Avoid unnecessary ref manipulation to return a session */
    ret_session = session;
    session = NULL;
    SCOPE_EXIT_RTN_VALUE(ret_session);
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_sip_endpoint::aors, ast_log, ast_party_id_copy(), AST_SIP_CONTACT_FILTER_REACHABLE, ast_sip_create_dialog_uac(), ast_sip_location_retrieve_contact_and_aor_from_list_filtered(), ast_sip_session_alloc(), ast_sip_session_check_supplement_create(), ast_sip_session_create_joint_call_stream(), AST_SIP_SESSION_OUTGOING_CALL, ast_sorcery_object_get_id(), ast_str_tmp, ast_stream_free(), ast_stream_get_format_count(), ast_stream_get_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_clone(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_to_str(), ast_strlen_zero(), ast_sip_session::contact, ast_sip_session::endpoint, ast_sip_endpoint::extensions, ast_sip_endpoint_extensions::flags, ast_sip_endpoint::id, ast_sip_session::inv_session, LOG_ERROR, ast_sip_endpoint::media, ast_sip_timer_options::min_se, NULL, RAII_VAR, S_OR, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, ast_sip_endpoint_id_configuration::self, ast_sip_timer_options::sess_expires, session, session_module, setup_outbound_invite_auth(), timer, ast_sip_endpoint_extensions::timer, ast_sip_endpoint_media_configuration::topology, and ast_sip_contact::uri.

Referenced by request().

◆ ast_sip_session_defer_termination()

int ast_sip_session_defer_termination ( struct ast_sip_session * session )

Defer local termination of a session until remote side terminates, or an amount of time passes.

Parameters

session The session to defer termination on

Return values

0	Success
-1	Failure

Definition at line 3589 of file res_pjsip_session.c.

{
    pj_time_val delay = { .sec = 60, };
    int res;
 
    /* The session should not have an active deferred termination request. */
    ast_assert(!session->defer_terminate);
 
    session->defer_terminate = 1;
 
    session->defer_end = 1;
    session->ended_while_deferred = 0;
 
    ao2_ref(session, +1);
    pj_timer_entry_init(&session->scheduled_termination, 0, session, session_termination_cb);
 
    res = (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(),
        &session->scheduled_termination, &delay) != PJ_SUCCESS) ? -1 : 0;
    if (res) {
        session->defer_terminate = 0;
        ao2_ref(session, -1);
    }
    return res;
}

References ao2_ref, ast_assert, ast_sip_get_pjsip_endpoint(), session, and session_termination_cb().

Referenced by refer_incoming_attended_request(), and refer_incoming_blind_request().

◆ ast_sip_session_defer_termination_cancel()

void ast_sip_session_defer_termination_cancel ( struct ast_sip_session * session )

Cancel a pending deferred termination.

Parameters

session The session to cancel a deferred termination on.

Definition at line 3629 of file res_pjsip_session.c.

{
    if (!session->defer_terminate) {
        /* Already canceled or timer fired. */
        return;
    }
 
    session->defer_terminate = 0;
 
    if (session->terminate_while_deferred) {
        /* Complete the termination started by the upper layer. */
        ast_sip_session_terminate(session, 0);
    }
 
    /* Stop the termination timer if it is still running. */
    sip_session_defer_termination_stop_timer(session);
}

References ast_sip_session_terminate(), session, and sip_session_defer_termination_stop_timer().

Referenced by defer_termination_cancel_task(), refer_incoming_attended_request(), and refer_incoming_blind_request().

◆ ast_sip_session_end_if_deferred()

void ast_sip_session_end_if_deferred ( struct ast_sip_session * session )

End the session if it had been previously deferred.

Parameters

session The session to end if it had been deferred

Definition at line 3647 of file res_pjsip_session.c.

{
    if (!session->defer_end) {
        return;
    }
 
    session->defer_end = 0;
 
    if (session->ended_while_deferred) {
        /* Complete the session end started by the remote hangup. */
        ast_debug(3, "%s: Ending session after being deferred\n", ast_sip_session_get_name(session));
        session->ended_while_deferred = 0;
        session_end(session);
    }
}

References ast_debug, ast_sip_session_get_name(), session, and session_end().

Referenced by defer_termination_cancel_task(), refer_attended_task(), refer_incoming_attended_request(), refer_incoming_blind_request(), and session_end_if_deferred_task().

◆ ast_sip_session_get_datastore()

struct ast_datastore * ast_sip_session_get_datastore	(	struct ast_sip_session *	session,
		const char *	name
	)

Retrieve a session datastore.

The datastore retrieved will have its reference count incremented. When the caller is done with the datastore, the reference counted needs to be decremented using ao2_ref().

Parameters

session	The session from which to retrieve the datastore
name	The name of the datastore to retrieve

Return values

NULL	Failed to find the specified datastore
non-NULL	The specified datastore

Definition at line 1331 of file res_pjsip_session.c.

{
    return ao2_find(session->datastores, name, OBJ_KEY);
}

References ao2_find, name, OBJ_KEY, and session.

Referenced by add_header(), aoc_bye_outgoing_request(), aoc_bye_outgoing_response(), aoc_invite_outgoing_response(), aoc_send_as_xml(), chan_pjsip_get_rtp_peer(), channel_read_pjsip(), direct_media_mitigate_glare(), handle_outgoing_response(), incoming_request(), incoming_response(), outgoing_request(), read_header(), read_headers(), reason_header_outgoing_response(), remove_header(), rfc3329_incoming_response(), rfc3329_outgoing_request(), session_refresh_state_get_or_alloc(), t38_automatic_reject(), t38_state_get_or_alloc(), transport_info_on_tx_request(), and update_header().

◆ ast_sip_session_get_dialog()

pjsip_dialog * ast_sip_session_get_dialog ( const struct ast_sip_session * session )

Retrieves a dialog from a session.

Parameters

session The session to retrieve the dialog from

Return values

non-NULL	if dialog exists
NULL	if no dialog

Definition at line 3678 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
 
    if (!inv_session) {
        return NULL;
    }
 
    return inv_session->dlg;
}

References ast_sip_session::inv_session, NULL, and session.

◆ ast_sip_session_get_name()

const char * ast_sip_session_get_name ( const struct ast_sip_session * session )

Get the channel or endpoint name associated with the session.

Since: 18.0.0

Parameters

session

Return values

Channel name or endpoint name or "unknown"

Definition at line 117 of file res_pjsip_session.c.

{
    if (!session) {
        return "(null session)";
    }
    if (session->channel) {
        return ast_channel_name(session->channel);
    } else if (session->endpoint) {
        return ast_sorcery_object_get_id(session->endpoint);
    } else {
        return "unknown";
    }
}

References ast_channel_name(), ast_sorcery_object_get_id(), and session.

Referenced by add_date_header(), add_eprofile_to_channel(), add_fingerprints_if_present(), add_sdp_streams(), answer(), apply_negotiated_sdp_stream(), ast_sip_session_add_reason_header(), ast_sip_session_create_invite(), ast_sip_session_end_if_deferred(), ast_sip_session_media_state_add(), ast_sip_session_regenerate_answer(), ast_sip_session_terminate(), call(), chan_pjsip_call(), chan_pjsip_incoming_ack(), chan_pjsip_incoming_prack(), chan_pjsip_incoming_request(), chan_pjsip_incoming_response(), chan_pjsip_incoming_response_update_cause(), chan_pjsip_new(), chan_pjsip_session_begin(), chan_pjsip_session_end(), create_local_sdp(), create_outgoing_sdp_stream(), delay_request(), generate_session_refresh_sdp(), get_codecs(), get_destination(), handle_incoming_before_media(), handle_incoming_request(), handle_incoming_request(), handle_incoming_response(), handle_incoming_sdp(), handle_negotiated_sdp(), handle_negotiated_sdp_session_media(), handle_new_invite_request(), handle_outgoing_request(), handle_outgoing_request(), handle_outgoing_response(), invite_collision_timeout(), invite_proceeding(), invite_terminated(), negotiate_incoming_sdp_stream(), new_invite(), on_topology_change_response(), outbound_invite_auth(), pbx_start_incoming_request(), pjsip_channel_info_schedule_update(), process_failure(), reason_header_outgoing_response(), reschedule_reinvite(), resend_reinvite(), sdp_requires_deferral(), send_delayed_request(), send_topology_change_refresh(), session_destructor(), session_inv_on_create_offer(), session_inv_on_media_update(), session_inv_on_rx_offer(), session_inv_on_state_changed(), session_inv_on_tsx_state_changed(), session_on_rx_request(), session_on_rx_response(), session_on_tsx_state(), session_outgoing_nat_hook(), set_caps(), set_from_header(), set_incoming_call_offer_cap(), set_outstanding_invite_timeout(), sip_session_refresh(), stir_shaken_incoming_request(), and stir_shaken_outgoing_request().

◆ ast_sip_session_get_pjsip_inv_state()

pjsip_inv_state ast_sip_session_get_pjsip_inv_state ( const struct ast_sip_session * session )

Retrieves the pjsip_inv_state from a session.

Parameters

session The session to retrieve the state from

Return values

state	if inv_session exists
PJSIP_INV_STATE_NULL	if inv_session is NULL

Definition at line 3689 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
 
    if (!inv_session) {
        return PJSIP_INV_STATE_NULL;
    }
 
    return inv_session->state;
}

References ast_sip_session::inv_session, and session.

◆ ast_sip_session_is_pending_stream_default()

int ast_sip_session_is_pending_stream_default	(	const struct ast_sip_session *	session,
		const struct ast_stream *	stream
	)

Determines if a provided pending stream will be the default stream or not.

Since: 15.0.0

Parameters

session	The session to check against
stream	The pending stream

Return values

1	if stream will be default
0	if stream will NOT be the default

Definition at line 368 of file res_pjsip_session.c.

{
    int index;
 
    if (!session->pending_media_state->topology) {
        ast_log(LOG_WARNING, "Pending topology was NULL for channel '%s'\n",
            session->channel ? ast_channel_name(session->channel) : "unknown");
        return 0;
    }
 
    if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
        return 0;
    }
 
    for (index = 0; index < ast_stream_topology_get_count(session->pending_media_state->topology); ++index) {
        if (ast_stream_get_type(ast_stream_topology_get_stream(session->pending_media_state->topology, index)) !=
            ast_stream_get_type(stream)) {
            continue;
        }
 
        return ast_stream_topology_get_stream(session->pending_media_state->topology, index) == stream ? 1 : 0;
    }
 
    return 0;
}

References ast_channel_name(), ast_log, ast_stream_get_state(), ast_stream_get_type(), AST_STREAM_STATE_REMOVED, ast_stream_topology_get_count(), ast_stream_topology_get_stream(), LOG_WARNING, and session.

Referenced by create_outgoing_sdp_stream(), handle_incoming_sdp(), handle_negotiated_sdp_session_media(), sdp_requires_deferral(), set_caps(), and set_session_media_remotely_held().

◆ ast_sip_session_media_add_read_callback()

int ast_sip_session_media_add_read_callback	(	struct ast_sip_session *	session,
		struct ast_sip_session_media *	session_media,
		int	fd,
		ast_sip_session_media_read_cb	callback
	)

Set a read callback for a media session with a specific file descriptor.

Since: 15.0.0

Parameters

session	The session
session_media	The media session
fd	The file descriptor
callback	The read callback

Return values

0	the read callback was successfully added
-1	the read callback could not be added

Note: This operations on the pending media state

Definition at line 394 of file res_pjsip_session.c.

{
    struct ast_sip_session_media_read_callback_state callback_state = {
        .fd = fd,
        .read_callback = callback,
        .session = session_media,
    };
 
    /* The contents of the vector are whole structs and not pointers */
    return AST_VECTOR_APPEND(&session->pending_media_state->read_callbacks, callback_state);
}

References AST_VECTOR_APPEND, callback(), ast_sip_session_media_read_callback_state::fd, and session.

Referenced by apply_negotiated_sdp_stream(), and apply_negotiated_sdp_stream().

◆ ast_sip_session_media_get_transport()

struct ast_sip_session_media * ast_sip_session_media_get_transport	(	struct ast_sip_session *	session,
		struct ast_sip_session_media *	session_media
	)

Retrieve the underlying media session that is acting as transport for a media session.

Since: 15.0.0

Parameters

session	The session
session_media	The media session to retrieve the transport for

Note: This operates on the pending media state; This function is guaranteed to return non-NULL

Definition at line 423 of file res_pjsip_session.c.

{
    int index;
 
    if (!session->endpoint->media.bundle || ast_strlen_zero(session_media->mid)) {
        return session_media;
    }
 
    for (index = 0; index < AST_VECTOR_SIZE(&session->pending_media_state->sessions); ++index) {
        struct ast_sip_session_media *bundle_group_session_media;
 
        bundle_group_session_media = AST_VECTOR_GET(&session->pending_media_state->sessions, index);
 
        /* The first session which is in the bundle group is considered the authoritative session for transport */
        if (bundle_group_session_media->bundle_group == session_media->bundle_group) {
            return bundle_group_session_media;
        }
    }
 
    return session_media;
}

References ast_strlen_zero(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_sip_session_media::bundle_group, ast_sip_session_media::mid, and session.

Referenced by apply_negotiated_sdp_stream(), create_outgoing_sdp_stream(), and negotiate_incoming_sdp_stream().

◆ ast_sip_session_media_set_write_callback()

int ast_sip_session_media_set_write_callback	(	struct ast_sip_session *	session,
		struct ast_sip_session_media *	session_media,
		ast_sip_session_media_write_cb	callback
	)

Set a write callback for a media session.

Since: 15.0.0

Parameters

session	The session
session_media	The media session
callback	The write callback

Return values

0	the write callback was successfully add
-1	the write callback is already set to something different

Note: This operates on the pending media state

Definition at line 407 of file res_pjsip_session.c.

{
    if (session_media->write_callback) {
        if (session_media->write_callback == callback) {
            return 0;
        }
 
        return -1;
    }
 
    session_media->write_callback = callback;
 
    return 0;
}

References callback(), and ast_sip_session_media::write_callback.

Referenced by apply_negotiated_sdp_stream(), and apply_negotiated_sdp_stream().

◆ ast_sip_session_media_state_add()

struct ast_sip_session_media * ast_sip_session_media_state_add	(	struct ast_sip_session *	session,
		struct ast_sip_session_media_state *	media_state,
		enum ast_media_type	type,
		int	position
	)

Allocate an ast_session_media and add it to the media state's vector.

Since: 15.0.0

This allocates a session media of the specified type. The position argument determines where in the vector that the new session media will be inserted.

Note: The returned ast_session_media is the reference held by the vector. Callers of this function must NOT decrement the refcount of the session media.

Parameters

session	Session on which to query active media state for
media_state	Media state to place the session media into
type	The type of the session media
position	Position at which to insert the new session media.

Note: The active media state will be queried and if a media session already exists at the given position for the same type it will be reused instead of allocating a new one.

Return values

non-NULL	success
NULL	failure

Definition at line 499 of file res_pjsip_session.c.

{
    struct ast_sip_session_media *session_media = NULL;
    struct ast_sip_session_media *current_session_media = NULL;
    SCOPE_ENTER(1, "%s Adding position %d\n", ast_sip_session_get_name(session), position);
 
    /* It is possible for this media state to already contain a session for the stream. If this
     * is the case we simply return it.
     */
    if (position < AST_VECTOR_SIZE(&media_state->sessions)) {
        current_session_media = AST_VECTOR_GET(&media_state->sessions, position);
        if (current_session_media && current_session_media->type == type) {
            SCOPE_EXIT_RTN_VALUE(current_session_media, "Using existing media_session\n");
        }
    }
 
    /* Determine if we can reuse the session media from the active media state if present */
    if (position < AST_VECTOR_SIZE(&session->active_media_state->sessions)) {
        session_media = AST_VECTOR_GET(&session->active_media_state->sessions, position);
        /* A stream can never exist without an accompanying media session */
        if (session_media->type == type) {
            ao2_ref(session_media, +1);
            ast_trace(1, "Reusing existing media session\n");
            /*
             * If this session_media was previously removed, its bundle group was probably reset
             * to -1 so if bundling is enabled on the endpoint, we need to reset it to 0, set
             * the bundled flag and reset its mid.
             */
            if (session->endpoint->media.bundle && session_media->bundle_group == -1) {
                session_media->bundled = session->endpoint->media.webrtc;
                session_media->bundle_group = 0;
                ast_free(session_media->mid);
                if (ast_asprintf(&session_media->mid, "%s-%d", ast_codec_media_type2str(type), position) < 0) {
                    ao2_ref(session_media, -1);
                    SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't alloc mid\n");
                }
            }
        } else {
            ast_trace(1, "Can't reuse existing media session because the types are different. %s <> %s\n",
                ast_codec_media_type2str(type), ast_codec_media_type2str(session_media->type));
            session_media = NULL;
        }
    }
 
    if (!session_media) {
        /* No existing media session we can use so create a new one */
        session_media = ao2_alloc_options(sizeof(*session_media), session_media_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
        if (!session_media) {
            return NULL;
        }
        ast_trace(1, "Creating new media session\n");
 
        session_media->encryption = session->endpoint->media.rtp.encryption;
        session_media->remote_ice = session->endpoint->media.rtp.ice_support;
        session_media->remote_rtcp_mux = session->endpoint->media.rtcp_mux;
        session_media->keepalive_sched_id = -1;
        session_media->timeout_sched_id = -1;
        session_media->type = type;
        session_media->stream_num = position;
 
        if (session->endpoint->media.bundle) {
            /* This is a new stream so create a new mid based on media type and position, which makes it unique.
             * If this is the result of an offer the mid will just end up getting replaced.
             */
            if (ast_asprintf(&session_media->mid, "%s-%d", ast_codec_media_type2str(type), position) < 0) {
                ao2_ref(session_media, -1);
                SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't alloc mid\n");
            }
            session_media->bundle_group = 0;
 
            /* Some WebRTC clients can't handle an offer to bundle media streams. Instead they expect them to
             * already be bundled. Every client handles this scenario though so if WebRTC is enabled just go
             * ahead and treat the streams as having already been bundled.
             */
            session_media->bundled = session->endpoint->media.webrtc;
        } else {
            session_media->bundle_group = -1;
        }
    }
 
    ast_free(session_media->stream_name);
    session_media->stream_name = ast_strdup(ast_stream_get_name(ast_stream_topology_get_stream(media_state->topology, position)));
 
    if (AST_VECTOR_REPLACE(&media_state->sessions, position, session_media)) {
        ao2_ref(session_media, -1);
 
        SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't replace media_session\n");
    }
 
    ao2_cleanup(current_session_media);
 
    /* If this stream will be active in some way and it is the first of this type then consider this the default media session to match */
    if (!media_state->default_session[type] && ast_stream_get_state(ast_stream_topology_get_stream(media_state->topology, position)) != AST_STREAM_STATE_REMOVED) {
        ast_trace(1, "Setting media session as default for %s\n", ast_codec_media_type2str(session_media->type));
 
        media_state->default_session[type] = session_media;
    }
 
    SCOPE_EXIT_RTN_VALUE(session_media, "Done\n");
}

Referenced by create_local_sdp(), handle_incoming_sdp(), sdp_requires_deferral(), and t38_create_media_state().

◆ ast_sip_session_media_state_alloc()

struct ast_sip_session_media_state * ast_sip_session_media_state_alloc ( void )

Allocate a session media state structure.

Since: 15.0.0

Return values

non-NULL	success
NULL	failure

Definition at line 247 of file res_pjsip_session.c.

{
    return internal_sip_session_media_state_alloc(
        DEFAULT_NUM_SESSION_MEDIA, DEFAULT_NUM_SESSION_MEDIA);
}

References DEFAULT_NUM_SESSION_MEDIA, and internal_sip_session_media_state_alloc().

Referenced by ast_sip_session_alloc(), session_refresh_state_get_or_alloc(), t38_create_media_state(), and topology_change_refresh_data_alloc().

◆ ast_sip_session_media_state_clone()

struct ast_sip_session_media_state * ast_sip_session_media_state_clone ( const struct ast_sip_session_media_state * media_state )

Clone a media state.

Since: 15.0.0

Parameters

media_state The media state to clone

Return values

non-NULL	success
NULL	failure

Definition at line 306 of file res_pjsip_session.c.

{
    struct ast_sip_session_media_state *cloned;
    int index;
 
    if (!media_state) {
        return NULL;
    }
 
    cloned = internal_sip_session_media_state_alloc(
        AST_VECTOR_SIZE(&media_state->sessions),
        AST_VECTOR_SIZE(&media_state->read_callbacks));
    if (!cloned) {
        return NULL;
    }
 
    if (media_state->topology) {
        cloned->topology = ast_stream_topology_clone(media_state->topology);
        if (!cloned->topology) {
            ast_sip_session_media_state_free(cloned);
            return NULL;
        }
    }
 
    for (index = 0; index < AST_VECTOR_SIZE(&media_state->sessions); ++index) {
        struct ast_sip_session_media *session_media = AST_VECTOR_GET(&media_state->sessions, index);
        enum ast_media_type type = ast_stream_get_type(ast_stream_topology_get_stream(cloned->topology, index));
 
        ao2_bump(session_media);
        if (AST_VECTOR_REPLACE(&cloned->sessions, index, session_media)) {
            ao2_cleanup(session_media);
        }
        if (ast_stream_get_state(ast_stream_topology_get_stream(cloned->topology, index)) != AST_STREAM_STATE_REMOVED &&
            !cloned->default_session[type]) {
            cloned->default_session[type] = session_media;
        }
    }
 
    for (index = 0; index < AST_VECTOR_SIZE(&media_state->read_callbacks); ++index) {
        struct ast_sip_session_media_read_callback_state *read_callback = AST_VECTOR_GET_ADDR(&media_state->read_callbacks, index);
 
        AST_VECTOR_REPLACE(&cloned->read_callbacks, index, *read_callback);
    }
 
    return cloned;
}

References ao2_bump, ao2_cleanup, ast_sip_session_media_state_free(), ast_stream_get_state(), ast_stream_get_type(), AST_STREAM_STATE_REMOVED, ast_stream_topology_clone(), ast_stream_topology_get_stream(), AST_VECTOR_GET, AST_VECTOR_GET_ADDR, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_sip_session_media_state::default_session, internal_sip_session_media_state_alloc(), NULL, ast_sip_session_media_read_callback_state::read_callback, ast_sip_session_media_state::read_callbacks, ast_sip_session_media_state::sessions, ast_sip_session_media_state::topology, and type.

Referenced by handle_negotiated_sdp(), reschedule_reinvite(), resolve_refresh_media_states(), sip_session_refresh(), and t38_reinvite_sdp_cb().

◆ ast_sip_session_media_state_free()

void ast_sip_session_media_state_free ( struct ast_sip_session_media_state * media_state )

Free a session media state structure.

Since: 15.0.0

Definition at line 353 of file res_pjsip_session.c.

{
    if (!media_state) {
        return;
    }
 
    /* This will reset the internal state so we only have to free persistent things */
    ast_sip_session_media_state_reset(media_state);
 
    AST_VECTOR_FREE(&media_state->sessions);
    AST_VECTOR_FREE(&media_state->read_callbacks);
 
    ast_free(media_state);
}

References ast_free, ast_sip_session_media_state_reset(), AST_VECTOR_FREE, ast_sip_session_media_state::read_callbacks, and ast_sip_session_media_state::sessions.

Referenced by ast_sip_session_media_state_clone(), delay_request(), delayed_request_free(), handle_negotiated_sdp(), reschedule_reinvite(), resolve_refresh_media_states(), session_destructor(), session_refresh_state_destroy(), sip_session_refresh(), t38_create_media_state(), t38_reinvite_response_cb(), t38_state_destroy(), and topology_change_refresh_data_free().

◆ ast_sip_session_media_state_reset()

void ast_sip_session_media_state_reset ( struct ast_sip_session_media_state * media_state )

Reset a media state to a clean state.

Since: 15.0.0

Parameters

media_state The media state to reset

Definition at line 287 of file res_pjsip_session.c.

{
    int index;
 
    if (!media_state) {
        return;
    }
 
    AST_VECTOR_RESET(&media_state->sessions, ao2_cleanup);
    AST_VECTOR_RESET(&media_state->read_callbacks, AST_VECTOR_ELEM_CLEANUP_NOOP);
 
    for (index = 0; index < AST_MEDIA_TYPE_END; ++index) {
        media_state->default_session[index] = NULL;
    }
 
    ast_stream_topology_free(media_state->topology);
    media_state->topology = NULL;
}

References ao2_cleanup, AST_MEDIA_TYPE_END, ast_stream_topology_free(), AST_VECTOR_ELEM_CLEANUP_NOOP, AST_VECTOR_RESET, ast_sip_session_media_state::default_session, NULL, ast_sip_session_media_state::read_callbacks, ast_sip_session_media_state::sessions, and ast_sip_session_media_state::topology.

Referenced by ast_sip_session_media_state_free(), ast_sip_session_terminate(), handle_negotiated_sdp(), on_topology_change_response(), session_inv_on_media_update(), session_inv_on_rx_offer(), session_reinvite_on_rx_request(), sip_session_refresh(), and t38_reinvite_response_cb().

◆ ast_sip_session_media_stats_save()

void ast_sip_session_media_stats_save	(	struct ast_sip_session *	sip_session,
		struct ast_sip_session_media_state *	media_state
	)

Save a media stats.

Parameters

sip_session	Session on which to save active media state for
media_state	The media state to save

Definition at line 253 of file res_pjsip_session.c.

{
    int i;
    int ret;
 
    if (!media_state || !sip_session) {
        return;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(&media_state->sessions); i++) {
        struct ast_rtp_instance_stats *stats_tmp = NULL;
        struct ast_sip_session_media *media = AST_VECTOR_GET(&media_state->sessions, i);
        if (!media || !media->rtp) {
            continue;
        }
 
        stats_tmp = ast_calloc(1, sizeof(struct ast_rtp_instance_stats));
        if (!stats_tmp) {
            return;
        }
 
        ret = ast_rtp_instance_get_stats(media->rtp, stats_tmp, AST_RTP_INSTANCE_STAT_ALL);
        if (ret) {
            ast_free(stats_tmp);
            continue;
        }
 
        /* remove all the duplicated stats if exist */
        AST_VECTOR_REMOVE_CMP_UNORDERED(&sip_session->media_stats, stats_tmp, media_stats_local_ssrc_cmp, ast_free);
 
        AST_VECTOR_APPEND(&sip_session->media_stats, stats_tmp);
    }
}

References ast_calloc, ast_free, ast_rtp_instance_get_stats(), AST_RTP_INSTANCE_STAT_ALL, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_REMOVE_CMP_UNORDERED, AST_VECTOR_SIZE, ast_sip_session::media_stats, media_stats_local_ssrc_cmp(), NULL, ast_sip_session_media::rtp, and ast_sip_session_media_state::sessions.

Referenced by ast_sip_session_terminate(), and handle_negotiated_sdp().

◆ ast_sip_session_refresh()

int ast_sip_session_refresh	(	struct ast_sip_session *	session,
		ast_sip_session_request_creation_cb	on_request_creation,
		ast_sip_session_sdp_creation_cb	on_sdp_creation,
		ast_sip_session_response_cb	on_response,
		enum ast_sip_session_refresh_method	method,
		int	generate_new_sdp,
		struct ast_sip_session_media_state *	media_state
	)

Send a reinvite or UPDATE on a session.

This method will inspect the session in order to construct an appropriate session refresh request. As with any outgoing request in res_pjsip_session, this will call into registered supplements in case they wish to add anything.

Note: The on_request_creation callback may or may not be called in the same thread where this function is called. Request creation may need to be delayed due to the current INVITE transaction state.

Parameters

session	The session on which the reinvite will be sent
on_request_creation	Callback called when request is created
on_sdp_creation	Callback called when SDP is created
on_response	Callback called when response for request is received
method	The method that should be used when constructing the session refresh
generate_new_sdp	Boolean to indicate if a new SDP should be created
media_state	Optional requested media state for the SDP

Return values

0	Successfully sent refresh
-1	Failure to send refresh

Note: If a media_state is passed in ownership will be taken in all cases

Definition at line 2637 of file res_pjsip_session.c.

{
    return sip_session_refresh(session, on_request_creation, on_sdp_creation,
        on_response, method, generate_new_sdp, media_state, NULL, 0);
}

References method, NULL, session, and sip_session_refresh().

Referenced by dtmf_mode_refresh_cb(), refresh_write_cb(), remote_send_hold_refresh(), send_direct_media_request(), send_topology_change_refresh(), t38_interpret_parameters(), and update_connected_line_information().

◆ ast_sip_session_regenerate_answer()

int ast_sip_session_regenerate_answer	(	struct ast_sip_session *	session,
		ast_sip_session_sdp_creation_cb	on_sdp_creation
	)

Regenerate SDP Answer.

This method is used when an SDP offer has been received but an SDP answer has not been sent yet. It requests that a new local SDP be created and set as the SDP answer. As with any outgoing request in res_pjsip_session, this will call into registered supplements in case they wish to add anything.

Parameters

session	The session on which the answer will be updated
on_sdp_creation	Callback called when SDP is created

Return values

0	Successfully updated the SDP answer
-1	Failure to updated the SDP answer

Definition at line 2648 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
    pjmedia_sdp_session *new_answer = NULL;
    const pjmedia_sdp_session *previous_offer = NULL;
    SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
 
    /* The SDP answer can only be regenerated if it is still pending to be sent */
    if (!inv_session->neg || (pjmedia_sdp_neg_get_state(inv_session->neg) != PJMEDIA_SDP_NEG_STATE_REMOTE_OFFER &&
        pjmedia_sdp_neg_get_state(inv_session->neg) != PJMEDIA_SDP_NEG_STATE_WAIT_NEGO)) {
        ast_log(LOG_WARNING, "Requested to regenerate local SDP answer for channel '%s' but negotiation in state '%s'\n",
            ast_channel_name(session->channel), pjmedia_sdp_neg_state_str(pjmedia_sdp_neg_get_state(inv_session->neg)));
        SCOPE_EXIT_RTN_VALUE(-1, "Bad negotiation state\n");
    }
 
    pjmedia_sdp_neg_get_neg_remote(inv_session->neg, &previous_offer);
    if (pjmedia_sdp_neg_get_state(inv_session->neg) == PJMEDIA_SDP_NEG_STATE_WAIT_NEGO) {
        /* Transition the SDP negotiator back to when it received the remote offer */
        pjmedia_sdp_neg_negotiate(inv_session->pool, inv_session->neg, 0);
        pjmedia_sdp_neg_set_remote_offer(inv_session->pool, inv_session->neg, previous_offer);
    }
 
    new_answer = create_local_sdp(inv_session, session, previous_offer, 0);
    if (!new_answer) {
        ast_log(LOG_WARNING, "Could not create a new local SDP answer for channel '%s'\n",
            ast_channel_name(session->channel));
        SCOPE_EXIT_RTN_VALUE(-1, "Couldn't create new SDP\n");
    }
 
    if (on_sdp_creation) {
        if (on_sdp_creation(session, new_answer)) {
            SCOPE_EXIT_RTN_VALUE(-1, "Callback failed\n");
        }
    }
 
    pjsip_inv_set_sdp_answer(inv_session, new_answer);
 
    SCOPE_EXIT_RTN_VALUE(0);
}

References ast_channel_name(), ast_log, ast_sip_session_get_name(), create_local_sdp(), LOG_WARNING, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, and session.

Referenced by dtmf_mode_refresh_cb().

◆ ast_sip_session_register_sdp_handler()

int ast_sip_session_register_sdp_handler	(	struct ast_sip_session_sdp_handler *	handler,
		const char *	stream_type
	)

Register an SDP handler.

An SDP handler is responsible for parsing incoming SDP streams and ensuring that Asterisk can cope with the contents. Similarly, the SDP handler will be responsible for constructing outgoing SDP streams.

Multiple handlers for the same stream type may be registered. They will be visited in the order they were registered. Handlers will be visited for each stream type until one claims to have handled the stream.

Parameters

handler	The SDP handler to register
stream_type	The type of media stream for which to call the handler

Return values

0	Success
-1	Failure

Definition at line 147 of file res_pjsip_session.c.

{
    RAII_VAR(struct sdp_handler_list *, handler_list,
            ao2_find(sdp_handlers, stream_type, OBJ_KEY), ao2_cleanup);
    SCOPED_AO2LOCK(lock, sdp_handlers);
 
    if (handler_list) {
        struct ast_sip_session_sdp_handler *iter;
        /* Check if this handler is already registered for this stream type */
        AST_LIST_TRAVERSE(&handler_list->list, iter, next) {
            if (!strcmp(iter->id, handler->id)) {
                ast_log(LOG_WARNING, "Handler '%s' already registered for stream type '%s'.\n", handler->id, stream_type);
                return -1;
            }
        }
        AST_LIST_INSERT_TAIL(&handler_list->list, handler, next);
        ast_debug(1, "Registered SDP stream handler '%s' for stream type '%s'\n", handler->id, stream_type);
 
        return 0;
    }
 
    /* No stream of this type has been registered yet, so we need to create a new list */
    handler_list = ao2_alloc(sizeof(*handler_list) + strlen(stream_type), NULL);
    if (!handler_list) {
        return -1;
    }
    /* Safe use of strcpy */
    strcpy(handler_list->stream_type, stream_type);
    AST_LIST_HEAD_INIT_NOLOCK(&handler_list->list);
    AST_LIST_INSERT_TAIL(&handler_list->list, handler, next);
    if (!ao2_link(sdp_handlers, handler_list)) {
        return -1;
    }
    ast_debug(1, "Registered SDP stream handler '%s' for stream type '%s'\n", handler->id, stream_type);
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ao2_find, ao2_link, ast_debug, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log, handler(), ast_sip_session_sdp_handler::id, lock, LOG_WARNING, ast_sip_session_sdp_handler::next, NULL, OBJ_KEY, RAII_VAR, SCOPED_AO2LOCK, sdp_handlers, and sdp_handler_list::stream_type.

Referenced by load_module(), and load_module().

◆ ast_sip_session_remove_datastore()

void ast_sip_session_remove_datastore	(	struct ast_sip_session *	session,
		const char *	name
	)

Remove a session datastore from the session.

This operation may cause the datastore's free() callback to be called if the reference count reaches zero.

Parameters

session	The session to remove the datastore from
name	The name of the datastore to remove

Definition at line 1336 of file res_pjsip_session.c.

{
    ao2_callback(session->datastores, OBJ_KEY | OBJ_UNLINK | OBJ_NODATA, NULL, (void *) name);
}

References ao2_callback, name, NULL, OBJ_KEY, OBJ_NODATA, OBJ_UNLINK, and session.

Referenced by direct_media_mitigate_glare(), handle_outgoing_response(), outgoing_request(), reason_header_outgoing_response(), refresh_write_cb(), and session_refresh_state_get_or_alloc().

◆ ast_sip_session_resume_reinvite()

void ast_sip_session_resume_reinvite ( struct ast_sip_session * session )

Resumes processing of a deferred incoming re-invite.

Parameters

session The session which has a pending incoming re-invite

Note: When resuming a re-invite it is given to the pjsip stack as if it had just been received from a transport, this means that the deferral callback will be called again.

Definition at line 2919 of file res_pjsip_session.c.

{
    if (!session->deferred_reinvite) {
        return;
    }
 
    if (session->channel) {
        pjsip_endpt_process_rx_data(ast_sip_get_pjsip_endpoint(),
            session->deferred_reinvite, NULL, NULL);
    }
    pjsip_rx_data_free_cloned(session->deferred_reinvite);
    session->deferred_reinvite = NULL;
}

References ast_sip_get_pjsip_endpoint(), NULL, and session.

Referenced by t38_automatic_reject(), and t38_interpret_parameters().

◆ ast_sip_session_send_request()

void ast_sip_session_send_request	(	struct ast_sip_session *	session,
		pjsip_tx_data *	tdata
	)

Send a SIP request.

This will send the SIP request specified in tdata and call into any registered supplements' outgoing_request callback.

Parameters

session	The session to which to send the request
tdata	The request to send

Definition at line 2963 of file res_pjsip_session.c.

{
    ast_sip_session_send_request_with_cb(session, tdata, NULL);
}

References ast_sip_session_send_request_with_cb(), NULL, and session.

Referenced by aoc_send_as_xml(), ast_sip_session_terminate(), call(), check_request_status(), handle_incoming_before_media(), outbound_invite_auth(), session_inv_on_tsx_state_changed(), transmit_info_dtmf(), and transmit_info_with_vidupdate().

◆ ast_sip_session_send_request_with_cb()

void ast_sip_session_send_request_with_cb	(	struct ast_sip_session *	session,
		pjsip_tx_data *	tdata,
		ast_sip_session_response_cb	on_response
	)

Send a SIP request and get called back when a response is received.

This will send the request out exactly the same as ast_sip_send_request() does. The difference is that when a response arrives, the specified callback will be called into

Parameters

session	The session on which to send the request
tdata	The request to send
on_response	Callback to be called when a response is received

Definition at line 2939 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
 
    /* For every request except BYE we disallow sending of the message when
     * the session has been disconnected. A BYE request is special though
     * because it can be sent again after the session is disconnected except
     * with credentials.
     */
    if (inv_session->state == PJSIP_INV_STATE_DISCONNECTED &&
        tdata->msg->line.req.method.id != PJSIP_BYE_METHOD) {
        return;
    }
 
    ast_sip_mod_data_set(tdata->pool, tdata->mod_data, session_module.id,
                 MOD_DATA_ON_RESPONSE, on_response);
 
    handle_outgoing_request(session, tdata);
    pjsip_inv_send_msg(session->inv_session, tdata);
 
    return;
}

References ast_sip_mod_data_set, handle_outgoing_request(), MOD_DATA_ON_RESPONSE, session, and session_module.

Referenced by ast_sip_session_send_request(), session_inv_on_tsx_state_changed(), and sip_session_refresh().

◆ ast_sip_session_send_response()

void ast_sip_session_send_response	(	struct ast_sip_session *	session,
		pjsip_tx_data *	tdata
	)

Send a SIP response.

This will send the SIP response specified in tdata and call into any registered supplements' outgoing_response callback.

Parameters

session	The session on which to send the response.
tdata	The response to send

Definition at line 2689 of file res_pjsip_session.c.

{
    pjsip_dialog *dlg = pjsip_tdata_get_dlg(tdata);
    RAII_VAR(struct ast_sip_session *, dlg_session, dlg ? ast_sip_dialog_get_session(dlg) : NULL, ao2_cleanup);
    if (!dlg_session) {
        /* If the dialog has a session, handle_outgoing_response will be called
           from session_on_tx_response. If it does not, call it from here. */
        handle_outgoing_response(session, tdata);
    }
    pjsip_inv_send_msg(session->inv_session, tdata);
    return;
}

References ao2_cleanup, ast_sip_dialog_get_session(), handle_outgoing_response(), NULL, RAII_VAR, and session.

Referenced by answer(), ast_sip_session_terminate(), chan_pjsip_incoming_request(), indicate(), new_invite(), pjsip_hangup(), refer_incoming_invite_request(), transfer_redirect(), and update_connected_line_information().

◆ ast_sip_session_suspend()

void ast_sip_session_suspend ( struct ast_sip_session * session )

Request and wait for the session serializer to be suspended.

Since: 12.7.0

Parameters

session Which session to suspend the serializer.

Note: No channel locks can be held while calling without risk of deadlock.

Definition at line 3226 of file res_pjsip_session.c.

{
    ast_taskpool_serializer_suspend(session->serializer);
}

References ast_taskpool_serializer_suspend(), and session.

Referenced by chan_pjsip_indicate().

◆ ast_sip_session_terminate()

void ast_sip_session_terminate	(	struct ast_sip_session *	session,
		int	response
	)

Terminate a session and, if possible, send the provided response code.

Parameters

session	The session to terminate
response	The response code to use for termination if possible

Warning: Calling this function MAY cause the last session reference to be released and the session destructor to be called. If you need to do something with session after this call, be sure to bump the ref count before calling terminate.

Definition at line 3472 of file res_pjsip_session.c.

{
    pj_status_t status;
    pjsip_tx_data *packet = NULL;
    SCOPE_ENTER(1, "%s Response %d\n", ast_sip_session_get_name(session), response);
 
    if (session->defer_terminate) {
        session->terminate_while_deferred = 1;
        SCOPE_EXIT_RTN("Deferred\n");
    }
 
    if (!response) {
        response = 603;
    }
 
    /* The media sessions need to exist for the lifetime of the underlying channel
     * to ensure that anything (such as bridge_native_rtp) has access to them as
     * appropriate. Since ast_sip_session_terminate is called by chan_pjsip and other
     * places when the session is to be terminated we terminate any existing
     * media sessions here.
     */
    ast_sip_session_media_stats_save(session, session->active_media_state);
    /* Publish the replacement under the channel lock used by media readers.
     * Reset the detached state after unlocking: stream teardown may wait for
     * scheduler callbacks that need the channel lock.
     */
    if (session->channel) {
        ast_channel_lock(session->channel);
    }
    SWAP(session->active_media_state, session->pending_media_state);
    if (session->channel) {
        ast_channel_unlock(session->channel);
    }
    ast_sip_session_media_state_reset(session->pending_media_state);
 
    switch (session->inv_session->state) {
    case PJSIP_INV_STATE_NULL:
        if (!session->inv_session->invite_tsx) {
            /*
             * Normally, it's pjproject's transaction cleanup that ultimately causes the
             * final session reference to be released but if both STATE and invite_tsx are NULL,
             * we never created a transaction in the first place.  In this case, we need to
             * do the cleanup ourselves.
             */
            /* Transfer the inv_session session reference to the session_end_task */
            session->inv_session->mod_data[session_module.id] = NULL;
            pjsip_inv_terminate(session->inv_session, response, PJ_TRUE);
            session_end(session);
            /*
             * session_end_completion will cleanup the final session reference unless
             * ast_sip_session_terminate's caller is holding one.
             */
            session_end_completion(session);
        } else {
            pjsip_inv_terminate(session->inv_session, response, PJ_TRUE);
        }
        break;
    case PJSIP_INV_STATE_CONFIRMED:
        if (session->inv_session->invite_tsx) {
            ast_debug(3, "%s: Delay sending BYE because of outstanding transaction...\n",
                ast_sip_session_get_name(session));
            /*
             * If this is delayed the only thing that will happen is a BYE request, so
             * no response code needs to be stored. Queue the BYE as before, then arm
             * a transaction timeout so a malformed/lost final re-INVITE response
             * cannot leave the session and RTP state referenced forever.
             */
            if (delay_request(session, NULL, NULL, NULL, 0, DELAYED_METHOD_BYE, NULL, NULL, 1)) {
                ast_log(LOG_ERROR, "%s: Unable to delay BYE request\n",
                    ast_sip_session_get_name(session));
            } else if (set_outstanding_invite_timeout(session)) {
                session->terminate_on_invite_timeout = 1;
            }
            break;
        }
        /* Fall through */
    default:
        status = pjsip_inv_end_session(session->inv_session, response, NULL, &packet);
        if (status == PJ_SUCCESS && packet) {
            /* Flush any delayed requests so they cannot overlap this transaction. */
            flush_delayed_requests(session);
 
            if (packet->msg->type == PJSIP_RESPONSE_MSG) {
                ast_sip_session_send_response(session, packet);
            } else {
                ast_sip_session_send_request(session, packet);
            }
        }
        break;
    }
    SCOPE_EXIT_RTN();
}

References ast_channel_lock, ast_channel_unlock, ast_debug, ast_log, ast_sip_session_get_name(), ast_sip_session_media_state_reset(), ast_sip_session_media_stats_save(), ast_sip_session_send_request(), ast_sip_session_send_response(), delay_request(), DELAYED_METHOD_BYE, flush_delayed_requests(), LOG_ERROR, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN, session, session_end(), session_end_completion(), session_module, set_outstanding_invite_timeout(), status, and SWAP.

Referenced by ast_sip_session_defer_termination_cancel(), chan_pjsip_incoming_request(), hangup(), reject_incoming_call(), send_delayed_request(), and session_termination_task().

◆ ast_sip_session_unregister_sdp_handler()

void ast_sip_session_unregister_sdp_handler	(	struct ast_sip_session_sdp_handler *	handler,
		const char *	stream_type
	)

Unregister an SDP handler.

Parameters

handler	The SDP handler to unregister
stream_type	Stream type for which the SDP handler was registered

Definition at line 208 of file res_pjsip_session.c.

{
    ao2_callback_data(sdp_handlers, OBJ_KEY | OBJ_UNLINK | OBJ_NODATA, remove_handler, (void *)stream_type, handler);
}

References ao2_callback_data, handler(), OBJ_KEY, OBJ_NODATA, OBJ_UNLINK, remove_handler(), and sdp_handlers.

Referenced by unload_module(), and unload_module().

◆ ast_sip_session_unsuspend()

void ast_sip_session_unsuspend ( struct ast_sip_session * session )

Request the session serializer be unsuspended.

Since: 12.7.0

Parameters

session Which session to unsuspend the serializer.

Definition at line 3231 of file res_pjsip_session.c.

{
    ast_taskpool_serializer_unsuspend(session->serializer);
}

References ast_taskpool_serializer_unsuspend(), and session.

Referenced by chan_pjsip_indicate().

◆ check_content_disposition()

static int check_content_disposition ( pjsip_rx_data * rdata )

static

if there is required media we don't understand, return 1

Definition at line 3984 of file res_pjsip_session.c.

{
    pjsip_msg_body *body = rdata->msg_info.msg->body;
    pjsip_ctype_hdr *ctype_hdr = rdata->msg_info.ctype;
 
    if (body && ctype_hdr &&
        ast_sip_is_media_type_in(&ctype_hdr->media, &pjsip_media_type_multipart_mixed,
            &pjsip_media_type_multipart_alternative, SENTINEL)) {
        pjsip_multipart_part *part = pjsip_multipart_get_first_part(body);
        while (part != NULL) {
            if (check_content_disposition_in_multipart(part)) {
                return 1;
            }
            part = pjsip_multipart_get_next_part(body, part);
        }
    }
    return 0;
}

References ast_sip_is_media_type_in(), check_content_disposition_in_multipart(), NULL, pjsip_media_type_multipart_alternative, pjsip_media_type_multipart_mixed, and SENTINEL.

Referenced by new_invite().

◆ check_content_disposition_in_multipart()

static int check_content_disposition_in_multipart ( pjsip_multipart_part * part )

static

Definition at line 3960 of file res_pjsip_session.c.

{
    pjsip_hdr *hdr = part->hdr.next;
    static const pj_str_t str_handling_required = {"handling=required", 16};
 
    while (hdr != &part->hdr) {
        if (hdr->type == PJSIP_H_OTHER) {
            pjsip_generic_string_hdr *generic_hdr = (pjsip_generic_string_hdr*)hdr;
 
            if (!pj_stricmp2(&hdr->name, "Content-Disposition") &&
                pj_stristr(&generic_hdr->hvalue, &str_handling_required) &&
                !check_sdp_content_type_supported(&part->body->content_type)) {
                return 1;
            }
        }
        hdr = hdr->next;
    }
 
    return 0;
}

References check_sdp_content_type_supported().

Referenced by check_content_disposition().

◆ check_delayed_requests()

static void check_delayed_requests	(	struct ast_sip_session *	session,
		int()(void vsession)	cb
	)

static

Definition at line 1643 of file res_pjsip_session.c.

{
    ao2_ref(session, +1);
    if (ast_sip_push_task(session->serializer, cb, session)) {
        ao2_ref(session, -1);
    }
}

References ao2_ref, ast_sip_push_task, and session.

Referenced by session_inv_on_tsx_state_changed().

◆ check_request_status()

static int check_request_status	(	pjsip_inv_session *	inv,
		pjsip_event *	e
	)

static

Definition at line 4669 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    pjsip_transaction *tsx = e->body.tsx_state.tsx;
 
    if (inv->state == PJSIP_INV_STATE_DISCONNECTED && inv->cancelling) {
        return 0;
    }
 
    if (tsx->status_code != 503 && tsx->status_code != 408) {
        return 0;
    }
 
    if (!ast_sip_failover_request(tsx->last_tx)) {
        return 0;
    }
 
    pjsip_inv_uac_restart(inv, PJ_FALSE);
    /*
     * Bump the ref since it will be on a new transaction and
     * we don't want it to go away along with the old transaction.
     */
    pjsip_tx_data_add_ref(tsx->last_tx);
    ast_sip_session_send_request(session, tsx->last_tx);
    return 1;
}

References ast_sip_failover_request(), ast_sip_session_send_request(), session, and session_module.

Referenced by session_inv_on_state_changed().

◆ check_sdp_content_type_supported()

static int check_sdp_content_type_supported ( pjsip_media_type * content_type )

static

Definition at line 3948 of file res_pjsip_session.c.

{
    pjsip_media_type app_sdp;
    pjsip_media_type_init2(&app_sdp, "application", "sdp");
 
    if (!pjsip_media_type_cmp(content_type, &app_sdp, 0)) {
        return 1;
    }
 
    return 0;
}

Referenced by check_content_disposition_in_multipart().

◆ create_local_sdp()

static struct pjmedia_sdp_session * create_local_sdp	(	pjsip_inv_session *	inv,
		struct ast_sip_session *	session,
		const pjmedia_sdp_session *	offer,
		const unsigned int	ignore_active_stream_topology
	)

static

Definition at line 5206 of file res_pjsip_session.c.

{
    static const pj_str_t STR_IN = { "IN", 2 };
    static const pj_str_t STR_IP4 = { "IP4", 3 };
    static const pj_str_t STR_IP6 = { "IP6", 3 };
    pjmedia_sdp_session *local;
    int i;
    int stream;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (inv->state == PJSIP_INV_STATE_DISCONNECTED) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Failed to create session SDP. Session has been already disconnected\n",
            ast_sip_session_get_name(session));
    }
 
    if (!inv->pool_prov || !(local = PJ_POOL_ZALLOC_T(inv->pool_prov, pjmedia_sdp_session))) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Pool allocation failure\n", ast_sip_session_get_name(session));
    }
 
    if (!offer) {
        local->origin.version = local->origin.id = (pj_uint32_t)(ast_random());
    } else {
        local->origin.version = offer->origin.version + 1;
        local->origin.id = offer->origin.id;
    }
 
    pj_strdup2(inv->pool_prov, &local->origin.user, session->endpoint->media.sdpowner);
    pj_strdup2(inv->pool_prov, &local->name, session->endpoint->media.sdpsession);
 
    if (!session->pending_media_state->topology || !ast_stream_topology_get_count(session->pending_media_state->topology)) {
        /* We've encountered a situation where we have been told to create a local SDP but noone has given us any indication
         * of what kind of stream topology they would like. We try to not alter the current state of the SDP negotiation
         * by using what is currently negotiated. If this is unavailable we fall back to what is configured on the endpoint.
         * We will also do this if wanted by the ignore_active_stream_topology flag.
         */
        ast_trace(-1, "no information about stream topology received\n");
        ast_stream_topology_free(session->pending_media_state->topology);
        if (session->active_media_state->topology && !ignore_active_stream_topology) {
            ast_trace(-1, "using existing topology\n");
            session->pending_media_state->topology = ast_stream_topology_clone(session->active_media_state->topology);
        } else {
            if (ignore_active_stream_topology) {
                ast_trace(-1, "fall back to endpoint configuration - ignore active stream topolog\n");
            } else {
                ast_trace(-1, "fall back to endpoint configuration\n");
            }
            session->pending_media_state->topology = ast_stream_topology_clone(session->endpoint->media.topology);
        }
        if (!session->pending_media_state->topology) {
            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: No pending media state topology\n", ast_sip_session_get_name(session));
        }
    }
 
    ast_trace(-1, "%s: Processing streams\n", ast_sip_session_get_name(session));
 
    for (i = 0; i < ast_stream_topology_get_count(session->pending_media_state->topology); ++i) {
        struct ast_sip_session_media *session_media;
        struct ast_stream *stream = ast_stream_topology_get_stream(session->pending_media_state->topology, i);
        unsigned int streams = local->media_count;
        SCOPE_ENTER(4, "%s: Processing stream %s\n", ast_sip_session_get_name(session),
            ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
 
        /* This code does not enforce any maximum stream count limitations as that is done on either
         * the handling of an incoming SDP offer or on the handling of a session refresh.
         */
 
        session_media = ast_sip_session_media_state_add(session, session->pending_media_state, ast_stream_get_type(stream), i);
        if (!session_media) {
            local = NULL;
            SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't alloc/add session media for stream %s\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
 
        if (add_sdp_streams(session_media, session, local, offer, stream)) {
            local = NULL;
            SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't add sdp streams for stream %s\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
 
        /* If a stream was actually added then add any additional details */
        if (streams != local->media_count) {
            pjmedia_sdp_media *media = local->media[streams];
            pj_str_t stmp;
            pjmedia_sdp_attr *attr;
 
            /* Add the media identifier if present */
            if (!ast_strlen_zero(session_media->mid)) {
                attr = pjmedia_sdp_attr_create(inv->pool_prov, "mid", pj_cstr(&stmp, session_media->mid));
                pjmedia_sdp_attr_add(&media->attr_count, media->attr, attr);
            }
 
            ast_trace(-1, "%s: Stream %s added%s%s\n", ast_sip_session_get_name(session),
                ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                S_COR(!ast_strlen_zero(session_media->mid), " with mid ", ""), S_OR(session_media->mid, ""));
 
        }
 
        /* Ensure that we never exceed the maximum number of streams PJMEDIA will allow. */
        if (local->media_count == PJMEDIA_MAX_SDP_MEDIA) {
            SCOPE_EXIT_EXPR(break, "%s: Stream %s exceeded max pjmedia count of %d\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                PJMEDIA_MAX_SDP_MEDIA);
        }
 
        SCOPE_EXIT("%s: Done with %s\n", ast_sip_session_get_name(session),
            ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
 
    }
 
    /* Add any bundle groups that are present on the media state */
    ast_trace(-1, "%s: Adding bundle groups (if available)\n", ast_sip_session_get_name(session));
    if (add_bundle_groups(session, inv->pool_prov, local)) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Couldn't add bundle groups\n", ast_sip_session_get_name(session));
    }
 
    /* Use the connection details of an available media if possible for SDP level */
    ast_trace(-1, "%s: Copying connection details\n", ast_sip_session_get_name(session));
 
    for (stream = 0; stream < local->media_count; stream++) {
        SCOPE_ENTER(4, "%s: Processing media %d\n", ast_sip_session_get_name(session), stream);
        if (!local->media[stream]->conn) {
            SCOPE_EXIT_EXPR(continue, "%s: Media %d has no connection info\n", ast_sip_session_get_name(session), stream);
        }
 
        if (local->conn) {
            if (!pj_strcmp(&local->conn->net_type, &local->media[stream]->conn->net_type) &&
                !pj_strcmp(&local->conn->addr_type, &local->media[stream]->conn->addr_type) &&
                !pj_strcmp(&local->conn->addr, &local->media[stream]->conn->addr)) {
                local->media[stream]->conn = NULL;
            }
            SCOPE_EXIT_EXPR(continue, "%s: Media %d has good existing connection info\n", ast_sip_session_get_name(session), stream);
        }
 
        /* This stream's connection info will serve as the connection details for SDP level */
        local->conn = local->media[stream]->conn;
        local->media[stream]->conn = NULL;
 
        SCOPE_EXIT_EXPR(continue, "%s: Media %d reset\n", ast_sip_session_get_name(session), stream);
    }
 
    /* If no SDP level connection details are present then create some */
    if (!local->conn) {
        ast_trace(-1, "%s: Creating connection details\n", ast_sip_session_get_name(session));
 
        local->conn = pj_pool_zalloc(inv->pool_prov, sizeof(struct pjmedia_sdp_conn));
        local->conn->net_type = STR_IN;
        local->conn->addr_type = session->endpoint->media.rtp.ipv6 ? STR_IP6 : STR_IP4;
 
        if (!ast_strlen_zero(session->endpoint->media.address)) {
            pj_strdup2(inv->pool_prov, &local->conn->addr, session->endpoint->media.address);
        } else {
            pj_strdup2(inv->pool_prov, &local->conn->addr, ast_sip_get_host_ip_string(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET()));
        }
    }
 
    pj_strassign(&local->origin.net_type, &local->conn->net_type);
    pj_strassign(&local->origin.addr_type, &local->conn->addr_type);
    pj_strassign(&local->origin.addr, &local->conn->addr);
 
end:
    SCOPE_EXIT_RTN_VALUE(local, "%s\n", ast_sip_session_get_name(session));
}

References add_bundle_groups(), add_sdp_streams(), ast_random(), ast_sip_get_host_ip_string(), ast_sip_session_get_name(), ast_sip_session_media_state_add(), ast_str_tmp, ast_stream_get_type(), ast_stream_to_str(), ast_stream_topology_clone(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_strlen_zero(), ast_trace, end, LOG_ERROR, ast_sip_session_media::mid, NULL, S_COR, S_OR, SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_EXPR, SCOPE_EXIT_LOG_EXPR, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, and session.

Referenced by ast_sip_session_create_invite(), ast_sip_session_regenerate_answer(), generate_session_refresh_sdp(), new_invite(), session_inv_on_create_offer(), and session_inv_on_rx_offer().

◆ datastore_cmp()

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

static

Definition at line 3009 of file res_pjsip_session.c.

{
    const struct ast_datastore *datastore1 = obj;
    const struct ast_datastore *datastore2 = arg;
    const char *uid2 = flags & OBJ_KEY ? arg : datastore2->uid;
 
    ast_assert(datastore1->uid != NULL);
    ast_assert(uid2 != NULL);
 
    return strcmp(datastore1->uid, uid2) ? 0 : CMP_MATCH | CMP_STOP;
}

References ast_assert, CMP_MATCH, CMP_STOP, NULL, OBJ_KEY, and ast_datastore::uid.

Referenced by ast_sip_session_alloc().

◆ datastore_hash()

static int datastore_hash	(	const void *	obj,
		int	flags
	)

static

Definition at line 2999 of file res_pjsip_session.c.

{
    const struct ast_datastore *datastore = obj;
    const char *uid = flags & OBJ_KEY ? obj : datastore->uid;
 
    ast_assert(uid != NULL);
 
    return ast_str_hash(uid);
}

References ast_assert, ast_str_hash(), NULL, OBJ_KEY, and ast_datastore::uid.

Referenced by ast_sip_session_alloc().

◆ delay_request()

static int delay_request	(	struct ast_sip_session *	session,
		ast_sip_session_request_creation_cb	on_request,
		ast_sip_session_sdp_creation_cb	on_sdp_creation,
		ast_sip_session_response_cb	on_response,
		int	generate_new_sdp,
		enum delayed_method	method,
		struct ast_sip_session_media_state *	pending_media_state,
		struct ast_sip_session_media_state *	active_media_state,
		int	queue_head
	)

static

Definition at line 1652 of file res_pjsip_session.c.

{
    struct ast_sip_session_delayed_request *delay = delayed_request_alloc(method,
            on_request, on_sdp_creation, on_response, generate_new_sdp, pending_media_state,
            active_media_state);
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (!delay) {
        ast_sip_session_media_state_free(pending_media_state);
        ast_sip_session_media_state_free(active_media_state);
        SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "Unable to allocate delay request\n");
    }
 
    if (method == DELAYED_METHOD_BYE || queue_head) {
        /* Send BYE as early as possible */
        AST_LIST_INSERT_HEAD(&session->delayed_requests, delay, next);
    } else {
        AST_LIST_INSERT_TAIL(&session->delayed_requests, delay, next);
    }
    SCOPE_EXIT_RTN_VALUE(0);
}

References ast_sip_session_delayed_request::active_media_state, AST_LIST_INSERT_HEAD, AST_LIST_INSERT_TAIL, ast_sip_session_get_name(), ast_sip_session_media_state_free(), DELAYED_METHOD_BYE, delayed_request_alloc(), ast_sip_session_delayed_request::generate_new_sdp, LOG_ERROR, method, ast_sip_session_delayed_request::next, ast_sip_session_delayed_request::on_response, ast_sip_session_delayed_request::on_sdp_creation, ast_sip_session_delayed_request::pending_media_state, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, and session.

Referenced by ast_sip_session_terminate(), reschedule_reinvite(), and sip_session_refresh().

◆ delayed_method2str()

static const char * delayed_method2str ( enum delayed_method method )

static

Definition at line 1356 of file res_pjsip_session.c.

{
    const char *str = "<unknown>";
 
    switch (method) {
    case DELAYED_METHOD_INVITE:
        str = "INVITE";
        break;
    case DELAYED_METHOD_UPDATE:
        str = "UPDATE";
        break;
    case DELAYED_METHOD_BYE:
        str = "BYE";
        break;
    }
 
    return str;
}

References DELAYED_METHOD_BYE, DELAYED_METHOD_INVITE, DELAYED_METHOD_UPDATE, method, and str.

Referenced by invite_proceeding(), invite_terminated(), and send_delayed_request().

◆ delayed_request_alloc()

static struct ast_sip_session_delayed_request * delayed_request_alloc	(	enum delayed_method	method,
		ast_sip_session_request_creation_cb	on_request_creation,
		ast_sip_session_sdp_creation_cb	on_sdp_creation,
		ast_sip_session_response_cb	on_response,
		int	generate_new_sdp,
		struct ast_sip_session_media_state *	pending_media_state,
		struct ast_sip_session_media_state *	active_media_state
	)

static

Definition at line 1401 of file res_pjsip_session.c.

{
    struct ast_sip_session_delayed_request *delay = ast_calloc(1, sizeof(*delay));
 
    if (!delay) {
        return NULL;
    }
    delay->method = method;
    delay->on_request_creation = on_request_creation;
    delay->on_sdp_creation = on_sdp_creation;
    delay->on_response = on_response;
    delay->generate_new_sdp = generate_new_sdp;
    delay->pending_media_state = pending_media_state;
    delay->active_media_state = active_media_state;
    return delay;
}

References ast_sip_session_delayed_request::active_media_state, ast_calloc, ast_sip_session_delayed_request::generate_new_sdp, method, ast_sip_session_delayed_request::method, NULL, ast_sip_session_delayed_request::on_request_creation, ast_sip_session_delayed_request::on_response, ast_sip_session_delayed_request::on_sdp_creation, and ast_sip_session_delayed_request::pending_media_state.

Referenced by delay_request().

◆ delayed_request_free()

static void delayed_request_free ( struct ast_sip_session_delayed_request * delay )

static

Definition at line 1425 of file res_pjsip_session.c.

{
    ast_sip_session_media_state_free(delay->pending_media_state);
    ast_sip_session_media_state_free(delay->active_media_state);
    ast_free(delay);
}

References ast_sip_session_delayed_request::active_media_state, ast_free, ast_sip_session_media_state_free(), and ast_sip_session_delayed_request::pending_media_state.

Referenced by flush_delayed_requests(), invite_proceeding(), and invite_terminated().

◆ does_method_match()

static pj_bool_t does_method_match	(	const pj_str_t *	message_method,
		const char *	supplement_method
	)

static

Definition at line 4226 of file res_pjsip_session.c.

{
    pj_str_t method;
 
    if (ast_strlen_zero(supplement_method)) {
        return PJ_TRUE;
    }
 
    pj_cstr(&method, supplement_method);
 
    return pj_stristr(&method, message_method) ? PJ_TRUE : PJ_FALSE;
}

References ast_strlen_zero(), message_method, and method.

Referenced by handle_incoming_request(), handle_incoming_response(), handle_outgoing_request(), handle_outgoing_response(), and has_supplement().

◆ fetch_callerid_num()

static int fetch_callerid_num	(	struct ast_sip_session *	session,
		pjsip_rx_data *	rdata,
		char *	buf,
		size_t	len
	)

static

Fetch just the Caller ID number in order of PAI, RPID, From.

Definition at line 3701 of file res_pjsip_session.c.

{
    int res = -1;
    struct ast_party_id id;
 
    ast_party_id_init(&id);
    if (!ast_sip_set_id_from_invite(rdata, &id, &session->endpoint->id.self, session->endpoint->id.trust_inbound)) {
        ast_copy_string(buf, id.number.str, len);
        res = 0;
    }
    ast_party_id_free(&id);
    return res;
}

References ast_copy_string(), ast_party_id_free(), ast_party_id_init(), ast_sip_set_id_from_invite(), buf, id, len(), and session.

Referenced by get_destination().

◆ flush_delayed_requests()

static void flush_delayed_requests ( struct ast_sip_session * session )

static

Definition at line 1436 of file res_pjsip_session.c.

{
    struct ast_sip_session_delayed_request *delay;
 
    while ((delay = AST_LIST_REMOVE_HEAD(&session->delayed_requests, next))) {
        delayed_request_free(delay);
    }
}

References AST_LIST_REMOVE_HEAD, delayed_request_free(), ast_sip_session_delayed_request::next, and session.

Referenced by ast_sip_session_terminate(), session_destructor(), and session_inv_on_tsx_state_changed().

◆ generate_session_refresh_sdp()

static pjmedia_sdp_session * generate_session_refresh_sdp ( struct ast_sip_session * session )

static

Definition at line 1733 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
    const pjmedia_sdp_session *previous_sdp = NULL;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (inv_session->neg) {
        if (pjmedia_sdp_neg_was_answer_remote(inv_session->neg)) {
            pjmedia_sdp_neg_get_active_remote(inv_session->neg, &previous_sdp);
        } else {
            pjmedia_sdp_neg_get_active_local(inv_session->neg, &previous_sdp);
        }
    }
    SCOPE_EXIT_RTN_VALUE(create_local_sdp(inv_session, session, previous_sdp, 0));
}

References ast_sip_session_get_name(), create_local_sdp(), NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, and session.

Referenced by sip_session_refresh().

◆ get_destination()

static enum sip_get_destination_result get_destination	(	struct ast_sip_session *	session,
		pjsip_rx_data *	rdata
	)

static

Determine where in the dialplan a call should go.

This uses the username in the request URI to try to match an extension in the endpoint's configured context in order to route the call.

Parameters

session	The inbound SIP session
rdata	The SIP INVITE

Definition at line 3736 of file res_pjsip_session.c.

{
    char cid_num[AST_CHANNEL_NAME];
    pjsip_uri *ruri = rdata->msg_info.msg->line.req.uri;
    struct ast_features_pickup_config *pickup_cfg;
    const char *pickupexten;
 
    if (!ast_sip_is_allowed_uri(ruri)) {
        return SIP_GET_DEST_UNSUPPORTED_URI;
    }
 
    ast_copy_pj_str(session->exten, ast_sip_pjsip_uri_get_username(ruri), sizeof(session->exten));
    if (ast_strlen_zero(session->exten)) {
        /* Some SIP devices send an empty extension for PLAR: this should map to s */
        ast_debug(1, "RURI contains no user portion: defaulting to extension 's'\n");
        ast_copy_string(session->exten, "s", sizeof(session->exten));
    }
 
    /*
     * We may want to match in the dialplan without any user
     * options getting in the way.
     */
    AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(session->exten);
 
    pickup_cfg = ast_get_chan_features_pickup_config(NULL); /* session->channel doesn't exist yet, using NULL */
    if (!pickup_cfg) {
        ast_log(LOG_ERROR, "%s: Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n",
            ast_sip_session_get_name(session));
        pickupexten = "";
    } else {
        pickupexten = ast_strdupa(pickup_cfg->pickupexten);
        ao2_ref(pickup_cfg, -1);
    }
 
    fetch_callerid_num(session, rdata, cid_num, sizeof(cid_num));
 
    /* If there's an overlap_context override specified, use that; otherwise, just use the endpoint's context */
 
    if (!strcmp(session->exten, pickupexten) ||
        ast_exists_extension(NULL, S_OR(session->endpoint->overlap_context, session->endpoint->context), session->exten, 1, S_OR(cid_num, NULL))) {
        /*
         * Save off the INVITE Request-URI in case it is
         * needed: CHANNEL(pjsip,request_uri)
         */
        session->request_uri = pjsip_uri_clone(session->inv_session->pool, ruri);
 
        return SIP_GET_DEST_EXTEN_FOUND;
    }
 
    /*
     * Check for partial match via overlap dialling (if enabled)
     */
    if (session->endpoint->allow_overlap && (
        !strncmp(session->exten, pickupexten, strlen(session->exten)) ||
        ast_canmatch_extension(NULL, S_OR(session->endpoint->overlap_context, session->endpoint->context), session->exten, 1, S_OR(cid_num, NULL)))) {
        /* Overlap partial match */
        return SIP_GET_DEST_EXTEN_PARTIAL;
    }
 
    return SIP_GET_DEST_EXTEN_NOT_FOUND;
}

References ao2_ref, ast_canmatch_extension(), AST_CHANNEL_NAME, ast_copy_pj_str(), ast_copy_string(), ast_debug, ast_exists_extension(), ast_get_chan_features_pickup_config(), ast_log, ast_sip_is_allowed_uri(), ast_sip_pjsip_uri_get_username(), ast_sip_session_get_name(), AST_SIP_USER_OPTIONS_TRUNCATE_CHECK, ast_strdupa, ast_strlen_zero(), fetch_callerid_num(), LOG_ERROR, NULL, ast_features_pickup_config::pickupexten, S_OR, session, SIP_GET_DEST_EXTEN_FOUND, SIP_GET_DEST_EXTEN_NOT_FOUND, SIP_GET_DEST_EXTEN_PARTIAL, and SIP_GET_DEST_UNSUPPORTED_URI.

Referenced by new_invite().

◆ get_mid_bundle_group()

static int get_mid_bundle_group	(	const pjmedia_sdp_session *	sdp,
		const char *	mid
	)

static

Definition at line 621 of file res_pjsip_session.c.

{
    int bundle_group = 0;
    int index;
 
    for (index = 0; index < sdp->attr_count; ++index) {
        pjmedia_sdp_attr *attr = sdp->attr[index];
        char value[pj_strlen(&attr->value) + 1], *mids = value, *attr_mid;
 
        if (pj_strcmp2(&attr->name, "group") || pj_strncmp2(&attr->value, "BUNDLE", 6)) {
            continue;
        }
 
        ast_copy_pj_str(value, &attr->value, sizeof(value));
 
        /* Skip the BUNDLE at the front */
        mids += 7;
 
        while ((attr_mid = strsep(&mids, " "))) {
            if (!strcmp(attr_mid, mid)) {
                /* The ordering of attributes determines our internal identification of the bundle group based on number,
                 * with -1 being not in a bundle group. Since this is only exposed internally for response purposes it's
                 * actually even fine if things move around.
                 */
                return bundle_group;
            }
        }
 
        bundle_group++;
    }
 
    return -1;
}

References ast_copy_pj_str(), ast_sip_session_media::bundle_group, ast_sip_session_media::mid, strsep(), and value.

Referenced by set_mid_and_bundle_group().

◆ handle_incoming()

static int handle_incoming	(	struct ast_sip_session *	session,
		pjsip_rx_data *	rdata,
		enum ast_sip_session_response_priority	response_priority
	)

static

Definition at line 4578 of file res_pjsip_session.c.

{
    if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG) {
        handle_incoming_request(session, rdata);
    } else {
        handle_incoming_response(session, rdata, response_priority);
    }
 
    return 0;
}

References handle_incoming_request(), handle_incoming_response(), and session.

Referenced by handle_incoming_before_media(), session_inv_on_redirected(), and session_inv_on_tsx_state_changed().

◆ handle_incoming_before_media()

static void handle_incoming_before_media	(	pjsip_inv_session *	inv,
		struct ast_sip_session *	session,
		pjsip_rx_data *	rdata
	)

static

Definition at line 4696 of file res_pjsip_session.c.

{
    pjsip_msg *msg;
    ast_debug(3, "%s: Received %s\n", ast_sip_session_get_name(session), rdata->msg_info.msg->type == PJSIP_REQUEST_MSG ?
            "request" : "response");
 
 
    handle_incoming(session, rdata, AST_SIP_SESSION_BEFORE_MEDIA);
    msg = rdata->msg_info.msg;
    if (msg->type == PJSIP_REQUEST_MSG
        && msg->line.req.method.id == PJSIP_ACK_METHOD
        && pjmedia_sdp_neg_get_state(inv->neg) != PJMEDIA_SDP_NEG_STATE_DONE) {
        pjsip_tx_data *tdata;
 
        /*
         * SDP negotiation failed on an incoming call that delayed
         * negotiation and then gave us an invalid SDP answer.  We
         * need to send a BYE to end the call because of the invalid
         * SDP answer.
         */
        ast_debug(1,
            "%s: Ending session due to incomplete SDP negotiation.  %s\n",
            ast_sip_session_get_name(session),
            pjsip_rx_data_get_info(rdata));
        if (pjsip_inv_end_session(inv, 400, NULL, &tdata) == PJ_SUCCESS
            && tdata) {
            ast_sip_session_send_request(session, tdata);
        }
    }
}

References ast_debug, AST_SIP_SESSION_BEFORE_MEDIA, ast_sip_session_get_name(), ast_sip_session_send_request(), handle_incoming(), NULL, and session.

Referenced by session_inv_on_state_changed().

◆ handle_incoming_request()

static void handle_incoming_request	(	struct ast_sip_session *	session,
		pjsip_rx_data *	rdata
	)

static

Definition at line 4507 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *supplement;
    struct pjsip_request_line req = rdata->msg_info.msg->line.req;
    SCOPE_ENTER(3, "%s: Method is %.*s\n", ast_sip_session_get_name(session), (int) pj_strlen(&req.method.name), pj_strbuf(&req.method.name));
 
    AST_LIST_TRAVERSE(&session->supplements, supplement, next) {
        if (supplement->incoming_request && does_method_match(&req.method.name, supplement->method)) {
            if (supplement->incoming_request(session, rdata)) {
                break;
            }
        }
    }
 
    SCOPE_EXIT("%s\n", ast_sip_session_get_name(session));
}

References AST_LIST_TRAVERSE, ast_sip_session_get_name(), does_method_match(), ast_sip_session_supplement::incoming_request, ast_sip_session_supplement::method, SCOPE_ENTER, SCOPE_EXIT, and session.

Referenced by handle_incoming(), and new_invite().

◆ handle_incoming_response()

static void handle_incoming_response	(	struct ast_sip_session *	session,
		pjsip_rx_data *	rdata,
		enum ast_sip_session_response_priority	response_priority
	)

static

Definition at line 4558 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *supplement;
    struct pjsip_status_line status = rdata->msg_info.msg->line.status;
    SCOPE_ENTER(3, "%s: Response is %d %.*s\n", ast_sip_session_get_name(session),
        status.code, (int) pj_strlen(&status.reason), pj_strbuf(&status.reason));
 
    AST_LIST_TRAVERSE(&session->supplements, supplement, next) {
        if (!(supplement->response_priority & response_priority)) {
            continue;
        }
        if (supplement->incoming_response && does_method_match(&rdata->msg_info.cseq->method.name, supplement->method)) {
            supplement->incoming_response(session, rdata);
        }
    }
 
    SCOPE_EXIT("%s\n", ast_sip_session_get_name(session));
}

References AST_LIST_TRAVERSE, ast_sip_session_get_name(), does_method_match(), ast_sip_session_supplement::incoming_response, ast_sip_session_supplement::method, ast_sip_session_supplement::response_priority, SCOPE_ENTER, SCOPE_EXIT, session, and status.

Referenced by handle_incoming().

◆ handle_incoming_sdp()

static int handle_incoming_sdp	(	struct ast_sip_session *	session,
		const pjmedia_sdp_session *	sdp
	)

static

Definition at line 788 of file res_pjsip_session.c.

{
    int i;
    int handled = 0;
    int type_streams[AST_MEDIA_TYPE_END] = {0};
    SCOPE_ENTER(3, "%s: Media count: %d\n", ast_sip_session_get_name(session), sdp->media_count);
 
    if (session->inv_session && session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
        SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Failed to handle incoming SDP. Session has been already disconnected\n",
            ast_sip_session_get_name(session));
    }
 
    /* It is possible for SDP deferral to have already created a pending topology */
    if (!session->pending_media_state->topology) {
        session->pending_media_state->topology = ast_stream_topology_alloc();
        if (!session->pending_media_state->topology) {
            SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Couldn't alloc pending topology\n",
                ast_sip_session_get_name(session));
        }
    }
 
    for (i = 0; i < sdp->media_count; ++i) {
        /* See if there are registered handlers for this media stream type */
        char media[20];
        struct ast_sip_session_sdp_handler *handler;
        RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
        struct ast_sip_session_media *session_media = NULL;
        int res;
        int bundle_only;
        enum ast_media_type type;
        struct ast_stream *stream = NULL;
        pjmedia_sdp_media *remote_stream = sdp->media[i];
        SCOPE_ENTER(4, "%s: Processing stream %d\n", ast_sip_session_get_name(session), i);
 
        /* We need a null-terminated version of the media string */
        ast_copy_pj_str(media, &sdp->media[i]->desc.media, sizeof(media));
        type = ast_media_type_from_str(media);
 
        /* See if we have an already existing stream, which can occur from SDP deferral checking */
        if (i < ast_stream_topology_get_count(session->pending_media_state->topology)) {
            stream = ast_stream_topology_get_stream(session->pending_media_state->topology, i);
            ast_trace(-1, "%s: Using existing pending stream %s\n", ast_sip_session_get_name(session),
                ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
        if (!stream) {
            struct ast_stream *existing_stream = NULL;
            char *stream_name = NULL, *stream_name_allocated = NULL;
            const char *stream_label = NULL;
 
            if (session->active_media_state->topology &&
                (i < ast_stream_topology_get_count(session->active_media_state->topology))) {
                existing_stream = ast_stream_topology_get_stream(session->active_media_state->topology, i);
                ast_trace(-1, "%s: Found existing active stream %s\n", ast_sip_session_get_name(session),
                    ast_str_tmp(128, ast_stream_to_str(existing_stream, &STR_TMP)));
 
                if (ast_stream_get_state(existing_stream) != AST_STREAM_STATE_REMOVED) {
                    stream_name = (char *)ast_stream_get_name(existing_stream);
                    stream_label = ast_stream_get_metadata(existing_stream, "SDP:LABEL");
                }
            }
 
            if (ast_strlen_zero(stream_name)) {
                if (ast_asprintf(&stream_name_allocated, "%s-%d", ast_codec_media_type2str(type), i) < 0) {
                    handled = 0;
                    SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't alloc stream name\n",
                         ast_sip_session_get_name(session));
 
                }
                stream_name = stream_name_allocated;
                ast_trace(-1, "%s: Using %s for new stream name\n", ast_sip_session_get_name(session),
                    stream_name);
            }
 
            stream = ast_stream_alloc(stream_name, type);
            ast_free(stream_name_allocated);
            if (!stream) {
                handled = 0;
                SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't alloc stream\n",
                     ast_sip_session_get_name(session));
            }
 
            if (!ast_strlen_zero(stream_label)) {
                ast_stream_set_metadata(stream, "SDP:LABEL", stream_label);
                ast_trace(-1, "%s: Using %s for new stream label\n", ast_sip_session_get_name(session),
                    stream_label);
 
            }
 
            if (ast_stream_topology_set_stream(session->pending_media_state->topology, i, stream)) {
                ast_stream_free(stream);
                handled = 0;
                SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't set stream in topology\n",
                     ast_sip_session_get_name(session));
            }
 
            /* For backwards compatibility with the core the default audio stream is always sendrecv */
            if (!ast_sip_session_is_pending_stream_default(session, stream) || strcmp(media, "audio")) {
                if (pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL)) {
                    /* Stream state reflects our state of a stream, so in the case of
                     * sendonly and recvonly we store the opposite since that is what ours
                     * is.
                     */
                    ast_stream_set_state(stream, AST_STREAM_STATE_RECVONLY);
                } else if (pjmedia_sdp_media_find_attr2(remote_stream, "recvonly", NULL)) {
                    ast_stream_set_state(stream, AST_STREAM_STATE_SENDONLY);
                } else if (pjmedia_sdp_media_find_attr2(remote_stream, "inactive", NULL)) {
                    ast_stream_set_state(stream, AST_STREAM_STATE_INACTIVE);
                } else {
                    ast_stream_set_state(stream, AST_STREAM_STATE_SENDRECV);
                }
            } else {
                ast_stream_set_state(stream, AST_STREAM_STATE_SENDRECV);
            }
            ast_trace(-1, "%s: Using new stream %s\n", ast_sip_session_get_name(session),
                ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
 
        session_media = ast_sip_session_media_state_add(session, session->pending_media_state, ast_media_type_from_str(media), i);
        if (!session_media) {
            SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't alloc session media\n",
                 ast_sip_session_get_name(session));
        }
 
        /* MID and BUNDLE membership must be known before interpreting a zero port. */
        set_mid_and_bundle_group(session, session_media, sdp, remote_stream);
        bundle_only = is_bundle_only_stream(session_media, remote_stream);
 
        /* A zero port normally declines a stream. RFC 9143 defines an exception
         * for a bundled stream carrying the bundle-only attribute.
         */
        if ((!remote_stream->desc.port && !bundle_only)
            || is_stream_limitation_reached(type, session->endpoint, type_streams)) {
            remove_stream_from_bundle(session_media, stream);
            SCOPE_EXIT_EXPR(continue, "%s: Declining incoming SDP media stream %s'\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
 
        if (bundle_only) {
            ast_trace(-1, "%s: Accepting zero-port bundle-only SDP media stream %s\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
 
        set_remote_mslabel_and_stream_group(session, session_media, sdp, remote_stream, stream);
 
        if (session_media->handler) {
            handler = session_media->handler;
            ast_trace(-1, "%s: Negotiating incoming SDP media stream %s using %s SDP handler\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                session_media->handler->id);
            res = handler->negotiate_incoming_sdp_stream(session, session_media, sdp, i, stream);
            if (res < 0) {
                /* Catastrophic failure. Abort! */
                SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't negotiate stream %s\n",
                     ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
            } else if (res == 0) {
                remove_stream_from_bundle(session_media, stream);
                SCOPE_EXIT_EXPR(continue, "%s: Declining incoming SDP media stream %s\n",
                    ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
            } else if (res > 0) {
                handled = 1;
                ++type_streams[type];
                /* Handled by this handler. Move to the next stream */
                SCOPE_EXIT_EXPR(continue, "%s: Media stream %s handled by %s\n",
                    ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                    session_media->handler->id);
            }
        }
 
        handler_list = ao2_find(sdp_handlers, media, OBJ_KEY);
        if (!handler_list) {
            SCOPE_EXIT_EXPR(continue, "%s: Media stream %s has no registered handlers\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
        }
        AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
            if (handler == session_media->handler) {
                continue;
            }
            ast_trace(-1, "%s: Negotiating incoming SDP media stream %s using %s SDP handler\n",
                ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                handler->id);
 
            res = handler->negotiate_incoming_sdp_stream(session, session_media, sdp, i, stream);
            if (res < 0) {
                /* Catastrophic failure. Abort! */
                handled = 0;
                SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Couldn't negotiate stream %s\n",
                     ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
            } else if (res == 0) {
                remove_stream_from_bundle(session_media, stream);
                ast_trace(-1, "%s: Declining incoming SDP media stream %s\n",
                    ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
                continue;
            } else if (res > 0) {
                session_media_set_handler(session_media, handler);
                handled = 1;
                ++type_streams[type];
                ast_trace(-1, "%s: Media stream %s handled by %s\n",
                    ast_sip_session_get_name(session), ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)),
                    session_media->handler->id);
                break;
            }
        }
 
        SCOPE_EXIT("%s: Done with stream %s\n", ast_sip_session_get_name(session),
            ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
    }
 
end:
    SCOPE_EXIT_RTN_VALUE(handled ? 0 : -1, "%s: Handled? %s\n", ast_sip_session_get_name(session),
        handled ? "yes" : "no");
}

References ao2_cleanup, ao2_find, ast_asprintf, ast_codec_media_type2str(), ast_copy_pj_str(), ast_free, AST_LIST_TRAVERSE, AST_MEDIA_TYPE_END, ast_media_type_from_str(), ast_sip_session_get_name(), ast_sip_session_is_pending_stream_default(), ast_sip_session_media_state_add(), ast_str_tmp, ast_stream_alloc(), ast_stream_free(), ast_stream_get_metadata(), ast_stream_get_name(), ast_stream_get_state(), ast_stream_set_metadata(), ast_stream_set_state(), AST_STREAM_STATE_INACTIVE, AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_REMOVED, AST_STREAM_STATE_SENDONLY, AST_STREAM_STATE_SENDRECV, ast_stream_to_str(), ast_stream_topology_alloc(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_set_stream(), ast_strlen_zero(), ast_trace, end, ast_sip_session_media::handler, handler(), ast_sip_session_sdp_handler::id, is_bundle_only_stream(), is_stream_limitation_reached(), LOG_ERROR, NULL, OBJ_KEY, RAII_VAR, remove_stream_from_bundle(), SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_EXPR, SCOPE_EXIT_LOG_EXPR, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, sdp_handlers, session, session_media_set_handler(), set_mid_and_bundle_group(), set_remote_mslabel_and_stream_group(), and type.

Referenced by new_invite(), and session_inv_on_rx_offer().

◆ handle_negotiated_sdp()

static int handle_negotiated_sdp	(	struct ast_sip_session *	session,
		const pjmedia_sdp_session *	local,
		const pjmedia_sdp_session *	remote
	)

static

Definition at line 1099 of file res_pjsip_session.c.

{
    int i;
    struct ast_stream_topology *topology;
    unsigned int changed = 0; /* 0 = unchanged, 1 = new source, 2 = new topology */
    SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
 
    if (!session->pending_media_state->topology) {
        if (session->active_media_state->topology) {
            /*
             * This happens when we have negotiated media after receiving a 183,
             * and we're now receiving a 200 with a new SDP.  In this case, there
             * is active_media_state, but the pending_media_state has been reset.
             */
            struct ast_sip_session_media_state *active_media_state_clone;
 
            active_media_state_clone =
                ast_sip_session_media_state_clone(session->active_media_state);
            if (!active_media_state_clone) {
                ast_log(LOG_WARNING, "%s: Unable to clone active media state\n",
                    ast_sip_session_get_name(session));
                return -1;
            }
 
            ast_sip_session_media_state_free(session->pending_media_state);
            session->pending_media_state = active_media_state_clone;
        } else {
            ast_log(LOG_WARNING, "%s: No pending or active media state\n",
                ast_sip_session_get_name(session));
            return -1;
        }
    }
 
    /* If we're handling negotiated streams, then we should already have set
     * up session media instances (and Asterisk streams) that correspond to
     * the local SDP, and there should be the same number of session medias
     * and streams as there are local SDP streams
     */
    if (ast_stream_topology_get_count(session->pending_media_state->topology) != local->media_count
        || AST_VECTOR_SIZE(&session->pending_media_state->sessions) != local->media_count) {
        ast_log(LOG_WARNING, "%s: Local SDP contains %d media streams while we expected it to contain %u\n",
            ast_sip_session_get_name(session),
            ast_stream_topology_get_count(session->pending_media_state->topology), local->media_count);
        SCOPE_EXIT_RTN_VALUE(-1, "Media stream count mismatch\n");
    }
 
    AST_VECTOR_RESET(&session->pending_media_state->read_callbacks, AST_VECTOR_ELEM_CLEANUP_NOOP);
 
    for (i = 0; i < local->media_count; ++i) {
        struct ast_sip_session_media *session_media;
        struct ast_stream *stream;
 
        if (!remote->media[i]) {
            continue;
        }
 
        session_media = AST_VECTOR_GET(&session->pending_media_state->sessions, i);
        stream = ast_stream_topology_get_stream(session->pending_media_state->topology, i);
 
        /* Make sure that this stream is in the correct state. If we need to change
         * the state to REMOVED, then our work here is done, so go ahead and move on
         * to the next stream.
         */
        /*
         * A zero port in a remote answer declines the stream.  In an offer,
         * however, RFC 9143 permits a bundled stream to use port zero together
         * with a=bundle-only.  In that case, keep the stream if our local answer
         * accepted it with a non-zero port.
         */
        if (!local->media[i]->desc.port
            || (!remote->media[i]->desc.port
                && !is_bundle_only_stream(session_media, remote->media[i]))) {
            ast_stream_set_state(stream, AST_STREAM_STATE_REMOVED);
            continue;
        }
 
        /* If the stream state is REMOVED, nothing needs to be done, so move on to the
         * next stream. This can occur if an internal thing has requested it to be
         * removed, or if we remove it as a result of the stream limit being reached.
         */
        if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
            /*
             * Defer removing the handler until we are ready to activate
             * the new topology.  The channel's thread may still be using
             * the stream and we could crash before we are ready.
             */
            continue;
        }
 
        if (handle_negotiated_sdp_session_media(session_media, session, local, remote, i, stream)) {
            SCOPE_EXIT_RTN_VALUE(-1, "Unable to handle negotiated session media\n");
        }
 
        changed |= session_media->changed;
        session_media->changed = 0;
    }
 
    /* Apply the pending media state to the channel and make it active */
    ast_channel_lock(session->channel);
 
    /* Now update the stream handler for any declined/removed streams */
    for (i = 0; i < local->media_count; ++i) {
        struct ast_sip_session_media *session_media;
        struct ast_stream *stream;
 
        if (!remote->media[i]) {
            continue;
        }
 
        session_media = AST_VECTOR_GET(&session->pending_media_state->sessions, i);
        stream = ast_stream_topology_get_stream(session->pending_media_state->topology, i);
 
        if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED
            && session_media->handler) {
            /*
             * This stream is no longer being used and the channel's thread
             * is held off because we have the channel lock so release any
             * resources the handler may have on it.
             */
            session_media_set_handler(session_media, NULL);
        }
    }
 
    /* Update the topology on the channel to match the accepted one */
    topology = ast_stream_topology_clone(session->pending_media_state->topology);
    if (topology) {
        ast_channel_set_stream_topology(session->channel, topology);
        /* If this is a remotely done renegotiation that has changed the stream topology notify what is
         * currently handling this channel. Note that fax uses its own process, so if we are transitioning
         * between audio and fax or vice versa we don't notify.
         */
        if (pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE &&
            session->active_media_state && session->active_media_state->topology &&
            !ast_stream_topology_equal(session->active_media_state->topology, topology) &&
            !session->active_media_state->default_session[AST_MEDIA_TYPE_IMAGE] &&
            !session->pending_media_state->default_session[AST_MEDIA_TYPE_IMAGE]) {
            changed = 2;
        }
    }
 
    /* Remove all current file descriptors from the channel */
    for (i = 0; i < AST_VECTOR_SIZE(&session->active_media_state->read_callbacks); ++i) {
        ast_channel_internal_fd_clear(session->channel, i + AST_EXTENDED_FDS);
    }
 
    /* Add all the file descriptors from the pending media state */
    for (i = 0; i < AST_VECTOR_SIZE(&session->pending_media_state->read_callbacks); ++i) {
        struct ast_sip_session_media_read_callback_state *callback_state;
 
        callback_state = AST_VECTOR_GET_ADDR(&session->pending_media_state->read_callbacks, i);
        ast_channel_internal_fd_set(session->channel, i + AST_EXTENDED_FDS, callback_state->fd);
    }
 
    /* Active and pending flip flop as needed */
    ast_sip_session_media_stats_save(session, session->active_media_state);
    SWAP(session->active_media_state, session->pending_media_state);
    ast_sip_session_media_state_reset(session->pending_media_state);
 
    ast_channel_unlock(session->channel);
 
    if (changed == 1) {
        struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED };
 
        ast_queue_frame(session->channel, &f);
    } else if (changed == 2) {
        ast_channel_stream_topology_changed_externally(session->channel);
    } else {
        ast_queue_frame(session->channel, &ast_null_frame);
    }
 
    SCOPE_EXIT_RTN_VALUE(0);
}

References ast_channel_internal_fd_clear(), ast_channel_internal_fd_set(), ast_channel_lock, ast_channel_set_stream_topology(), ast_channel_stream_topology_changed_externally(), ast_channel_unlock, AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED, AST_EXTENDED_FDS, AST_FRAME_CONTROL, ast_log, AST_MEDIA_TYPE_IMAGE, ast_null_frame, ast_queue_frame(), ast_sip_session_get_name(), ast_sip_session_media_state_clone(), ast_sip_session_media_state_free(), ast_sip_session_media_state_reset(), ast_sip_session_media_stats_save(), ast_stream_get_state(), ast_stream_set_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_clone(), ast_stream_topology_equal(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_VECTOR_ELEM_CLEANUP_NOOP, AST_VECTOR_GET, AST_VECTOR_GET_ADDR, AST_VECTOR_RESET, AST_VECTOR_SIZE, ast_sip_session_media::changed, ast_sip_session_media_read_callback_state::fd, handle_negotiated_sdp_session_media(), ast_sip_session_media::handler, ast_frame_subclass::integer, is_bundle_only_stream(), LOG_WARNING, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, session_media_set_handler(), ast_frame::subclass, and SWAP.

Referenced by session_inv_on_media_update().

◆ handle_negotiated_sdp_session_media()

static int handle_negotiated_sdp_session_media	(	struct ast_sip_session_media *	session_media,
		struct ast_sip_session *	session,
		const pjmedia_sdp_session *	local,
		const pjmedia_sdp_session *	remote,
		int	index,
		struct ast_stream *	asterisk_stream
	)

static

Definition at line 1000 of file res_pjsip_session.c.

{
    /* See if there are registered handlers for this media stream type */
    struct pjmedia_sdp_media *local_stream = local->media[index];
    char media[20];
    struct ast_sip_session_sdp_handler *handler;
    RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
    int res;
    SCOPE_ENTER(1, "%s\n", session ? ast_sip_session_get_name(session) : "unknown");
 
    /* We need a null-terminated version of the media string */
    ast_copy_pj_str(media, &local->media[index]->desc.media, sizeof(media));
 
    /* For backwards compatibility we only reflect the stream state correctly on
     * the non-default streams and any non-audio streams. This is because the stream
     * state of the default audio stream is also used for signaling that someone has
     * placed us on hold. This situation is not handled currently and can result in
     * the remote side being sorted of placed on hold too.
     */
    if (!ast_sip_session_is_pending_stream_default(session, asterisk_stream) || strcmp(media, "audio")) {
        /* Determine the state of the stream based on our local SDP */
        if (pjmedia_sdp_media_find_attr2(local_stream, "sendonly", NULL)) {
            ast_stream_set_state(asterisk_stream, AST_STREAM_STATE_SENDONLY);
        } else if (pjmedia_sdp_media_find_attr2(local_stream, "recvonly", NULL)) {
            ast_stream_set_state(asterisk_stream, AST_STREAM_STATE_RECVONLY);
        } else if (pjmedia_sdp_media_find_attr2(local_stream, "inactive", NULL)) {
            ast_stream_set_state(asterisk_stream, AST_STREAM_STATE_INACTIVE);
        } else {
            ast_stream_set_state(asterisk_stream, AST_STREAM_STATE_SENDRECV);
        }
    } else {
        ast_stream_set_state(asterisk_stream, AST_STREAM_STATE_SENDRECV);
    }
 
    set_mid_and_bundle_group(session, session_media, remote, remote->media[index]);
    set_remote_mslabel_and_stream_group(session, session_media, remote, remote->media[index], asterisk_stream);
 
    handler = session_media->handler;
    if (handler) {
        ast_debug(4, "%s: Applying negotiated SDP media stream '%s' using %s SDP handler\n",
            ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
            handler->id);
        res = handler->apply_negotiated_sdp_stream(session, session_media, local, remote, index, asterisk_stream);
        if (res >= 0) {
            ast_debug(4, "%s: Applied negotiated SDP media stream '%s' using %s SDP handler\n",
                ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
                handler->id);
            SCOPE_EXIT_RTN_VALUE(0,  "%s: Applied negotiated SDP media stream '%s' using %s SDP handler\n",
                ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
                handler->id);
        }
        SCOPE_EXIT_RTN_VALUE(-1,  "%s: Failed to apply negotiated SDP media stream '%s' using %s SDP handler\n",
            ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
            handler->id);
    }
 
    handler_list = ao2_find(sdp_handlers, media, OBJ_KEY);
    if (!handler_list) {
        ast_debug(4, "%s: No registered SDP handlers for media type '%s'\n", ast_sip_session_get_name(session), media);
        return -1;
    }
    AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
        if (handler == session_media->handler) {
            continue;
        }
        ast_debug(4, "%s: Applying negotiated SDP media stream '%s' using %s SDP handler\n",
            ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
            handler->id);
        res = handler->apply_negotiated_sdp_stream(session, session_media, local, remote, index, asterisk_stream);
        if (res < 0) {
            /* Catastrophic failure. Abort! */
            SCOPE_EXIT_RTN_VALUE(-1, "%s: Handler '%s' returned %d\n",
                ast_sip_session_get_name(session), handler->id, res);
        }
        if (res > 0) {
            ast_debug(4, "%s: Applied negotiated SDP media stream '%s' using %s SDP handler\n",
                ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
                handler->id);
            /* Handled by this handler. Move to the next stream */
            session_media_set_handler(session_media, handler);
            SCOPE_EXIT_RTN_VALUE(0, "%s: Handler '%s' handled this sdp stream\n",
                ast_sip_session_get_name(session), handler->id);
        }
    }
 
    res = 0;
    if (session_media->handler && session_media->handler->stream_stop) {
        ast_debug(4, "%s: Stopping SDP media stream '%s' as it is not currently negotiated\n",
            ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type));
        session_media->handler->stream_stop(session_media);
    }
 
    SCOPE_EXIT_RTN_VALUE(0, "%s: Media type '%s' %s\n",
        ast_sip_session_get_name(session), ast_codec_media_type2str(session_media->type),
        res ? "not negotiated.  Stopped" : "handled");
}

References ao2_cleanup, ao2_find, ast_codec_media_type2str(), ast_copy_pj_str(), ast_debug, AST_LIST_TRAVERSE, ast_sip_session_get_name(), ast_sip_session_is_pending_stream_default(), ast_stream_set_state(), AST_STREAM_STATE_INACTIVE, AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_SENDONLY, AST_STREAM_STATE_SENDRECV, ast_sip_session_media::handler, handler(), ast_sip_session_sdp_handler::next, NULL, OBJ_KEY, RAII_VAR, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, sdp_handlers, session, session_media_set_handler(), set_mid_and_bundle_group(), set_remote_mslabel_and_stream_group(), ast_sip_session_sdp_handler::stream_stop, and ast_sip_session_media::type.

Referenced by handle_negotiated_sdp().

◆ handle_new_invite_request()

static void handle_new_invite_request ( pjsip_rx_data * rdata )

static

Definition at line 4147 of file res_pjsip_session.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint,
            ast_pjsip_rdata_get_endpoint(rdata), ao2_cleanup);
    pjsip_inv_session *inv_session = NULL;
    struct ast_sip_session *session;
    struct new_invite invite;
    char *req_uri = TRACE_ATLEAST(1) ? ast_alloca(256) : "";
    int res = TRACE_ATLEAST(1) ? pjsip_uri_print(PJSIP_URI_IN_REQ_URI, rdata->msg_info.msg->line.req.uri, req_uri, 256) : 0;
    SCOPE_ENTER(1, "Request: %s\n", res ? req_uri : "");
 
    ast_assert(endpoint != NULL);
 
    inv_session = pre_session_setup(rdata, endpoint);
    if (!inv_session) {
        /* pre_session_setup() returns a response on failure */
        SCOPE_EXIT_RTN("Failure in pre session setup\n");
    }
 
    /*
     * Upon a successful pre_session_setup the associated dialog is returned locked
     * and with an added reference. Well actually two references. One added when the
     * dialog itself was created, and another added when the pjsip invite session was
     * created and the dialog was added to it.
     *
     * In order to ensure the dialog's, and any of its internal attributes, lifetimes
     * we'll hold the lock and maintain the reference throughout the entire new invite
     * handling process. See ast_sip_create_dialog_uas_locked for more details but,
     * basically we do this to make sure a transport failure does not destroy the dialog
     * and/or transaction out from underneath us between pjsip calls. Alternatively, we
     * could probably release the lock if we needed to, but then we'd have to re-lock and
     * check the dialog and transaction prior to every pjsip call.
     *
     * That means any off nominal/failure paths in this function must remove the associated
     * dialog reference added at dialog creation, and remove the lock. As well the
     * referenced pjsip invite session must be "cleaned up", which should also then
     * remove its reference to the dialog at that time.
     *
     * Nominally we'll unlock the dialog, and release the reference when all new invite
     * process handling has successfully completed.
     */
 
    session = ast_sip_session_alloc(endpoint, NULL, inv_session, rdata);
    if (!session) {
        /* Dialog's lock and reference are removed in new_invite_initial_answer */
        if (!new_invite_initial_answer(inv_session, rdata, 500, 500, PJ_FALSE)) {
            /* Terminate the session if it wasn't done in the answer */
            pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
        }
        SCOPE_EXIT_RTN("Couldn't create session\n");
    }
    session->call_direction = AST_SIP_SESSION_INCOMING_CALL;
 
    /*
     * The current thread is supposed be the session serializer to prevent
     * any initial INVITE retransmissions from trying to setup the same
     * call again.
     */
    ast_assert(ast_taskprocessor_is_task(session->serializer));
 
    invite.session = session;
    invite.rdata = rdata;
    new_invite(&invite);
 
    /*
     * The dialog lock and reference added at dialog creation time must be
     * maintained throughout the new invite process. Since we're pretty much
     * done at this point with things it's safe to go ahead and remove the lock
     * and the reference here. See ast_sip_create_dialog_uas_locked for more info.
     *
     * Note, any future functionality added that does work using the dialog must
     * be done before this.
     */
    pjsip_dlg_dec_lock(inv_session->dlg);
 
    SCOPE_EXIT("Request: %s Session: %s\n", req_uri, ast_sip_session_get_name(session));
    ao2_ref(session, -1);
}

References ao2_cleanup, ao2_ref, ast_alloca, ast_assert, ast_pjsip_rdata_get_endpoint(), ast_sip_session_alloc(), ast_sip_session_get_name(), AST_SIP_SESSION_INCOMING_CALL, ast_taskprocessor_is_task(), ast_sip_session::endpoint, ast_sip_session::inv_session, new_invite_initial_answer(), NULL, pre_session_setup(), RAII_VAR, new_invite::rdata, SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_RTN, new_invite::session, session, and TRACE_ATLEAST.

Referenced by session_on_rx_request().

◆ handle_outgoing_request()

static void handle_outgoing_request	(	struct ast_sip_session *	session,
		pjsip_tx_data *	tdata
	)

static

Definition at line 4590 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *supplement;
    struct pjsip_request_line req = tdata->msg->line.req;
    SCOPE_ENTER(3, "%s: Method is %.*s\n", ast_sip_session_get_name(session),
        (int) pj_strlen(&req.method.name), pj_strbuf(&req.method.name));
 
    ast_sip_message_apply_transport(session->endpoint->transport, tdata);
 
    AST_LIST_TRAVERSE(&session->supplements, supplement, next) {
        if (supplement->outgoing_request && does_method_match(&req.method.name, supplement->method)) {
            supplement->outgoing_request(session, tdata);
        }
    }
    SCOPE_EXIT("%s\n", ast_sip_session_get_name(session));
}

References AST_LIST_TRAVERSE, ast_sip_message_apply_transport(), ast_sip_session_get_name(), does_method_match(), ast_sip_session_supplement::method, ast_sip_session_supplement::outgoing_request, SCOPE_ENTER, SCOPE_EXIT, and session.

Referenced by ast_sip_session_send_request_with_cb().

◆ handle_outgoing_response()

static void handle_outgoing_response	(	struct ast_sip_session *	session,
		pjsip_tx_data *	tdata
	)

static

Definition at line 4607 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *supplement;
    struct pjsip_status_line status = tdata->msg->line.status;
    pjsip_cseq_hdr *cseq = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL);
    SCOPE_ENTER(3, "%s: Method is %.*s, Response is %d %.*s\n", ast_sip_session_get_name(session),
        (int) pj_strlen(&cseq->method.name),
        pj_strbuf(&cseq->method.name), status.code, (int) pj_strlen(&status.reason),
        pj_strbuf(&status.reason));
 
 
    if (!cseq) {
        SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: Cannot send response due to missing sequence header",
            ast_sip_session_get_name(session));
    }
 
    ast_sip_message_apply_transport(session->endpoint->transport, tdata);
 
    AST_LIST_TRAVERSE(&session->supplements, supplement, next) {
        if (supplement->outgoing_response && does_method_match(&cseq->method.name, supplement->method)) {
            supplement->outgoing_response(session, tdata);
        }
    }
 
    SCOPE_EXIT("%s\n", ast_sip_session_get_name(session));
}

References AST_LIST_TRAVERSE, ast_sip_message_apply_transport(), ast_sip_session_get_name(), does_method_match(), LOG_ERROR, ast_sip_session_supplement::method, NULL, ast_sip_session_supplement::outgoing_response, SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_LOG_RTN, session, and status.

Referenced by ast_sip_session_send_response(), and session_on_tx_response().

◆ handle_session_begin()

static void handle_session_begin ( struct ast_sip_session * session )

static

Definition at line 4524 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
 
    AST_LIST_TRAVERSE(&session->supplements, iter, next) {
        if (iter->session_begin) {
            iter->session_begin(session);
        }
    }
}

References AST_LIST_TRAVERSE, ast_sip_session_supplement::next, session, and ast_sip_session_supplement::session_begin.

Referenced by ast_sip_session_alloc().

◆ handle_session_destroy()

static void handle_session_destroy ( struct ast_sip_session * session )

static

Definition at line 4535 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
 
    AST_LIST_TRAVERSE(&session->supplements, iter, next) {
        if (iter->session_destroy) {
            iter->session_destroy(session);
        }
    }
}

References AST_LIST_TRAVERSE, ast_sip_session_supplement::next, session, and ast_sip_session_supplement::session_destroy.

Referenced by session_destructor().

◆ handle_session_end()

static void handle_session_end ( struct ast_sip_session * session )

static

Definition at line 4546 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
 
    /* Session is dead.  Notify the supplements. */
    AST_LIST_TRAVERSE(&session->supplements, iter, next) {
        if (iter->session_end) {
            iter->session_end(session);
        }
    }
}

References AST_LIST_TRAVERSE, ast_sip_session_supplement::next, session, and ast_sip_session_supplement::session_end.

Referenced by session_end().

◆ has_supplement()

static pj_bool_t has_supplement	(	const struct ast_sip_session *	session,
		const pjsip_rx_data *	rdata
	)

static

Definition at line 4239 of file res_pjsip_session.c.

{
    struct ast_sip_session_supplement *supplement;
    struct pjsip_method *method = &rdata->msg_info.msg->line.req.method;
 
    if (!session) {
        return PJ_FALSE;
    }
 
    AST_LIST_TRAVERSE(&session->supplements, supplement, next) {
        if (does_method_match(&method->name, supplement->method)) {
            return PJ_TRUE;
        }
    }
    return PJ_FALSE;
}

References AST_LIST_TRAVERSE, does_method_match(), ast_sip_session_supplement::method, method, and session.

Referenced by session_on_rx_request().

◆ internal_sip_session_media_state_alloc()

static struct ast_sip_session_media_state * internal_sip_session_media_state_alloc	(	size_t	sessions,
		size_t	read_callbacks
	)

static

Definition at line 223 of file res_pjsip_session.c.

{
    struct ast_sip_session_media_state *media_state;
 
    media_state = ast_calloc(1, sizeof(*media_state));
    if (!media_state) {
        return NULL;
    }
 
    if (AST_VECTOR_INIT(&media_state->sessions, sessions) < 0) {
        ast_free(media_state);
        return NULL;
    }
 
    if (AST_VECTOR_INIT(&media_state->read_callbacks, read_callbacks) < 0) {
        AST_VECTOR_FREE(&media_state->sessions);
        ast_free(media_state);
        return NULL;
    }
 
    return media_state;
}

References ast_calloc, ast_free, AST_VECTOR_FREE, AST_VECTOR_INIT, NULL, ast_sip_session_media_state::read_callbacks, sessions, and ast_sip_session_media_state::sessions.

Referenced by ast_sip_session_media_state_alloc(), and ast_sip_session_media_state_clone().

◆ invite_collision_timeout()

static int invite_collision_timeout ( void * vsession )

static

Definition at line 1599 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
    int res;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (session->inv_session->invite_tsx) {
        /*
         * INVITE transaction still active.  Let it send
         * the collision re-INVITE when it terminates.
         */
        ao2_ref(session, -1);
        res = 0;
    } else {
        res = invite_terminated(session);
    }
 
    SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_sip_session_get_name(session));
}

References ao2_ref, ast_sip_session_get_name(), invite_terminated(), SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, and session.

Referenced by resend_reinvite().

◆ invite_proceeding()

static int invite_proceeding ( void * vsession )

static

Definition at line 1501 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
    struct ast_sip_session_delayed_request *delay;
    int found = 0;
    int res = 0;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&session->delayed_requests, delay, next) {
        switch (delay->method) {
        case DELAYED_METHOD_INVITE:
            break;
        case DELAYED_METHOD_UPDATE:
            AST_LIST_REMOVE_CURRENT(next);
            ast_trace(-1, "%s: Sending delayed %s request\n", ast_sip_session_get_name(session),
                delayed_method2str(delay->method));
            res = send_delayed_request(session, delay);
            delayed_request_free(delay);
            if (!res) {
                found = 1;
            }
            break;
        case DELAYED_METHOD_BYE:
            /* A BYE is pending so don't bother anymore. */
            found = 1;
            break;
        }
        if (found) {
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    ao2_ref(session, -1);
    SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_sip_session_get_name(session));
}

References ao2_ref, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_sip_session_get_name(), ast_trace, delayed_method2str(), DELAYED_METHOD_BYE, DELAYED_METHOD_INVITE, DELAYED_METHOD_UPDATE, delayed_request_free(), ast_sip_session_delayed_request::method, ast_sip_session_delayed_request::next, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, send_delayed_request(), and session.

Referenced by session_inv_on_tsx_state_changed(), and update_completed().

◆ invite_terminated()

static int invite_terminated ( void * vsession )

static

Definition at line 1548 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
    struct ast_sip_session_delayed_request *delay;
    int found = 0;
    int res = 0;
    int timer_running;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    /* re-INVITE collision timer running? */
    timer_running = pj_timer_entry_running(&session->rescheduled_reinvite);
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&session->delayed_requests, delay, next) {
        switch (delay->method) {
        case DELAYED_METHOD_INVITE:
            if (!timer_running) {
                found = 1;
            }
            break;
        case DELAYED_METHOD_UPDATE:
        case DELAYED_METHOD_BYE:
            found = 1;
            break;
        }
        if (found) {
            AST_LIST_REMOVE_CURRENT(next);
            ast_trace(-1, "%s: Sending delayed %s request\n", ast_sip_session_get_name(session),
                delayed_method2str(delay->method));
            res = send_delayed_request(session, delay);
            delayed_request_free(delay);
            if (!res) {
                break;
            }
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    ao2_ref(session, -1);
    SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_sip_session_get_name(session));
}

References ao2_ref, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_sip_session_get_name(), ast_trace, delayed_method2str(), DELAYED_METHOD_BYE, DELAYED_METHOD_INVITE, DELAYED_METHOD_UPDATE, delayed_request_free(), ast_sip_session_delayed_request::method, ast_sip_session_delayed_request::next, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, send_delayed_request(), and session.

Referenced by invite_collision_timeout(), session_inv_on_tsx_state_changed(), and update_completed().

◆ is_bundle_only_stream()

static int is_bundle_only_stream	(	const struct ast_sip_session_media *	session_media,
		const struct pjmedia_sdp_media *	stream
	)

static

Determine whether a zero-port stream is offered for BUNDLE-only use.

RFC 9143 permits an offerer to use a zero port together with the bundle-only attribute when the stream is to be accepted only as part of the associated BUNDLE group. A zero port without these conditions still means that the stream is disabled.

Definition at line 781 of file res_pjsip_session.c.

{
    return !stream->desc.port && session_media->bundled
        && pjmedia_sdp_media_find_attr2(stream, "bundle-only", NULL);
}

References ast_sip_session_media::bundled, and NULL.

Referenced by handle_incoming_sdp(), and handle_negotiated_sdp().

◆ is_media_state_valid()

static int is_media_state_valid	(	const char *	session_name,
		struct ast_sip_session_media_state *	state
	)

static

Definition at line 1864 of file res_pjsip_session.c.

{
    int stream_count = ast_stream_topology_get_count(state->topology);
    int session_count = AST_VECTOR_SIZE(&state->sessions);
    int i;
    int res = 0;
    SCOPE_ENTER(3, "%s: Topology: %s\n", session_name,
        ast_str_tmp(256, ast_stream_topology_to_str(state->topology, &STR_TMP)));
 
    if (session_count != stream_count) {
        SCOPE_EXIT_RTN_VALUE(0, "%s: %d media sessions but %d streams\n", session_name,
            session_count, stream_count);
    }
 
    for (i = 0; i < stream_count; i++) {
        struct ast_sip_session_media *media = NULL;
        struct ast_stream *stream = ast_stream_topology_get_stream(state->topology, i);
        const char *stream_name = NULL;
        int j;
        SCOPE_ENTER(4, "%s: Checking stream %s\n", session_name, ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
 
        if (!stream) {
            SCOPE_EXIT_EXPR(goto end, "%s: stream %d is null\n", session_name, i);
        }
        stream_name = ast_stream_get_name(stream);
 
        for (j = 0; j < stream_count; j++) {
            struct ast_stream *possible_dup = ast_stream_topology_get_stream(state->topology, j);
            if (j == i || !possible_dup) {
                continue;
            }
            if (!STREAM_REMOVED(stream) && ast_strings_equal(stream_name, GET_STREAM_NAME_SAFE(possible_dup))) {
                SCOPE_EXIT_EXPR(goto end, "%s: stream %i %s is duplicated to %d\n", session_name,
                    i, stream_name, j);
            }
        }
 
        media = AST_VECTOR_GET(&state->sessions, i);
        if (!media) {
            SCOPE_EXIT_EXPR(continue, "%s: media %d is null\n", session_name, i);
        }
 
        for (j = 0; j < session_count; j++) {
            struct ast_sip_session_media *possible_dup = AST_VECTOR_GET(&state->sessions, j);
            if (j == i || !possible_dup) {
                continue;
            }
            if (!ast_strlen_zero(media->label) && !ast_strlen_zero(possible_dup->label)
                && ast_strings_equal(media->label, possible_dup->label)) {
                SCOPE_EXIT_EXPR(goto end, "%s: media %d %s is duplicated to %d\n", session_name,
                    i, media->label, j);
            }
        }
 
        if (media->stream_num != i) {
            SCOPE_EXIT_EXPR(goto end, "%s: media %d has stream_num %d\n", session_name,
                i, media->stream_num);
        }
 
        if (media->type != ast_stream_get_type(stream)) {
            SCOPE_EXIT_EXPR(goto end, "%s: media %d has type %s but stream has type %s\n", stream_name,
                i, ast_codec_media_type2str(media->type), ast_codec_media_type2str(ast_stream_get_type(stream)));
        }
        SCOPE_EXIT("%s: Done with stream %s\n", session_name, ast_str_tmp(128, ast_stream_to_str(stream, &STR_TMP)));
    }
 
    res = 1;
end:
    SCOPE_EXIT_RTN_VALUE(res, "%s: %s\n", session_name, res ? "Valid" : "NOT Valid");
}

References ast_codec_media_type2str(), ast_str_tmp, ast_stream_get_name(), ast_stream_get_type(), ast_stream_to_str(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_to_str(), ast_strings_equal(), ast_strlen_zero(), AST_VECTOR_GET, AST_VECTOR_SIZE, end, GET_STREAM_NAME_SAFE, ast_sip_session_media::label, NULL, SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_EXPR, SCOPE_EXIT_RTN_VALUE, session_count, ast_sip_session_media::stream_name, ast_sip_session_media::stream_num, STREAM_REMOVED, and ast_sip_session_media::type.

Referenced by resolve_refresh_media_states().

◆ is_stream_limitation_reached()

static int is_stream_limitation_reached	(	enum ast_media_type	type,
		const struct ast_sip_endpoint *	endpoint,
		int *	type_streams
	)

static

Definition at line 601 of file res_pjsip_session.c.

{
    switch (type) {
    case AST_MEDIA_TYPE_AUDIO:
        return !(type_streams[type] < endpoint->media.max_audio_streams);
    case AST_MEDIA_TYPE_VIDEO:
        return !(type_streams[type] < endpoint->media.max_video_streams);
    case AST_MEDIA_TYPE_IMAGE:
        /* We don't have an option for image (T.38) streams so cap it to one. */
        return (type_streams[type] > 0);
    case AST_MEDIA_TYPE_UNKNOWN:
    case AST_MEDIA_TYPE_TEXT:
    default:
        /* We don't want any unknown or "other" streams on our endpoint,
         * so always just say we've reached the limit
         */
        return 1;
    }
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_IMAGE, AST_MEDIA_TYPE_TEXT, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, ast_sip_endpoint_media_configuration::max_audio_streams, ast_sip_endpoint_media_configuration::max_video_streams, ast_sip_endpoint::media, and type.

Referenced by handle_incoming_sdp(), and sip_session_refresh().

◆ load_module()

static int load_module ( void )

static

Definition at line 6242 of file res_pjsip_session.c.

{
    pjsip_endpoint *endpt;
 
    if (!ast_sip_get_sorcery() || !ast_sip_get_pjsip_endpoint()) {
        return AST_MODULE_LOAD_DECLINE;
    }
    if (!(nat_hook = ast_sorcery_alloc(ast_sip_get_sorcery(), "nat_hook", NULL))) {
        return AST_MODULE_LOAD_DECLINE;
    }
    nat_hook->outgoing_external_message = session_outgoing_nat_hook;
    ast_sorcery_create(ast_sip_get_sorcery(), nat_hook);
    sdp_handlers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        SDP_HANDLER_BUCKETS, sdp_handler_list_hash, NULL, sdp_handler_list_cmp);
    if (!sdp_handlers) {
        return AST_MODULE_LOAD_DECLINE;
    }
    endpt = ast_sip_get_pjsip_endpoint();
    pjsip_inv_usage_init(endpt, &inv_callback);
    pjsip_100rel_init_module(endpt);
    pjsip_timer_init_module(endpt);
    if (ast_sip_register_service(&session_module)) {
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_sip_register_service(&session_reinvite_module);
    ast_sip_register_service(&outbound_invite_auth_module);
 
    pjsip_reason_header_load();
 
    ast_module_shutdown_ref(ast_module_info->self);
#ifdef TEST_FRAMEWORK
    AST_TEST_REGISTER(test_resolve_refresh_media_states);
#endif
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_module_shutdown_ref, ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sip_register_service(), ast_sorcery_alloc(), ast_sorcery_create(), AST_TEST_REGISTER, inv_callback, nat_hook, NULL, outbound_invite_auth_module, ast_sip_nat_hook::outgoing_external_message, pjsip_reason_header_load(), SDP_HANDLER_BUCKETS, sdp_handler_list_cmp(), sdp_handler_list_hash(), sdp_handlers, ast_module_info::self, session_module, session_outgoing_nat_hook(), and session_reinvite_module.

◆ media_stats_local_ssrc_cmp()

static int media_stats_local_ssrc_cmp	(	const struct ast_rtp_instance_stats *	vec_elem,
		const struct ast_rtp_instance_stats *	srch
	)

static

Definition at line 213 of file res_pjsip_session.c.

{
    if (vec_elem->local_ssrc == srch->local_ssrc) {
        return 1;
    }
 
    return 0;
}

References ast_rtp_instance_stats::local_ssrc.

Referenced by ast_sip_session_media_stats_save().

◆ new_invite()

static int new_invite ( struct new_invite * invite )

static

Definition at line 4003 of file res_pjsip_session.c.

{
    pjsip_tx_data *tdata = NULL;
    pjsip_timer_setting timer;
    pjsip_rdata_sdp_info *sdp_info;
    pjmedia_sdp_session *local = NULL;
    char buffer[AST_SOCKADDR_BUFLEN];
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(invite->session));
 
 
    /* From this point on, any calls to pjsip_inv_terminate have the last argument as PJ_TRUE
     * so that we will be notified so we can destroy the session properly
     */
 
    if (invite->session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
        ast_trace_log(-1, LOG_ERROR, "%s: Session already DISCONNECTED [reason=%d (%s)]\n",
            ast_sip_session_get_name(invite->session),
            invite->session->inv_session->cause,
            pjsip_get_status_text(invite->session->inv_session->cause)->ptr);
        SCOPE_EXIT_RTN_VALUE(-1);
    }
 
    switch (get_destination(invite->session, invite->rdata)) {
    case SIP_GET_DEST_EXTEN_FOUND:
        /* Things worked. Keep going */
        break;
    case SIP_GET_DEST_UNSUPPORTED_URI:
        ast_trace(-1, "%s: Call (%s:%s) to extension '%s' - unsupported uri\n",
            ast_sip_session_get_name(invite->session),
            invite->rdata->tp_info.transport->type_name,
            pj_sockaddr_print(&invite->rdata->pkt_info.src_addr, buffer, sizeof(buffer), 3),
            invite->session->exten);
        if (pjsip_inv_initial_answer(invite->session->inv_session, invite->rdata, 416, NULL, NULL, &tdata) == PJ_SUCCESS) {
            ast_sip_session_send_response(invite->session, tdata);
        } else  {
            pjsip_inv_terminate(invite->session->inv_session, 416, PJ_TRUE);
        }
        goto end;
    case SIP_GET_DEST_EXTEN_PARTIAL:
        ast_trace(-1, "%s: Call (%s:%s) to extension '%s' - partial match\n",
            ast_sip_session_get_name(invite->session),
            invite->rdata->tp_info.transport->type_name,
            pj_sockaddr_print(&invite->rdata->pkt_info.src_addr, buffer, sizeof(buffer), 3),
            invite->session->exten);
 
        if (pjsip_inv_initial_answer(invite->session->inv_session, invite->rdata, 484, NULL, NULL, &tdata) == PJ_SUCCESS) {
            ast_sip_session_send_response(invite->session, tdata);
        } else  {
            pjsip_inv_terminate(invite->session->inv_session, 484, PJ_TRUE);
        }
        goto end;
    case SIP_GET_DEST_EXTEN_NOT_FOUND:
    default:
        ast_trace_log(-1, LOG_NOTICE, "%s: Call (%s:%s) to extension '%s' rejected because extension not found in context '%s'.\n",
            ast_sip_session_get_name(invite->session),
            invite->rdata->tp_info.transport->type_name,
            pj_sockaddr_print(&invite->rdata->pkt_info.src_addr, buffer, sizeof(buffer), 3),
            invite->session->exten,
            invite->session->endpoint->context);
 
        if (pjsip_inv_initial_answer(invite->session->inv_session, invite->rdata, 404, NULL, NULL, &tdata) == PJ_SUCCESS) {
            ast_sip_session_send_response(invite->session, tdata);
        } else  {
            pjsip_inv_terminate(invite->session->inv_session, 404, PJ_TRUE);
        }
        goto end;
    };
 
    if (check_content_disposition(invite->rdata)) {
        if (pjsip_inv_initial_answer(invite->session->inv_session, invite->rdata, 415, NULL, NULL, &tdata) == PJ_SUCCESS) {
            ast_sip_session_send_response(invite->session, tdata);
        } else  {
            pjsip_inv_terminate(invite->session->inv_session, 415, PJ_TRUE);
        }
        goto end;
    }
 
    pjsip_timer_setting_default(&timer);
    timer.min_se = invite->session->endpoint->extensions.timer.min_se;
    timer.sess_expires = invite->session->endpoint->extensions.timer.sess_expires;
    pjsip_timer_init_session(invite->session->inv_session, &timer);
 
    /*
     * At this point, we've verified what we can that won't take awhile,
     * so let's go ahead and send a 100 Trying out to stop any
     * retransmissions.
     */
    if (pjsip_inv_initial_answer(invite->session->inv_session, invite->rdata, 100, NULL, NULL, &tdata) != PJ_SUCCESS) {
        if (tdata) {
            pjsip_inv_send_msg(invite->session->inv_session, tdata);
        } else {
            pjsip_inv_terminate(invite->session->inv_session, 500, PJ_TRUE);
        }
        goto end;
    }
 
    ast_trace(-1, "%s: Call (%s:%s) to extension '%s' sending 100 Trying\n",
        ast_sip_session_get_name(invite->session),
        invite->rdata->tp_info.transport->type_name,
        pj_sockaddr_print(&invite->rdata->pkt_info.src_addr, buffer, sizeof(buffer), 3),
        invite->session->exten);
    ast_sip_session_send_response(invite->session, tdata);
 
    sdp_info = pjsip_rdata_get_sdp_info(invite->rdata);
    if (sdp_info && (sdp_info->sdp_err == PJ_SUCCESS) && sdp_info->sdp) {
        if (handle_incoming_sdp(invite->session, sdp_info->sdp)) {
            tdata = NULL;
            if (pjsip_inv_end_session(invite->session->inv_session, 488, NULL, &tdata) == PJ_SUCCESS
                && tdata) {
                ast_sip_session_send_response(invite->session, tdata);
            }
            goto end;
        }
        /* We are creating a local SDP which is an answer to their offer */
        local = create_local_sdp(invite->session->inv_session, invite->session, sdp_info->sdp, 0);
    } else {
        /* We are creating a local SDP which is an offer */
        local = create_local_sdp(invite->session->inv_session, invite->session, NULL, 0);
    }
 
    /* If we were unable to create a local SDP terminate the session early, it won't go anywhere */
    if (!local) {
        tdata = NULL;
        if (pjsip_inv_end_session(invite->session->inv_session, 500, NULL, &tdata) == PJ_SUCCESS
            && tdata) {
            ast_sip_session_send_response(invite->session, tdata);
        }
        goto end;
    }
 
    pjsip_inv_set_local_sdp(invite->session->inv_session, local);
    pjmedia_sdp_neg_set_prefer_remote_codec_order(invite->session->inv_session->neg, PJ_FALSE);
#ifdef PJMEDIA_SDP_NEG_ANSWER_MULTIPLE_CODECS
    if (!invite->session->endpoint->preferred_codec_only) {
        pjmedia_sdp_neg_set_answer_multiple_codecs(invite->session->inv_session->neg, PJ_TRUE);
    }
#endif
 
    handle_incoming_request(invite->session, invite->rdata);
 
end:
    SCOPE_EXIT_RTN_VALUE(0, "%s\n", ast_sip_session_get_name(invite->session));
}

References ast_sip_session_get_name(), ast_sip_session_send_response(), AST_SOCKADDR_BUFLEN, ast_trace, ast_trace_log, check_content_disposition(), ast_sip_endpoint::context, create_local_sdp(), end, ast_sip_session::endpoint, ast_sip_session::exten, ast_sip_endpoint::extensions, get_destination(), handle_incoming_request(), handle_incoming_sdp(), ast_sip_session::inv_session, LOG_ERROR, LOG_NOTICE, ast_sip_timer_options::min_se, NULL, ast_sip_endpoint::preferred_codec_only, new_invite::rdata, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, ast_sip_timer_options::sess_expires, new_invite::session, SIP_GET_DEST_EXTEN_FOUND, SIP_GET_DEST_EXTEN_NOT_FOUND, SIP_GET_DEST_EXTEN_PARTIAL, SIP_GET_DEST_UNSUPPORTED_URI, timer, and ast_sip_endpoint_extensions::timer.

◆ new_invite_initial_answer()

static int new_invite_initial_answer	(	pjsip_inv_session *	inv_session,
		pjsip_rx_data *	rdata,
		int	answer_code,
		int	terminate_code,
		pj_bool_t	notify
	)

static

Definition at line 3820 of file res_pjsip_session.c.

{
    pjsip_tx_data *tdata = NULL;
    int res = 0;
 
    if (inv_session->state != PJSIP_INV_STATE_DISCONNECTED) {
        if (pjsip_inv_initial_answer(
                inv_session, rdata, answer_code, NULL, NULL, &tdata) != PJ_SUCCESS) {
 
            pjsip_inv_terminate(inv_session, terminate_code ? terminate_code : answer_code, notify);
            res = -1;
        } else {
            pjsip_inv_send_msg(inv_session, tdata);
        }
    }
 
    if (answer_code >= 300) {
        /*
         * A session is ending. The dialog has a reference that needs to be
         * removed and holds a lock that needs to be unlocked before returning.
         */
        pjsip_dlg_dec_lock(inv_session->dlg);
    }
 
    return res;
}

References NULL.

Referenced by handle_new_invite_request(), and pre_session_setup().

◆ outbound_invite_auth()

static pj_bool_t outbound_invite_auth ( pjsip_rx_data * rdata )

static

Definition at line 3246 of file res_pjsip_session.c.

{
    pjsip_transaction *tsx;
    pjsip_dialog *dlg;
    pjsip_inv_session *inv;
    pjsip_tx_data *tdata;
    struct ast_sip_session *session;
 
    if (rdata->msg_info.msg->line.status.code != 401
        && rdata->msg_info.msg->line.status.code != 407) {
        /* Doesn't pertain to us. Move on */
        return PJ_FALSE;
    }
 
    tsx = pjsip_rdata_get_tsx(rdata);
    dlg = pjsip_rdata_get_dlg(rdata);
    if (!dlg || !tsx) {
        return PJ_FALSE;
    }
 
    if (tsx->method.id != PJSIP_INVITE_METHOD) {
        /* Not an INVITE that needs authentication */
        return PJ_FALSE;
    }
 
    inv = pjsip_dlg_get_inv_session(dlg);
    session = inv->mod_data[session_module.id];
 
    if (PJSIP_INV_STATE_CONFIRMED <= inv->state) {
        /*
         * We cannot handle reINVITE authentication at this
         * time because the reINVITE transaction is still in
         * progress.
         */
        ast_debug(3, "%s: A reINVITE is being challenged\n", ast_sip_session_get_name(session));
        return PJ_FALSE;
    }
    ast_debug(3, "%s: Initial INVITE is being challenged.\n", ast_sip_session_get_name(session));
 
    if (++session->authentication_challenge_count > MAX_RX_CHALLENGES) {
        ast_debug(3, "%s: Initial INVITE reached maximum number of auth attempts.\n", ast_sip_session_get_name(session));
        return PJ_FALSE;
    }
 
    if (ast_sip_create_request_with_auth(&session->endpoint->outbound_auths, rdata,
        tsx->last_tx, &tdata)) {
        return PJ_FALSE;
    }
 
    /*
     * Restart the outgoing initial INVITE transaction to deal
     * with authentication.
     */
    pjsip_inv_uac_restart(inv, PJ_FALSE);
 
    ast_sip_session_send_request(session, tdata);
    return PJ_TRUE;
}

References ast_debug, ast_sip_create_request_with_auth(), ast_sip_session_get_name(), ast_sip_session_send_request(), MAX_RX_CHALLENGES, session, and session_module.

◆ pre_session_setup()

static pjsip_inv_session * pre_session_setup	(	pjsip_rx_data *	rdata,
		const struct ast_sip_endpoint *	endpoint
	)

static

Definition at line 3867 of file res_pjsip_session.c.

{
    pjsip_tx_data *tdata;
    pjsip_dialog *dlg;
    pjsip_inv_session *inv_session;
    unsigned int options = endpoint->extensions.flags;
    const pj_str_t STR_100REL = { "100rel", 6};
    unsigned int i;
    pj_status_t dlg_status = PJ_EUNKNOWN;
 
    /*
     * If 100rel is set to "peer_supported" on the endpoint and the peer indicated support for 100rel
     * in the Supported header, send 1xx responses reliably by adding PJSIP_INV_REQUIRE_100REL to pjsip_inv_options flags.
     */
    if (endpoint->rel100 == AST_SIP_100REL_PEER_SUPPORTED && rdata->msg_info.supported != NULL) {
        for (i = 0; i < rdata->msg_info.supported->count; ++i) {
            if (pj_stricmp(&rdata->msg_info.supported->values[i], &STR_100REL) == 0) {
                options |= PJSIP_INV_REQUIRE_100REL;
                break;
            }
        }
    }
 
    if (pjsip_inv_verify_request(rdata, &options, NULL, NULL, ast_sip_get_pjsip_endpoint(), &tdata) != PJ_SUCCESS) {
        if (tdata) {
            if (pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL) != PJ_SUCCESS) {
                pjsip_tx_data_dec_ref(tdata);
            }
        } else {
            pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
        }
        return NULL;
    }
 
    dlg = ast_sip_create_dialog_uas_locked(endpoint, rdata, &dlg_status);
    if (!dlg) {
        if (dlg_status != PJ_EEXISTS) {
            pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
        }
        return NULL;
    }
 
    /*
     * The returned dialog holds a lock and has a reference added. Any paths where the
     * dialog invite session is not returned must unlock the dialog and remove its reference.
     */
 
    if (pjsip_inv_create_uas(dlg, rdata, NULL, options, &inv_session) != PJ_SUCCESS) {
        pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
        /*
         * The acquired dialog holds a lock, and a reference. Since the dialog is not
         * going to be returned here it must first be unlocked and de-referenced. This
         * must be done prior to calling dialog termination.
         */
        pjsip_dlg_dec_lock(dlg);
        pjsip_dlg_terminate(dlg);
        return NULL;
    }
 
#if defined(HAVE_PJSIP_REPLACE_MEDIA_STREAM) || defined(PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE)
    inv_session->sdp_neg_flags = PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE;
#endif
    if (pjsip_dlg_add_usage(dlg, &session_module, NULL) != PJ_SUCCESS) {
        /* Dialog's lock and a reference are removed in new_invite_initial_answer */
        new_invite_initial_answer(inv_session, rdata, 500, 500, PJ_FALSE);
        /* Remove 2nd reference added at inv_session creation */
        pjsip_dlg_dec_session(inv_session->dlg, &session_module);
        return NULL;
    }
 
    return inv_session;
}

References AST_SIP_100REL_PEER_SUPPORTED, ast_sip_create_dialog_uas_locked(), ast_sip_get_pjsip_endpoint(), ast_sip_endpoint::extensions, ast_sip_endpoint_extensions::flags, new_invite_initial_answer(), NULL, options, ast_sip_endpoint::rel100, and session_module.

Referenced by handle_new_invite_request().

◆ remove_handler()

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

static

Definition at line 185 of file res_pjsip_session.c.

{
    struct sdp_handler_list *handler_list = obj;
    struct ast_sip_session_sdp_handler *handler = data;
    struct ast_sip_session_sdp_handler *iter;
    const char *stream_type = arg;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&handler_list->list, iter, next) {
        if (!strcmp(iter->id, handler->id)) {
            AST_LIST_REMOVE_CURRENT(next);
            ast_debug(1, "Unregistered SDP stream handler '%s' for stream type '%s'\n", handler->id, stream_type);
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (AST_LIST_EMPTY(&handler_list->list)) {
        ast_debug(3, "No more handlers exist for stream type '%s'\n", stream_type);
        return CMP_MATCH;
    } else {
        return CMP_STOP;
    }
}

References ast_debug, AST_LIST_EMPTY, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, CMP_MATCH, CMP_STOP, handler(), ast_sip_session_sdp_handler::id, sdp_handler_list::list, and ast_sip_session_sdp_handler::next.

Referenced by ast_sip_session_unregister_sdp_handler().

◆ remove_stream_from_bundle()

static void remove_stream_from_bundle	(	struct ast_sip_session_media *	session_media,
		struct ast_stream *	stream
	)

static

Definition at line 763 of file res_pjsip_session.c.

{
    ast_stream_set_state(stream, AST_STREAM_STATE_REMOVED);
    ast_free(session_media->mid);
    session_media->mid = NULL;
    session_media->bundle_group = -1;
    session_media->bundled = 0;
}

References ast_free, ast_stream_set_state(), AST_STREAM_STATE_REMOVED, ast_sip_session_media::bundle_group, ast_sip_session_media::bundled, ast_sip_session_media::mid, and NULL.

Referenced by handle_incoming_sdp().

◆ reschedule_reinvite()

static void reschedule_reinvite	(	struct ast_sip_session *	session,
		ast_sip_session_response_cb	on_response
	)

static

Definition at line 4378 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv = session->inv_session;
    pj_time_val tv;
    struct ast_sip_session_media_state *pending_media_state = NULL;
    struct ast_sip_session_media_state *active_media_state = NULL;
    const char *session_name = ast_sip_session_get_name(session);
    int use_pending = 0;
    int use_active = 0;
 
    SCOPE_ENTER(3, "%s\n", session_name);
 
    /*
     * If the two media state topologies are the same this means that the session refresh request
     * did not specify a desired topology, so it does not care. If that is the case we don't even
     * pass one in here resulting in the current topology being used.  It's possible though that
     * either one of the topologies could be NULL so we have to test for that before we check for
     * equality.
     */
 
    /* We only want to clone a media state if its topology is not null */
    use_pending = session->pending_media_state->topology != NULL;
    use_active = session->active_media_state->topology != NULL;
 
    /*
     * If both media states have topologies, we can test for equality.  If they're equal we're not going to
     * clone either states.
     */
    if (use_pending && use_active && ast_stream_topology_equal(session->active_media_state->topology, session->pending_media_state->topology)) {
        use_pending = 0;
        use_active = 0;
    }
 
    if (use_pending) {
        pending_media_state = ast_sip_session_media_state_clone(session->pending_media_state);
        if (!pending_media_state) {
            SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: Failed to clone pending media state\n", session_name);
        }
    }
 
    if (use_active) {
        active_media_state = ast_sip_session_media_state_clone(session->active_media_state);
        if (!active_media_state) {
            ast_sip_session_media_state_free(pending_media_state);
            SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: Failed to clone active media state\n", session_name);
        }
    }
 
    if (delay_request(session, NULL, NULL, on_response, 1, DELAYED_METHOD_INVITE, pending_media_state,
        active_media_state, 1)) {
        ast_sip_session_media_state_free(pending_media_state);
        ast_sip_session_media_state_free(active_media_state);
        SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: Failed to add delayed request\n", session_name);
    }
 
    if (pj_timer_entry_running(&session->rescheduled_reinvite)) {
        /* Timer already running.  Something weird is going on. */
        SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: re-INVITE collision while timer running!!!\n", session_name);
    }
 
    tv.sec = 0;
    if (inv->role == PJSIP_ROLE_UAC) {
        tv.msec = 2100 + ast_random() % 2000;
    } else {
        tv.msec = ast_random() % 2000;
    }
    pj_timer_entry_init(&session->rescheduled_reinvite, 0, session, resend_reinvite);
 
    ao2_ref(session, +1);
    if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(),
        &session->rescheduled_reinvite, &tv) != PJ_SUCCESS) {
        ao2_ref(session, -1);
        SCOPE_EXIT_LOG_RTN(LOG_ERROR, "%s: Couldn't schedule timer\n", session_name);
    }
 
    SCOPE_EXIT_RTN();
}

References ao2_ref, ast_random(), ast_sip_get_pjsip_endpoint(), ast_sip_session_get_name(), ast_sip_session_media_state_clone(), ast_sip_session_media_state_free(), ast_stream_topology_equal(), delay_request(), DELAYED_METHOD_INVITE, LOG_ERROR, NULL, resend_reinvite(), SCOPE_ENTER, SCOPE_EXIT_LOG_RTN, SCOPE_EXIT_RTN, and session.

Referenced by session_inv_on_tsx_state_changed().

◆ resend_reinvite()

static void resend_reinvite	(	pj_timer_heap_t *	timer,
		pj_timer_entry *	entry
	)

static

Definition at line 4357 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = entry->user_data;
 
    ast_debug(3, "%s: re-INVITE collision timer expired.\n",
        ast_sip_session_get_name(session));
 
    if (AST_LIST_EMPTY(&session->delayed_requests)) {
        /* No delayed request pending, so just return */
        ao2_ref(session, -1);
        return;
    }
    if (ast_sip_push_task(session->serializer, invite_collision_timeout, session)) {
        /*
         * Uh oh.  We now have nothing in the foreseeable future
         * to trigger sending the delayed requests.
         */
        ao2_ref(session, -1);
    }
}

References ao2_ref, ast_debug, AST_LIST_EMPTY, ast_sip_push_task, ast_sip_session_get_name(), invite_collision_timeout(), and session.

Referenced by reschedule_reinvite().

◆ resolve_refresh_media_states()

static struct ast_sip_session_media_state * resolve_refresh_media_states	(	const char *	session_name,
		struct ast_sip_session_media_state *	delayed_pending_state,
		struct ast_sip_session_media_state *	delayed_active_state,
		struct ast_sip_session_media_state *	current_active_state,
		int	run_post_validation
	)

static

Definition at line 1948 of file res_pjsip_session.c.

{
    RAII_VAR(struct ast_sip_session_media_state *, new_pending_state, NULL, ast_sip_session_media_state_free);
    struct ast_sip_session_media_state *returned_media_state = NULL;
    struct ast_stream_topology *delayed_pending = delayed_pending_state->topology;
    struct ast_stream_topology *delayed_active = delayed_active_state->topology;
    struct ast_stream_topology *current_active = current_active_state->topology;
    struct ast_stream_topology *new_pending = NULL;
    int i;
    int max_stream_count;
    int res;
    SCOPE_ENTER(2, "%s: DP: %s  DA: %s  CA: %s\n", session_name,
        ast_str_tmp(256, ast_stream_topology_to_str(delayed_pending, &STR_TMP)),
        ast_str_tmp(256, ast_stream_topology_to_str(delayed_active, &STR_TMP)),
        ast_str_tmp(256, ast_stream_topology_to_str(current_active, &STR_TMP))
    );
 
    max_stream_count = MAX(ast_stream_topology_get_count(delayed_pending),
        ast_stream_topology_get_count(delayed_active));
    max_stream_count = MAX(max_stream_count, ast_stream_topology_get_count(current_active));
 
    /*
     * The new_pending_state is always based on the currently negotiated state because
     * the stream ordering in its topology must be preserved.
     */
    new_pending_state = ast_sip_session_media_state_clone(current_active_state);
    if (!new_pending_state) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Couldn't clone current_active_state to new_pending_state\n", session_name);
    }
    new_pending = new_pending_state->topology;
 
    for (i = 0; i < max_stream_count; i++) {
        struct ast_stream *dp_stream = GET_STREAM_SAFE(delayed_pending, i);
        struct ast_stream *da_stream = GET_STREAM_SAFE(delayed_active, i);
        struct ast_stream *ca_stream = GET_STREAM_SAFE(current_active, i);
        struct ast_stream *np_stream = GET_STREAM_SAFE(new_pending, i);
        struct ast_stream *found_da_stream = NULL;
        struct ast_stream *found_np_stream = NULL;
        enum ast_stream_state dp_state = GET_STREAM_STATE_SAFE(dp_stream);
        enum ast_stream_state da_state = GET_STREAM_STATE_SAFE(da_stream);
        enum ast_stream_state ca_state = GET_STREAM_STATE_SAFE(ca_stream);
        enum ast_stream_state np_state = GET_STREAM_STATE_SAFE(np_stream);
        enum ast_stream_state found_da_state = AST_STREAM_STATE_END;
        enum ast_stream_state found_np_state = AST_STREAM_STATE_END;
        const char *da_name = GET_STREAM_NAME_SAFE(da_stream);
        const char *dp_name = GET_STREAM_NAME_SAFE(dp_stream);
        const char *ca_name = GET_STREAM_NAME_SAFE(ca_stream);
        const char *np_name = GET_STREAM_NAME_SAFE(np_stream);
        const char *found_da_name __attribute__((unused)) = "";
        const char *found_np_name __attribute__((unused)) = "";
        int found_da_slot __attribute__((unused)) = -1;
        int found_np_slot = -1;
        int removed_np_slot = -1;
        int j;
        SCOPE_ENTER(3, "%s: slot: %d DP: %s  DA: %s  CA: %s\n", session_name, i,
            ast_str_tmp(128, ast_stream_to_str(dp_stream, &STR_TMP)),
            ast_str_tmp(128, ast_stream_to_str(da_stream, &STR_TMP)),
            ast_str_tmp(128, ast_stream_to_str(ca_stream, &STR_TMP)));
 
        if (STATE_NONE(da_state) && STATE_NONE(dp_state) && STATE_NONE(ca_state)) {
            SCOPE_EXIT_EXPR(break, "%s: All gone\n", session_name);
        }
 
        /*
         * Simple cases are handled first to avoid having to search the NP and DA
         * topologies for streams with the same name but not in the same position.
         */
 
        if (STATE_NONE(dp_state) && !STATE_NONE(da_state)) {
            /*
             * The slot in the delayed pending topology can't be empty if the delayed
             * active topology has a stream there.  Streams can't just go away.  They
             * can be reused or marked "removed" but they can't go away.
             */
            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_WARNING, "%s: DP slot is empty but DA is not\n", session_name);
        }
 
        if (STATE_NONE(dp_state)) {
            /*
             * The current active topology can certainly have streams that weren't
             * in existence when the delayed request was queued.  In this case,
             * no action is needed since we already copied the current active topology
             * to the new pending one.
             */
            SCOPE_EXIT_EXPR(continue, "%s: No DP stream so use CA stream as is\n", session_name);
        }
 
        if (ast_strings_equal(dp_name, da_name) && ast_strings_equal(da_name, ca_name)) {
            /*
             * The delayed pending stream in this slot matches by name, the streams
             * in the same slot in the other two topologies.  Easy case.
             */
            ast_trace(-1, "%s: Same stream in all 3 states\n", session_name);
            if (dp_state == da_state && da_state == ca_state) {
                /* All the same state, no need to update. */
                SCOPE_EXIT_EXPR(continue, "%s: All in the same state so nothing to do\n", session_name);
            }
            if (da_state != ca_state) {
                /*
                 * Something set the CA state between the time this request was queued
                 * and now.  The CA state wins so we don't do anything.
                 */
                SCOPE_EXIT_EXPR(continue, "%s: Ignoring request to change state from %s to %s\n",
                    session_name, ast_stream_state2str(ca_state), ast_stream_state2str(dp_state));
            }
            if (dp_state != da_state) {
                /* DP needs to update the state */
                ast_stream_set_state(np_stream, dp_state);
                SCOPE_EXIT_EXPR(continue, "%s: Changed NP stream state from %s to %s\n",
                    session_name, ast_stream_state2str(ca_state), ast_stream_state2str(dp_state));
            }
        }
 
        /*
         * We're done with the simple cases.  For the rest, we need to identify if the
         * DP stream we're trying to take action on is already in the other topologies
         * possibly in a different slot.  To do that, if the stream in the DA or CA slots
         * doesn't match the current DP stream, we need to iterate over the topology
         * looking for a stream with the same name.
         */
 
        /*
         * Since we already copied all of the CA streams to the NP topology, we'll use it
         * instead of CA because we'll be updating the NP as we go.
         */
        if (!ast_strings_equal(dp_name, np_name)) {
            /*
             * The NP stream in this slot doesn't have the same name as the DP stream
             * so we need to see if it's in another NP slot.  We're not going to stop
             * when we find a matching stream because we also want to find the first
             * removed removed slot, if any, so we can re-use this slot.  We'll break
             * early if we find both before we reach the end.
             */
            ast_trace(-1, "%s: Checking if DP is already in NP somewhere\n", session_name);
            for (j = 0; j < ast_stream_topology_get_count(new_pending); j++) {
                struct ast_stream *possible_existing = ast_stream_topology_get_stream(new_pending, j);
                const char *possible_existing_name = GET_STREAM_NAME_SAFE(possible_existing);
 
                ast_trace(-1, "%s: Checking %s against %s\n", session_name, dp_name, possible_existing_name);
                if (found_np_slot == -1 && ast_strings_equal(dp_name, possible_existing_name)) {
                    ast_trace(-1, "%s: Pending stream %s slot %d is in NP slot %d\n", session_name,
                    dp_name, i, j);
                    found_np_slot = j;
                    found_np_stream = possible_existing;
                    found_np_state = ast_stream_get_state(possible_existing);
                    found_np_name = ast_stream_get_name(possible_existing);
                }
                if (STREAM_REMOVED(possible_existing) && removed_np_slot == -1) {
                    removed_np_slot = j;
                }
                if (removed_np_slot >= 0 && found_np_slot >= 0) {
                    break;
                }
            }
        } else {
            /* Makes the subsequent code easier */
            found_np_slot = i;
            found_np_stream = np_stream;
            found_np_state = np_state;
            found_np_name = np_name;
        }
 
        if (!ast_strings_equal(dp_name, da_name)) {
            /*
             * The DA stream in this slot doesn't have the same name as the DP stream
             * so we need to see if it's in another DA slot.  In real life, the DA stream
             * in this slot could have a different name but there shouldn't be a case
             * where the DP stream is another slot in the DA topology.  Just in case though.
             * We don't care about removed slots in the DA topology.
             */
            ast_trace(-1, "%s: Checking if DP is already in DA somewhere\n", session_name);
            for (j = 0; j < ast_stream_topology_get_count(delayed_active); j++) {
                struct ast_stream *possible_existing = ast_stream_topology_get_stream(delayed_active, j);
                const char *possible_existing_name = GET_STREAM_NAME_SAFE(possible_existing);
 
                ast_trace(-1, "%s: Checking %s against %s\n", session_name, dp_name, possible_existing_name);
                if (ast_strings_equal(dp_name, possible_existing_name)) {
                    ast_trace(-1, "%s: Pending stream %s slot %d is already in delayed active slot %d\n",
                        session_name, dp_name, i, j);
                    found_da_slot = j;
                    found_da_stream = possible_existing;
                    found_da_state = ast_stream_get_state(possible_existing);
                    found_da_name = ast_stream_get_name(possible_existing);
                    break;
                }
            }
        } else {
            /* Makes the subsequent code easier */
            found_da_slot = i;
            found_da_stream = da_stream;
            found_da_state = da_state;
            found_da_name = da_name;
        }
 
        ast_trace(-1, "%s: Found NP slot: %d  Found removed NP slot: %d Found DA slot: %d\n",
            session_name, found_np_slot, removed_np_slot, found_da_slot);
 
        /*
         * Now we know whether the DP stream is new or changing state and we know if the DP
         * stream exists in the other topologies and if so, where in those topologies it exists.
         */
 
        if (!found_da_stream) {
            /*
             * The DP stream isn't in the DA topology which would imply that the intention of the
             * request was to add the stream, not change its state.  It's possible though that
             * the stream was added by another request between the time this request was queued
             * and now so we need to check the CA topology as well.
             */
            ast_trace(-1, "%s: There was no corresponding DA stream so the request was to add a stream\n", session_name);
 
            if (found_np_stream) {
                /*
                 * We found it in the CA topology.  Since the intention was to add it
                 * and it's already there, there's nothing to do.
                 */
                SCOPE_EXIT_EXPR(continue, "%s: New stream requested but it's already in CA\n", session_name);
            } else {
                /* OK, it's not in either which would again imply that the intention of the
                 * request was to add the stream.
                 */
                ast_trace(-1, "%s: There was no corresponding NP stream\n", session_name);
                if (STATE_REMOVED(dp_state)) {
                    /*
                     * How can DP request to remove a stream that doesn't seem to exist anythere?
                     * It's not.  It's possible that the stream was already removed and the slot
                     * reused in the CA topology, but it would still have to exist in the DA
                     * topology.  Bail.
                     */
                    SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR,
                        "%s: Attempting to remove stream %d:%s but it doesn't exist anywhere.\n", session_name, i, dp_name);
                } else {
                    /*
                     * We're now sure we want to add the the stream.  Since we can re-use
                     * slots in the CA topology that have streams marked as "removed", we
                     * use the slot we saved in removed_np_slot if it exists.
                     */
                    ast_trace(-1, "%s: Checking for open slot\n", session_name);
                    if (removed_np_slot >= 0) {
                        struct ast_sip_session_media *old_media = AST_VECTOR_GET(&new_pending_state->sessions, removed_np_slot);
                        res = ast_stream_topology_set_stream(new_pending, removed_np_slot, ast_stream_clone(dp_stream, NULL));
                        if (res != 0) {
                            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_WARNING, "%s: Couldn't set stream in new topology\n", session_name);
                        }
                        /*
                         * Since we're reusing the removed_np_slot slot for something else, we need
                         * to free and remove any session media already in it.
                         * ast_stream_topology_set_stream() took care of freeing the old stream.
                         */
                        res = AST_VECTOR_REPLACE(&new_pending_state->sessions, removed_np_slot, NULL);
                        if (res != 0) {
                            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_WARNING, "%s: Couldn't replace media session\n", session_name);
                        }
 
                        ao2_cleanup(old_media);
                        SCOPE_EXIT_EXPR(continue, "%s: Replaced removed stream in slot %d\n",
                            session_name, removed_np_slot);
                    } else {
                        int new_slot = ast_stream_topology_append_stream(new_pending, ast_stream_clone(dp_stream, NULL));
                        if (new_slot < 0) {
                            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_WARNING, "%s: Couldn't append stream in new topology\n", session_name);
                        }
 
                        res = AST_VECTOR_REPLACE(&new_pending_state->sessions, new_slot, NULL);
                        if (res != 0) {
                            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_WARNING, "%s: Couldn't replace media session\n", session_name);
                        }
                        SCOPE_EXIT_EXPR(continue, "%s: Appended new stream to slot %d\n",
                            session_name, new_slot);
                    }
                }
            }
        } else {
            /*
             * The DP stream exists in the DA topology so it's a change of some sort.
             */
            ast_trace(-1, "%s: There was a corresponding DA stream so the request was to change/remove a stream\n", session_name);
            if (dp_state == found_da_state) {
                /* No change? Let's see if it's in CA */
                if (!found_np_stream) {
                    /*
                     * The DP and DA state are the same which would imply that the stream
                     * already exists but it's not in the CA topology.  It's possible that
                     * between the time this request was queued and now the stream was removed
                     * from the CA topology and the slot used for something else.  Nothing
                     * we can do here.
                     */
                    SCOPE_EXIT_EXPR(continue, "%s: Stream doesn't exist in CA so nothing to do\n", session_name);
                } else if (dp_state == found_np_state) {
                    SCOPE_EXIT_EXPR(continue, "%s: States are the same all around so nothing to do\n", session_name);
                } else {
                    SCOPE_EXIT_EXPR(continue, "%s: Something changed the CA state so we're going to leave it as is\n", session_name);
                }
            } else {
                /* We have a state change. */
                ast_trace(-1, "%s: Requesting state change to %s\n", session_name, ast_stream_state2str(dp_state));
                if (!found_np_stream) {
                    SCOPE_EXIT_EXPR(continue, "%s: Stream doesn't exist in CA so nothing to do\n", session_name);
                } else if (da_state == found_np_state) {
                    ast_stream_set_state(found_np_stream, dp_state);
                    SCOPE_EXIT_EXPR(continue, "%s: Changed NP stream state from %s to %s\n",
                        session_name, ast_stream_state2str(found_np_state), ast_stream_state2str(dp_state));
                } else {
                    SCOPE_EXIT_EXPR(continue, "%s: Something changed the CA state so we're going to leave it as is\n",
                        session_name);
                }
            }
        }
 
        SCOPE_EXIT("%s: Done with slot %d\n", session_name, i);
    }
 
    ast_trace(-1, "%s: Resetting default media states\n", session_name);
    for (i = 0; i < AST_MEDIA_TYPE_END; i++) {
        int j;
        new_pending_state->default_session[i] = NULL;
        for (j = 0; j < AST_VECTOR_SIZE(&new_pending_state->sessions); j++) {
            struct ast_sip_session_media *media = AST_VECTOR_GET(&new_pending_state->sessions, j);
            struct ast_stream *stream = ast_stream_topology_get_stream(new_pending_state->topology, j);
 
            if (media && media->type == i && !STREAM_REMOVED(stream)) {
                new_pending_state->default_session[i] = media;
                break;
            }
        }
    }
 
    if (run_post_validation) {
        ast_trace(-1, "%s: Running post-validation\n", session_name);
        if (!is_media_state_valid(session_name, new_pending_state)) {
            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "State not consistent\n");
        }
    }
 
    /*
     * We need to move the new pending state to another variable and set new_pending_state to NULL
     * so RAII_VAR doesn't free it.
     */
    returned_media_state = new_pending_state;
    new_pending_state = NULL;
    SCOPE_EXIT_RTN_VALUE(returned_media_state, "%s: NP: %s\n", session_name,
        ast_str_tmp(256, ast_stream_topology_to_str(new_pending, &STR_TMP)));
}

References ao2_cleanup, AST_MEDIA_TYPE_END, ast_sip_session_media_state_clone(), ast_sip_session_media_state_free(), ast_str_tmp, ast_stream_clone(), ast_stream_get_name(), ast_stream_get_state(), ast_stream_set_state(), ast_stream_state2str(), AST_STREAM_STATE_END, ast_stream_to_str(), ast_stream_topology_append_stream(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_set_stream(), ast_stream_topology_to_str(), ast_strings_equal(), ast_trace, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, GET_STREAM_NAME_SAFE, GET_STREAM_SAFE, GET_STREAM_STATE_SAFE, is_media_state_valid(), LOG_ERROR, LOG_WARNING, MAX, NULL, RAII_VAR, SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_EXPR, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, STATE_NONE, STATE_REMOVED, STREAM_REMOVED, ast_sip_session_media_state::topology, and ast_sip_session_media::type.

Referenced by sip_session_refresh().

◆ sdp_handler_list_cmp()

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

static

Definition at line 138 of file res_pjsip_session.c.

{
    struct sdp_handler_list *handler_list1 = obj;
    struct sdp_handler_list *handler_list2 = arg;
    const char *stream_type2 = flags & OBJ_KEY ? arg : handler_list2->stream_type;
 
    return strcmp(handler_list1->stream_type, stream_type2) ? 0 : CMP_MATCH | CMP_STOP;
}

References CMP_MATCH, CMP_STOP, OBJ_KEY, and sdp_handler_list::stream_type.

Referenced by load_module().

◆ sdp_handler_list_hash()

static int sdp_handler_list_hash	(	const void *	obj,
		int	flags
	)

static

Definition at line 109 of file res_pjsip_session.c.

{
    const struct sdp_handler_list *handler_list = obj;
    const char *stream_type = flags & OBJ_KEY ? obj : handler_list->stream_type;
 
    return ast_str_hash(stream_type);
}

References ast_str_hash(), OBJ_KEY, and sdp_handler_list::stream_type.

Referenced by load_module().

◆ sdp_requires_deferral()

static int sdp_requires_deferral	(	struct ast_sip_session *	session,
		const pjmedia_sdp_session *	sdp
	)

static

Determine whether the SDP provided requires deferral of negotiating or not.

Return values

1	re-invite should be deferred and resumed later
0	re-invite should not be deferred

Definition at line 2721 of file res_pjsip_session.c.

{
    int i;
 
    if (!session->pending_media_state->topology) {
        session->pending_media_state->topology = ast_stream_topology_alloc();
        if (!session->pending_media_state->topology) {
            return -1;
        }
    }
 
    for (i = 0; i < sdp->media_count; ++i) {
        /* See if there are registered handlers for this media stream type */
        char media[20];
        struct ast_sip_session_sdp_handler *handler;
        RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
        struct ast_stream *existing_stream = NULL;
        struct ast_stream *stream;
        enum ast_media_type type;
        struct ast_sip_session_media *session_media = NULL;
        enum ast_sip_session_sdp_stream_defer res;
        pjmedia_sdp_media *remote_stream = sdp->media[i];
 
        /* We need a null-terminated version of the media string */
        ast_copy_pj_str(media, &sdp->media[i]->desc.media, sizeof(media));
 
        if (session->active_media_state->topology &&
            (i < ast_stream_topology_get_count(session->active_media_state->topology))) {
            existing_stream = ast_stream_topology_get_stream(session->active_media_state->topology, i);
        }
 
        type = ast_media_type_from_str(media);
        stream = ast_stream_alloc(existing_stream ? ast_stream_get_name(existing_stream) : ast_codec_media_type2str(type), type);
        if (!stream) {
            return -1;
        }
 
        /* As this is only called on an incoming SDP offer before processing it is not possible
         * for streams and their media sessions to exist.
         */
        if (ast_stream_topology_set_stream(session->pending_media_state->topology, i, stream)) {
            ast_stream_free(stream);
            return -1;
        }
 
        if (existing_stream) {
            const char *stream_label = ast_stream_get_metadata(existing_stream, "SDP:LABEL");
 
            if (!ast_strlen_zero(stream_label)) {
                ast_stream_set_metadata(stream, "SDP:LABEL", stream_label);
            }
        }
 
        session_media = ast_sip_session_media_state_add(session, session->pending_media_state, ast_media_type_from_str(media), i);
        if (!session_media) {
            return -1;
        }
 
        /* For backwards compatibility with the core the default audio stream is always sendrecv */
        if (!ast_sip_session_is_pending_stream_default(session, stream) || strcmp(media, "audio")) {
            if (pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL)) {
                /* Stream state reflects our state of a stream, so in the case of
                 * sendonly and recvonly we store the opposite since that is what ours
                 * is.
                 */
                ast_stream_set_state(stream, AST_STREAM_STATE_RECVONLY);
            } else if (pjmedia_sdp_media_find_attr2(remote_stream, "recvonly", NULL)) {
                ast_stream_set_state(stream, AST_STREAM_STATE_SENDONLY);
            } else if (pjmedia_sdp_media_find_attr2(remote_stream, "inactive", NULL)) {
                ast_stream_set_state(stream, AST_STREAM_STATE_INACTIVE);
            } else {
                ast_stream_set_state(stream, AST_STREAM_STATE_SENDRECV);
            }
        } else {
            ast_stream_set_state(stream, AST_STREAM_STATE_SENDRECV);
        }
 
        if (session_media->handler) {
            handler = session_media->handler;
            if (handler->defer_incoming_sdp_stream) {
                res = handler->defer_incoming_sdp_stream(session, session_media, sdp,
                    sdp->media[i]);
                switch (res) {
                case AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED:
                    break;
                case AST_SIP_SESSION_SDP_DEFER_ERROR:
                    return 0;
                case AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED:
                    break;
                case AST_SIP_SESSION_SDP_DEFER_NEEDED:
                    return 1;
                }
            }
            /* Handled by this handler. Move to the next stream */
            continue;
        }
 
        handler_list = ao2_find(sdp_handlers, media, OBJ_KEY);
        if (!handler_list) {
            ast_debug(3, "%s: No registered SDP handlers for media type '%s'\n", ast_sip_session_get_name(session), media);
            continue;
        }
        AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
            if (handler == session_media->handler) {
                continue;
            }
            if (!handler->defer_incoming_sdp_stream) {
                continue;
            }
            res = handler->defer_incoming_sdp_stream(session, session_media, sdp,
                sdp->media[i]);
            switch (res) {
            case AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED:
                continue;
            case AST_SIP_SESSION_SDP_DEFER_ERROR:
                session_media_set_handler(session_media, handler);
                return 0;
            case AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED:
                /* Handled by this handler. */
                session_media_set_handler(session_media, handler);
                break;
            case AST_SIP_SESSION_SDP_DEFER_NEEDED:
                /* Handled by this handler. */
                session_media_set_handler(session_media, handler);
                return 1;
            }
            /* Move to the next stream */
            break;
        }
    }
    return 0;
}

References ao2_cleanup, ao2_find, ast_codec_media_type2str(), ast_copy_pj_str(), ast_debug, AST_LIST_TRAVERSE, ast_media_type_from_str(), ast_sip_session_get_name(), ast_sip_session_is_pending_stream_default(), ast_sip_session_media_state_add(), AST_SIP_SESSION_SDP_DEFER_ERROR, AST_SIP_SESSION_SDP_DEFER_NEEDED, AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED, AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED, ast_stream_alloc(), ast_stream_free(), ast_stream_get_metadata(), ast_stream_get_name(), ast_stream_set_metadata(), ast_stream_set_state(), AST_STREAM_STATE_INACTIVE, AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_SENDONLY, AST_STREAM_STATE_SENDRECV, ast_stream_topology_alloc(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_set_stream(), ast_strlen_zero(), ast_sip_session_sdp_handler::defer_incoming_sdp_stream, ast_sip_session_media::handler, handler(), NULL, OBJ_KEY, RAII_VAR, sdp_handlers, session, session_media_set_handler(), and type.

Referenced by session_reinvite_on_rx_request().

◆ send_delayed_request()

static int send_delayed_request	(	struct ast_sip_session *	session,
		struct ast_sip_session_delayed_request *	delay
	)

static

Definition at line 1453 of file res_pjsip_session.c.

{
    int res;
    SCOPE_ENTER(3, "%s: sending delayed %s request\n",
        ast_sip_session_get_name(session),
        delayed_method2str(delay->method));
 
    switch (delay->method) {
    case DELAYED_METHOD_INVITE:
        res = sip_session_refresh(session, delay->on_request_creation,
            delay->on_sdp_creation, delay->on_response,
            AST_SIP_SESSION_REFRESH_METHOD_INVITE, delay->generate_new_sdp, delay->pending_media_state,
            delay->active_media_state, 1);
        /* Ownership of media state transitions to ast_sip_session_refresh */
        delay->pending_media_state = NULL;
        delay->active_media_state = NULL;
        SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_sip_session_get_name(session));
    case DELAYED_METHOD_UPDATE:
        res = sip_session_refresh(session, delay->on_request_creation,
            delay->on_sdp_creation, delay->on_response,
            AST_SIP_SESSION_REFRESH_METHOD_UPDATE, delay->generate_new_sdp, delay->pending_media_state,
            delay->active_media_state, 1);
        /* Ownership of media state transitions to ast_sip_session_refresh */
        delay->pending_media_state = NULL;
        delay->active_media_state = NULL;
        SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_sip_session_get_name(session));
    case DELAYED_METHOD_BYE:
        /* The delayed BYE is being sent now; timeout cleanup is no longer needed. */
        session->terminate_on_invite_timeout = 0;
        ast_sip_session_terminate(session, 0);
        SCOPE_EXIT_RTN_VALUE(0, "%s: Terminating session on delayed BYE\n", ast_sip_session_get_name(session));
    }
 
    SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Don't know how to send delayed %s(%d) request.\n",
        ast_sip_session_get_name(session),
        delayed_method2str(delay->method), delay->method);
}

References ast_sip_session_delayed_request::active_media_state, ast_sip_session_get_name(), AST_SIP_SESSION_REFRESH_METHOD_INVITE, AST_SIP_SESSION_REFRESH_METHOD_UPDATE, ast_sip_session_terminate(), delayed_method2str(), DELAYED_METHOD_BYE, DELAYED_METHOD_INVITE, DELAYED_METHOD_UPDATE, ast_sip_session_delayed_request::generate_new_sdp, LOG_WARNING, ast_sip_session_delayed_request::method, NULL, ast_sip_session_delayed_request::on_request_creation, ast_sip_session_delayed_request::on_response, ast_sip_session_delayed_request::on_sdp_creation, ast_sip_session_delayed_request::pending_media_state, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, session, and sip_session_refresh().

Referenced by invite_proceeding(), and invite_terminated().

◆ session_datastore_destroy()

static void session_datastore_destroy ( void * obj )

static

Definition at line 1275 of file res_pjsip_session.c.

{
    struct ast_datastore *datastore = obj;
 
    /* Using the destroy function (if present) destroy the data */
    if (datastore->info->destroy != NULL && datastore->data != NULL) {
        datastore->info->destroy(datastore->data);
        datastore->data = NULL;
    }
 
    ast_free((void *) datastore->uid);
    datastore->uid = NULL;
}

References ast_free, ast_datastore::data, ast_datastore_info::destroy, ast_datastore::info, NULL, and ast_datastore::uid.

Referenced by ast_sip_session_alloc_datastore().

◆ session_destructor()

static void session_destructor ( void * obj )

static

Definition at line 3021 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = obj;
 
#ifdef TEST_FRAMEWORK
    /* We dup the endpoint ID in case the endpoint gets freed out from under us */
    const char *endpoint_name = session->endpoint ?
        ast_strdupa(ast_sorcery_object_get_id(session->endpoint)) : "<none>";
#endif
 
    ast_debug(3, "%s: Destroying SIP session\n", ast_sip_session_get_name(session));
 
    ast_test_suite_event_notify("SESSION_DESTROYING",
        "Endpoint: %s\r\n"
        "AOR: %s\r\n"
        "Contact: %s"
        , endpoint_name
        , session->aor ? ast_sorcery_object_get_id(session->aor) : "<none>"
        , session->contact ? ast_sorcery_object_get_id(session->contact) : "<none>"
        );
 
    /* fire session destroy handler */
    handle_session_destroy(session);
 
    /* remove all registered supplements */
    ast_sip_session_remove_supplements(session);
    AST_LIST_HEAD_DESTROY(&session->supplements);
 
    /* remove all saved media stats */
    AST_VECTOR_RESET(&session->media_stats, ast_free);
    AST_VECTOR_FREE(&session->media_stats);
 
    ast_taskprocessor_unreference(session->serializer);
    ao2_cleanup(session->datastores);
    ast_sip_session_media_state_free(session->active_media_state);
    ast_sip_session_media_state_free(session->pending_media_state);
 
    flush_delayed_requests(session);
    ast_party_id_free(&session->id);
    ao2_cleanup(session->endpoint);
    ao2_cleanup(session->aor);
    ao2_cleanup(session->contact);
    ao2_cleanup(session->direct_media_cap);
 
    ast_dsp_free(session->dsp);
 
    if (session->inv_session) {
        struct pjsip_dialog *dlg = session->inv_session->dlg;
 
        /* The INVITE session uses the dialog pool for memory, so we need to
         * decrement its reference first before that of the dialog.
         */
 
#ifdef HAVE_PJSIP_INV_SESSION_REF
        pjsip_inv_dec_ref(session->inv_session);
#endif
        pjsip_dlg_dec_session(dlg, &session_module);
    }
 
    ast_test_suite_event_notify("SESSION_DESTROYED", "Endpoint: %s", endpoint_name);
}

References ao2_cleanup, ast_debug, ast_dsp_free(), ast_free, AST_LIST_HEAD_DESTROY, ast_party_id_free(), ast_sip_session_get_name(), ast_sip_session_media_state_free(), ast_sip_session_remove_supplements(), ast_sorcery_object_get_id(), ast_strdupa, ast_taskprocessor_unreference(), ast_test_suite_event_notify, AST_VECTOR_FREE, AST_VECTOR_RESET, flush_delayed_requests(), handle_session_destroy(), session, and session_module.

Referenced by ast_sip_session_alloc().

◆ session_end()

static int session_end ( void * vsession )

static

Definition at line 4634 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
 
    /* Stop the scheduled termination */
    sip_session_defer_termination_stop_timer(session);
 
    /* Session is dead.  Notify the supplements. */
    handle_session_end(session);
 
    return 0;
}

References handle_session_end(), session, and sip_session_defer_termination_stop_timer().

Referenced by ast_sip_session_end_if_deferred(), ast_sip_session_terminate(), and session_inv_on_state_changed().

◆ session_end_completion()

static int session_end_completion ( void * vsession )

static

Definition at line 4657 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
 
    ast_sip_dialog_set_serializer(session->inv_session->dlg, NULL);
    ast_sip_dialog_set_endpoint(session->inv_session->dlg, NULL);
 
    /* Now we can release the ref that was held by session->inv_session */
    ao2_cleanup(session);
    return 0;
}

References ao2_cleanup, ast_sip_dialog_set_endpoint(), ast_sip_dialog_set_serializer(), NULL, and session.

Referenced by ast_sip_session_terminate(), and session_end_if_disconnected().

◆ session_end_if_disconnected()

static int session_end_if_disconnected	(	int	id,
		pjsip_inv_session *	inv
	)

static

Definition at line 4814 of file res_pjsip_session.c.

{
    struct ast_sip_session *session;
 
    if (inv->state != PJSIP_INV_STATE_DISCONNECTED) {
        return 0;
    }
 
    /*
     * We are locking because ast_sip_dialog_get_session() needs
     * the dialog locked to get the session by other threads.
     */
    pjsip_dlg_inc_lock(inv->dlg);
    session = inv->mod_data[id];
    inv->mod_data[id] = NULL;
    pjsip_dlg_dec_lock(inv->dlg);
 
    /*
     * Pass the session ref held by session->inv_session to
     * session_end_completion().
     */
    if (session
        && ast_sip_push_task(session->serializer, session_end_completion, session)) {
        /* Do it anyway even though this is not the right thread. */
        session_end_completion(session);
    }
 
    return 1;
}

References ast_sip_push_task, id, NULL, session, and session_end_completion().

Referenced by session_inv_on_tsx_state_changed().

◆ session_inv_on_create_offer()

static void session_inv_on_create_offer	(	pjsip_inv_session *	inv,
		pjmedia_sdp_session **	p_offer
	)

static

Definition at line 5392 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    const pjmedia_sdp_session *previous_sdp = NULL;
    pjmedia_sdp_session *offer;
    int i;
    unsigned int ignore_active_stream_topology = 0;
 
    /* We allow PJSIP to produce an SDP if no channel is present. This may result
     * in an incorrect SDP occurring, but if no channel is present then we are in
     * the midst of a BYE and are hanging up. This ensures that all the code to
     * produce an SDP doesn't need to worry about a channel being present or not,
     * just in case.
     */
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
    if (!session->channel) {
        SCOPE_EXIT_RTN("%s: No channel\n", ast_sip_session_get_name(session));
    }
 
    /* Some devices send a re-INVITE offer with empty SDP. Asterisk by default return
     * an answer with the current used codecs, which is not strictly compliant to RFC
     * 3261 (SHOULD requirement). So we detect this condition and include all
     * configured codecs in the answer if the workaround is activated. The actual
     * logic is in the create_local_sdp function. We can't detect here that we have
     * no SDP body in the INVITE, as we don't have access to the message.
     */
    if (inv->invite_tsx && inv->state == PJSIP_INV_STATE_CONFIRMED
            && inv->invite_tsx->method.id == PJSIP_INVITE_METHOD) {
        ast_trace(-1, "re-INVITE\n");
        if (inv->invite_tsx->role == PJSIP_ROLE_UAS
                && ast_sip_get_all_codecs_on_empty_reinvite()) {
            ast_trace(-1, "UAS role, include all codecs in the answer on empty SDP\n");
            ignore_active_stream_topology = 1;
        }
    }
 
    if (inv->neg) {
        if (pjmedia_sdp_neg_was_answer_remote(inv->neg)) {
            pjmedia_sdp_neg_get_active_remote(inv->neg, &previous_sdp);
        } else {
            pjmedia_sdp_neg_get_active_local(inv->neg, &previous_sdp);
        }
    }
 
    if (ignore_active_stream_topology) {
        offer = create_local_sdp(inv, session, NULL, 1);
    } else {
        offer = create_local_sdp(inv, session, previous_sdp, 0);
    }
    if (!offer) {
        SCOPE_EXIT_RTN("%s: create offer failed\n", ast_sip_session_get_name(session));
    }
 
    ast_queue_unhold(session->channel);
 
    /*
     * Some devices indicate hold with deferred SDP reinvites (i.e. no SDP in the reinvite).
     * When hold is initially indicated, we
     * - Receive an INVITE with no SDP
     * - Send a 200 OK with SDP, indicating sendrecv in the media streams
     * - Receive an ACK with SDP, indicating sendonly in the media streams
     *
     * At this point, the pjmedia negotiator saves the state of the media direction so that
     * if we are to send any offers, we'll offer recvonly in the media streams. This is
     * problematic if the device is attempting to unhold, though. If the device unholds
     * by sending a reinvite with no SDP, then we will respond with a 200 OK with recvonly.
     * According to RFC 3264, if an offerer offers recvonly, then the answerer MUST respond
     * with sendonly or inactive. The result of this is that the stream is not off hold.
     *
     * Therefore, in this case, when we receive a reinvite while the stream is on hold, we
     * need to be sure to offer sendrecv. This way, the answerer can respond with sendrecv
     * in order to get the stream off hold. If this is actually a different purpose reinvite
     * (like a session timer refresh), then the answerer can respond to our sendrecv with
     * sendonly, keeping the stream on hold.
     */
    for (i = 0; i < offer->media_count; ++i) {
        pjmedia_sdp_media *m = offer->media[i];
        pjmedia_sdp_attr *recvonly;
        pjmedia_sdp_attr *inactive;
        pjmedia_sdp_attr *sendonly;
 
        recvonly = pjmedia_sdp_attr_find2(m->attr_count, m->attr, "recvonly", NULL);
        inactive = pjmedia_sdp_attr_find2(m->attr_count, m->attr, "inactive", NULL);
        sendonly = pjmedia_sdp_attr_find2(m->attr_count, m->attr, "sendonly", NULL);
        if (recvonly || inactive || sendonly) {
            pjmedia_sdp_attr *to_remove = recvonly ?: inactive ?: sendonly;
            pjmedia_sdp_attr *sendrecv;
 
            pjmedia_sdp_attr_remove(&m->attr_count, m->attr, to_remove);
 
            sendrecv = pjmedia_sdp_attr_create(session->inv_session->pool, "sendrecv", NULL);
            pjmedia_sdp_media_add_attr(m, sendrecv);
        }
    }
 
    *p_offer = offer;
    SCOPE_EXIT_RTN("%s: offer created\n", ast_sip_session_get_name(session));
}

References ast_queue_unhold(), ast_sip_get_all_codecs_on_empty_reinvite(), ast_sip_session_get_name(), ast_trace, create_local_sdp(), NULL, SCOPE_ENTER, SCOPE_EXIT_RTN, session, and session_module.

◆ session_inv_on_media_update()

static void session_inv_on_media_update	(	pjsip_inv_session *	inv,
		pj_status_t	status
	)

static

Definition at line 5491 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    const pjmedia_sdp_session *local, *remote;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (ast_shutdown_final()) {
        SCOPE_EXIT_RTN("%s: Shutdown in progress\n", ast_sip_session_get_name(session));
    }
 
    session = inv->mod_data[session_module.id];
    if (!session || !session->channel) {
        /*
         * If we don't have a session or channel then we really
         * don't care about media updates.
         * Just ignore
         */
        SCOPE_EXIT_RTN("%s: No channel or session\n", ast_sip_session_get_name(session));
    }
 
    if (session->endpoint) {
        int bail = 0;
 
        /*
         * If following_fork is set, then this is probably the result of a
         * forked INVITE and SDP asnwers coming from the different fork UAS
         * destinations.  In this case updated_sdp_answer will also be set.
         *
         * If only updated_sdp_answer is set, then this is the non-forking
         * scenario where the same UAS just needs to change something like
         * the media port.
         */
 
        if (inv->following_fork) {
            if (session->endpoint->media.rtp.follow_early_media_fork) {
                ast_trace(-1, "%s: Following early media fork with different To tags\n", ast_sip_session_get_name(session));
            } else {
                ast_trace(-1, "%s: Not following early media fork with different To tags\n", ast_sip_session_get_name(session));
                bail = 1;
            }
        }
#ifdef HAVE_PJSIP_INV_ACCEPT_MULTIPLE_SDP_ANSWERS
        else if (inv->updated_sdp_answer) {
            if (session->endpoint->media.rtp.accept_multiple_sdp_answers) {
                ast_trace(-1, "%s: Accepting updated SDP with same To tag\n", ast_sip_session_get_name(session));
            } else {
                ast_trace(-1, "%s: Ignoring updated SDP answer with same To tag\n", ast_sip_session_get_name(session));
                bail = 1;
            }
        }
#endif
        if (bail) {
            SCOPE_EXIT_RTN("%s: Bailing\n", ast_sip_session_get_name(session));
        }
    }
 
    if ((status != PJ_SUCCESS) || (pjmedia_sdp_neg_get_active_local(inv->neg, &local) != PJ_SUCCESS) ||
        (pjmedia_sdp_neg_get_active_remote(inv->neg, &remote) != PJ_SUCCESS)) {
        ast_channel_hangupcause_set(session->channel, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
        ast_set_hangupsource(session->channel, ast_channel_name(session->channel), 0);
        ast_queue_hangup(session->channel);
        SCOPE_EXIT_RTN("%s: Couldn't get active or local or remote negotiator.  Hanging up\n", ast_sip_session_get_name(session));
    }
 
    if (handle_negotiated_sdp(session, local, remote)) {
        ast_sip_session_media_state_reset(session->pending_media_state);
        SCOPE_EXIT_RTN("%s: handle_negotiated_sdp failed.  Resetting pending media state\n", ast_sip_session_get_name(session));
    }
    SCOPE_EXIT_RTN("%s\n", ast_sip_session_get_name(session));
}

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, ast_channel_hangupcause_set(), ast_channel_name(), ast_queue_hangup(), ast_set_hangupsource(), ast_shutdown_final(), ast_sip_session_get_name(), ast_sip_session_media_state_reset(), ast_trace, handle_negotiated_sdp(), SCOPE_ENTER, SCOPE_EXIT_RTN, session, session_module, and status.

◆ session_inv_on_new_session()

static void session_inv_on_new_session	(	pjsip_inv_session *	inv,
		pjsip_event *	e
	)

static

Definition at line 4809 of file res_pjsip_session.c.

{
    /* XXX STUB */
}

◆ session_inv_on_redirected()

static pjsip_redirect_op session_inv_on_redirected	(	pjsip_inv_session *	inv,
		const pjsip_uri *	target,
		const pjsip_event *	e
	)

static

Definition at line 5562 of file res_pjsip_session.c.

{
    struct ast_sip_session *session;
    const pjsip_sip_uri *uri;
 
    if (ast_shutdown_final()) {
        return PJSIP_REDIRECT_STOP;
    }
 
    session = inv->mod_data[session_module.id];
    if (!session || !session->channel) {
        return PJSIP_REDIRECT_STOP;
    }
 
    if (session->endpoint->redirect_method == AST_SIP_REDIRECT_URI_PJSIP) {
        return PJSIP_REDIRECT_ACCEPT;
    }
 
    if (!PJSIP_URI_SCHEME_IS_SIP(target) && !PJSIP_URI_SCHEME_IS_SIPS(target)) {
        return PJSIP_REDIRECT_STOP;
    }
 
    handle_incoming(session, e->body.rx_msg.rdata, AST_SIP_SESSION_BEFORE_REDIRECTING);
 
    uri = pjsip_uri_get_uri(target);
 
    if (session->endpoint->redirect_method == AST_SIP_REDIRECT_USER) {
        char exten[AST_MAX_EXTENSION];
 
        ast_copy_pj_str(exten, &uri->user, sizeof(exten));
 
        /*
         * We may want to match in the dialplan without any user
         * options getting in the way.
         */
        AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(exten);
 
        ast_channel_call_forward_set(session->channel, exten);
    } else if (session->endpoint->redirect_method == AST_SIP_REDIRECT_URI_CORE) {
        char target_uri[PJSIP_MAX_URL_SIZE];
        /* PJSIP/ + endpoint length + / + max URL size */
        char forward[8 + strlen(ast_sorcery_object_get_id(session->endpoint)) + PJSIP_MAX_URL_SIZE];
 
        pjsip_uri_print(PJSIP_URI_IN_REQ_URI, uri, target_uri, sizeof(target_uri));
        sprintf(forward, "PJSIP/%s/%s", ast_sorcery_object_get_id(session->endpoint), target_uri);
        ast_channel_call_forward_set(session->channel, forward);
    }
 
    return PJSIP_REDIRECT_STOP;
}

References ast_copy_pj_str(), AST_MAX_EXTENSION, ast_shutdown_final(), AST_SIP_REDIRECT_URI_CORE, AST_SIP_REDIRECT_URI_PJSIP, AST_SIP_REDIRECT_USER, AST_SIP_SESSION_BEFORE_REDIRECTING, AST_SIP_USER_OPTIONS_TRUNCATE_CHECK, ast_sorcery_object_get_id(), ast_sip_session::exten, handle_incoming(), session, and session_module.

◆ session_inv_on_rx_offer()

static void session_inv_on_rx_offer	(	pjsip_inv_session *	inv,
		const pjmedia_sdp_session *	offer
	)

static

Definition at line 5369 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    pjmedia_sdp_session *answer;
    SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
 
    if (ast_shutdown_final()) {
        SCOPE_EXIT_RTN("%s: Shutdown in progress\n", ast_sip_session_get_name(session));
    }
 
    session = inv->mod_data[session_module.id];
    if (handle_incoming_sdp(session, offer)) {
        ast_sip_session_media_state_reset(session->pending_media_state);
        SCOPE_EXIT_RTN("%s: handle_incoming_sdp failed\n", ast_sip_session_get_name(session));
    }
 
    if ((answer = create_local_sdp(inv, session, offer, 0))) {
        pjsip_inv_set_sdp_answer(inv, answer);
        SCOPE_EXIT_RTN("%s: Set SDP answer\n", ast_sip_session_get_name(session));
    }
    SCOPE_EXIT_RTN("%s: create_local_sdp failed\n", ast_sip_session_get_name(session));
}

References answer(), ast_shutdown_final(), ast_sip_session_get_name(), ast_sip_session_media_state_reset(), create_local_sdp(), handle_incoming_sdp(), SCOPE_ENTER, SCOPE_EXIT_RTN, session, and session_module.

◆ session_inv_on_state_changed()

static void session_inv_on_state_changed	(	pjsip_inv_session *	inv,
		pjsip_event *	e
	)

static

Definition at line 4728 of file res_pjsip_session.c.

{
    pjsip_event_id_e type;
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    SCOPE_ENTER(1, "%s Event: %s  Inv State: %s\n", ast_sip_session_get_name(session),
        pjsip_event_str(e->type), pjsip_inv_state_name(inv->state));
 
    if (ast_shutdown_final()) {
        SCOPE_EXIT_RTN("Shutting down\n");
    }
 
    if (e) {
        print_debug_details(inv, NULL, e);
        type = e->type;
    } else {
        type = PJSIP_EVENT_UNKNOWN;
    }
 
    session = inv->mod_data[session_module.id];
    if (!session) {
        SCOPE_EXIT_RTN("No session\n");
    }
 
    switch(type) {
    case PJSIP_EVENT_TX_MSG:
        break;
    case PJSIP_EVENT_RX_MSG:
        handle_incoming_before_media(inv, session, e->body.rx_msg.rdata);
        break;
    case PJSIP_EVENT_TSX_STATE:
        ast_debug(3, "%s: Source of transaction state change is %s\n", ast_sip_session_get_name(session),
            pjsip_event_str(e->body.tsx_state.type));
        /* Transaction state changes are prompted by some other underlying event. */
        switch(e->body.tsx_state.type) {
        case PJSIP_EVENT_TX_MSG:
            break;
        case PJSIP_EVENT_RX_MSG:
            if (!check_request_status(inv, e)) {
                handle_incoming_before_media(inv, session, e->body.tsx_state.src.rdata);
            }
            break;
        case PJSIP_EVENT_TRANSPORT_ERROR:
        case PJSIP_EVENT_TIMER:
            /*
             * Check the request status on transport error or timeout. A transport
             * error can occur when a TCP socket closes and that can be the result
             * of a 503. Also we may need to failover on a timeout (408).
             */
            check_request_status(inv, e);
            break;
        case PJSIP_EVENT_USER:
        case PJSIP_EVENT_UNKNOWN:
        case PJSIP_EVENT_TSX_STATE:
            /* Inception? */
            break;
        }
        break;
    case PJSIP_EVENT_TRANSPORT_ERROR:
    case PJSIP_EVENT_TIMER:
    case PJSIP_EVENT_UNKNOWN:
    case PJSIP_EVENT_USER:
    default:
        break;
    }
 
    if (inv->state == PJSIP_INV_STATE_DISCONNECTED) {
        if (session->defer_end) {
            ast_debug(3, "%s: Deferring session end\n", ast_sip_session_get_name(session));
            session->ended_while_deferred = 1;
            SCOPE_EXIT_RTN("Deferring\n");
        }
 
        if (ast_sip_push_task(session->serializer, session_end, session)) {
            /* Do it anyway even though this is not the right thread. */
            session_end(session);
        }
    }
 
    SCOPE_EXIT_RTN();
}

References ast_debug, ast_shutdown_final(), ast_sip_push_task, ast_sip_session_get_name(), check_request_status(), handle_incoming_before_media(), NULL, print_debug_details, SCOPE_ENTER, SCOPE_EXIT_RTN, session, session_end(), session_module, and type.

◆ session_inv_on_tsx_state_changed()

static void session_inv_on_tsx_state_changed	(	pjsip_inv_session *	inv,
		pjsip_transaction *	tsx,
		pjsip_event *	e
	)

static

Definition at line 4844 of file res_pjsip_session.c.

{
    ast_sip_session_response_cb cb;
    int id = session_module.id;
    pjsip_tx_data *tdata;
    struct ast_sip_session *session = inv->mod_data[session_module.id];
    SCOPE_ENTER(1, "%s TSX State: %s  Inv State: %s\n", ast_sip_session_get_name(session),
        pjsip_tsx_state_str(tsx->state), pjsip_inv_state_name(inv->state));
 
    if (ast_shutdown_final()) {
        SCOPE_EXIT_RTN("Shutting down\n");
    }
 
    session = inv->mod_data[id];
 
    print_debug_details(inv, tsx, e);
    if (!session) {
        /* The session has ended.  Ignore the transaction change. */
        SCOPE_EXIT_RTN("Session ended\n");
    }
 
    /*
     * If the session is disconnected really nothing else to do unless currently transacting
     * a BYE. If a BYE then hold off destruction until the transaction timeout occurs. This
     * has to be done for BYEs because sometimes the dialog can be in a disconnected
     * state but the BYE request transaction has not yet completed.
     */
    if (tsx->method.id != PJSIP_BYE_METHOD && session_end_if_disconnected(id, inv)) {
        SCOPE_EXIT_RTN("Disconnected\n");
    }
 
    switch (e->body.tsx_state.type) {
    case PJSIP_EVENT_TX_MSG:
        /* When we create an outgoing request, we do not have access to the transaction that
         * is created. Instead, We have to place transaction-specific data in the tdata. Here,
         * we transfer the data into the transaction. This way, when we receive a response, we
         * can dig this data out again
         */
        tsx->mod_data[id] = e->body.tsx_state.src.tdata->mod_data[id];
        break;
    case PJSIP_EVENT_RX_MSG:
        cb = ast_sip_mod_data_get(tsx->mod_data, id, MOD_DATA_ON_RESPONSE);
        /* As the PJSIP invite session implementation responds with a 200 OK before we have a
         * chance to be invoked session supplements for BYE requests actually end up executing
         * in the invite session state callback as well. To prevent session supplements from
         * running on the BYE request again we explicitly squash invocation of them here.
         */
        if ((e->body.tsx_state.src.rdata->msg_info.msg->type != PJSIP_REQUEST_MSG) ||
            (tsx->method.id != PJSIP_BYE_METHOD)) {
            handle_incoming(session, e->body.tsx_state.src.rdata,
                AST_SIP_SESSION_AFTER_MEDIA);
        }
        if (tsx->method.id == PJSIP_INVITE_METHOD) {
            if (tsx->role == PJSIP_ROLE_UAC) {
                if (tsx->state == PJSIP_TSX_STATE_COMPLETED) {
                    /* This means we got a non 2XX final response to our outgoing INVITE */
                    if (tsx->status_code == PJSIP_SC_REQUEST_PENDING) {
                        reschedule_reinvite(session, cb);
                        SCOPE_EXIT_RTN("Non 2XX final response\n");
                    }
                    if (inv->state == PJSIP_INV_STATE_CONFIRMED) {
                        ast_debug(1, "%s: reINVITE received final response code %d\n",
                            ast_sip_session_get_name(session),
                            tsx->status_code);
                        if ((tsx->status_code == 401 || tsx->status_code == 407
                            || (session->endpoint->security_negotiation && tsx->status_code == 494))
                            && ++session->authentication_challenge_count < MAX_RX_CHALLENGES
                            && !ast_sip_create_request_with_auth(
                                &session->endpoint->outbound_auths,
                                e->body.tsx_state.src.rdata, tsx->last_tx, &tdata)) {
                            /* Send authed reINVITE */
                            ast_sip_session_send_request_with_cb(session, tdata, cb);
                            SCOPE_EXIT_RTN("Sending authed reinvite\n");
                        }
                        /* Per RFC3261 14.1 a response to a re-INVITE should only terminate
                         * the dialog if a 481 or 408 occurs. All other responses should leave
                         * the dialog untouched.
                         */
                        if (tsx->status_code == 481 || tsx->status_code == 408) {
                            if (pjsip_inv_end_session(inv, 500, NULL, &tdata) == PJ_SUCCESS
                                && tdata) {
                                ast_sip_session_send_request(session, tdata);
                            }
                        }
                    }
                } else if (tsx->state == PJSIP_TSX_STATE_TERMINATED) {
                    if (!inv->cancelling
                        && inv->role == PJSIP_ROLE_UAC
                        && inv->state == PJSIP_INV_STATE_CONFIRMED
                        && pjmedia_sdp_neg_was_answer_remote(inv->neg)
                        && pjmedia_sdp_neg_get_state(inv->neg) == PJMEDIA_SDP_NEG_STATE_DONE
                        && (session->channel && ast_channel_hangupcause(session->channel) == AST_CAUSE_BEARERCAPABILITY_NOTAVAIL)
                        ) {
                        /*
                         * We didn't send a CANCEL but the UAS sent us the 200 OK with an invalid or unacceptable codec SDP.
                         * In this case the SDP negotiation is incomplete and PJPROJECT has already sent the ACK.
                         * So, we send the BYE with 503 status code here. And the actual hangup cause code is already set
                         * to AST_CAUSE_BEARERCAPABILITY_NOTAVAIL by the session_inv_on_media_update(), setting the 503
                         * status code doesn't affect to hangup cause code.
                         */
                        ast_debug(1, "Endpoint '%s(%s)': Ending session due to 200 OK with incomplete SDP negotiation.  %s\n",
                            ast_sorcery_object_get_id(session->endpoint),
                            session->channel ? ast_channel_name(session->channel) : "",
                            pjsip_rx_data_get_info(e->body.tsx_state.src.rdata));
                        pjsip_inv_end_session(session->inv_session, 503, NULL, &tdata);
                        SCOPE_EXIT_RTN("Incomplete SDP negotiation\n");
                    }
 
                    if (inv->cancelling && tsx->status_code == PJSIP_SC_OK) {
                        int sdp_negotiation_done =
                            pjmedia_sdp_neg_get_state(inv->neg) == PJMEDIA_SDP_NEG_STATE_DONE;
 
                        /*
                         * We can get here for the following reasons.
                         *
                         * 1) The race condition detailed in RFC5407 section 3.1.2.
                         * We sent a CANCEL at the same time that the UAS sent us a
                         * 200 OK with a valid SDP for the original INVITE.  As a
                         * result, we have now received a 200 OK for a cancelled
                         * call and the SDP negotiation is complete.  We need to
                         * immediately send a BYE to end the dialog.
                         *
                         * 2) We sent a CANCEL and hit the race condition but the
                         * UAS sent us an invalid SDP with the 200 OK.  In this case
                         * the SDP negotiation is incomplete and PJPROJECT has
                         * already sent the BYE for us because of the invalid SDP.
                         */
                        ast_test_suite_event_notify("PJSIP_SESSION_CANCELED",
                            "Endpoint: %s\r\n"
                            "Channel: %s\r\n"
                            "Message: %s\r\n"
                            "SDP: %s",
                            ast_sorcery_object_get_id(session->endpoint),
                            session->channel ? ast_channel_name(session->channel) : "",
                            pjsip_rx_data_get_info(e->body.tsx_state.src.rdata),
                            sdp_negotiation_done ? "complete" : "incomplete");
                        if (!sdp_negotiation_done) {
                            ast_debug(1, "%s: Incomplete SDP negotiation cancelled session.  %s\n",
                                ast_sip_session_get_name(session),
                                pjsip_rx_data_get_info(e->body.tsx_state.src.rdata));
                        } else if (pjsip_inv_end_session(inv, 500, NULL, &tdata) == PJ_SUCCESS
                            && tdata) {
                            ast_debug(1, "%s: Ending session due to RFC5407 race condition.  %s\n",
                                ast_sip_session_get_name(session),
                                pjsip_rx_data_get_info(e->body.tsx_state.src.rdata));
                            ast_sip_session_send_request(session, tdata);
                        }
                    }
                }
            }
        } else {
            /* All other methods */
            if (tsx->role == PJSIP_ROLE_UAC) {
                if (tsx->state == PJSIP_TSX_STATE_COMPLETED) {
                    /* This means we got a final response to our outgoing method */
                    ast_debug(1, "%s: %.*s received final response code %d\n",
                        ast_sip_session_get_name(session),
                        (int) pj_strlen(&tsx->method.name), pj_strbuf(&tsx->method.name),
                        tsx->status_code);
                    if ((tsx->status_code == 401 || tsx->status_code == 407 || tsx->status_code == 494)
                        && ++session->authentication_challenge_count < MAX_RX_CHALLENGES
                        && !ast_sip_create_request_with_auth(
                            &session->endpoint->outbound_auths,
                            e->body.tsx_state.src.rdata, tsx->last_tx, &tdata)) {
                        /* Send authed version of the method */
                        ast_sip_session_send_request_with_cb(session, tdata, cb);
                        SCOPE_EXIT_RTN("Sending authed %.*s\n",
                            (int) pj_strlen(&tsx->method.name), pj_strbuf(&tsx->method.name));
                    }
                }
            }
        }
        if (cb) {
            cb(session, e->body.tsx_state.src.rdata);
        }
        break;
    case PJSIP_EVENT_TRANSPORT_ERROR:
    case PJSIP_EVENT_TIMER:
        /*
         * The timer event is run by the pjsip monitor thread and not
         * by the session serializer.
         */
        if (session_end_if_disconnected(id, inv)) {
            SCOPE_EXIT_RTN("Disconnected\n");
        }
        break;
    case PJSIP_EVENT_USER:
    case PJSIP_EVENT_UNKNOWN:
    case PJSIP_EVENT_TSX_STATE:
        /* Inception? */
        break;
    }
 
    if (session->terminate_on_invite_timeout && uac_invite_tsx_terminates_dialog(tsx)) {
        /*
         * PJPROJECT already considers this dialog terminated; the delayed BYE is
         * obsolete and still owns media state that must be released.
         */
        ast_debug(3, "%s: Flushing delayed requests because outstanding INVITE terminated dialog\n",
            ast_sip_session_get_name(session));
        flush_delayed_requests(session);
        session->terminate_on_invite_timeout = 0;
    }
 
    if (AST_LIST_EMPTY(&session->delayed_requests)) {
        /* No delayed request pending, so just return */
        SCOPE_EXIT_RTN("Nothing delayed\n");
    }
 
    if (tsx->method.id == PJSIP_INVITE_METHOD) {
        if (tsx->state == PJSIP_TSX_STATE_PROCEEDING) {
            ast_debug(3, "%s: INVITE delay check. tsx-state:%s\n",
                ast_sip_session_get_name(session),
                pjsip_tsx_state_str(tsx->state));
            check_delayed_requests(session, invite_proceeding);
        } else if (tsx->state == PJSIP_TSX_STATE_TERMINATED) {
            /*
             * Terminated INVITE transactions always should result in
             * queuing delayed requests, no matter what event caused
             * the transaction to terminate.
             */
            ast_debug(3, "%s: INVITE delay check. tsx-state:%s\n",
                ast_sip_session_get_name(session),
                pjsip_tsx_state_str(tsx->state));
            check_delayed_requests(session, invite_terminated);
        }
    } else if (tsx->role == PJSIP_ROLE_UAC
        && tsx->state == PJSIP_TSX_STATE_COMPLETED
        && !pj_strcmp2(&tsx->method.name, "UPDATE")) {
        ast_debug(3, "%s: UPDATE delay check. tsx-state:%s\n",
            ast_sip_session_get_name(session),
            pjsip_tsx_state_str(tsx->state));
        check_delayed_requests(session, update_completed);
    }
 
    SCOPE_EXIT_RTN();
}

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, ast_channel_hangupcause(), ast_channel_name(), ast_debug, AST_LIST_EMPTY, ast_shutdown_final(), ast_sip_create_request_with_auth(), ast_sip_mod_data_get, AST_SIP_SESSION_AFTER_MEDIA, ast_sip_session_get_name(), ast_sip_session_send_request(), ast_sip_session_send_request_with_cb(), ast_sorcery_object_get_id(), ast_test_suite_event_notify, check_delayed_requests(), flush_delayed_requests(), handle_incoming(), id, invite_proceeding(), invite_terminated(), MAX_RX_CHALLENGES, MOD_DATA_ON_RESPONSE, NULL, print_debug_details, reschedule_reinvite(), SCOPE_ENTER, SCOPE_EXIT_RTN, session, session_end_if_disconnected(), session_module, uac_invite_tsx_terminates_dialog(), and update_completed().

◆ session_media_dtor()

static void session_media_dtor ( void * obj )

static

Definition at line 478 of file res_pjsip_session.c.

{
    struct ast_sip_session_media *session_media = obj;
 
    /* It is possible for multiple handlers to have allocated memory on the
     * session media (usually through a stream changing types). Therefore, we
     * traverse all the SDP handlers and let them all call stream_destroy on
     * the session_media
     */
    ao2_callback(sdp_handlers, 0, stream_destroy, session_media);
 
    if (session_media->srtp) {
        ast_sdp_srtp_destroy(session_media->srtp);
    }
 
    ast_free(session_media->mid);
    ast_free(session_media->remote_mslabel);
    ast_free(session_media->remote_label);
    ast_free(session_media->stream_name);
}

References ao2_callback, ast_free, ast_sdp_srtp_destroy(), ast_sip_session_media::mid, ast_sip_session_media::remote_label, ast_sip_session_media::remote_mslabel, sdp_handlers, ast_sip_session_media::srtp, stream_destroy(), and ast_sip_session_media::stream_name.

Referenced by ast_sip_session_media_state_add().

◆ session_media_set_handler()

static void session_media_set_handler	(	struct ast_sip_session_media *	session_media,
		struct ast_sip_session_sdp_handler *	handler
	)

static

Set an SDP stream handler for a corresponding session media.

Note: Always use this function to set the SDP handler for a session media.

This function will properly free resources on the SDP handler currently being used by the session media, then set the session media to use the new SDP handler.

Definition at line 454 of file res_pjsip_session.c.

{
    ast_assert(session_media->handler != handler);
 
    if (session_media->handler) {
        session_media->handler->stream_destroy(session_media);
    }
    session_media->handler = handler;
}

References ast_assert, ast_sip_session_media::handler, handler(), and ast_sip_session_sdp_handler::stream_destroy.

Referenced by add_sdp_streams(), handle_incoming_sdp(), handle_negotiated_sdp(), handle_negotiated_sdp_session_media(), and sdp_requires_deferral().

◆ session_on_rx_request()

static pj_bool_t session_on_rx_request ( pjsip_rx_data * rdata )

static

Called when a new SIP request comes into PJSIP.

This function is called under two circumstances 1) An out-of-dialog request is received by PJSIP 2) An in-dialog request that the inv_session layer does not handle is received (such as an in-dialog INFO)

Except for INVITEs, there is very little we actually do in this function 1) For requests we don't handle, we return PJ_FALSE 2) For new INVITEs, handle them now to prevent retransmissions from trying to setup the same call again. 3) For in-dialog requests we handle, we process them in the .on_state_changed = session_inv_on_state_changed or .on_tsx_state_changed = session_inv_on_tsx_state_changed callbacks instead.

Definition at line 4312 of file res_pjsip_session.c.

{
    pj_status_t handled = PJ_FALSE;
    struct pjsip_request_line req = rdata->msg_info.msg->line.req;
    pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
    pjsip_inv_session *inv_session = (dlg ? pjsip_dlg_get_inv_session(dlg) : NULL);
    struct ast_sip_session *session = (inv_session ? inv_session->mod_data[session_module.id] : NULL);
    char *req_uri = TRACE_ATLEAST(1) ? ast_alloca(256) : "";
    int res = TRACE_ATLEAST(1) ? pjsip_uri_print(PJSIP_URI_IN_REQ_URI, rdata->msg_info.msg->line.req.uri, req_uri, 256) : 0;
    SCOPE_ENTER(1, "%s Request: %.*s %s\n", ast_sip_session_get_name(session),
        (int) pj_strlen(&req.method.name), pj_strbuf(&req.method.name), res ? req_uri : "");
 
    switch (req.method.id) {
    case PJSIP_INVITE_METHOD:
        if (dlg) {
            ast_log(LOG_WARNING, "on_rx_request called for INVITE in mid-dialog?\n");
            break;
        }
        handled = PJ_TRUE;
        handle_new_invite_request(rdata);
        break;
    default:
        /* Handle other in-dialog methods if their supplements have been registered */
        handled = dlg && (inv_session = pjsip_dlg_get_inv_session(dlg)) &&
            has_supplement(inv_session->mod_data[session_module.id], rdata);
        break;
    }
 
    SCOPE_EXIT_RTN_VALUE(handled, "%s Handled request %.*s %s ? %s\n", ast_sip_session_get_name(session),
        (int) pj_strlen(&req.method.name), pj_strbuf(&req.method.name), req_uri,
        handled == PJ_TRUE ? "yes" : "no");
}

References ast_alloca, ast_log, ast_sip_session_get_name(), handle_new_invite_request(), has_supplement(), ast_sip_session::inv_session, LOG_WARNING, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, session_module, and TRACE_ATLEAST.

◆ session_on_rx_response()

static pj_bool_t session_on_rx_response ( pjsip_rx_data * rdata )

static

Definition at line 4282 of file res_pjsip_session.c.

{
 
    struct pjsip_status_line status = rdata->msg_info.msg->line.status;
    pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
    pjsip_inv_session *inv_session = dlg ? pjsip_dlg_get_inv_session(dlg) : NULL;
    struct ast_sip_session *session = (inv_session ? inv_session->mod_data[session_module.id] : NULL);
    SCOPE_ENTER(1, "%s Method: %.*s Status: %d\n", ast_sip_session_get_name(session),
        (int)rdata->msg_info.cseq->method.name.slen, rdata->msg_info.cseq->method.name.ptr, status.code);
 
    SCOPE_EXIT_RTN_VALUE(PJ_FALSE);
}

References ast_sip_session_get_name(), ast_sip_session::inv_session, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, session_module, and status.

◆ session_on_tsx_state()

static void session_on_tsx_state	(	pjsip_transaction *	tsx,
		pjsip_event *	e
	)

static

Definition at line 4260 of file res_pjsip_session.c.

{
 
    pjsip_dialog *dlg = pjsip_tsx_get_dlg(tsx);
    pjsip_inv_session *inv_session = (dlg ? pjsip_dlg_get_inv_session(dlg) : NULL);
    struct ast_sip_session *session = (inv_session ? inv_session->mod_data[session_module.id] : NULL);
    SCOPE_ENTER(1, "%s TSX State: %s  Inv State: %s\n", ast_sip_session_get_name(session),
            pjsip_tsx_state_str(tsx->state), inv_session ? pjsip_inv_state_name(inv_session->state) : "unknown");
 
    if (session) {
        ast_trace(2, "Topology: Pending: %s  Active: %s\n",
            ast_str_tmp(256, ast_stream_topology_to_str(session->pending_media_state->topology, &STR_TMP)),
            ast_str_tmp(256, ast_stream_topology_to_str(session->active_media_state->topology, &STR_TMP)));
    }
 
    SCOPE_EXIT_RTN();
}

References ast_sip_session_get_name(), ast_str_tmp, ast_stream_topology_to_str(), ast_trace, ast_sip_session::inv_session, NULL, SCOPE_ENTER, SCOPE_EXIT_RTN, session, and session_module.

◆ session_on_tx_response()

static pj_bool_t session_on_tx_response ( pjsip_tx_data * tdata )

static

Definition at line 4346 of file res_pjsip_session.c.

{
    pjsip_dialog *dlg = pjsip_tdata_get_dlg(tdata);
    RAII_VAR(struct ast_sip_session *, session, dlg ? ast_sip_dialog_get_session(dlg) : NULL, ao2_cleanup);
    if (session) {
        handle_outgoing_response(session, tdata);
    }
 
    return PJ_SUCCESS;
}

References ao2_cleanup, ast_sip_dialog_get_session(), handle_outgoing_response(), NULL, RAII_VAR, and session.

◆ session_outgoing_nat_hook()

static void session_outgoing_nat_hook	(	pjsip_tx_data *	tdata,
		struct ast_sip_transport *	transport
	)

static

Hook for modifying outgoing messages with SDP to contain the proper address information.

Definition at line 5624 of file res_pjsip_session.c.

{
    RAII_VAR(struct ast_sip_transport_state *, transport_state, ast_sip_get_transport_state(ast_sorcery_object_get_id(transport)), ao2_cleanup);
    pjsip_sdp_info *sdp_info;
    pjmedia_sdp_session *sdp;
    pjsip_dialog *dlg = pjsip_tdata_get_dlg(tdata);
    RAII_VAR(struct ast_sip_session *, session, dlg ? ast_sip_dialog_get_session(dlg) : NULL, ao2_cleanup);
    int stream;
 
    /*
     * If there's no transport_state or body, just return.
     */
    if (ast_strlen_zero(transport->external_media_address) || !transport_state || !tdata->msg->body) {
        return;
    }
 
    sdp_info = pjsip_get_sdp_info(tdata->pool, tdata->msg->body, NULL, &pjsip_media_type_application_sdp);
    if (sdp_info->sdp_err != PJ_SUCCESS || !sdp_info->sdp) {
        return;
    }
    sdp = sdp_info->sdp;
 
    if (sdp->conn) {
        char host[NI_MAXHOST];
        struct ast_sockaddr our_sdp_addr = { { 0, } };
 
        ast_copy_pj_str(host, &sdp->conn->addr, sizeof(host));
        ast_sockaddr_parse(&our_sdp_addr, host, PARSE_PORT_FORBID);
 
        /* Reversed check here. We don't check the remote
         * endpoint being in our local net, but whether our
         * outgoing session IP is local. If it is, we'll do
         * rewriting. No localnet configured? Always rewrite. */
        if (ast_sip_transport_is_local(transport_state, &our_sdp_addr) || !transport_state->localnet) {
            ast_debug(5, "%s: Setting external media address to %s\n", ast_sip_session_get_name(session),
                ast_sockaddr_stringify_addr_remote(&transport_state->external_media_address));
            pj_strdup2(tdata->pool, &sdp->conn->addr, ast_sockaddr_stringify_addr_remote(&transport_state->external_media_address));
            pj_strassign(&sdp->origin.addr, &sdp->conn->addr);
        }
    }
 
    for (stream = 0; stream < sdp->media_count; ++stream) {
        /* See if there are registered handlers for this media stream type */
        char media[20];
        struct ast_sip_session_sdp_handler *handler;
        RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
 
        /* We need a null-terminated version of the media string */
        ast_copy_pj_str(media, &sdp->media[stream]->desc.media, sizeof(media));
 
        handler_list = ao2_find(sdp_handlers, media, OBJ_KEY);
        if (!handler_list) {
            ast_debug(4, "%s: No registered SDP handlers for media type '%s'\n",  ast_sip_session_get_name(session),
                media);
            continue;
        }
        AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
            if (handler->change_outgoing_sdp_stream_media_address) {
                handler->change_outgoing_sdp_stream_media_address(tdata, sdp->media[stream], transport);
            }
        }
    }
 
}

References ao2_cleanup, ao2_find, ast_copy_pj_str(), ast_debug, AST_LIST_TRAVERSE, ast_sip_dialog_get_session(), ast_sip_get_transport_state(), ast_sip_session_get_name(), ast_sip_transport_is_local, ast_sockaddr_parse(), ast_sockaddr_stringify_addr_remote(), ast_sorcery_object_get_id(), ast_strlen_zero(), ast_sip_transport::external_media_address, handler(), ast_sip_session_sdp_handler::next, NULL, OBJ_KEY, PARSE_PORT_FORBID, pjsip_media_type_application_sdp, RAII_VAR, sdp_handlers, and session.

Referenced by load_module().

◆ session_reinvite_on_rx_request()

static pj_bool_t session_reinvite_on_rx_request ( pjsip_rx_data * rdata )

static

Definition at line 2854 of file res_pjsip_session.c.

{
    pjsip_dialog *dlg;
    RAII_VAR(struct ast_sip_session *, session, NULL, ao2_cleanup);
    pjsip_rdata_sdp_info *sdp_info;
    int deferred;
 
    if (rdata->msg_info.msg->line.req.method.id != PJSIP_INVITE_METHOD ||
        !(dlg = pjsip_ua_find_dialog(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag, PJ_FALSE)) ||
        !(session = ast_sip_dialog_get_session(dlg)) ||
        !session->channel) {
        return PJ_FALSE;
    }
 
    if (session->inv_session->invite_tsx) {
        /* There's a transaction in progress so bail now and let pjproject send 491 */
        return PJ_FALSE;
    }
 
    if (session->deferred_reinvite) {
        pj_str_t key, deferred_key;
        pjsip_tx_data *tdata;
 
        /* We use memory from the new request on purpose so the deferred reinvite pool does not grow uncontrollably */
        pjsip_tsx_create_key(rdata->tp_info.pool, &key, PJSIP_ROLE_UAS, &rdata->msg_info.cseq->method, rdata);
        pjsip_tsx_create_key(rdata->tp_info.pool, &deferred_key, PJSIP_ROLE_UAS, &session->deferred_reinvite->msg_info.cseq->method,
            session->deferred_reinvite);
 
        /* If this is a retransmission ignore it */
        if (!pj_strcmp(&key, &deferred_key)) {
            return PJ_TRUE;
        }
 
        /* Otherwise this is a new re-invite, so reject it */
        if (pjsip_dlg_create_response(dlg, rdata, 491, NULL, &tdata) == PJ_SUCCESS) {
            if (pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL) != PJ_SUCCESS) {
                pjsip_tx_data_dec_ref(tdata);
            }
        }
 
        return PJ_TRUE;
    }
 
    if (!(sdp_info = pjsip_rdata_get_sdp_info(rdata)) ||
        (sdp_info->sdp_err != PJ_SUCCESS)) {
        return PJ_FALSE;
    }
 
    if (!sdp_info->sdp) {
        return PJ_FALSE;
    }
 
    deferred = sdp_requires_deferral(session, sdp_info->sdp);
    if (deferred == -1) {
        ast_sip_session_media_state_reset(session->pending_media_state);
        return PJ_FALSE;
    } else if (!deferred) {
        return PJ_FALSE;
    }
 
    pjsip_rx_data_clone(rdata, 0, &session->deferred_reinvite);
 
    return PJ_TRUE;
}

References ao2_cleanup, ast_sip_dialog_get_session(), ast_sip_get_pjsip_endpoint(), ast_sip_session_media_state_reset(), NULL, RAII_VAR, sdp_requires_deferral(), and session.

◆ session_termination_cb()

static void session_termination_cb	(	pj_timer_heap_t *	timer_heap,
		struct pj_timer_entry *	entry
	)

static

Definition at line 3580 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = entry->user_data;
 
    if (ast_sip_push_task(session->serializer, session_termination_task, session)) {
        ao2_cleanup(session);
    }
}

References ao2_cleanup, ast_sip_push_task, session, and session_termination_task().

Referenced by ast_sip_session_defer_termination().

◆ session_termination_task()

static int session_termination_task ( void * data )

static

Definition at line 3565 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = data;
 
    if (session->defer_terminate) {
        session->defer_terminate = 0;
        if (session->inv_session) {
            ast_sip_session_terminate(session, 0);
        }
    }
 
    ao2_ref(session, -1);
    return 0;
}

References ao2_ref, ast_sip_session_terminate(), and session.

Referenced by session_termination_cb().

◆ set_from_header()

static void set_from_header ( struct ast_sip_session * session )

static

Definition at line 1749 of file res_pjsip_session.c.

{
    struct ast_party_id effective_id;
    struct ast_party_id connected_id;
    pj_pool_t *dlg_pool;
    pjsip_fromto_hdr *dlg_info;
    pjsip_contact_hdr *dlg_contact;
    pjsip_name_addr *dlg_info_name_addr;
    pjsip_sip_uri *dlg_info_uri;
    pjsip_sip_uri *dlg_contact_uri;
    int restricted;
    const char *pjsip_from_domain;
 
    if (!session->channel || session->saved_from_hdr) {
        return;
    }
 
    /* We need to save off connected_id for RPID/PAI generation */
    ast_party_id_init(&connected_id);
    ast_channel_lock(session->channel);
    effective_id = ast_channel_connected_effective_id(session->channel);
    ast_party_id_copy(&connected_id, &effective_id);
    ast_channel_unlock(session->channel);
 
    restricted =
        ((ast_party_id_presentation(&connected_id) & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED);
 
    /* Now set up dlg->local.info so pjsip can correctly generate From */
 
    dlg_pool = session->inv_session->dlg->pool;
    dlg_info = session->inv_session->dlg->local.info;
    dlg_contact = session->inv_session->dlg->local.contact;
    dlg_info_name_addr = (pjsip_name_addr *) dlg_info->uri;
    dlg_info_uri = pjsip_uri_get_uri(dlg_info_name_addr);
    dlg_contact_uri = (pjsip_sip_uri*)pjsip_uri_get_uri(dlg_contact->uri);
 
    if (session->endpoint->id.trust_outbound || !restricted) {
        ast_sip_modify_id_header(dlg_pool, dlg_info, &connected_id);
        if (ast_sip_get_use_callerid_contact() && ast_strlen_zero(session->endpoint->contact_user)) {
            pj_strdup2(dlg_pool, &dlg_contact_uri->user, S_COR(connected_id.number.valid, connected_id.number.str, ""));
        }
    }
 
    ast_party_id_free(&connected_id);
 
    if (!ast_strlen_zero(session->endpoint->fromuser)) {
        dlg_info_name_addr->display.ptr = NULL;
        dlg_info_name_addr->display.slen = 0;
        pj_strdup2(dlg_pool, &dlg_info_uri->user, session->endpoint->fromuser);
    }
 
    if (!ast_strlen_zero(session->endpoint->fromdomain)) {
        pj_strdup2(dlg_pool, &dlg_info_uri->host, session->endpoint->fromdomain);
    }
 
    /*
     * Channel variable for compatibility with chan_sip SIPFROMDOMAIN
     */
    ast_channel_lock(session->channel);
    pjsip_from_domain = pbx_builtin_getvar_helper(session->channel, "SIPFROMDOMAIN");
    if (!ast_strlen_zero(pjsip_from_domain)) {
        ast_debug(3, "%s: From header domain reset by channel variable SIPFROMDOMAIN (%s)\n",
            ast_sip_session_get_name(session), pjsip_from_domain);
        pj_strdup2(dlg_pool, &dlg_info_uri->host, pjsip_from_domain);
    }
    ast_channel_unlock(session->channel);
 
    /* We need to save off the non-anonymized From for RPID/PAI generation (for domain) */
    session->saved_from_hdr = pjsip_hdr_clone(dlg_pool, dlg_info);
    ast_sip_add_usereqphone(session->endpoint, dlg_pool, session->saved_from_hdr->uri);
 
    /* In chan_sip, fromuser and fromdomain trump restricted so we only
     * anonymize if they're not set.
     */
    if (restricted) {
        /* fromuser doesn't provide a display name so we always set it */
        pj_strdup2(dlg_pool, &dlg_info_name_addr->display, "Anonymous");
 
        if (ast_strlen_zero(session->endpoint->fromuser)) {
            pj_strdup2(dlg_pool, &dlg_info_uri->user, "anonymous");
        }
 
        if (ast_sip_get_use_callerid_contact() && ast_strlen_zero(session->endpoint->contact_user)) {
            pj_strdup2(dlg_pool, &dlg_contact_uri->user, "anonymous");
        }
 
        if (ast_strlen_zero(session->endpoint->fromdomain)) {
            pj_strdup2(dlg_pool, &dlg_info_uri->host, "anonymous.invalid");
        }
    } else {
        ast_sip_add_usereqphone(session->endpoint, dlg_pool, dlg_info->uri);
    }
}

References ast_channel_connected_effective_id(), ast_channel_lock, ast_channel_unlock, ast_debug, ast_party_id_copy(), ast_party_id_free(), ast_party_id_init(), ast_party_id_presentation(), AST_PRES_ALLOWED, AST_PRES_RESTRICTION, ast_sip_add_usereqphone(), ast_sip_get_use_callerid_contact(), ast_sip_modify_id_header(), ast_sip_session_get_name(), ast_strlen_zero(), NULL, ast_party_id::number, pbx_builtin_getvar_helper(), S_COR, session, ast_party_number::str, and ast_party_number::valid.

Referenced by ast_sip_session_create_invite().

◆ set_mid_and_bundle_group()

static int set_mid_and_bundle_group	(	struct ast_sip_session *	session,
		struct ast_sip_session_media *	session_media,
		const pjmedia_sdp_session *	sdp,
		const struct pjmedia_sdp_media *	stream
	)

static

Definition at line 655 of file res_pjsip_session.c.

{
    pjmedia_sdp_attr *attr;
 
    if (!session->endpoint->media.bundle) {
        return 0;
    }
 
    /* By default on an incoming negotiation we assume no mid and bundle group is present */
    ast_free(session_media->mid);
    session_media->mid = NULL;
    session_media->bundle_group = -1;
    session_media->bundled = 0;
 
    /* Grab the media identifier for the stream */
    attr = pjmedia_sdp_media_find_attr2(stream, "mid", NULL);
    if (!attr) {
        return 0;
    }
 
    session_media->mid = ast_calloc(1, attr->value.slen + 1);
    if (!session_media->mid) {
        return 0;
    }
    ast_copy_pj_str(session_media->mid, &attr->value, attr->value.slen + 1);
 
    /* Determine what bundle group this is part of */
    session_media->bundle_group = get_mid_bundle_group(sdp, session_media->mid);
 
    /* If this is actually part of a bundle group then the other side requested or accepted the bundle request */
    session_media->bundled = session_media->bundle_group != -1;
 
    return 0;
}

References ast_calloc, ast_copy_pj_str(), ast_free, ast_sip_session_media::bundle_group, ast_sip_session_media::bundled, get_mid_bundle_group(), ast_sip_session_media::mid, NULL, and session.

Referenced by handle_incoming_sdp(), and handle_negotiated_sdp_session_media().

◆ set_outstanding_invite_timeout()

static int set_outstanding_invite_timeout ( struct ast_sip_session * session )

static

Definition at line 1688 of file res_pjsip_session.c.

{
    pjsip_transaction *tsx;
    pj_status_t status;
 
    if (!session->inv_session || !session->inv_session->invite_tsx) {
        return 0;
    }
 
    tsx = session->inv_session->invite_tsx;
    if (tsx->role != PJSIP_ROLE_UAC || tsx->method.id != PJSIP_INVITE_METHOD
        || tsx->state >= PJSIP_TSX_STATE_COMPLETED) {
        return 0;
    }
 
    status = pjsip_tsx_set_timeout(tsx, pjsip_cfg()->tsx.td);
    if (status != PJ_SUCCESS && status != PJ_EEXISTS) {
        char errmsg[PJ_ERR_MSG_SIZE];
 
        pj_strerror(status, errmsg, sizeof(errmsg));
        ast_log(LOG_WARNING, "%s: Failed to set timeout on outstanding INVITE transaction: %s\n",
            ast_sip_session_get_name(session), errmsg);
        return 0;
    }
 
    return 1;
}

References ast_log, ast_sip_session_get_name(), LOG_WARNING, session, and status.

Referenced by ast_sip_session_terminate().

◆ set_remote_mslabel_and_stream_group()

static void set_remote_mslabel_and_stream_group	(	struct ast_sip_session *	session,
		struct ast_sip_session_media *	session_media,
		const pjmedia_sdp_session *	sdp,
		const struct pjmedia_sdp_media *	stream,
		struct ast_stream *	asterisk_stream
	)

static

Definition at line 693 of file res_pjsip_session.c.

{
    int index;
 
    ast_free(session_media->remote_mslabel);
    session_media->remote_mslabel = NULL;
    ast_free(session_media->remote_label);
    session_media->remote_label = NULL;
 
    for (index = 0; index < stream->attr_count; ++index) {
        pjmedia_sdp_attr *attr = stream->attr[index];
        char attr_value[pj_strlen(&attr->value) + 1];
        char *ssrc_attribute_name, *ssrc_attribute_value = NULL;
        char *msid, *tmp = attr_value;
        static const pj_str_t STR_msid = { "msid", 4 };
        static const pj_str_t STR_ssrc = { "ssrc", 4 };
        static const pj_str_t STR_label = { "label", 5 };
 
        if (!pj_strcmp(&attr->name, &STR_label)) {
            ast_copy_pj_str(attr_value, &attr->value, sizeof(attr_value));
            session_media->remote_label = ast_strdup(attr_value);
        } else if (!pj_strcmp(&attr->name, &STR_msid)) {
            ast_copy_pj_str(attr_value, &attr->value, sizeof(attr_value));
            msid = strsep(&tmp, " ");
            session_media->remote_mslabel = ast_strdup(msid);
            break;
        } else if (!pj_strcmp(&attr->name, &STR_ssrc)) {
            ast_copy_pj_str(attr_value, &attr->value, sizeof(attr_value));
 
            if ((ssrc_attribute_name = strchr(attr_value, ' '))) {
                /* This has an actual attribute */
                *ssrc_attribute_name++ = '\0';
                ssrc_attribute_value = strchr(ssrc_attribute_name, ':');
                if (ssrc_attribute_value) {
                    /* Values are actually optional according to the spec */
                    *ssrc_attribute_value++ = '\0';
                }
 
                if (!strcasecmp(ssrc_attribute_name, "mslabel") && !ast_strlen_zero(ssrc_attribute_value)) {
                    session_media->remote_mslabel = ast_strdup(ssrc_attribute_value);
                    break;
                }
            }
        }
    }
 
    if (ast_strlen_zero(session_media->remote_mslabel)) {
        return;
    }
 
    /* Iterate through the existing streams looking for a match and if so then group this with it */
    for (index = 0; index < AST_VECTOR_SIZE(&session->pending_media_state->sessions); ++index) {
        struct ast_sip_session_media *group_session_media;
 
        group_session_media = AST_VECTOR_GET(&session->pending_media_state->sessions, index);
 
        if (ast_strlen_zero(group_session_media->remote_mslabel) ||
            strcmp(group_session_media->remote_mslabel, session_media->remote_mslabel)) {
            continue;
        }
 
        ast_stream_set_group(asterisk_stream, index);
        break;
    }
}

References ast_copy_pj_str(), ast_free, ast_strdup, ast_stream_set_group(), ast_strlen_zero(), AST_VECTOR_GET, AST_VECTOR_SIZE, NULL, ast_sip_session_media::remote_label, ast_sip_session_media::remote_mslabel, session, and strsep().

Referenced by handle_incoming_sdp(), and handle_negotiated_sdp_session_media().

◆ setup_outbound_invite_auth()

static int setup_outbound_invite_auth ( pjsip_dialog * dlg )

static

Definition at line 3321 of file res_pjsip_session.c.

{
    pj_status_t status;
 
    ++dlg->sess_count;
    status = pjsip_dlg_add_usage(dlg, &outbound_invite_auth_module, NULL);
    --dlg->sess_count;
 
    return status != PJ_SUCCESS ? -1 : 0;
}

References NULL, outbound_invite_auth_module, and status.

Referenced by ast_sip_session_create_outgoing().

◆ sip_channel_destroy()

static void sip_channel_destroy ( void * obj )

static

Destructor for SIP channel.

Definition at line 3084 of file res_pjsip_session.c.

{
    struct ast_sip_channel_pvt *channel = obj;
 
    ao2_cleanup(channel->pvt);
    ao2_cleanup(channel->session);
}

References ao2_cleanup, ast_sip_channel_pvt::pvt, and ast_sip_channel_pvt::session.

Referenced by ast_sip_channel_pvt_alloc().

◆ sip_session_defer_termination_stop_timer()

static void sip_session_defer_termination_stop_timer ( struct ast_sip_session * session )

static

Definition at line 3621 of file res_pjsip_session.c.

{
    if (pj_timer_heap_cancel_if_active(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()),
        &session->scheduled_termination, session->scheduled_termination.id)) {
        ao2_ref(session, -1);
    }
}

References ao2_ref, ast_sip_get_pjsip_endpoint(), and session.

Referenced by ast_sip_session_defer_termination_cancel(), and session_end().

◆ sip_session_refresh()

static int sip_session_refresh	(	struct ast_sip_session *	session,
		ast_sip_session_request_creation_cb	on_request_creation,
		ast_sip_session_sdp_creation_cb	on_sdp_creation,
		ast_sip_session_response_cb	on_response,
		enum ast_sip_session_refresh_method	method,
		int	generate_new_sdp,
		struct ast_sip_session_media_state *	pending_media_state,
		struct ast_sip_session_media_state *	active_media_state,
		int	queued
	)

static

Definition at line 2297 of file res_pjsip_session.c.

{
    pjsip_inv_session *inv_session = session->inv_session;
    pjmedia_sdp_session *new_sdp = NULL;
    pjsip_tx_data *tdata;
    int res = -1;
    SCOPE_ENTER(3, "%s: New SDP? %s  Queued? %s DP: %s  DA: %s\n", ast_sip_session_get_name(session),
        generate_new_sdp ? "yes" : "no", queued ? "yes" : "no",
        pending_media_state ? ast_str_tmp(256, ast_stream_topology_to_str(pending_media_state->topology, &STR_TMP)) : "none",
        active_media_state ? ast_str_tmp(256, ast_stream_topology_to_str(active_media_state->topology, &STR_TMP)) : "none");
 
    if (pending_media_state && (!pending_media_state->topology || !generate_new_sdp)) {
 
        ast_sip_session_media_state_free(pending_media_state);
        ast_sip_session_media_state_free(active_media_state);
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Not sending reinvite because %s%s\n", ast_sip_session_get_name(session),
            pending_media_state->topology == NULL ? "pending topology is null " : "",
                !generate_new_sdp ? "generate_new_sdp is false" : "");
    }
 
    if (inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
        /* Don't try to do anything with a hung-up call */
        ast_sip_session_media_state_free(pending_media_state);
        ast_sip_session_media_state_free(active_media_state);
        SCOPE_EXIT_RTN_VALUE(0, "%s: Not sending reinvite because of disconnected state\n",
                ast_sip_session_get_name(session));
    }
 
    /* If the dialog has not yet been established we have to defer until it has */
    if (inv_session->dlg->state != PJSIP_DIALOG_STATE_ESTABLISHED) {
        res = delay_request(session, on_request_creation, on_sdp_creation, on_response,
            generate_new_sdp,
            method == AST_SIP_SESSION_REFRESH_METHOD_INVITE
                ? DELAYED_METHOD_INVITE : DELAYED_METHOD_UPDATE,
            pending_media_state, active_media_state ? active_media_state : ast_sip_session_media_state_clone(session->active_media_state), queued);
        SCOPE_EXIT_RTN_VALUE(res, "%s: Delay sending reinvite because dialog has not been established\n",
            ast_sip_session_get_name(session));
    }
 
    if (method == AST_SIP_SESSION_REFRESH_METHOD_INVITE) {
        if (inv_session->invite_tsx) {
            /* We can't send a reinvite yet, so delay it */
            res = delay_request(session, on_request_creation, on_sdp_creation,
                on_response, generate_new_sdp, DELAYED_METHOD_INVITE, pending_media_state,
                active_media_state ? active_media_state : ast_sip_session_media_state_clone(session->active_media_state), queued);
            SCOPE_EXIT_RTN_VALUE(res, "%s: Delay sending reinvite because of outstanding transaction\n",
                ast_sip_session_get_name(session));
        } else if (inv_session->state != PJSIP_INV_STATE_CONFIRMED) {
            /* Initial INVITE transaction failed to progress us to a confirmed state
             * which means re-invites are not possible
             */
            ast_sip_session_media_state_free(pending_media_state);
            ast_sip_session_media_state_free(active_media_state);
            SCOPE_EXIT_RTN_VALUE(0, "%s: Not sending reinvite because not in confirmed state\n",
                ast_sip_session_get_name(session));
        }
    }
 
    if (generate_new_sdp) {
        /* SDP can only be generated if current negotiation has already completed */
        if (inv_session->neg
            && pjmedia_sdp_neg_get_state(inv_session->neg)
                != PJMEDIA_SDP_NEG_STATE_DONE) {
            res = delay_request(session, on_request_creation, on_sdp_creation,
                on_response, generate_new_sdp,
                method == AST_SIP_SESSION_REFRESH_METHOD_INVITE
                    ? DELAYED_METHOD_INVITE : DELAYED_METHOD_UPDATE, pending_media_state,
                active_media_state ? active_media_state : ast_sip_session_media_state_clone(session->active_media_state), queued);
            SCOPE_EXIT_RTN_VALUE(res, "%s: Delay session refresh with new SDP because SDP negotiation is not yet done\n",
                ast_sip_session_get_name(session));
        }
 
        /* If an explicitly requested media state has been provided use it instead of any pending one */
        if (pending_media_state) {
            int index;
            int type_streams[AST_MEDIA_TYPE_END] = {0};
 
            ast_trace(-1, "%s: Pending media state exists\n", ast_sip_session_get_name(session));
 
            /* Media state conveys a desired media state, so if there are outstanding
             * delayed requests we need to ensure we go into the queue and not jump
             * ahead. If we sent this media state now then updates could go out of
             * order.
             */
            if (!queued && !AST_LIST_EMPTY(&session->delayed_requests)) {
                res = delay_request(session, on_request_creation, on_sdp_creation,
                    on_response, generate_new_sdp,
                    method == AST_SIP_SESSION_REFRESH_METHOD_INVITE
                        ? DELAYED_METHOD_INVITE : DELAYED_METHOD_UPDATE, pending_media_state,
                        active_media_state ? active_media_state : ast_sip_session_media_state_clone(session->active_media_state), queued);
                SCOPE_EXIT_RTN_VALUE(res, "%s: Delay sending reinvite because of outstanding requests\n",
                    ast_sip_session_get_name(session));
            }
 
            /*
             * Attempt to resolve only if objects are available, and it's not
             * switching to or from an image type.
             */
            if (active_media_state && active_media_state->topology &&
                (!active_media_state->default_session[AST_MEDIA_TYPE_IMAGE] ==
                 !pending_media_state->default_session[AST_MEDIA_TYPE_IMAGE])) {
 
                struct ast_sip_session_media_state *new_pending_state;
 
                ast_trace(-1, "%s: Active media state exists and is%s equal to pending\n", ast_sip_session_get_name(session),
                    !ast_stream_topology_equal(active_media_state->topology,pending_media_state->topology) ? " not" : "");
                ast_trace(-1, "%s: DP: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(pending_media_state->topology, &STR_TMP)));
                ast_trace(-1, "%s: DA: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(active_media_state->topology, &STR_TMP)));
                ast_trace(-1, "%s: CP: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(session->pending_media_state->topology, &STR_TMP)));
                ast_trace(-1, "%s: CA: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(session->active_media_state->topology, &STR_TMP)));
 
                new_pending_state = resolve_refresh_media_states(ast_sip_session_get_name(session),
                    pending_media_state, active_media_state, session->active_media_state, 1);
                if (new_pending_state) {
                    ast_trace(-1, "%s: NP: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(new_pending_state->topology, &STR_TMP)));
                    ast_sip_session_media_state_free(pending_media_state);
                    pending_media_state = new_pending_state;
                } else {
                    ast_sip_session_media_state_reset(pending_media_state);
                    ast_sip_session_media_state_free(active_media_state);
                    SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Unable to merge media states\n", ast_sip_session_get_name(session));
                }
            }
 
            /* Prune the media state so the number of streams fit within the configured limits - we do it here
             * so that the index of the resulting streams in the SDP match. If we simply left the streams out
             * of the SDP when producing it we'd be in trouble. We also enforce formats here for media types that
             * are configurable on the endpoint.
             */
            ast_trace(-1, "%s: Pruning and checking formats of streams\n", ast_sip_session_get_name(session));
 
            for (index = 0; index < ast_stream_topology_get_count(pending_media_state->topology); ++index) {
                struct ast_stream *existing_stream = NULL;
                struct ast_stream *stream = ast_stream_topology_get_stream(pending_media_state->topology, index);
                SCOPE_ENTER(4, "%s: Checking stream %s\n", ast_sip_session_get_name(session),
                    ast_stream_get_name(stream));
 
                if (session->active_media_state->topology &&
                    index < ast_stream_topology_get_count(session->active_media_state->topology)) {
                    existing_stream = ast_stream_topology_get_stream(session->active_media_state->topology, index);
                    ast_trace(-1, "%s: Found existing stream %s\n", ast_sip_session_get_name(session),
                        ast_stream_get_name(existing_stream));
                }
 
                if (is_stream_limitation_reached(ast_stream_get_type(stream), session->endpoint, type_streams)) {
                    if (index < AST_VECTOR_SIZE(&pending_media_state->sessions)) {
                        struct ast_sip_session_media *session_media = AST_VECTOR_GET(&pending_media_state->sessions, index);
 
                        ao2_cleanup(session_media);
                        AST_VECTOR_REMOVE(&pending_media_state->sessions, index, 1);
                    }
 
                    ast_stream_topology_del_stream(pending_media_state->topology, index);
                    ast_trace(-1, "%s: Dropped overlimit stream %s\n", ast_sip_session_get_name(session),
                        ast_stream_get_name(stream));
 
                    /* A stream has potentially moved into our spot so we need to jump back so we process it */
                    index -= 1;
                    SCOPE_EXIT_EXPR(continue);
                }
 
                /* No need to do anything with stream if it's media state is removed */
                if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
                    /* If there is no existing stream we can just not have this stream in the topology at all. */
                    if (!existing_stream) {
                        ast_trace(-1, "%s: Dropped removed stream %s\n", ast_sip_session_get_name(session),
                            ast_stream_get_name(stream));
                        ast_stream_topology_del_stream(pending_media_state->topology, index);
                        /* TODO: Do we need to remove the corresponding media state? */
                        index -= 1;
                    }
                    SCOPE_EXIT_EXPR(continue);
                }
 
                /* Enforce the configured allowed codecs on audio and video streams */
                if ((ast_stream_get_type(stream) == AST_MEDIA_TYPE_AUDIO || ast_stream_get_type(stream) == AST_MEDIA_TYPE_VIDEO) &&
                    !ast_stream_get_metadata(stream, "pjsip_session_refresh")) {
                    struct ast_format_cap *joint_cap;
 
                    joint_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
                    if (!joint_cap) {
                        ast_sip_session_media_state_free(pending_media_state);
                        ast_sip_session_media_state_free(active_media_state);
                        res = -1;
                        SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Unable to alloc format caps\n", ast_sip_session_get_name(session));
                    }
                    ast_format_cap_get_compatible(ast_stream_get_formats(stream), session->endpoint->media.codecs, joint_cap);
                    if (!ast_format_cap_count(joint_cap)) {
                        ao2_ref(joint_cap, -1);
 
                        if (!existing_stream) {
                            /* If there is no existing stream we can just not have this stream in the topology
                             * at all.
                             */
                            ast_stream_topology_del_stream(pending_media_state->topology, index);
                            index -= 1;
                            SCOPE_EXIT_EXPR(continue, "%s: Dropped incompatible stream %s\n",
                                ast_sip_session_get_name(session), ast_stream_get_name(stream));
                        } else if (ast_stream_get_state(stream) != ast_stream_get_state(existing_stream) ||
                                strcmp(ast_stream_get_name(stream), ast_stream_get_name(existing_stream))) {
                            /* If the underlying stream is a different type or different name then we have to
                             * mark it as removed, as it is replacing an existing stream. We do this so order
                             * is preserved.
                             */
                            ast_stream_set_state(stream, AST_STREAM_STATE_REMOVED);
                            SCOPE_EXIT_EXPR(continue, "%s: Dropped incompatible stream %s\n",
                                ast_sip_session_get_name(session), ast_stream_get_name(stream));
                        } else {
                            /* However if the stream is otherwise remaining the same we can keep the formats
                             * that exist on it already which allows media to continue to flow. We don't modify
                             * the format capabilities but do need to cast it so that ao2_bump can raise the
                             * reference count.
                             */
                            joint_cap = ao2_bump((struct ast_format_cap *)ast_stream_get_formats(existing_stream));
                        }
                    }
                    ast_stream_set_formats(stream, joint_cap);
                    ao2_cleanup(joint_cap);
                }
 
                ++type_streams[ast_stream_get_type(stream)];
 
                SCOPE_EXIT();
            }
 
            if (session->active_media_state->topology) {
                /* SDP is a fun thing. Take for example the fact that streams are never removed. They just become
                 * declined. To better handle this in the case where something requests a topology change for fewer
                 * streams than are currently present we fill in the topology to match the current number of streams
                 * that are active.
                 */
 
                for (index = ast_stream_topology_get_count(pending_media_state->topology);
                    index < ast_stream_topology_get_count(session->active_media_state->topology); ++index) {
                    struct ast_stream *stream = ast_stream_topology_get_stream(session->active_media_state->topology, index);
                    struct ast_stream *cloned;
                    int position;
                    SCOPE_ENTER(4, "%s: Stream %s not in pending\n", ast_sip_session_get_name(session),
                        ast_stream_get_name(stream));
 
                    cloned = ast_stream_clone(stream, NULL);
                    if (!cloned) {
                        ast_sip_session_media_state_free(pending_media_state);
                        ast_sip_session_media_state_free(active_media_state);
                        res = -1;
                        SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Unable to clone stream %s\n",
                            ast_sip_session_get_name(session), ast_stream_get_name(stream));
                    }
 
                    ast_stream_set_state(cloned, AST_STREAM_STATE_REMOVED);
                    position = ast_stream_topology_append_stream(pending_media_state->topology, cloned);
                    if (position < 0) {
                        ast_stream_free(cloned);
                        ast_sip_session_media_state_free(pending_media_state);
                        ast_sip_session_media_state_free(active_media_state);
                        res = -1;
                        SCOPE_EXIT_LOG_EXPR(goto end, LOG_ERROR, "%s: Unable to append cloned stream\n",
                            ast_sip_session_get_name(session));
                    }
                    SCOPE_EXIT("%s: Appended empty stream in position %d to make counts match\n",
                        ast_sip_session_get_name(session), position);
                }
 
                /*
                 * We can suppress this re-invite if the pending topology is equal to the currently
                 * active topology.
                 */
                if (ast_stream_topology_equal(session->active_media_state->topology, pending_media_state->topology)) {
                    ast_trace(-1, "%s: CA: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(session->active_media_state->topology, &STR_TMP)));
                    ast_trace(-1, "%s: NP: %s\n", ast_sip_session_get_name(session), ast_str_tmp(256, ast_stream_topology_to_str(pending_media_state->topology, &STR_TMP)));
                    ast_sip_session_media_state_free(pending_media_state);
                    ast_sip_session_media_state_free(active_media_state);
                    /* For external consumers we return 0 to say success, but internally for
                     * send_delayed_request we return a separate value to indicate that this
                     * session refresh would be redundant so we didn't send it
                     */
                    SCOPE_EXIT_RTN_VALUE(queued ? 1 : 0, "%s: Topologies are equal. Not sending re-invite\n",
                        ast_sip_session_get_name(session));
                }
            }
 
            ast_sip_session_media_state_free(session->pending_media_state);
            session->pending_media_state = pending_media_state;
        }
 
        new_sdp = generate_session_refresh_sdp(session);
        if (!new_sdp) {
            ast_sip_session_media_state_reset(session->pending_media_state);
            ast_sip_session_media_state_free(active_media_state);
            SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Failed to generate session refresh SDP. Not sending session refresh\n",
                ast_sip_session_get_name(session));
        }
        if (on_sdp_creation) {
            if (on_sdp_creation(session, new_sdp)) {
                ast_sip_session_media_state_reset(session->pending_media_state);
                ast_sip_session_media_state_free(active_media_state);
                SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: on_sdp_creation failed\n", ast_sip_session_get_name(session));
            }
        }
    }
 
    if (method == AST_SIP_SESSION_REFRESH_METHOD_INVITE) {
        if (pjsip_inv_reinvite(inv_session, NULL, new_sdp, &tdata)) {
            if (generate_new_sdp) {
                ast_sip_session_media_state_reset(session->pending_media_state);
            }
            ast_sip_session_media_state_free(active_media_state);
            SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Failed to create reinvite properly\n", ast_sip_session_get_name(session));
        }
    } else if (pjsip_inv_update(inv_session, NULL, new_sdp, &tdata)) {
        if (generate_new_sdp) {
            ast_sip_session_media_state_reset(session->pending_media_state);
        }
        ast_sip_session_media_state_free(active_media_state);
        SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Failed to create UPDATE properly\n", ast_sip_session_get_name(session));
    }
    if (on_request_creation) {
        if (on_request_creation(session, tdata)) {
            if (generate_new_sdp) {
                ast_sip_session_media_state_reset(session->pending_media_state);
            }
            ast_sip_session_media_state_free(active_media_state);
            SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: on_request_creation failed.\n", ast_sip_session_get_name(session));
        }
    }
    ast_sip_session_send_request_with_cb(session, tdata, on_response);
    ast_sip_session_media_state_free(active_media_state);
 
end:
    SCOPE_EXIT_RTN_VALUE(res, "%s: Sending session refresh SDP via %s\n", ast_sip_session_get_name(session),
        method == AST_SIP_SESSION_REFRESH_METHOD_INVITE ? "re-INVITE" : "UPDATE");
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_format_cap_alloc, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_compatible(), AST_LIST_EMPTY, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_END, AST_MEDIA_TYPE_IMAGE, AST_MEDIA_TYPE_VIDEO, ast_sip_session_get_name(), ast_sip_session_media_state_clone(), ast_sip_session_media_state_free(), ast_sip_session_media_state_reset(), AST_SIP_SESSION_REFRESH_METHOD_INVITE, ast_sip_session_send_request_with_cb(), ast_str_tmp, ast_stream_clone(), ast_stream_free(), ast_stream_get_formats(), ast_stream_get_metadata(), ast_stream_get_name(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_set_formats(), ast_stream_set_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_append_stream(), ast_stream_topology_del_stream(), ast_stream_topology_equal(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_to_str(), ast_trace, AST_VECTOR_GET, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, ast_sip_session_media_state::default_session, delay_request(), DELAYED_METHOD_INVITE, DELAYED_METHOD_UPDATE, end, generate_session_refresh_sdp(), is_stream_limitation_reached(), LOG_ERROR, LOG_WARNING, method, NULL, ast_stream::position, resolve_refresh_media_states(), SCOPE_ENTER, SCOPE_EXIT, SCOPE_EXIT_EXPR, SCOPE_EXIT_LOG_EXPR, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, session, ast_sip_session_media_state::sessions, and ast_sip_session_media_state::topology.

Referenced by ast_sip_session_refresh(), and send_delayed_request().

◆ stream_destroy()

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

static

Definition at line 465 of file res_pjsip_session.c.

{
    struct sdp_handler_list *handler_list = obj;
    struct ast_sip_session_media *session_media = arg;
    struct ast_sip_session_sdp_handler *handler;
 
    AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
        handler->stream_destroy(session_media);
    }
 
    return 0;
}

References AST_LIST_TRAVERSE, handler(), sdp_handler_list::list, ast_sip_session_sdp_handler::next, and ast_sip_session_sdp_handler::stream_destroy.

Referenced by session_media_dtor().

◆ uac_invite_tsx_terminates_dialog()

static int uac_invite_tsx_terminates_dialog ( pjsip_transaction * tsx )

static

Definition at line 1721 of file res_pjsip_session.c.

{
    if (tsx->role != PJSIP_ROLE_UAC || tsx->method.id != PJSIP_INVITE_METHOD
        || tsx->state < PJSIP_TSX_STATE_COMPLETED) {
        return 0;
    }
 
    return tsx->status_code == PJSIP_SC_CALL_TSX_DOES_NOT_EXIST
        || (tsx->status_code == PJSIP_SC_REQUEST_TIMEOUT
            && !pjsip_cfg()->endpt.keep_inv_after_tsx_timeout);
}

Referenced by session_inv_on_tsx_state_changed().

◆ unload_module()

static int unload_module ( void )

static

Definition at line 6278 of file res_pjsip_session.c.

{
    pjsip_reason_header_unload();
 
#ifdef TEST_FRAMEWORK
    AST_TEST_UNREGISTER(test_resolve_refresh_media_states);
#endif
    ast_sip_unregister_service(&outbound_invite_auth_module);
    ast_sip_unregister_service(&session_reinvite_module);
    ast_sip_unregister_service(&session_module);
    ast_sorcery_delete(ast_sip_get_sorcery(), nat_hook);
    ao2_cleanup(nat_hook);
    ao2_cleanup(sdp_handlers);
    return 0;
}

References ao2_cleanup, ast_sip_get_sorcery(), ast_sip_unregister_service(), ast_sorcery_delete(), AST_TEST_UNREGISTER, nat_hook, outbound_invite_auth_module, pjsip_reason_header_unload(), sdp_handlers, session_module, and session_reinvite_module.

◆ update_completed()

static int update_completed ( void * vsession )

static

Definition at line 1629 of file res_pjsip_session.c.

{
    struct ast_sip_session *session = vsession;
    int res;
 
    if (session->inv_session->invite_tsx) {
        res = invite_proceeding(session);
    } else {
        res = invite_terminated(session);
    }
 
    return res;
}

References invite_proceeding(), invite_terminated(), and session.

Referenced by session_inv_on_tsx_state_changed().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Session resource" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", }

static

Definition at line 6300 of file res_pjsip_session.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 6300 of file res_pjsip_session.c.

◆ inv_callback

pjsip_inv_callback inv_callback

static

Definition at line 5613 of file res_pjsip_session.c.

                                         {
    .on_state_changed = session_inv_on_state_changed,
    .on_new_session = session_inv_on_new_session,
    .on_tsx_state_changed = session_inv_on_tsx_state_changed,
    .on_rx_offer = session_inv_on_rx_offer,
    .on_create_offer = session_inv_on_create_offer,
    .on_media_update = session_inv_on_media_update,
    .on_redirected = session_inv_on_redirected,
};

Referenced by load_module().

◆ nat_hook

struct ast_sip_nat_hook* nat_hook

static

NAT hook for modifying outgoing messages with SDP.

Definition at line 86 of file res_pjsip_session.c.

Referenced by load_module(), and unload_module().

◆ outbound_invite_auth_module

pjsip_module outbound_invite_auth_module

static

Initial value:

= {
    .name = {"Outbound INVITE Auth", 20},
    .priority = PJSIP_MOD_PRIORITY_DIALOG_USAGE,
    .on_rx_response = outbound_invite_auth,
}

Definition at line 3305 of file res_pjsip_session.c.

                                                  {
    .name = {"Outbound INVITE Auth", 20},
    .priority = PJSIP_MOD_PRIORITY_DIALOG_USAGE,
    .on_rx_response = outbound_invite_auth,
};

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

◆ sdp_handlers

struct ao2_container* sdp_handlers

static

Registered SDP stream handlers.

This container is keyed on stream types. Each object in the container is a linked list of handlers for the stream type.

Definition at line 95 of file res_pjsip_session.c.

Referenced by add_sdp_streams(), ast_sip_session_register_sdp_handler(), ast_sip_session_unregister_sdp_handler(), handle_incoming_sdp(), handle_negotiated_sdp_session_media(), load_module(), sdp_requires_deferral(), session_media_dtor(), session_outgoing_nat_hook(), and unload_module().

◆ session_module

pjsip_module session_module

static

Definition at line 2707 of file res_pjsip_session.c.

                                     {
    .name = {"Session Module", 14},
    .priority = PJSIP_MOD_PRIORITY_APPLICATION,
    .on_rx_request = session_on_rx_request,
    .on_rx_response = session_on_rx_response,
    .on_tsx_state = session_on_tsx_state,
    .on_tx_response = session_on_tx_response,
};

Referenced by __print_debug_details(), ast_sip_dialog_get_session(), ast_sip_session_alloc(), ast_sip_session_create_outgoing(), ast_sip_session_send_request_with_cb(), ast_sip_session_terminate(), check_request_status(), load_module(), outbound_invite_auth(), pre_session_setup(), session_destructor(), session_inv_on_create_offer(), session_inv_on_media_update(), session_inv_on_redirected(), session_inv_on_rx_offer(), session_inv_on_state_changed(), session_inv_on_tsx_state_changed(), session_on_rx_request(), session_on_rx_response(), session_on_tsx_state(), and unload_module().

◆ session_reinvite_module

pjsip_module session_reinvite_module

static

Initial value:

= {
    .name = { "Session Re-Invite Module", 24 },
    .priority = PJSIP_MOD_PRIORITY_UA_PROXY_LAYER - 1,
    .on_rx_request = session_reinvite_on_rx_request,
}

Definition at line 2933 of file res_pjsip_session.c.

                                              {
    .name = { "Session Re-Invite Module", 24 },
    .priority = PJSIP_MOD_PRIORITY_UA_PROXY_LAYER - 1,
    .on_rx_request = session_reinvite_on_rx_request,
};

Referenced by load_module(), and unload_module().

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DATASTORE_BUCKETS

◆ DEFAULT_NUM_SESSION_MEDIA

◆ GET_STREAM_NAME_SAFE

◆ GET_STREAM_SAFE

◆ GET_STREAM_STATE_SAFE

◆ MEDIA_BUCKETS

◆ MOD_DATA_ON_RESPONSE

◆ print_debug_details

◆ SDP_HANDLER_BUCKETS

◆ STATE_NONE

◆ STATE_REMOVED

◆ STREAM_REMOVED

Enumeration Type Documentation

◆ delayed_method

◆ sip_get_destination_result

Function Documentation

◆ __print_debug_details()

◆ __reg_module()

◆ __unreg_module()

◆ add_bundle_groups()

◆ add_sdp_streams()

◆ AST_MODULE_SELF_SYM()

◆ ast_sip_can_present_connected_id()

◆ ast_sip_channel_pvt_alloc()

◆ ast_sip_dialog_get_session()

◆ ast_sip_session_add_datastore()

◆ ast_sip_session_alloc()

◆ ast_sip_session_alloc_datastore()

◆ ast_sip_session_create_invite()

◆ ast_sip_session_create_outgoing()

◆ ast_sip_session_defer_termination()

◆ ast_sip_session_defer_termination_cancel()

◆ ast_sip_session_end_if_deferred()

◆ ast_sip_session_get_datastore()

◆ ast_sip_session_get_dialog()

◆ ast_sip_session_get_name()

◆ ast_sip_session_get_pjsip_inv_state()

◆ ast_sip_session_is_pending_stream_default()

◆ ast_sip_session_media_add_read_callback()

◆ ast_sip_session_media_get_transport()

◆ ast_sip_session_media_set_write_callback()

◆ ast_sip_session_media_state_add()

◆ ast_sip_session_media_state_alloc()

◆ ast_sip_session_media_state_clone()

◆ ast_sip_session_media_state_free()

◆ ast_sip_session_media_state_reset()

◆ ast_sip_session_media_stats_save()

◆ ast_sip_session_refresh()

◆ ast_sip_session_regenerate_answer()

◆ ast_sip_session_register_sdp_handler()

◆ ast_sip_session_remove_datastore()

◆ ast_sip_session_resume_reinvite()

◆ ast_sip_session_send_request()

◆ ast_sip_session_send_request_with_cb()

◆ ast_sip_session_send_response()

◆ ast_sip_session_suspend()

◆ ast_sip_session_terminate()

◆ ast_sip_session_unregister_sdp_handler()

◆ ast_sip_session_unsuspend()

◆ check_content_disposition()

◆ check_content_disposition_in_multipart()

◆ check_delayed_requests()

◆ check_request_status()

◆ check_sdp_content_type_supported()

◆ create_local_sdp()

◆ datastore_cmp()

◆ datastore_hash()

◆ delay_request()

◆ delayed_method2str()

◆ delayed_request_alloc()

◆ delayed_request_free()

◆ does_method_match()

◆ fetch_callerid_num()

◆ flush_delayed_requests()