res_pjsip_session.h File Reference

#include <pjlib.h>
#include "asterisk/linkedlists.h"
#include "asterisk/channel.h"
#include "asterisk/netsock2.h"
#include "asterisk/sdp_srtp.h"
#include "asterisk/codec.h"
#include <pjsip_ua.h>
#include "asterisk/res_pjsip.h"

Include dependency graph for res_pjsip_session.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_sip_channel_pvt
	A structure which contains a channel implementation and session. More...
struct	ast_sip_session
	A structure describing a SIP session. More...
struct	ast_sip_session_media
	A structure containing SIP session media information. More...
struct	ast_sip_session_media_read_callback_state
	Structure which contains read callback information. More...
struct	ast_sip_session_media_state
	Structure which contains media state information (streams, sessions) More...
struct	ast_sip_session_sdp_handler
	A handler for SDPs in SIP sessions. More...
struct	ast_sip_session_supplement
	A supplement to SIP message processing. More...

Macros
#define	ast_sip_session_register_supplement(supplement)    ast_sip_session_register_supplement_with_module(AST_MODULE_SELF, supplement)

Typedefs
typedef struct ast_frame *(*	ast_sip_session_media_read_cb) (struct ast_sip_session *session, struct ast_sip_session_media *session_media)
typedef int(*	ast_sip_session_media_write_cb) (struct ast_sip_session *session, struct ast_sip_session_media *session_media, struct ast_frame *frame)
typedef int(*	ast_sip_session_request_creation_cb) (struct ast_sip_session *session, pjsip_tx_data *tdata)
typedef int(*	ast_sip_session_response_cb) (struct ast_sip_session *session, pjsip_rx_data *rdata)
typedef int(*	ast_sip_session_sdp_creation_cb) (struct ast_sip_session *session, pjmedia_sdp_session *sdp)

Enumerations
enum	ast_sip_session_call_direction { AST_SIP_SESSION_INCOMING_CALL = 0 , AST_SIP_SESSION_OUTGOING_CALL }
	Indicates the call direction respective to Asterisk. More...
enum	ast_sip_session_response_priority { AST_SIP_SESSION_BEFORE_REDIRECTING = (1 << 0) , AST_SIP_SESSION_BEFORE_MEDIA = (1 << 1) , AST_SIP_SESSION_AFTER_MEDIA = (1 << 2) }
	Describes when a supplement should be called into on incoming responses. More...
enum	ast_sip_session_sdp_stream_defer { AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED , AST_SIP_SESSION_SDP_DEFER_ERROR , AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED , AST_SIP_SESSION_SDP_DEFER_NEEDED }
enum	ast_sip_session_t38state {   T38_DISABLED = 0 , T38_LOCAL_REINVITE , T38_PEER_REINVITE , T38_ENABLED ,   T38_REJECTED , T38_MAX_ENUM }
	T.38 states for a session. More...

Functions
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.
int	ast_sip_session_add_reason_header (struct ast_sip_session *session, const char *protocol, int code, const char *text)
	Adds a Reason header in the next reponse to an incoming INVITE.
int	ast_sip_session_add_supplements (struct ast_sip_session *session)
	Add supplements 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, 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_check_supplement_create (struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact, const char *location, const char *request_user, struct ast_stream_topology *req_topology)
	Check registered supplements for permission to create an outgoing session.
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_register_supplement_with_module (struct ast_module *module, struct ast_sip_session_supplement *supplement)
	Register a supplement to SIP session processing.
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_remove_supplements (struct ast_sip_session *session)
	Remove supplements from a SIP 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_unregister_supplement (struct ast_sip_session_supplement *supplement)
	Unregister a an supplement to SIP session processing.
void	ast_sip_session_unsuspend (struct ast_sip_session *session)
	Request the session serializer be unsuspended.

Macro Definition Documentation

ast_sip_session_register_supplement

#define ast_sip_session_register_supplement

(

supplement

)

ast_sip_session_register_supplement_with_module(AST_MODULE_SELF, supplement)

Definition at line 645 of file res_pjsip_session.h.

Typedef Documentation

ast_sip_session_media_read_cb

typedef struct ast_frame *(* ast_sip_session_media_read_cb) (struct ast_sip_session *session, struct ast_sip_session_media *session_media)

Definition at line 1 of file res_pjsip_session.h.

ast_sip_session_media_write_cb

typedef int(* ast_sip_session_media_write_cb) (struct ast_sip_session *session, struct ast_sip_session_media *session_media, struct ast_frame *frame)

Definition at line 71 of file res_pjsip_session.h.

ast_sip_session_request_creation_cb

typedef int(* ast_sip_session_request_creation_cb) (struct ast_sip_session *session, pjsip_tx_data *tdata)

Definition at line 254 of file res_pjsip_session.h.

ast_sip_session_response_cb

typedef int(* ast_sip_session_response_cb) (struct ast_sip_session *session, pjsip_rx_data *rdata)

Definition at line 255 of file res_pjsip_session.h.

ast_sip_session_sdp_creation_cb

typedef int(* ast_sip_session_sdp_creation_cb) (struct ast_sip_session *session, pjmedia_sdp_session *sdp)

Definition at line 256 of file res_pjsip_session.h.

Enumeration Type Documentation

ast_sip_session_call_direction

enum ast_sip_session_call_direction

Indicates the call direction respective to Asterisk.

Enumerator
AST_SIP_SESSION_INCOMING_CALL
AST_SIP_SESSION_OUTGOING_CALL

Definition at line 168 of file res_pjsip_session.h.

                                    {
    AST_SIP_SESSION_INCOMING_CALL = 0,
    AST_SIP_SESSION_OUTGOING_CALL,
};

ast_sip_session_response_priority

enum ast_sip_session_response_priority

Describes when a supplement should be called into on incoming responses.

In most cases, session supplements will not need to worry about this because in most cases, the correct value will be automatically applied. However, there are rare circumstances when a supplement will want to specify when it should be called.

The values below are listed in chronological order.

Enumerator
AST_SIP_SESSION_BEFORE_REDIRECTING	When processing 3XX responses, the supplement is called into before the redirecting information is processed.
AST_SIP_SESSION_BEFORE_MEDIA	For responses to INVITE transactions, the supplement is called into before media is negotiated. This priority is applied by default to any session supplement that does not specify a response priority.
AST_SIP_SESSION_AFTER_MEDIA	For INVITE transactions, the supplement is called into after media is negotiated.

Definition at line 267 of file res_pjsip_session.h.

                                       {
    /*!
     * When processing 3XX responses, the supplement is called into before
     * the redirecting information is processed.
     */
    AST_SIP_SESSION_BEFORE_REDIRECTING = (1 << 0),
    /*!
     * For responses to INVITE transactions, the supplement is called into
     * before media is negotiated.
     *
     * This priority is applied by default to any session supplement that
     * does not specify a response priority.
     */
    AST_SIP_SESSION_BEFORE_MEDIA = (1 << 1),
    /*!
     * For INVITE transactions, the supplement is called into after media
     * is negotiated.
     */
    AST_SIP_SESSION_AFTER_MEDIA = (1 << 2),
};

ast_sip_session_sdp_stream_defer

enum ast_sip_session_sdp_stream_defer

Enumerator
AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED	The stream was not handled by this handler. If there are other registered handlers for this stream type, they will be called.
AST_SIP_SESSION_SDP_DEFER_ERROR	There was an error encountered. No further operations will take place and the current negotiation will be abandoned.
AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED	Re-invite is not needed
AST_SIP_SESSION_SDP_DEFER_NEEDED	Re-invite should be deferred and will be resumed later. No further operations will take place.

Definition at line 396 of file res_pjsip_session.h.

                                      {
    /*! The stream was not handled by this handler. If there are other registered handlers for this stream type, they will be called. */
    AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED,
    /*! There was an error encountered. No further operations will take place and the current negotiation will be abandoned. */
    AST_SIP_SESSION_SDP_DEFER_ERROR,
    /*! Re-invite is not needed */
    AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED,
    /*! Re-invite should be deferred and will be resumed later. No further operations will take place. */
    AST_SIP_SESSION_SDP_DEFER_NEEDED,
};

ast_sip_session_t38state

enum ast_sip_session_t38state

T.38 states for a session.

Enumerator
T38_DISABLED	Not enabled
T38_LOCAL_REINVITE	Offered from local - REINVITE
T38_PEER_REINVITE	Offered from peer - REINVITE
T38_ENABLED	Negotiated (enabled)
T38_REJECTED	Refused
T38_MAX_ENUM	Not an actual state; used as max value in the enum

Definition at line 56 of file res_pjsip_session.h.

                              {
    T38_DISABLED = 0,   /*!< Not enabled */
    T38_LOCAL_REINVITE, /*!< Offered from local - REINVITE */
    T38_PEER_REINVITE,  /*!< Offered from peer - REINVITE */
    T38_ENABLED,        /*!< Negotiated (enabled) */
    T38_REJECTED,       /*!< Refused */
    T38_MAX_ENUM,       /*!< Not an actual state; used as max value in the enum */
};

Function Documentation

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 3057 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 3620 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(), and session_reinvite_on_rx_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 1284 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(), and t38_state_get_or_alloc().

ast_sip_session_add_reason_header()

int ast_sip_session_add_reason_header	(	struct ast_sip_session *	session,
		const char *	protocol,
		int	code,
		const char *	text
	)

Adds a Reason header in the next reponse to an incoming INVITE.

Parameters

session	The session
protocol	Usually "SIP" but may be "STIR" for stir-shaken
code	SIP response code
text	Reason string

Return values

0	the header is accepted
-1	the header is rejected

Definition at line 123 of file pjsip_session_reason_header.c.

{
    struct return_reason_data *rr;
    RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
    const char *tag = ast_sip_session_get_name(session);
    SCOPE_ENTER(4, "%s: Adding Reason header %s %d %s\n",
        tag, S_OR(protocol,"<missing protocol>"),
        code, S_OR(text, "<missing text>"));
 
    if (ast_strlen_zero(protocol) || !text) {
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Missing protocol or text\n", tag);
    }
    rr = ast_calloc(1, sizeof(*rr));
    if (!rr) {
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Failed to allocate datastore\n", tag);
    }
    datastore = ast_sip_session_alloc_datastore(
        &return_reason_info, return_reason_info.type);
    rr->protocol = ast_strdup(protocol);
    rr->response_code = code;
    rr->response_str = ast_strdup(text);
    datastore->data = rr;
    if (ast_sip_session_add_datastore(session, datastore) != 0) {
        SCOPE_EXIT_RTN_VALUE(-1,
            "%s: Failed to add datastore to session\n", tag);
    }
 
    SCOPE_EXIT_RTN_VALUE(0, "%s: Done\n", tag);
}

References ao2_cleanup, ast_calloc, ast_sip_session_add_datastore(), ast_sip_session_alloc_datastore(), ast_sip_session_get_name(), ast_strdup, ast_strlen_zero(), NULL, return_reason_data::protocol, RAII_VAR, return_reason_data::response_code, return_reason_data::response_str, return_reason_info, S_OR, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, text, and ast_datastore_info::type.

Referenced by process_failure().

ast_sip_session_add_supplements()

int ast_sip_session_add_supplements

(

struct ast_sip_session *

session

)

Add supplements to a SIP session.

Parameters

session

The session to initialize

Definition at line 90 of file pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
    SCOPED_LOCK(lock, &session_supplements, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
 
    AST_RWLIST_TRAVERSE(&session_supplements, iter, next) {
        struct ast_sip_session_supplement *copy = supplement_dup(iter);
 
        if (!copy) {
            return -1;
        }
 
        /* referenced session created. increasing module reference. */
        ast_module_ref(copy->module);
 
        AST_LIST_INSERT_TAIL(&session->supplements, copy, next);
    }
 
    return 0;
}

References AST_LIST_INSERT_TAIL, ast_module_ref, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, copy(), lock, ast_sip_session_supplement::next, SCOPED_LOCK, session, and supplement_dup().

Referenced by ast_sip_session_alloc().

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 3073 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 {
        char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
 
        /* Create name with seq number appended. */
        ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/outsess/%s",
            ast_sorcery_object_get_id(endpoint));
 
        session->serializer = ast_sip_create_serializer(tps_name);
    }
    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_create_serializer(), 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_session_add_supplements(), ast_sip_session_media_state_alloc(), ast_sorcery_object_get_id(), ast_taskprocessor_build_name(), AST_TASKPROCESSOR_MAX_NAME, 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 1254 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(), and t38_state_get_or_alloc().

ast_sip_session_check_supplement_create()

int ast_sip_session_check_supplement_create	(	struct ast_sip_endpoint *	endpoint,
		struct ast_sip_contact *	contact,
		const char *	location,
		const char *	request_user,
		struct ast_stream_topology *	req_topology
	)

Check registered supplements for permission to create an outgoing session.

Iterates the global supplement list and calls any registered session_create callbacks. The first callback to return a non-zero value stops the iteration and causes this function to return -1, blocking the session creation.

This is called at the beginning of ast_sip_session_create_outgoing() before any dialog or invite session resources are allocated.

Since

20.20.0

22.10.0

23.4.0

Parameters

endpoint	The endpoint the outgoing session would be created for
contact	The contact to use for the outgoing session, or NULL
location	Name of the location to call, be it named location or explicit URI, or NULL
request_user	Optional request user to place in the request URI, or NULL
req_topology	The requested stream capabilities

Return values

0	Session creation is allowed
-1	Session creation is blocked by a supplement

Definition at line 111 of file pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
    SCOPED_LOCK(lock, &session_supplements, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
 
    AST_RWLIST_TRAVERSE(&session_supplements, iter, next) {
        if (iter->session_create && iter->session_create(endpoint, contact, location,
                request_user, req_topology)) {
            return -1;
        }
    }
 
    return 0;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, lock, ast_sip_session_supplement::next, SCOPED_LOCK, and ast_sip_session_supplement::session_create.

Referenced by ast_sip_session_create_outgoing().

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 2933 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 3299 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 3546 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 3586 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 3604 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 1296 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(), 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 3635 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(), 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 3646 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");
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_ref, ast_asprintf, ast_codec_media_type2str(), ast_free, ast_sip_session_get_name(), ast_strdup, ast_stream_get_name(), ast_stream_get_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_get_stream(), ast_trace, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_sip_session_media::bundle_group, ast_sip_session_media::bundled, ast_sip_session_media_state::default_session, ast_sip_session_media::encryption, ast_sip_session_media::keepalive_sched_id, ast_sip_session_media::mid, NULL, ast_sip_session_media::remote_ice, ast_sip_session_media::remote_rtcp_mux, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, session_media_dtor(), ast_sip_session_media_state::sessions, ast_sip_session_media::stream_name, ast_sip_session_media::stream_num, ast_sip_session_media::timeout_sched_id, ast_sip_session_media_state::topology, type, and ast_sip_session_media::type.

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 2602 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 2613 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_register_supplement_with_module()

void ast_sip_session_register_supplement_with_module	(	struct ast_module *	module,
		struct ast_sip_session_supplement *	supplement
	)

Register a supplement to SIP session processing.

This allows for someone to insert themselves in the processing of SIP requests and responses. This, for example could allow for a module to set channel data based on headers in an incoming message. Similarly, a module could reject an incoming request if desired.

Parameters

module	Referenced module(NULL safe)
supplement	The supplement to register

Definition at line 35 of file pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
    int inserted = 0;
    SCOPED_LOCK(lock, &session_supplements, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
 
    ast_assert(supplement != NULL);
 
    supplement->module = module;
 
    if (!supplement->response_priority) {
        supplement->response_priority = AST_SIP_SESSION_BEFORE_MEDIA;
    }
 
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&session_supplements, iter, next) {
        if (iter->priority > supplement->priority) {
            AST_RWLIST_INSERT_BEFORE_CURRENT(supplement, next);
            inserted = 1;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    if (!inserted) {
        AST_RWLIST_INSERT_TAIL(&session_supplements, supplement, next);
    }
}

References ast_assert, AST_RWLIST_INSERT_BEFORE_CURRENT, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, AST_SIP_SESSION_BEFORE_MEDIA, lock, ast_sip_session_supplement::next, NULL, ast_sip_session_supplement::priority, ast_sip_session_supplement::response_priority, and SCOPED_LOCK.

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 1301 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_remove_supplements()

void ast_sip_session_remove_supplements

(

struct ast_sip_session *

session

)

Remove supplements from a SIP session.

Parameters

session

The session to remove

Definition at line 128 of file pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
 
    if (!session) {
        return;
    }
 
    /* free the supplements */
    while ((iter = AST_LIST_REMOVE_HEAD(&session->supplements, next))) {
        if (iter->module) {
            /* referenced session closed. decreasing module reference. */
            ast_module_unref(iter->module);
        }
 
        ast_free(iter);
    }
 
    return;
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_module_unref, ast_sip_session_supplement::next, and session.

Referenced by session_destructor().

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 2884 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 2928 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 2904 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 2654 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 3193 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 3439 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);
    SWAP(session->active_media_state, session->pending_media_state);
    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_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_unregister_supplement()

void ast_sip_session_unregister_supplement

(

struct ast_sip_session_supplement *

supplement

)

Unregister a an supplement to SIP session processing.

Parameters

supplement

The supplement to unregister

Definition at line 63 of file pjsip_session.c.

{
    struct ast_sip_session_supplement *iter;
    SCOPED_LOCK(lock, &session_supplements, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
 
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&session_supplements, iter, next) {
        if (supplement == iter) {
            AST_RWLIST_REMOVE_CURRENT(next);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
}

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, lock, ast_sip_session_supplement::next, and SCOPED_LOCK.

Referenced by ast_res_pjsip_cleanup_message_filter(), load_module(), load_module(), pjsip_reason_header_unload(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), 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 3198 of file res_pjsip_session.c.

{
    ast_taskpool_serializer_unsuspend(session->serializer);
}

References ast_taskpool_serializer_unsuspend(), and session.

Referenced by chan_pjsip_indicate().