2013-04-25 18:25:31 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
|
|
*
|
|
|
|
* Joshua Colp <jcolp@digium.com>
|
|
|
|
*
|
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*! \file
|
|
|
|
*
|
|
|
|
* \author Joshua Colp <jcolp@digium.com>
|
|
|
|
*
|
2013-07-30 18:14:50 +00:00
|
|
|
* \brief PSJIP SIP Channel Driver
|
2013-04-25 18:25:31 +00:00
|
|
|
*
|
|
|
|
* \ingroup channel_drivers
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*** MODULEINFO
|
|
|
|
<depend>pjproject</depend>
|
2013-07-30 18:14:50 +00:00
|
|
|
<depend>res_pjsip</depend>
|
2019-04-02 19:42:44 +00:00
|
|
|
<depend>res_pjsip_pubsub</depend>
|
2013-07-30 18:14:50 +00:00
|
|
|
<depend>res_pjsip_session</depend>
|
2013-04-25 18:25:31 +00:00
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
#include <pjsip.h>
|
|
|
|
#include <pjsip_ua.h>
|
|
|
|
#include <pjlib.h>
|
|
|
|
|
|
|
|
#include "asterisk/lock.h"
|
|
|
|
#include "asterisk/channel.h"
|
|
|
|
#include "asterisk/module.h"
|
|
|
|
#include "asterisk/pbx.h"
|
|
|
|
#include "asterisk/rtp_engine.h"
|
|
|
|
#include "asterisk/acl.h"
|
|
|
|
#include "asterisk/callerid.h"
|
|
|
|
#include "asterisk/file.h"
|
|
|
|
#include "asterisk/cli.h"
|
|
|
|
#include "asterisk/app.h"
|
|
|
|
#include "asterisk/musiconhold.h"
|
|
|
|
#include "asterisk/causes.h"
|
|
|
|
#include "asterisk/taskprocessor.h"
|
2013-06-22 14:03:22 +00:00
|
|
|
#include "asterisk/dsp.h"
|
2013-06-22 12:40:16 +00:00
|
|
|
#include "asterisk/stasis_endpoints.h"
|
|
|
|
#include "asterisk/stasis_channels.h"
|
2013-07-18 19:25:51 +00:00
|
|
|
#include "asterisk/indications.h"
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
#include "asterisk/format_cache.h"
|
2014-08-20 22:52:44 +00:00
|
|
|
#include "asterisk/translate.h"
|
2014-04-29 11:27:14 +00:00
|
|
|
#include "asterisk/threadstorage.h"
|
2014-04-30 12:32:12 +00:00
|
|
|
#include "asterisk/features_config.h"
|
|
|
|
#include "asterisk/pickup.h"
|
2014-06-26 17:17:25 +00:00
|
|
|
#include "asterisk/test.h"
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
#include "asterisk/message.h"
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
#include "asterisk/res_pjsip.h"
|
|
|
|
#include "asterisk/res_pjsip_session.h"
|
2017-05-30 14:12:47 +00:00
|
|
|
#include "asterisk/stream.h"
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-12-11 13:06:30 +00:00
|
|
|
#include "pjsip/include/chan_pjsip.h"
|
|
|
|
#include "pjsip/include/dialplan_functions.h"
|
2016-03-27 03:33:14 +00:00
|
|
|
#include "pjsip/include/cli_functions.h"
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2014-04-29 11:27:14 +00:00
|
|
|
AST_THREADSTORAGE(uniqueid_threadbuf);
|
|
|
|
#define UNIQUEID_BUFSIZE 256
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static const char channel_type[] = "PJSIP";
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-06-22 12:40:16 +00:00
|
|
|
static unsigned int chan_idx;
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static void chan_pjsip_pvt_dtor(void *obj)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-11-19 09:46:06 +00:00
|
|
|
/*! \brief Asterisk core interaction functions */
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
static struct ast_channel *chan_pjsip_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause);
|
2017-05-30 14:12:47 +00:00
|
|
|
static struct ast_channel *chan_pjsip_request_with_stream_topology(const char *type,
|
|
|
|
struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids,
|
|
|
|
const struct ast_channel *requestor, const char *data, int *cause);
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
static int chan_pjsip_sendtext_data(struct ast_channel *ast, struct ast_msg_data *msg);
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_sendtext(struct ast_channel *ast, const char *text);
|
|
|
|
static int chan_pjsip_digit_begin(struct ast_channel *ast, char digit);
|
|
|
|
static int chan_pjsip_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
|
|
|
|
static int chan_pjsip_call(struct ast_channel *ast, const char *dest, int timeout);
|
|
|
|
static int chan_pjsip_hangup(struct ast_channel *ast);
|
|
|
|
static int chan_pjsip_answer(struct ast_channel *ast);
|
2017-05-30 14:12:47 +00:00
|
|
|
static struct ast_frame *chan_pjsip_read_stream(struct ast_channel *ast);
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_write(struct ast_channel *ast, struct ast_frame *f);
|
2017-05-30 14:12:47 +00:00
|
|
|
static int chan_pjsip_write_stream(struct ast_channel *ast, int stream_num, struct ast_frame *f);
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
|
|
|
|
static int chan_pjsip_transfer(struct ast_channel *ast, const char *target);
|
|
|
|
static int chan_pjsip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
|
|
|
|
static int chan_pjsip_devicestate(const char *data);
|
|
|
|
static int chan_pjsip_queryoption(struct ast_channel *ast, int option, void *data, int *datalen);
|
2014-04-29 11:27:14 +00:00
|
|
|
static const char *chan_pjsip_get_uniqueid(struct ast_channel *ast);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
/*! \brief PBX interface structure for channel registration */
|
2013-12-11 13:06:30 +00:00
|
|
|
struct ast_channel_tech chan_pjsip_tech = {
|
2013-04-25 18:25:31 +00:00
|
|
|
.type = channel_type,
|
2013-07-30 18:14:50 +00:00
|
|
|
.description = "PJSIP Channel Driver",
|
|
|
|
.requester = chan_pjsip_request,
|
2017-05-30 14:12:47 +00:00
|
|
|
.requester_with_stream_topology = chan_pjsip_request_with_stream_topology,
|
2013-07-30 18:14:50 +00:00
|
|
|
.send_text = chan_pjsip_sendtext,
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
.send_text_data = chan_pjsip_sendtext_data,
|
2013-07-30 18:14:50 +00:00
|
|
|
.send_digit_begin = chan_pjsip_digit_begin,
|
|
|
|
.send_digit_end = chan_pjsip_digit_end,
|
|
|
|
.call = chan_pjsip_call,
|
|
|
|
.hangup = chan_pjsip_hangup,
|
|
|
|
.answer = chan_pjsip_answer,
|
2017-05-30 14:12:47 +00:00
|
|
|
.read_stream = chan_pjsip_read_stream,
|
2013-07-30 18:14:50 +00:00
|
|
|
.write = chan_pjsip_write,
|
2017-05-30 14:12:47 +00:00
|
|
|
.write_stream = chan_pjsip_write_stream,
|
|
|
|
.exception = chan_pjsip_read_stream,
|
2013-07-30 18:14:50 +00:00
|
|
|
.indicate = chan_pjsip_indicate,
|
|
|
|
.transfer = chan_pjsip_transfer,
|
|
|
|
.fixup = chan_pjsip_fixup,
|
|
|
|
.devicestate = chan_pjsip_devicestate,
|
|
|
|
.queryoption = chan_pjsip_queryoption,
|
2013-12-11 13:06:30 +00:00
|
|
|
.func_channel_read = pjsip_acf_channel_read,
|
2014-04-29 11:27:14 +00:00
|
|
|
.get_pvt_uniqueid = chan_pjsip_get_uniqueid,
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
.properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER | AST_CHAN_TP_SEND_TEXT_DATA
|
2013-04-25 18:25:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*! \brief SIP session interaction functions */
|
2013-07-30 18:14:50 +00:00
|
|
|
static void chan_pjsip_session_begin(struct ast_sip_session *session);
|
|
|
|
static void chan_pjsip_session_end(struct ast_sip_session *session);
|
|
|
|
static int chan_pjsip_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata);
|
|
|
|
static void chan_pjsip_incoming_response(struct ast_sip_session *session, struct pjsip_rx_data *rdata);
|
2020-12-31 11:53:34 +00:00
|
|
|
static void chan_pjsip_incoming_response_update_cause(struct ast_sip_session *session, struct pjsip_rx_data *rdata);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
/*! \brief SIP session supplement structure */
|
2013-07-30 18:14:50 +00:00
|
|
|
static struct ast_sip_session_supplement chan_pjsip_supplement = {
|
2013-04-25 18:25:31 +00:00
|
|
|
.method = "INVITE",
|
2014-01-15 13:16:10 +00:00
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL,
|
2013-07-30 18:14:50 +00:00
|
|
|
.session_begin = chan_pjsip_session_begin,
|
|
|
|
.session_end = chan_pjsip_session_end,
|
|
|
|
.incoming_request = chan_pjsip_incoming_request,
|
2020-12-31 11:53:34 +00:00
|
|
|
.incoming_response = chan_pjsip_incoming_response,
|
2014-09-02 20:29:58 +00:00
|
|
|
/* It is important that this supplement runs after media has been negotiated */
|
|
|
|
.response_priority = AST_SIP_SESSION_AFTER_MEDIA,
|
2013-04-25 18:25:31 +00:00
|
|
|
};
|
|
|
|
|
2018-06-07 13:46:03 +00:00
|
|
|
/*! \brief SIP session supplement structure just for responses */
|
|
|
|
static struct ast_sip_session_supplement chan_pjsip_supplement_response = {
|
|
|
|
.method = "INVITE",
|
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL,
|
2020-12-31 11:53:34 +00:00
|
|
|
.incoming_response = chan_pjsip_incoming_response_update_cause,
|
2018-06-07 13:46:03 +00:00
|
|
|
.response_priority = AST_SIP_SESSION_BEFORE_MEDIA | AST_SIP_SESSION_AFTER_MEDIA,
|
|
|
|
};
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_incoming_ack(struct ast_sip_session *session, struct pjsip_rx_data *rdata);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static struct ast_sip_session_supplement chan_pjsip_ack_supplement = {
|
2013-04-25 18:25:31 +00:00
|
|
|
.method = "ACK",
|
2014-01-15 13:16:10 +00:00
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL,
|
2013-07-30 18:14:50 +00:00
|
|
|
.incoming_request = chan_pjsip_incoming_ack,
|
2013-04-25 18:25:31 +00:00
|
|
|
};
|
|
|
|
|
2023-05-25 15:14:47 +00:00
|
|
|
static int chan_pjsip_incoming_prack(struct ast_sip_session *session, struct pjsip_rx_data *rdata);
|
|
|
|
|
|
|
|
static struct ast_sip_session_supplement chan_pjsip_prack_supplement = {
|
|
|
|
.method = "PRACK",
|
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL,
|
|
|
|
.incoming_request = chan_pjsip_incoming_prack,
|
|
|
|
};
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called by RTP engine to get local audio RTP peer */
|
2013-07-30 18:14:50 +00:00
|
|
|
static enum ast_rtp_glue_result chan_pjsip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
2013-04-25 18:25:31 +00:00
|
|
|
struct ast_sip_endpoint *endpoint;
|
chan_pjsip: Handle T.38 faxes with direct media bridges
When a channel is in a direct media bridge, a re-INVITE may arrive that forces
Asterisk to re-negotiate the media to a T.38 fax. When this occurs, the bridge
must change its technology to a simple bridge, and re-INVITE the media back
to Asterisk.
Generally, this logic mostly already exists in Asterisk. However, prior to this
patch, there were a few bugs:
(1) The T.38 framehook currently prevents a channel capable of T.38 faxes from
ever entering into a direct media bridge. This applies even when the only
media being passed over the channel is audio. This patch fixes this bug
by having the framehook specify that it defers caring about any frame type.
This allows the channels to enter into a direct media bridge, which will
be broken when a re-INVITE is received.
(2) When a re-INVITE is received, nothing instructed the bridging layer to
re-inspect the allowed bridging technology. This now occurs when either
a re-INVITE is received from a peer, or when a response is received from
the far end (that is, when the T.38 state changes to either
T38_PEER_REINVITE or T38_LOCAL_REINVITE).
(3) chan_pjsip needs to do a small amount of work to prevent a direct media
bridge from being chosen when a T.38 session is in progress. When a T.38
session supplement has a t38 datastore - which is added when we detect
we should start thinking about T.38 on a channel - we now refuse a native
RTP bridge.
(4) When a BYE request is received, we don't terminate the T.38 session. If
the other side of a T.38 fax survives the hangup (due to the 'g' flag
in Dial, for example), we don't currently re-INVITE the media on the
other channel back to audio. This patch now has res_pjsip_t38 intercept
BYE requests and inform the far side that the T.38 session is terminated.
This naturally causes the correct re-INVITEs to be sent.
ASTERISK-25582
Change-Id: Iabd6aa578e633d16e6b9f342091264e4324a79eb
2015-11-21 03:08:49 +00:00
|
|
|
struct ast_datastore *datastore;
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session_media *media;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!channel || !channel->session) {
|
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX Getting the first RTP instance for direct media related stuff seems just
|
|
|
|
* absolutely wrong. But the native RTP bridge knows no other method than single-stream
|
|
|
|
* for direct media. So this is the best we can do.
|
|
|
|
*/
|
|
|
|
media = channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
|
|
|
if (!media || !media->rtp) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
chan_pjsip: Handle T.38 faxes with direct media bridges
When a channel is in a direct media bridge, a re-INVITE may arrive that forces
Asterisk to re-negotiate the media to a T.38 fax. When this occurs, the bridge
must change its technology to a simple bridge, and re-INVITE the media back
to Asterisk.
Generally, this logic mostly already exists in Asterisk. However, prior to this
patch, there were a few bugs:
(1) The T.38 framehook currently prevents a channel capable of T.38 faxes from
ever entering into a direct media bridge. This applies even when the only
media being passed over the channel is audio. This patch fixes this bug
by having the framehook specify that it defers caring about any frame type.
This allows the channels to enter into a direct media bridge, which will
be broken when a re-INVITE is received.
(2) When a re-INVITE is received, nothing instructed the bridging layer to
re-inspect the allowed bridging technology. This now occurs when either
a re-INVITE is received from a peer, or when a response is received from
the far end (that is, when the T.38 state changes to either
T38_PEER_REINVITE or T38_LOCAL_REINVITE).
(3) chan_pjsip needs to do a small amount of work to prevent a direct media
bridge from being chosen when a T.38 session is in progress. When a T.38
session supplement has a t38 datastore - which is added when we detect
we should start thinking about T.38 on a channel - we now refuse a native
RTP bridge.
(4) When a BYE request is received, we don't terminate the T.38 session. If
the other side of a T.38 fax survives the hangup (due to the 'g' flag
in Dial, for example), we don't currently re-INVITE the media on the
other channel back to audio. This patch now has res_pjsip_t38 intercept
BYE requests and inform the far side that the T.38 session is terminated.
This naturally causes the correct re-INVITEs to be sent.
ASTERISK-25582
Change-Id: Iabd6aa578e633d16e6b9f342091264e4324a79eb
2015-11-21 03:08:49 +00:00
|
|
|
datastore = ast_sip_session_get_datastore(channel->session, "t38");
|
|
|
|
if (datastore) {
|
|
|
|
ao2_ref(datastore, -1);
|
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
2013-07-23 12:27:03 +00:00
|
|
|
endpoint = channel->session->endpoint;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
*instance = media->rtp;
|
2013-04-25 18:25:31 +00:00
|
|
|
ao2_ref(*instance, +1);
|
|
|
|
|
|
|
|
ast_assert(endpoint != NULL);
|
2013-07-30 15:17:56 +00:00
|
|
|
if (endpoint->media.rtp.encryption != AST_SIP_MEDIA_ENCRYPT_NONE) {
|
2013-07-23 13:52:06 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
if (endpoint->media.direct_media.enabled) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_REMOTE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return AST_RTP_GLUE_RESULT_LOCAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called by RTP engine to get local video RTP peer */
|
2013-07-30 18:14:50 +00:00
|
|
|
static enum ast_rtp_glue_result chan_pjsip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
2013-07-23 13:52:06 +00:00
|
|
|
struct ast_sip_endpoint *endpoint;
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session_media *media;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!channel || !channel->session) {
|
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
|
|
|
media = channel->session->active_media_state->default_session[AST_MEDIA_TYPE_VIDEO];
|
|
|
|
if (!media || !media->rtp) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
2013-07-23 13:52:06 +00:00
|
|
|
endpoint = channel->session->endpoint;
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
*instance = media->rtp;
|
2013-04-25 18:25:31 +00:00
|
|
|
ao2_ref(*instance, +1);
|
|
|
|
|
2013-07-23 13:52:06 +00:00
|
|
|
ast_assert(endpoint != NULL);
|
2013-07-30 15:17:56 +00:00
|
|
|
if (endpoint->media.rtp.encryption != AST_SIP_MEDIA_ENCRYPT_NONE) {
|
2013-07-23 13:52:06 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_FORBID;
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
return AST_RTP_GLUE_RESULT_LOCAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called by RTP engine to get peer capabilities */
|
2013-07-30 18:14:50 +00:00
|
|
|
static void chan_pjsip_get_codec(struct ast_channel *chan, struct ast_format_cap *result)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s Native formats %s\n", ast_channel_name(chan),
|
|
|
|
ast_str_tmp(AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_get_names(ast_channel_nativeformats(chan), &STR_TMP)));
|
2016-10-23 12:38:59 +00:00
|
|
|
ast_format_cap_append_from_cap(result, ast_channel_nativeformats(chan), AST_MEDIA_TYPE_UNKNOWN);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN();
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 13:06:30 +00:00
|
|
|
/*! \brief Destructor function for \ref transport_info_data */
|
|
|
|
static void transport_info_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct transport_info_data *data = obj;
|
|
|
|
ast_free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Datastore used to store local/remote addresses for the
|
|
|
|
* INVITE request that created the PJSIP channel */
|
|
|
|
static struct ast_datastore_info transport_info = {
|
|
|
|
.type = "chan_pjsip_transport_info",
|
|
|
|
.destroy = transport_info_destroy,
|
|
|
|
};
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
static struct ast_datastore_info direct_media_mitigation_info = { };
|
|
|
|
|
|
|
|
static int direct_media_mitigate_glare(struct ast_sip_session *session)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
|
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
if (session->endpoint->media.direct_media.glare_mitigation ==
|
2013-04-25 18:25:31 +00:00
|
|
|
AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_NONE) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
datastore = ast_sip_session_get_datastore(session, "direct_media_glare_mitigation");
|
|
|
|
if (!datastore) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Removing the datastore ensures we won't try to mitigate glare on subsequent reinvites */
|
|
|
|
ast_sip_session_remove_datastore(session, "direct_media_glare_mitigation");
|
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
if ((session->endpoint->media.direct_media.glare_mitigation ==
|
2013-04-25 18:25:31 +00:00
|
|
|
AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_OUTGOING &&
|
|
|
|
session->inv_session->role == PJSIP_ROLE_UAC) ||
|
2013-07-30 15:17:56 +00:00
|
|
|
(session->endpoint->media.direct_media.glare_mitigation ==
|
2013-04-25 18:25:31 +00:00
|
|
|
AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_INCOMING &&
|
|
|
|
session->inv_session->role == PJSIP_ROLE_UAS)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
/*! \brief Helper function to find the position for RTCP */
|
|
|
|
static int rtp_find_rtcp_fd_position(struct ast_sip_session *session, struct ast_rtp_instance *rtp)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
for (index = 0; index < AST_VECTOR_SIZE(&session->active_media_state->read_callbacks); ++index) {
|
|
|
|
struct ast_sip_session_media_read_callback_state *callback_state =
|
|
|
|
AST_VECTOR_GET_ADDR(&session->active_media_state->read_callbacks, index);
|
|
|
|
|
|
|
|
if (callback_state->fd != ast_rtp_instance_fd(rtp, 1)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-06-09 15:37:53 +00:00
|
|
|
/*!
|
|
|
|
* \pre chan is locked
|
|
|
|
*/
|
2013-04-25 18:25:31 +00:00
|
|
|
static int check_for_rtp_changes(struct ast_channel *chan, struct ast_rtp_instance *rtp,
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session_media *media, struct ast_sip_session *session)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2017-05-30 14:12:47 +00:00
|
|
|
int changed = 0, position = -1;
|
|
|
|
|
|
|
|
if (media->rtp) {
|
|
|
|
position = rtp_find_rtcp_fd_position(session, media->rtp);
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (rtp) {
|
|
|
|
changed = ast_rtp_instance_get_and_cmp_remote_address(rtp, &media->direct_media_addr);
|
|
|
|
if (media->rtp) {
|
2017-05-30 14:12:47 +00:00
|
|
|
if (position != -1) {
|
|
|
|
ast_channel_set_fd(chan, position + AST_EXTENDED_FDS, -1);
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_RTCP, 0);
|
|
|
|
}
|
|
|
|
} else if (!ast_sockaddr_isnull(&media->direct_media_addr)){
|
|
|
|
ast_sockaddr_setnull(&media->direct_media_addr);
|
|
|
|
changed = 1;
|
|
|
|
if (media->rtp) {
|
|
|
|
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_RTCP, 1);
|
2017-05-30 14:12:47 +00:00
|
|
|
if (position != -1) {
|
|
|
|
ast_channel_set_fd(chan, position + AST_EXTENDED_FDS, ast_rtp_instance_fd(media->rtp, 1));
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2016-03-16 17:37:01 +00:00
|
|
|
struct rtp_direct_media_data {
|
|
|
|
struct ast_channel *chan;
|
|
|
|
struct ast_rtp_instance *rtp;
|
|
|
|
struct ast_rtp_instance *vrtp;
|
|
|
|
struct ast_format_cap *cap;
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void rtp_direct_media_data_destroy(void *data)
|
|
|
|
{
|
|
|
|
struct rtp_direct_media_data *cdata = data;
|
|
|
|
|
|
|
|
ao2_cleanup(cdata->session);
|
|
|
|
ao2_cleanup(cdata->cap);
|
|
|
|
ao2_cleanup(cdata->vrtp);
|
|
|
|
ao2_cleanup(cdata->rtp);
|
|
|
|
ao2_cleanup(cdata->chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct rtp_direct_media_data *rtp_direct_media_data_create(
|
|
|
|
struct ast_channel *chan, struct ast_rtp_instance *rtp, struct ast_rtp_instance *vrtp,
|
|
|
|
const struct ast_format_cap *cap, struct ast_sip_session *session)
|
|
|
|
{
|
|
|
|
struct rtp_direct_media_data *cdata = ao2_alloc(sizeof(*cdata), rtp_direct_media_data_destroy);
|
|
|
|
|
|
|
|
if (!cdata) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cdata->chan = ao2_bump(chan);
|
|
|
|
cdata->rtp = ao2_bump(rtp);
|
|
|
|
cdata->vrtp = ao2_bump(vrtp);
|
|
|
|
cdata->cap = ao2_bump((struct ast_format_cap *)cap);
|
|
|
|
cdata->session = ao2_bump(session);
|
|
|
|
|
|
|
|
return cdata;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int send_direct_media_request(void *data)
|
|
|
|
{
|
|
|
|
struct rtp_direct_media_data *cdata = data;
|
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(cdata->chan);
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session *session;
|
2016-03-16 17:37:01 +00:00
|
|
|
int changed = 0;
|
|
|
|
int res = 0;
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
/* XXX In an ideal world each media stream would be direct, but for now preserve behavior
|
|
|
|
* and connect only the default media sessions for audio and video.
|
|
|
|
*/
|
|
|
|
|
2016-06-09 15:37:53 +00:00
|
|
|
/* The channel needs to be locked when checking for RTP changes.
|
|
|
|
* Otherwise, we could end up destroying an underlying RTCP structure
|
|
|
|
* at the same time that the channel thread is attempting to read RTCP
|
|
|
|
*/
|
|
|
|
ast_channel_lock(cdata->chan);
|
2017-05-30 14:12:47 +00:00
|
|
|
session = channel->session;
|
|
|
|
if (session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO]) {
|
2016-03-16 17:37:01 +00:00
|
|
|
changed |= check_for_rtp_changes(
|
2017-05-30 14:12:47 +00:00
|
|
|
cdata->chan, cdata->rtp, session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO], session);
|
2016-03-16 17:37:01 +00:00
|
|
|
}
|
2017-05-30 14:12:47 +00:00
|
|
|
if (session->active_media_state->default_session[AST_MEDIA_TYPE_VIDEO]) {
|
2016-03-16 17:37:01 +00:00
|
|
|
changed |= check_for_rtp_changes(
|
2017-05-30 14:12:47 +00:00
|
|
|
cdata->chan, cdata->vrtp, session->active_media_state->default_session[AST_MEDIA_TYPE_VIDEO], session);
|
2016-03-16 17:37:01 +00:00
|
|
|
}
|
2016-06-09 15:37:53 +00:00
|
|
|
ast_channel_unlock(cdata->chan);
|
2016-03-16 17:37:01 +00:00
|
|
|
|
|
|
|
if (direct_media_mitigate_glare(cdata->session)) {
|
|
|
|
ast_debug(4, "Disregarding setting RTP on %s: mitigating re-INVITE glare\n", ast_channel_name(cdata->chan));
|
2016-03-18 19:31:12 +00:00
|
|
|
ao2_ref(cdata, -1);
|
2016-03-16 17:37:01 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cdata->cap && ast_format_cap_count(cdata->cap) &&
|
|
|
|
!ast_format_cap_identical(cdata->session->direct_media_cap, cdata->cap)) {
|
|
|
|
ast_format_cap_remove_by_type(cdata->session->direct_media_cap, AST_MEDIA_TYPE_UNKNOWN);
|
|
|
|
ast_format_cap_append_from_cap(cdata->session->direct_media_cap, cdata->cap, AST_MEDIA_TYPE_UNKNOWN);
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (changed) {
|
|
|
|
ast_debug(4, "RTP changed on %s; initiating direct media update\n", ast_channel_name(cdata->chan));
|
|
|
|
res = ast_sip_session_refresh(cdata->session, NULL, NULL, NULL,
|
2017-05-30 14:12:47 +00:00
|
|
|
cdata->session->endpoint->media.direct_media.method, 1, NULL);
|
2016-03-16 17:37:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(cdata, -1);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called by RTP engine to change where the remote party should send media */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_set_rtp_peer(struct ast_channel *chan,
|
2013-04-25 18:25:31 +00:00
|
|
|
struct ast_rtp_instance *rtp,
|
|
|
|
struct ast_rtp_instance *vrtp,
|
|
|
|
struct ast_rtp_instance *tpeer,
|
|
|
|
const struct ast_format_cap *cap,
|
|
|
|
int nat_active)
|
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
|
|
|
struct ast_sip_session *session = channel->session;
|
2016-03-16 17:37:01 +00:00
|
|
|
struct rtp_direct_media_data *cdata;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s %s\n", ast_channel_name(chan),
|
|
|
|
ast_str_tmp(AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_get_names(cap, &STR_TMP)));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
/* Don't try to do any direct media shenanigans on early bridges */
|
2013-12-13 18:33:25 +00:00
|
|
|
if ((rtp || vrtp || tpeer) && !ast_channel_is_bridged(chan)) {
|
2014-06-04 14:13:07 +00:00
|
|
|
ast_debug(4, "Disregarding setting RTP on %s: channel is not bridged\n", ast_channel_name(chan));
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Channel not bridged\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
if (nat_active && session->endpoint->media.direct_media.disable_on_nat) {
|
2014-06-04 14:13:07 +00:00
|
|
|
ast_debug(4, "Disregarding setting RTP on %s: NAT is active\n", ast_channel_name(chan));
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "NAT is active\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2016-03-16 17:37:01 +00:00
|
|
|
cdata = rtp_direct_media_data_create(chan, rtp, vrtp, cap, session);
|
|
|
|
if (!cdata) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2016-03-16 17:37:01 +00:00
|
|
|
if (ast_sip_push_task(session->serializer, send_direct_media_request, cdata)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to send direct media request for channel %s\n", ast_channel_name(chan));
|
|
|
|
ao2_ref(cdata, -1);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Local glue for interacting with the RTP engine core */
|
2013-07-30 18:14:50 +00:00
|
|
|
static struct ast_rtp_glue chan_pjsip_rtp_glue = {
|
|
|
|
.type = "PJSIP",
|
|
|
|
.get_rtp_info = chan_pjsip_get_rtp_peer,
|
|
|
|
.get_vrtp_info = chan_pjsip_get_vrtp_peer,
|
|
|
|
.get_codec = chan_pjsip_get_codec,
|
|
|
|
.update_peer = chan_pjsip_set_rtp_peer,
|
2013-04-25 18:25:31 +00:00
|
|
|
};
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
static void set_channel_on_rtp_instance(const struct ast_sip_session *session,
|
|
|
|
const char *channel_id)
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
{
|
2017-05-30 14:12:47 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < AST_VECTOR_SIZE(&session->active_media_state->sessions); ++i) {
|
|
|
|
struct ast_sip_session_media *session_media;
|
|
|
|
|
|
|
|
session_media = AST_VECTOR_GET(&session->active_media_state->sessions, i);
|
|
|
|
if (!session_media || !session_media->rtp) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_rtp_instance_set_channel_id(session_media->rtp, channel_id);
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
}
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Determine if a topology is compatible with format capabilities
|
|
|
|
*
|
|
|
|
* This will return true if ANY formats in the topology are compatible with the format
|
|
|
|
* capabilities.
|
|
|
|
*
|
|
|
|
* XXX When supporting true multistream, we will need to be sure to mark which streams from
|
|
|
|
* top1 are compatible with which streams from top2. Then the ones that are not compatible
|
|
|
|
* will need to be marked as "removed" so that they are negotiated as expected.
|
|
|
|
*
|
|
|
|
* \param top Topology
|
|
|
|
* \param cap Format capabilities
|
|
|
|
* \retval 1 The topology has at least one compatible format
|
|
|
|
* \retval 0 The topology has no compatible formats or an error occurred.
|
|
|
|
*/
|
|
|
|
static int compatible_formats_exist(struct ast_stream_topology *top, struct ast_format_cap *cap)
|
|
|
|
{
|
|
|
|
struct ast_format_cap *cap_from_top;
|
|
|
|
int res;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "Topology: %s Formats: %s\n",
|
|
|
|
ast_str_tmp(AST_FORMAT_CAP_NAMES_LEN, ast_stream_topology_to_str(top, &STR_TMP)),
|
|
|
|
ast_str_tmp(AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_get_names(cap, &STR_TMP)));
|
2017-05-30 14:12:47 +00:00
|
|
|
|
2020-06-26 16:14:58 +00:00
|
|
|
cap_from_top = ast_stream_topology_get_formats(top);
|
2017-05-30 14:12:47 +00:00
|
|
|
|
|
|
|
if (!cap_from_top) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Topology had no formats\n");
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
}
|
2017-05-30 14:12:47 +00:00
|
|
|
|
|
|
|
res = ast_format_cap_iscompatible(cap_from_top, cap);
|
|
|
|
ao2_ref(cap_from_top, -1);
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(res, "Compatible? %s\n", res ? "yes" : "no");
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Function called to create a new PJSIP Asterisk channel */
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
static struct ast_channel *chan_pjsip_new(struct ast_sip_session *session, int state, const char *exten, const char *title, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *cid_name)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
|
|
|
struct ast_channel *chan;
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
struct ast_format_cap *caps;
|
2013-07-30 18:14:50 +00:00
|
|
|
RAII_VAR(struct chan_pjsip_pvt *, pvt, NULL, ao2_cleanup);
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel;
|
2014-01-02 19:08:19 +00:00
|
|
|
struct ast_variable *var;
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_stream_topology *topology;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!(pvt = ao2_alloc_options(sizeof(*pvt), chan_pjsip_pvt_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create pvt\n");
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2014-08-19 16:16:03 +00:00
|
|
|
chan = ast_channel_alloc_with_endpoint(1, state,
|
|
|
|
S_COR(session->id.number.valid, session->id.number.str, ""),
|
|
|
|
S_COR(session->id.name.valid, session->id.name.str, ""),
|
2015-06-11 23:52:09 +00:00
|
|
|
session->endpoint->accountcode,
|
|
|
|
exten, session->endpoint->context,
|
|
|
|
assignedids, requestor, 0,
|
2014-08-19 16:16:03 +00:00
|
|
|
session->endpoint->persistent, "PJSIP/%s-%08x",
|
|
|
|
ast_sorcery_object_get_id(session->endpoint),
|
|
|
|
(unsigned) ast_atomic_fetchadd_int((int *) &chan_idx, +1));
|
ARI: Fix endpoint/channel subscription issues; allow for subscriptions to tech
This patch serves two purposes:
(1) It fixes some bugs with endpoint subscriptions not reporting all of the
channel events
(2) It serves as the preliminary work needed for ASTERISK-23692, which allows
for sending/receiving arbitrary out of call text messages through ARI in a
technology agnostic fashion.
The messaging functionality described on ASTERISK-23692 requires two things:
(1) The ability to send/receive messages associated with an endpoint. This is
relatively straight forwards with the endpoint core in Asterisk now.
(2) The ability to send/receive messages associated with a technology and an
arbitrary technology defined URI. This is less straight forward, as
endpoints are formed from a tech + resource pair. We don't have a
mechanism to note that a technology that *may* have endpoints exists.
This patch provides such a mechanism, and fixes a few bugs along the way.
The first major bug this patch fixes is the forwarding of channel messages
to their respective endpoints. Prior to this patch, there were two problems:
(1) Channel caching messages weren't forwarded. Thus, the endpoints missed
most of the interesting bits (such as channel creation, destruction, state
changes, etc.)
(2) Channels weren't associated with their endpoint until after creation.
This resulted in endpoints missing the channel creation message, which
limited the usefulness of the subscription in the first place (a major use
case being 'tell me when this endpoint has a channel'). Unfortunately,
this meant another parameter to ast_channel_alloc. Since not all channel
technologies support an ast_endpoint, this patch makes such a call
optional and opts for a new function, ast_channel_alloc_with_endpoint.
When endpoints are created, they will implicitly create a technology endpoint
for their technology (if one does not already exist). A technology endpoint is
special in that it has no state, cannot have channels created for it, cannot
be created explicitly, and cannot be destroyed except on shutdown. It does,
however, have all messages from other endpoints in its technology forwarded to
it.
Combined with the bug fixes, we now have Stasis messages being properly
forwarded. Consider the following scenario: two PJSIP endpoints (foo and bar),
where bar has a single channel associated with it and foo has two channels
associated with it. The messages would be forwarded as follows:
channel PJSIP/foo-1 --
\
--> endpoint PJSIP/foo --
/ \
channel PJSIP/foo-2 -- \
---- > endpoint PJSIP
/
channel PJSIP/bar-1 -----> endpoint PJSIP/bar --
ARI, through the applications resource, can:
- subscribe to endpoint:PJSIP/foo and get notifications for channels
PJSIP/foo-1,PJSIP/foo-2 and endpoint PJSIP/foo
- subscribe to endpoint:PJSIP/bar and get notifications for channels
PJSIP/bar-1 and endpoint PJSIP/bar
- subscribe to endpoint:PJSIP and get notifications for channels
PJSIP/foo-1,PJSIP/foo-2,PJSIP/bar-1 and endpoints PJSIP/foo,PJSIP/bar
Note that since endpoint PJSIP never changes, it never has events itself. It
merely provides an aggregation point for all other endpoints in its technology
(which in turn aggregate all channel messages associated with that endpoint).
This patch also adds endpoints to res_xmpp and chan_motif, because the actual
messaging work will need it (messaging without XMPP is just sad).
Review: https://reviewboard.asterisk.org/r/3760/
ASTERISK-23692
........
Merged revisions 419196 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419203 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-22 16:20:58 +00:00
|
|
|
if (!chan) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create channel\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_channel_tech_set(chan, &chan_pjsip_tech);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-23 12:27:03 +00:00
|
|
|
if (!(channel = ast_sip_channel_pvt_alloc(pvt, session))) {
|
2013-12-18 19:28:05 +00:00
|
|
|
ast_channel_unlock(chan);
|
2013-07-23 12:27:03 +00:00
|
|
|
ast_hangup(chan);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create pvt channel\n");
|
2013-07-23 12:27:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_tech_pvt_set(chan, channel);
|
2013-07-05 17:33:33 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!ast_stream_topology_get_count(session->pending_media_state->topology) ||
|
|
|
|
!compatible_formats_exist(session->pending_media_state->topology, session->endpoint->media.codecs)) {
|
|
|
|
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
|
|
|
|
if (!caps) {
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_hangup(chan);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create caps\n");
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, AST_MEDIA_TYPE_UNKNOWN);
|
2017-05-30 14:12:47 +00:00
|
|
|
topology = ast_stream_topology_clone(session->endpoint->media.topology);
|
2013-04-25 18:25:31 +00:00
|
|
|
} else {
|
2020-06-26 16:14:58 +00:00
|
|
|
caps = ast_stream_topology_get_formats(session->pending_media_state->topology);
|
2017-05-30 14:12:47 +00:00
|
|
|
topology = ast_stream_topology_clone(session->pending_media_state->topology);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!topology || !caps) {
|
|
|
|
ao2_cleanup(caps);
|
|
|
|
ast_stream_topology_free(topology);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_hangup(chan);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't get caps or clone topology\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
ast_channel_stage_snapshot(chan);
|
|
|
|
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ast_channel_nativeformats_set(chan, caps);
|
2017-05-30 14:12:47 +00:00
|
|
|
ast_channel_set_stream_topology(chan, topology);
|
2014-09-19 17:16:32 +00:00
|
|
|
|
2014-10-02 15:33:50 +00:00
|
|
|
if (!ast_format_cap_empty(caps)) {
|
ARI/PJSIP: Apply requesting channel's format cap to created channels
This patch addresses the following problems:
* ari/resource_channels: In ARI, we currently create a format capability
structure of SLIN and apply it to the new channel being created. This was
originally done when the PBX core was used to create the channel, as there
was a condition where a newly created channel could be created without any
formats. Unfortunately, now that the Dial API is being used, this has two
drawbacks:
(a) SLIN, while it will ensure audio will flows, can cause a lot of
needless transcodings to occur, particularly when a Local channel is
created to the dialplan. When no format capabilities are available, the
Dial API handles this better by handing all audio formats to the requsted
channels. As such, we defer to that API to provide the format
capabilities.
(b) If a channel (requester) is causing this channel to be created, we
currently don't use its format capabilities as we are passing in our own.
However, the Dial API will use the requester channel's formats if none
are passed into it, and the requester channel exists and has format
capabilities. This is the "best" scenario, as it is the most likely to
create a media path that minimizes transcoding.
Fixing this simply entails removing the providing of the format capabilities
structure to the Dial API.
* chan_pjsip: Rather than blindly picking the first format in the format
capability structure - which actually *can* be a video or text format - we
select an audio format, and only pick the first format if that fails. That
minimizes the weird scenario where we attempt to transcode between video/audio.
* res_pjsip_sdp_rtp: Applied the joint capapbilites to the format structure.
Since ast_request already limits us down to one format capability once the
format capabilities are passed along, there's no reason to squelch it here.
* channel: Fixed a comment. The reason we have to minimize our requested
format capabilities down to a single format is due to Asterisk's inability
to convey the format to be used back "up" a channel chain. Consider the
following:
PJSIP/A => L;1 <=> L;2 => PJSIP/B
g,u,a g,u,a g,u,a u
That is, we have PJSIP/A dialing a Local channel, where the Local;2 dials
PJSIP/B. PJSIP/A has native format capabilities g722,ulaw,alaw; the Local
channel has inherited those format capabilities down the line; PJSIP/B
supports only ulaw. According to these format capabilities, ulaw is
acceptable and should be selected across all the channels, and no
transcoding should occur. However, there is no way to convey this: when L;2
and PJSIP/B are put into a bridge, we will select ulaw, but that is not
conveyed to PJSIP/A and L;1. Thus, we end up with:
PJSIP/A <=> L;1 <=> L;2 <=> PJSIP/B
g g X u u
Which causes g722 to be written to PJSIP/B.
Even if we can convey the 'ulaw' choice back up the chain (which through
some severe hacking in Local channels was accomplished), such that the chain
looks like:
PJSIP/A <=> L;1 <=> L;2 <=> PJSIP/B
u u u u
We have no way to tell PJSIP/A's *channel driver* to Answer in the SDP back
with only 'ulaw'. This results in all the channel structures being set up
correctly, but PJSIP/A *still* sending g722 and causing the chain to fall
apart.
There's a lot of difficulty just in setting this up, as there are numerous
race conditions in the act of bridging, and no clean mechanism to pass the
selected format backwards down an established channel chain. As such, the
best that can be done at this point in time is clarifying the comment.
Review: https://reviewboard.asterisk.org/r/4434/
ASTERISK-24812 #close
Reported by: Matt Jordan
........
Merged revisions 432195 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@432196 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-24 22:00:51 +00:00
|
|
|
struct ast_format *fmt;
|
2014-10-02 15:33:50 +00:00
|
|
|
|
ARI/PJSIP: Apply requesting channel's format cap to created channels
This patch addresses the following problems:
* ari/resource_channels: In ARI, we currently create a format capability
structure of SLIN and apply it to the new channel being created. This was
originally done when the PBX core was used to create the channel, as there
was a condition where a newly created channel could be created without any
formats. Unfortunately, now that the Dial API is being used, this has two
drawbacks:
(a) SLIN, while it will ensure audio will flows, can cause a lot of
needless transcodings to occur, particularly when a Local channel is
created to the dialplan. When no format capabilities are available, the
Dial API handles this better by handing all audio formats to the requsted
channels. As such, we defer to that API to provide the format
capabilities.
(b) If a channel (requester) is causing this channel to be created, we
currently don't use its format capabilities as we are passing in our own.
However, the Dial API will use the requester channel's formats if none
are passed into it, and the requester channel exists and has format
capabilities. This is the "best" scenario, as it is the most likely to
create a media path that minimizes transcoding.
Fixing this simply entails removing the providing of the format capabilities
structure to the Dial API.
* chan_pjsip: Rather than blindly picking the first format in the format
capability structure - which actually *can* be a video or text format - we
select an audio format, and only pick the first format if that fails. That
minimizes the weird scenario where we attempt to transcode between video/audio.
* res_pjsip_sdp_rtp: Applied the joint capapbilites to the format structure.
Since ast_request already limits us down to one format capability once the
format capabilities are passed along, there's no reason to squelch it here.
* channel: Fixed a comment. The reason we have to minimize our requested
format capabilities down to a single format is due to Asterisk's inability
to convey the format to be used back "up" a channel chain. Consider the
following:
PJSIP/A => L;1 <=> L;2 => PJSIP/B
g,u,a g,u,a g,u,a u
That is, we have PJSIP/A dialing a Local channel, where the Local;2 dials
PJSIP/B. PJSIP/A has native format capabilities g722,ulaw,alaw; the Local
channel has inherited those format capabilities down the line; PJSIP/B
supports only ulaw. According to these format capabilities, ulaw is
acceptable and should be selected across all the channels, and no
transcoding should occur. However, there is no way to convey this: when L;2
and PJSIP/B are put into a bridge, we will select ulaw, but that is not
conveyed to PJSIP/A and L;1. Thus, we end up with:
PJSIP/A <=> L;1 <=> L;2 <=> PJSIP/B
g g X u u
Which causes g722 to be written to PJSIP/B.
Even if we can convey the 'ulaw' choice back up the chain (which through
some severe hacking in Local channels was accomplished), such that the chain
looks like:
PJSIP/A <=> L;1 <=> L;2 <=> PJSIP/B
u u u u
We have no way to tell PJSIP/A's *channel driver* to Answer in the SDP back
with only 'ulaw'. This results in all the channel structures being set up
correctly, but PJSIP/A *still* sending g722 and causing the chain to fall
apart.
There's a lot of difficulty just in setting this up, as there are numerous
race conditions in the act of bridging, and no clean mechanism to pass the
selected format backwards down an established channel chain. As such, the
best that can be done at this point in time is clarifying the comment.
Review: https://reviewboard.asterisk.org/r/4434/
ASTERISK-24812 #close
Reported by: Matt Jordan
........
Merged revisions 432195 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@432196 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-24 22:00:51 +00:00
|
|
|
fmt = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_AUDIO);
|
|
|
|
if (!fmt) {
|
|
|
|
/* Since our capabilities aren't empty, this will succeed */
|
|
|
|
fmt = ast_format_cap_get_format(caps, 0);
|
|
|
|
}
|
2014-10-02 15:33:50 +00:00
|
|
|
ast_channel_set_writeformat(chan, fmt);
|
|
|
|
ast_channel_set_rawwriteformat(chan, fmt);
|
|
|
|
ast_channel_set_readformat(chan, fmt);
|
|
|
|
ast_channel_set_rawreadformat(chan, fmt);
|
|
|
|
ao2_ref(fmt, -1);
|
|
|
|
}
|
|
|
|
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ao2_ref(caps, -1);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (state == AST_STATE_RING) {
|
|
|
|
ast_channel_rings_set(chan, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_adsicpe_set(chan, AST_ADSI_UNAVAILABLE);
|
|
|
|
|
2014-08-19 16:16:03 +00:00
|
|
|
ast_party_id_copy(&ast_channel_caller(chan)->id, &session->id);
|
|
|
|
ast_party_id_copy(&ast_channel_caller(chan)->ani, &session->id);
|
2021-06-08 20:44:23 +00:00
|
|
|
ast_channel_caller(chan)->ani2 = session->ani2;
|
2014-08-19 16:16:03 +00:00
|
|
|
|
2017-12-07 23:51:08 +00:00
|
|
|
if (!ast_strlen_zero(exten)) {
|
|
|
|
/* Set provided DNID on the new channel. */
|
|
|
|
ast_channel_dialed(chan)->number.str = ast_strdup(exten);
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_channel_priority_set(chan, 1);
|
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
ast_channel_callgroup_set(chan, session->endpoint->pickup.callgroup);
|
|
|
|
ast_channel_pickupgroup_set(chan, session->endpoint->pickup.pickupgroup);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
ast_channel_named_callgroups_set(chan, session->endpoint->pickup.named_callgroups);
|
|
|
|
ast_channel_named_pickupgroups_set(chan, session->endpoint->pickup.named_pickupgroups);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2013-07-18 19:25:51 +00:00
|
|
|
if (!ast_strlen_zero(session->endpoint->language)) {
|
|
|
|
ast_channel_language_set(chan, session->endpoint->language);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(session->endpoint->zone)) {
|
|
|
|
struct ast_tone_zone *zone = ast_get_indication_zone(session->endpoint->zone);
|
|
|
|
if (!zone) {
|
|
|
|
ast_log(LOG_ERROR, "Unknown country code '%s' for tonezone. Check indications.conf for available country codes.\n", session->endpoint->zone);
|
|
|
|
}
|
|
|
|
ast_channel_zone_set(chan, zone);
|
|
|
|
}
|
|
|
|
|
2014-08-20 20:04:43 +00:00
|
|
|
for (var = session->endpoint->channel_vars; var; var = var->next) {
|
|
|
|
char buf[512];
|
|
|
|
pbx_builtin_setvar_helper(chan, var->name, ast_get_encoded_str(
|
|
|
|
var->value, buf, sizeof(buf)));
|
|
|
|
}
|
|
|
|
|
2013-12-05 22:10:20 +00:00
|
|
|
ast_channel_stage_snapshot_done(chan);
|
2013-12-18 19:28:05 +00:00
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
set_channel_on_rtp_instance(session, ast_channel_uniqueid(chan));
|
2013-12-18 19:28:05 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(chan);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
struct answer_data {
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
unsigned long indent;
|
|
|
|
};
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
static int answer(void *data)
|
|
|
|
{
|
2020-07-06 19:23:24 +00:00
|
|
|
struct answer_data *ans_data = data;
|
2013-08-23 13:58:08 +00:00
|
|
|
pj_status_t status = PJ_SUCCESS;
|
2014-02-26 19:00:56 +00:00
|
|
|
pjsip_tx_data *packet = NULL;
|
2020-07-06 19:23:24 +00:00
|
|
|
struct ast_sip_session *session = ans_data->session;
|
|
|
|
SCOPE_ENTER_TASK(1, ans_data->indent, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2014-11-20 14:49:48 +00:00
|
|
|
if (session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
2016-10-18 14:04:54 +00:00
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(session->inv_session->cause)->ptr);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Disconnected\n");
|
2014-11-20 14:49:48 +00:00
|
|
|
}
|
|
|
|
|
2013-08-23 13:58:08 +00:00
|
|
|
pjsip_dlg_inc_lock(session->inv_session->dlg);
|
|
|
|
if (session->inv_session->invite_tsx) {
|
|
|
|
status = pjsip_inv_answer(session->inv_session, 200, NULL, NULL, &packet);
|
2014-02-26 19:00:56 +00:00
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR,"Cannot answer '%s' because there is no associated SIP transaction\n",
|
|
|
|
ast_channel_name(session->channel));
|
2013-08-23 13:58:08 +00:00
|
|
|
}
|
|
|
|
pjsip_dlg_dec_lock(session->inv_session->dlg);
|
|
|
|
|
|
|
|
if (status == PJ_SUCCESS && packet) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_sip_session_send_response(session, packet);
|
|
|
|
}
|
|
|
|
|
2017-11-10 01:58:12 +00:00
|
|
|
if (status != PJ_SUCCESS) {
|
|
|
|
char err[PJ_ERR_MSG_SIZE];
|
|
|
|
|
|
|
|
pj_strerror(status, err, sizeof(err));
|
|
|
|
ast_log(LOG_WARNING,"Cannot answer '%s': %s\n",
|
|
|
|
ast_channel_name(session->channel), err);
|
|
|
|
/*
|
|
|
|
* Return this value so we can distinguish between this
|
|
|
|
* failure and the threadpool synchronous push failing.
|
|
|
|
*/
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-2, "pjproject failure\n");
|
2017-11-10 01:58:12 +00:00
|
|
|
}
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Function called by core when we should answer a PJSIP session */
|
|
|
|
static int chan_pjsip_answer(struct ast_channel *ast)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2014-12-12 15:31:38 +00:00
|
|
|
struct ast_sip_session *session;
|
2020-07-06 19:23:24 +00:00
|
|
|
struct answer_data ans_data = { 0, };
|
2017-11-10 01:58:12 +00:00
|
|
|
int res;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_channel_name(ast));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (ast_channel_state(ast) == AST_STATE_UP) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Already up\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_setstate(ast, AST_STATE_UP);
|
2014-12-12 15:31:38 +00:00
|
|
|
session = ao2_bump(channel->session);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2014-12-12 15:31:38 +00:00
|
|
|
/* the answer task needs to be pushed synchronously otherwise a race condition
|
|
|
|
can occur between this thread and bridging (specifically when native bridging
|
|
|
|
attempts to do direct media) */
|
|
|
|
ast_channel_unlock(ast);
|
2020-07-06 19:23:24 +00:00
|
|
|
ans_data.session = session;
|
|
|
|
ans_data.indent = ast_trace_get_indent();
|
|
|
|
res = ast_sip_push_task_wait_serializer(session->serializer, answer, &ans_data);
|
2017-11-10 01:58:12 +00:00
|
|
|
if (res) {
|
|
|
|
if (res == -1) {
|
|
|
|
ast_log(LOG_ERROR,"Cannot answer '%s': Unable to push answer task to the threadpool.\n",
|
|
|
|
ast_channel_name(session->channel));
|
|
|
|
}
|
2014-12-12 15:31:38 +00:00
|
|
|
ao2_ref(session, -1);
|
|
|
|
ast_channel_lock(ast);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Couldn't push task\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
2014-12-12 15:31:38 +00:00
|
|
|
ao2_ref(session, -1);
|
|
|
|
ast_channel_lock(ast);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 14:16:41 +00:00
|
|
|
/*! \brief Internal helper function called when CNG tone is detected */
|
2019-09-15 19:35:45 +00:00
|
|
|
static struct ast_frame *chan_pjsip_cng_tone_detected(struct ast_channel *ast, struct ast_sip_session *session,
|
|
|
|
struct ast_frame *f)
|
2013-07-30 14:16:41 +00:00
|
|
|
{
|
|
|
|
const char *target_context;
|
|
|
|
int exists;
|
2016-07-16 01:44:52 +00:00
|
|
|
int dsp_features;
|
2013-07-30 14:16:41 +00:00
|
|
|
|
2016-07-16 01:44:52 +00:00
|
|
|
dsp_features = ast_dsp_get_features(session->dsp);
|
|
|
|
dsp_features &= ~DSP_FEATURE_FAX_DETECT;
|
|
|
|
if (dsp_features) {
|
|
|
|
ast_dsp_set_features(session->dsp, dsp_features);
|
2013-07-30 14:16:41 +00:00
|
|
|
} else {
|
|
|
|
ast_dsp_free(session->dsp);
|
|
|
|
session->dsp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If already executing in the fax extension don't do anything */
|
2019-09-15 19:35:45 +00:00
|
|
|
if (!strcmp(ast_channel_exten(ast), "fax")) {
|
2013-07-30 14:16:41 +00:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2022-12-12 17:12:57 +00:00
|
|
|
target_context = ast_channel_context(ast);
|
2013-07-30 14:16:41 +00:00
|
|
|
|
2016-07-13 23:48:01 +00:00
|
|
|
/*
|
|
|
|
* We need to unlock the channel here because ast_exists_extension has the
|
2013-07-30 14:16:41 +00:00
|
|
|
* potential to start and stop an autoservice on the channel. Such action
|
|
|
|
* is prone to deadlock if the channel is locked.
|
2016-07-13 23:48:01 +00:00
|
|
|
*
|
|
|
|
* ast_async_goto() has its own restriction on not holding the channel lock.
|
2013-07-30 14:16:41 +00:00
|
|
|
*/
|
2019-09-15 19:35:45 +00:00
|
|
|
ast_channel_unlock(ast);
|
2016-07-13 23:48:01 +00:00
|
|
|
ast_frfree(f);
|
|
|
|
f = &ast_null_frame;
|
2019-09-15 19:35:45 +00:00
|
|
|
exists = ast_exists_extension(ast, target_context, "fax", 1,
|
|
|
|
S_COR(ast_channel_caller(ast)->id.number.valid,
|
|
|
|
ast_channel_caller(ast)->id.number.str, NULL));
|
2013-07-30 14:16:41 +00:00
|
|
|
if (exists) {
|
|
|
|
ast_verb(2, "Redirecting '%s' to fax extension due to CNG detection\n",
|
2019-09-15 19:35:45 +00:00
|
|
|
ast_channel_name(ast));
|
|
|
|
pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
|
|
|
|
if (ast_async_goto(ast, target_context, "fax", 1)) {
|
2013-07-30 14:16:41 +00:00
|
|
|
ast_log(LOG_ERROR, "Failed to async goto '%s' into fax extension in '%s'\n",
|
2019-09-15 19:35:45 +00:00
|
|
|
ast_channel_name(ast), target_context);
|
2013-07-30 14:16:41 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_NOTICE, "FAX CNG detected on '%s' but no fax extension in '%s'\n",
|
2019-09-15 19:35:45 +00:00
|
|
|
ast_channel_name(ast), target_context);
|
2013-07-30 14:16:41 +00:00
|
|
|
}
|
2019-09-15 19:35:45 +00:00
|
|
|
|
|
|
|
/* It's possible for a masquerade to have occurred when doing the ast_async_goto resulting in
|
|
|
|
* the channel on the session having changed. Since we need to return with the original channel
|
|
|
|
* locked we lock the channel that was passed in and not session->channel.
|
|
|
|
*/
|
|
|
|
ast_channel_lock(ast);
|
2013-07-30 14:16:41 +00:00
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2020-01-23 15:06:35 +00:00
|
|
|
/*! \brief Determine if the given frame is in a format we've negotiated */
|
|
|
|
static int is_compatible_format(struct ast_sip_session *session, struct ast_frame *f)
|
|
|
|
{
|
|
|
|
struct ast_stream_topology *topology = session->active_media_state->topology;
|
|
|
|
struct ast_stream *stream = ast_stream_topology_get_stream(topology, f->stream_num);
|
2020-04-21 09:52:24 +00:00
|
|
|
const struct ast_format_cap *cap = ast_stream_get_formats(stream);
|
2020-01-23 15:06:35 +00:00
|
|
|
|
|
|
|
return ast_format_cap_iscompatible_format(cap, f->subclass.format) != AST_FORMAT_CMP_NOT_EQUAL;
|
|
|
|
}
|
|
|
|
|
2016-11-15 21:01:27 +00:00
|
|
|
/*!
|
2017-12-22 14:23:22 +00:00
|
|
|
* \brief Function called by core to read any waiting frames
|
2016-11-15 21:01:27 +00:00
|
|
|
*
|
|
|
|
* \note The channel is already locked.
|
|
|
|
*/
|
2017-05-30 14:12:47 +00:00
|
|
|
static struct ast_frame *chan_pjsip_read_stream(struct ast_channel *ast)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session *session = channel->session;
|
|
|
|
struct ast_sip_session_media_read_callback_state *callback_state;
|
2013-04-25 18:25:31 +00:00
|
|
|
struct ast_frame *f;
|
2017-05-30 14:12:47 +00:00
|
|
|
int fdno = ast_channel_fdno(ast) - AST_EXTENDED_FDS;
|
2020-02-26 00:30:04 +00:00
|
|
|
struct ast_frame *cur;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
if (fdno >= AST_VECTOR_SIZE(&session->active_media_state->read_callbacks)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return &ast_null_frame;
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
callback_state = AST_VECTOR_GET_ADDR(&session->active_media_state->read_callbacks, fdno);
|
|
|
|
f = callback_state->read_callback(session, callback_state->session);
|
|
|
|
|
|
|
|
if (!f) {
|
2013-06-22 14:03:22 +00:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2020-02-26 00:30:04 +00:00
|
|
|
for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
|
|
|
|
if (cur->frametype == AST_FRAME_VOICE) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cur || callback_state->session != session->active_media_state->default_session[callback_state->session->type]) {
|
2013-06-22 14:03:22 +00:00
|
|
|
return f;
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-07-28 12:53:44 +00:00
|
|
|
session = channel->session;
|
2015-07-16 14:46:14 +00:00
|
|
|
|
2017-07-28 12:53:44 +00:00
|
|
|
/*
|
|
|
|
* Asymmetric RTP only has one native format set at a time.
|
|
|
|
* Therefore we need to update the native format to the current
|
|
|
|
* raw read format BEFORE the native format check
|
|
|
|
*/
|
2016-10-23 12:38:59 +00:00
|
|
|
if (!session->endpoint->asymmetric_rtp_codec &&
|
2020-02-26 00:30:04 +00:00
|
|
|
ast_format_cmp(ast_channel_rawwriteformat(ast), cur->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL &&
|
|
|
|
is_compatible_format(session, cur)) {
|
2017-06-06 12:04:21 +00:00
|
|
|
struct ast_format_cap *caps;
|
|
|
|
|
|
|
|
/* For maximum compatibility we ensure that the formats match that of the received media */
|
2016-10-23 12:38:59 +00:00
|
|
|
ast_debug(1, "Oooh, got a frame with format of %s on channel '%s' when we're sending '%s', switching to match\n",
|
2020-02-26 00:30:04 +00:00
|
|
|
ast_format_get_name(cur->subclass.format), ast_channel_name(ast),
|
2016-10-23 12:38:59 +00:00
|
|
|
ast_format_get_name(ast_channel_rawwriteformat(ast)));
|
2017-06-06 12:04:21 +00:00
|
|
|
|
|
|
|
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
|
|
|
|
if (caps) {
|
|
|
|
ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(ast), AST_MEDIA_TYPE_UNKNOWN);
|
|
|
|
ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_AUDIO);
|
2020-02-26 00:30:04 +00:00
|
|
|
ast_format_cap_append(caps, cur->subclass.format, 0);
|
2017-06-06 12:04:21 +00:00
|
|
|
ast_channel_nativeformats_set(ast, caps);
|
|
|
|
ao2_ref(caps, -1);
|
|
|
|
}
|
|
|
|
|
2020-02-26 00:30:04 +00:00
|
|
|
ast_set_write_format_path(ast, ast_channel_writeformat(ast), cur->subclass.format);
|
|
|
|
ast_set_read_format_path(ast, ast_channel_readformat(ast), cur->subclass.format);
|
2016-10-23 12:38:59 +00:00
|
|
|
|
|
|
|
if (ast_channel_is_bridged(ast)) {
|
|
|
|
ast_channel_set_unbridged_nolock(ast, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-26 00:30:04 +00:00
|
|
|
if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), cur->subclass.format)
|
|
|
|
== AST_FORMAT_CMP_NOT_EQUAL) {
|
2017-07-28 12:53:44 +00:00
|
|
|
ast_debug(1, "Oooh, got a frame with format of %s on channel '%s' when it has not been negotiated\n",
|
2020-02-26 00:30:04 +00:00
|
|
|
ast_format_get_name(cur->subclass.format), ast_channel_name(ast));
|
2017-07-28 12:53:44 +00:00
|
|
|
ast_frfree(f);
|
|
|
|
return &ast_null_frame;
|
|
|
|
}
|
|
|
|
|
2016-07-16 01:44:52 +00:00
|
|
|
if (session->dsp) {
|
|
|
|
int dsp_features;
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2016-07-16 01:44:52 +00:00
|
|
|
dsp_features = ast_dsp_get_features(session->dsp);
|
|
|
|
if ((dsp_features & DSP_FEATURE_FAX_DETECT)
|
|
|
|
&& session->endpoint->faxdetect_timeout
|
|
|
|
&& session->endpoint->faxdetect_timeout <= ast_channel_get_up_time(ast)) {
|
|
|
|
dsp_features &= ~DSP_FEATURE_FAX_DETECT;
|
|
|
|
if (dsp_features) {
|
|
|
|
ast_dsp_set_features(session->dsp, dsp_features);
|
|
|
|
} else {
|
|
|
|
ast_dsp_free(session->dsp);
|
|
|
|
session->dsp = NULL;
|
|
|
|
}
|
|
|
|
ast_debug(3, "Channel driver fax CNG detection timeout on %s\n",
|
|
|
|
ast_channel_name(ast));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (session->dsp) {
|
|
|
|
f = ast_dsp_process(ast, session->dsp, f);
|
2013-06-22 14:03:22 +00:00
|
|
|
if (f && (f->frametype == AST_FRAME_DTMF)) {
|
2013-07-30 14:16:41 +00:00
|
|
|
if (f->subclass.integer == 'f') {
|
2016-07-16 01:44:52 +00:00
|
|
|
ast_debug(3, "Channel driver fax CNG detected on %s\n",
|
|
|
|
ast_channel_name(ast));
|
2019-09-15 19:35:45 +00:00
|
|
|
f = chan_pjsip_cng_tone_detected(ast, session, f);
|
|
|
|
/* When chan_pjsip_cng_tone_detected returns it is possible for the
|
|
|
|
* channel pointed to by ast and by session->channel to differ due to a
|
|
|
|
* masquerade. It's best not to touch things after this.
|
|
|
|
*/
|
2013-07-30 14:16:41 +00:00
|
|
|
} else {
|
|
|
|
ast_debug(3, "* Detected inband DTMF '%c' on '%s'\n", f->subclass.integer,
|
|
|
|
ast_channel_name(ast));
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
static int chan_pjsip_write_stream(struct ast_channel *ast, int stream_num, struct ast_frame *frame)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session *session = channel->session;
|
|
|
|
struct ast_sip_session_media *media = NULL;
|
2013-05-13 17:20:33 +00:00
|
|
|
int res = 0;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
/* The core provides a guarantee that the stream will exist when we are called if stream_num is provided */
|
|
|
|
if (stream_num >= 0) {
|
|
|
|
/* What is not guaranteed is that a media session will exist */
|
|
|
|
if (stream_num < AST_VECTOR_SIZE(&channel->session->active_media_state->sessions)) {
|
|
|
|
media = AST_VECTOR_GET(&channel->session->active_media_state->sessions, stream_num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
switch (frame->frametype) {
|
|
|
|
case AST_FRAME_VOICE:
|
|
|
|
if (!media) {
|
|
|
|
return 0;
|
2017-05-30 14:12:47 +00:00
|
|
|
} else if (media->type != AST_MEDIA_TYPE_AUDIO) {
|
|
|
|
ast_debug(3, "Channel %s stream %d is of type '%s', not audio!\n",
|
|
|
|
ast_channel_name(ast), stream_num, ast_codec_media_type2str(media->type));
|
|
|
|
return 0;
|
|
|
|
} else if (media == channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO] &&
|
|
|
|
ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
|
2015-11-09 09:01:41 +00:00
|
|
|
struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
|
2014-08-20 22:52:44 +00:00
|
|
|
struct ast_str *write_transpath = ast_str_alloca(256);
|
|
|
|
struct ast_str *read_transpath = ast_str_alloca(256);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
ast_log(LOG_WARNING,
|
2014-08-20 22:52:44 +00:00
|
|
|
"Channel %s asked to send %s frame when native formats are %s (rd:%s->%s;%s wr:%s->%s;%s)\n",
|
|
|
|
ast_channel_name(ast),
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ast_format_get_name(frame->subclass.format),
|
|
|
|
ast_format_cap_get_names(ast_channel_nativeformats(ast), &cap_buf),
|
2014-08-20 22:52:44 +00:00
|
|
|
ast_format_get_name(ast_channel_rawreadformat(ast)),
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ast_format_get_name(ast_channel_readformat(ast)),
|
2014-08-20 22:52:44 +00:00
|
|
|
ast_translate_path_to_str(ast_channel_readtrans(ast), &read_transpath),
|
|
|
|
ast_format_get_name(ast_channel_writeformat(ast)),
|
|
|
|
ast_format_get_name(ast_channel_rawwriteformat(ast)),
|
|
|
|
ast_translate_path_to_str(ast_channel_writetrans(ast), &write_transpath));
|
2013-04-25 18:25:31 +00:00
|
|
|
return 0;
|
2017-05-30 14:12:47 +00:00
|
|
|
} else if (media->write_callback) {
|
|
|
|
res = media->write_callback(session, media, frame);
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AST_FRAME_VIDEO:
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!media) {
|
|
|
|
return 0;
|
|
|
|
} else if (media->type != AST_MEDIA_TYPE_VIDEO) {
|
|
|
|
ast_debug(3, "Channel %s stream %d is of type '%s', not video!\n",
|
|
|
|
ast_channel_name(ast), stream_num, ast_codec_media_type2str(media->type));
|
|
|
|
return 0;
|
|
|
|
} else if (media->write_callback) {
|
|
|
|
res = media->write_callback(session, media, frame);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
break;
|
2013-07-30 14:16:41 +00:00
|
|
|
case AST_FRAME_MODEM:
|
2017-05-30 14:12:47 +00:00
|
|
|
if (!media) {
|
|
|
|
return 0;
|
|
|
|
} else if (media->type != AST_MEDIA_TYPE_IMAGE) {
|
|
|
|
ast_debug(3, "Channel %s stream %d is of type '%s', not image!\n",
|
|
|
|
ast_channel_name(ast), stream_num, ast_codec_media_type2str(media->type));
|
|
|
|
return 0;
|
|
|
|
} else if (media->write_callback) {
|
|
|
|
res = media->write_callback(session, media, frame);
|
|
|
|
}
|
2013-07-30 14:16:41 +00:00
|
|
|
break;
|
2017-09-05 14:35:12 +00:00
|
|
|
case AST_FRAME_CNG:
|
|
|
|
break;
|
2018-03-21 13:52:08 +00:00
|
|
|
case AST_FRAME_RTCP:
|
2018-03-28 12:27:31 +00:00
|
|
|
/* We only support writing out feedback */
|
|
|
|
if (frame->subclass.integer != AST_RTP_RTCP_PSFB || !media) {
|
|
|
|
return 0;
|
|
|
|
} else if (media->type != AST_MEDIA_TYPE_VIDEO) {
|
|
|
|
ast_debug(3, "Channel %s stream %d is of type '%s', not video! Unable to write RTCP feedback.\n",
|
|
|
|
ast_channel_name(ast), stream_num, ast_codec_media_type2str(media->type));
|
|
|
|
return 0;
|
|
|
|
} else if (media->write_callback) {
|
|
|
|
res = media->write_callback(session, media, frame);
|
|
|
|
}
|
2018-03-21 13:52:08 +00:00
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
default:
|
2014-05-09 22:49:26 +00:00
|
|
|
ast_log(LOG_WARNING, "Can't send %u type frames with PJSIP\n", frame->frametype);
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
static int chan_pjsip_write(struct ast_channel *ast, struct ast_frame *frame)
|
|
|
|
{
|
|
|
|
return chan_pjsip_write_stream(ast, -1, frame);
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called by core to change the underlying owner channel */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(newchan);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-12-12 19:18:06 +00:00
|
|
|
if (channel->session->channel != oldchan) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-10-03 17:47:42 +00:00
|
|
|
/*
|
|
|
|
* The masquerade has suspended the channel's session
|
|
|
|
* serializer so we can safely change it outside of
|
|
|
|
* the serializer thread.
|
|
|
|
*/
|
|
|
|
channel->session->channel = newchan;
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
set_channel_on_rtp_instance(channel->session, ast_channel_uniqueid(newchan));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-20 18:18:25 +00:00
|
|
|
/*! AO2 hash function for on hold UIDs */
|
|
|
|
static int uid_hold_hash_fn(const void *obj, const int flags)
|
|
|
|
{
|
|
|
|
const char *key = obj;
|
|
|
|
|
|
|
|
switch (flags & OBJ_SEARCH_MASK) {
|
|
|
|
case OBJ_SEARCH_KEY:
|
|
|
|
break;
|
|
|
|
case OBJ_SEARCH_OBJECT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Hash can only work on something with a full key. */
|
|
|
|
ast_assert(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return ast_str_hash(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! AO2 sort function for on hold UIDs */
|
|
|
|
static int uid_hold_sort_fn(const void *obj_left, const void *obj_right, const int flags)
|
|
|
|
{
|
|
|
|
const char *left = obj_left;
|
|
|
|
const char *right = obj_right;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
switch (flags & OBJ_SEARCH_MASK) {
|
|
|
|
case OBJ_SEARCH_OBJECT:
|
|
|
|
case OBJ_SEARCH_KEY:
|
|
|
|
cmp = strcmp(left, right);
|
|
|
|
break;
|
|
|
|
case OBJ_SEARCH_PARTIAL_KEY:
|
|
|
|
cmp = strncmp(left, right, strlen(right));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Sort can only work on something with a full or partial key. */
|
|
|
|
ast_assert(0);
|
|
|
|
cmp = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ao2_container *pjsip_uids_onhold;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Add a channel ID to the list of PJSIP channels on hold
|
|
|
|
*
|
|
|
|
* \param chan_uid - Unique ID of the channel being put into the hold list
|
|
|
|
*
|
|
|
|
* \retval 0 Channel has been added to or was already in the hold list
|
|
|
|
* \retval -1 Failed to add channel to the hold list
|
|
|
|
*/
|
|
|
|
static int chan_pjsip_add_hold(const char *chan_uid)
|
|
|
|
{
|
|
|
|
RAII_VAR(char *, hold_uid, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
hold_uid = ao2_find(pjsip_uids_onhold, chan_uid, OBJ_SEARCH_KEY);
|
|
|
|
if (hold_uid) {
|
|
|
|
/* Device is already on hold. Nothing to do. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Device wasn't in hold list already. Create a new one. */
|
|
|
|
hold_uid = ao2_alloc_options(strlen(chan_uid) + 1, NULL,
|
|
|
|
AO2_ALLOC_OPT_LOCK_NOLOCK);
|
|
|
|
if (!hold_uid) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_copy_string(hold_uid, chan_uid, strlen(chan_uid) + 1);
|
|
|
|
|
|
|
|
if (ao2_link(pjsip_uids_onhold, hold_uid) == 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Remove a channel ID from the list of PJSIP channels on hold
|
|
|
|
*
|
|
|
|
* \param chan_uid - Unique ID of the channel being taken out of the hold list
|
|
|
|
*/
|
|
|
|
static void chan_pjsip_remove_hold(const char *chan_uid)
|
|
|
|
{
|
|
|
|
ao2_find(pjsip_uids_onhold, chan_uid, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Determine whether a channel ID is in the list of PJSIP channels on hold
|
|
|
|
*
|
|
|
|
* \param chan_uid - Channel being checked
|
|
|
|
*
|
|
|
|
* \retval 0 The channel is not in the hold list
|
|
|
|
* \retval 1 The channel is in the hold list
|
|
|
|
*/
|
|
|
|
static int chan_pjsip_get_hold(const char *chan_uid)
|
|
|
|
{
|
|
|
|
RAII_VAR(char *, hold_uid, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
hold_uid = ao2_find(pjsip_uids_onhold, chan_uid, OBJ_SEARCH_KEY);
|
|
|
|
if (!hold_uid) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-06-22 12:40:16 +00:00
|
|
|
/*! \brief Function called to get the device state of an endpoint */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_devicestate(const char *data)
|
2013-06-22 12:40:16 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", data), ao2_cleanup);
|
|
|
|
enum ast_device_state state = AST_DEVICE_UNKNOWN;
|
|
|
|
RAII_VAR(struct ast_endpoint_snapshot *, endpoint_snapshot, NULL, ao2_cleanup);
|
|
|
|
struct ast_devstate_aggregate aggregate;
|
|
|
|
int num, inuse = 0;
|
|
|
|
|
|
|
|
if (!endpoint) {
|
|
|
|
return AST_DEVICE_INVALID;
|
|
|
|
}
|
|
|
|
|
|
|
|
endpoint_snapshot = ast_endpoint_latest_snapshot(ast_endpoint_get_tech(endpoint->persistent),
|
2013-10-02 22:22:17 +00:00
|
|
|
ast_endpoint_get_resource(endpoint->persistent));
|
|
|
|
|
|
|
|
if (!endpoint_snapshot) {
|
|
|
|
return AST_DEVICE_INVALID;
|
|
|
|
}
|
2013-06-22 12:40:16 +00:00
|
|
|
|
|
|
|
if (endpoint_snapshot->state == AST_ENDPOINT_OFFLINE) {
|
|
|
|
state = AST_DEVICE_UNAVAILABLE;
|
|
|
|
} else if (endpoint_snapshot->state == AST_ENDPOINT_ONLINE) {
|
|
|
|
state = AST_DEVICE_NOT_INUSE;
|
|
|
|
}
|
|
|
|
|
2018-10-10 14:28:18 +00:00
|
|
|
if (!endpoint_snapshot->num_channels) {
|
2013-06-22 12:40:16 +00:00
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_devstate_aggregate_init(&aggregate);
|
|
|
|
|
|
|
|
for (num = 0; num < endpoint_snapshot->num_channels; num++) {
|
|
|
|
struct ast_channel_snapshot *snapshot;
|
|
|
|
|
2018-10-10 14:28:18 +00:00
|
|
|
snapshot = ast_channel_snapshot_get_latest(endpoint_snapshot->channel_ids[num]);
|
|
|
|
if (!snapshot) {
|
2013-06-22 12:40:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-11-07 17:18:34 +00:00
|
|
|
if (chan_pjsip_get_hold(snapshot->base->uniqueid)) {
|
device state: Update the core to report ONHOLD if a channel is on hold
In Asterisk, it is possible for a device to have a status of ONHOLD. This is
not typically an easy thing to determine, as a channel being on hold is not
a direct channel state. Typically, this has to be calculated outside of the
core independently in channel drivers, notably, chan_sip and chan_pjsip. Both
of these channel drivers already have to calculate device state in a fashion
more complex than the core can handle, as they aggregate all state of all
channels associated with a peer/endpoint; they also independently track
whether or not one of those channels is currently on hold and mark the device
state appropriately.
In 12+, we now have the ability to report an AST_DEVICE_ONHOLD state for all
channels that defer their device state to the core. This is due to channel hold
state actually now being tracked on the channel itself. If a channel driver
defers its device state to the core (which many, such as DAHDI, IAX2, and
others do in most situations), the device state core already goes out to get a
channel associated with the device. As such, it can now also factor the channel
hold state in its calculation.
This patch adds this logic to the device state core. It also uses an existing
mapping between device state and channel state to handle more channel states.
chan_pjsip has been updated slightly as well to make use of this (as it was,
for some reason, reporting a channel state of BUSY as a device state of INUSE,
which feels slightly wrong).
Review: https://reviewboard.asterisk.org/r/3771/
ASTERISK-24038 #close
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419358 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-24 15:20:58 +00:00
|
|
|
ast_devstate_aggregate_add(&aggregate, AST_DEVICE_ONHOLD);
|
|
|
|
} else {
|
|
|
|
ast_devstate_aggregate_add(&aggregate, ast_state_chan2dev(snapshot->state));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((snapshot->state == AST_STATE_UP) || (snapshot->state == AST_STATE_RING) ||
|
2013-06-22 12:40:16 +00:00
|
|
|
(snapshot->state == AST_STATE_BUSY)) {
|
|
|
|
inuse++;
|
|
|
|
}
|
2018-10-10 14:28:18 +00:00
|
|
|
|
|
|
|
ao2_ref(snapshot, -1);
|
2013-06-22 12:40:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (endpoint->devicestate_busy_at && (inuse == endpoint->devicestate_busy_at)) {
|
|
|
|
state = AST_DEVICE_BUSY;
|
|
|
|
} else if (ast_devstate_aggregate_result(&aggregate) != AST_DEVICE_INVALID) {
|
|
|
|
state = ast_devstate_aggregate_result(&aggregate);
|
|
|
|
}
|
|
|
|
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
2013-07-30 14:16:41 +00:00
|
|
|
/*! \brief Function called to query options on a channel */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_queryoption(struct ast_channel *ast, int option, void *data, int *datalen)
|
2013-07-30 14:16:41 +00:00
|
|
|
{
|
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
|
|
|
int res = -1;
|
2015-03-30 02:39:57 +00:00
|
|
|
enum ast_t38_state state = T38_STATE_UNAVAILABLE;
|
2013-07-30 14:16:41 +00:00
|
|
|
|
2020-06-03 16:23:31 +00:00
|
|
|
if (!channel) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-30 14:16:41 +00:00
|
|
|
switch (option) {
|
|
|
|
case AST_OPTION_T38_STATE:
|
2020-06-03 16:23:31 +00:00
|
|
|
if (channel->session->endpoint->media.t38.enabled) {
|
|
|
|
switch (channel->session->t38state) {
|
2013-07-30 14:16:41 +00:00
|
|
|
case T38_LOCAL_REINVITE:
|
|
|
|
case T38_PEER_REINVITE:
|
|
|
|
state = T38_STATE_NEGOTIATING;
|
|
|
|
break;
|
|
|
|
case T38_ENABLED:
|
|
|
|
state = T38_STATE_NEGOTIATED;
|
|
|
|
break;
|
|
|
|
case T38_REJECTED:
|
|
|
|
state = T38_STATE_REJECTED;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
state = T38_STATE_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*((enum ast_t38_state *) data) = state;
|
|
|
|
res = 0;
|
|
|
|
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-04-29 11:27:14 +00:00
|
|
|
static const char *chan_pjsip_get_uniqueid(struct ast_channel *ast)
|
|
|
|
{
|
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2014-04-30 20:39:17 +00:00
|
|
|
char *uniqueid = ast_threadstorage_get(&uniqueid_threadbuf, UNIQUEID_BUFSIZE);
|
2014-04-29 11:27:14 +00:00
|
|
|
|
2022-04-25 22:40:49 +00:00
|
|
|
if (!channel || !uniqueid) {
|
2014-04-30 20:39:17 +00:00
|
|
|
return "";
|
2014-04-29 11:27:14 +00:00
|
|
|
}
|
|
|
|
|
2014-04-30 20:39:17 +00:00
|
|
|
ast_copy_pj_str(uniqueid, &channel->session->inv_session->dlg->call_id->id, UNIQUEID_BUFSIZE);
|
|
|
|
|
|
|
|
return uniqueid;
|
2014-04-29 11:27:14 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
struct indicate_data {
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
int condition;
|
|
|
|
int response_code;
|
|
|
|
void *frame_data;
|
|
|
|
size_t datalen;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void indicate_data_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct indicate_data *ind_data = obj;
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_free(ind_data->frame_data);
|
|
|
|
ao2_ref(ind_data->session, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct indicate_data *indicate_data_alloc(struct ast_sip_session *session,
|
|
|
|
int condition, int response_code, const void *frame_data, size_t datalen)
|
|
|
|
{
|
|
|
|
struct indicate_data *ind_data = ao2_alloc(sizeof(*ind_data), indicate_data_destroy);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!ind_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
ind_data->frame_data = ast_malloc(datalen);
|
|
|
|
if (!ind_data->frame_data) {
|
|
|
|
ao2_ref(ind_data, -1);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
memcpy(ind_data->frame_data, frame_data, datalen);
|
|
|
|
ind_data->datalen = datalen;
|
|
|
|
ind_data->condition = condition;
|
|
|
|
ind_data->response_code = response_code;
|
|
|
|
ao2_ref(session, +1);
|
|
|
|
ind_data->session = session;
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
return ind_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int indicate(void *data)
|
|
|
|
{
|
2013-05-13 17:20:33 +00:00
|
|
|
pjsip_tx_data *packet = NULL;
|
2013-04-25 18:25:31 +00:00
|
|
|
struct indicate_data *ind_data = data;
|
|
|
|
struct ast_sip_session *session = ind_data->session;
|
|
|
|
int response_code = ind_data->response_code;
|
|
|
|
|
2014-11-20 14:49:48 +00:00
|
|
|
if ((session->inv_session->state != PJSIP_INV_STATE_DISCONNECTED) &&
|
|
|
|
(pjsip_inv_answer(session->inv_session, response_code, NULL, NULL, &packet) == PJ_SUCCESS)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_sip_session_send_response(session, packet);
|
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(ind_data, -1);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Send SIP INFO with video update request */
|
|
|
|
static int transmit_info_with_vidupdate(void *data)
|
|
|
|
{
|
|
|
|
const char * xml =
|
|
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n"
|
|
|
|
" <media_control>\r\n"
|
|
|
|
" <vc_primitive>\r\n"
|
|
|
|
" <to_encoder>\r\n"
|
|
|
|
" <picture_fast_update/>\r\n"
|
|
|
|
" </to_encoder>\r\n"
|
|
|
|
" </vc_primitive>\r\n"
|
|
|
|
" </media_control>\r\n";
|
|
|
|
|
|
|
|
const struct ast_sip_body body = {
|
|
|
|
.type = "application",
|
|
|
|
.subtype = "media_control+xml",
|
|
|
|
.body_text = xml
|
|
|
|
};
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
RAII_VAR(struct ast_sip_session *, session, data, ao2_cleanup);
|
2013-04-25 18:25:31 +00:00
|
|
|
struct pjsip_tx_data *tdata;
|
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(session->inv_session->cause)->ptr);
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2016-10-18 14:04:54 +00:00
|
|
|
}
|
|
|
|
|
2014-01-15 13:16:10 +00:00
|
|
|
if (ast_sip_create_request("INFO", session->inv_session->dlg, session->endpoint, NULL, NULL, &tdata)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_log(LOG_ERROR, "Could not create text video update INFO request\n");
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
if (ast_sip_add_body(tdata, &body)) {
|
|
|
|
ast_log(LOG_ERROR, "Could not add body to text video update INFO request\n");
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
ast_sip_session_send_request(session, tdata);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-13 16:37:17 +00:00
|
|
|
/*!
|
|
|
|
* \internal
|
|
|
|
* \brief TRUE if a COLP update can be sent to the peer.
|
|
|
|
* \since 13.3.0
|
|
|
|
*
|
|
|
|
* \param session The session to see if the COLP update is allowed.
|
|
|
|
*
|
|
|
|
* \retval 0 Update is not allowed.
|
|
|
|
* \retval 1 Update is allowed.
|
|
|
|
*/
|
|
|
|
static int is_colp_update_allowed(struct ast_sip_session *session)
|
|
|
|
{
|
|
|
|
struct ast_party_id connected_id;
|
|
|
|
int update_allowed = 0;
|
|
|
|
|
2018-10-22 16:49:37 +00:00
|
|
|
if (!session->endpoint->id.send_connected_line
|
|
|
|
|| (!session->endpoint->id.send_pai && !session->endpoint->id.send_rpid)) {
|
2015-03-13 16:37:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if privacy allows the update. Check while the channel
|
|
|
|
* is locked so we can work with the shallow connected_id copy.
|
|
|
|
*/
|
|
|
|
ast_channel_lock(session->channel);
|
|
|
|
connected_id = ast_channel_connected_effective_id(session->channel);
|
|
|
|
if (connected_id.number.valid
|
|
|
|
&& (session->endpoint->id.trust_outbound
|
|
|
|
|| (ast_party_id_presentation(&connected_id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED)) {
|
|
|
|
update_allowed = 1;
|
|
|
|
}
|
|
|
|
ast_channel_unlock(session->channel);
|
|
|
|
|
|
|
|
return update_allowed;
|
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
/*! \brief Update connected line information */
|
|
|
|
static int update_connected_line_information(void *data)
|
|
|
|
{
|
2015-03-13 16:37:17 +00:00
|
|
|
struct ast_sip_session *session = data;
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(session->inv_session->cause)->ptr);
|
|
|
|
ao2_ref(session, -1);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-03-13 16:37:17 +00:00
|
|
|
if (ast_channel_state(session->channel) == AST_STATE_UP
|
|
|
|
|| session->inv_session->role == PJSIP_ROLE_UAC) {
|
|
|
|
if (is_colp_update_allowed(session)) {
|
|
|
|
enum ast_sip_session_refresh_method method;
|
|
|
|
int generate_new_sdp;
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2015-03-13 16:37:17 +00:00
|
|
|
method = session->endpoint->id.refresh_method;
|
2017-06-29 19:50:14 +00:00
|
|
|
if (session->inv_session->options & PJSIP_INV_SUPPORT_UPDATE) {
|
2015-03-13 16:37:17 +00:00
|
|
|
method = AST_SIP_SESSION_REFRESH_METHOD_UPDATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only the INVITE method actually needs SDP, UPDATE can do without */
|
|
|
|
generate_new_sdp = (method == AST_SIP_SESSION_REFRESH_METHOD_INVITE);
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
ast_sip_session_refresh(session, NULL, NULL, NULL, method, generate_new_sdp, NULL);
|
2014-11-20 14:49:48 +00:00
|
|
|
}
|
2015-03-24 19:41:36 +00:00
|
|
|
} else if (session->endpoint->id.rpid_immediate
|
|
|
|
&& session->inv_session->state != PJSIP_INV_STATE_DISCONNECTED
|
2015-03-13 16:37:17 +00:00
|
|
|
&& is_colp_update_allowed(session)) {
|
|
|
|
int response_code = 0;
|
2014-11-20 14:49:48 +00:00
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
if (ast_channel_state(session->channel) == AST_STATE_RING) {
|
|
|
|
response_code = !session->endpoint->inband_progress ? 180 : 183;
|
|
|
|
} else if (ast_channel_state(session->channel) == AST_STATE_RINGING) {
|
|
|
|
response_code = 183;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (response_code) {
|
|
|
|
struct pjsip_tx_data *packet = NULL;
|
|
|
|
|
|
|
|
if (pjsip_inv_answer(session->inv_session, response_code, NULL, NULL, &packet) == PJ_SUCCESS) {
|
|
|
|
ast_sip_session_send_response(session, packet);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-13 16:37:17 +00:00
|
|
|
ao2_ref(session, -1);
|
2013-06-22 14:03:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-05-19 14:23:11 +00:00
|
|
|
/*! \brief Update local hold state and send a re-INVITE with the new SDP */
|
|
|
|
static int remote_send_hold_refresh(struct ast_sip_session *session, unsigned int held)
|
2014-11-03 14:45:01 +00:00
|
|
|
{
|
2022-05-19 14:23:11 +00:00
|
|
|
struct ast_sip_session_media *session_media = session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
2017-05-30 14:12:47 +00:00
|
|
|
if (session_media) {
|
|
|
|
session_media->locally_held = held;
|
|
|
|
}
|
|
|
|
ast_sip_session_refresh(session, NULL, NULL, NULL, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1, NULL);
|
2014-11-03 14:45:01 +00:00
|
|
|
ao2_ref(session, -1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Update local hold state to be held */
|
|
|
|
static int remote_send_hold(void *data)
|
|
|
|
{
|
|
|
|
return remote_send_hold_refresh(data, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Update local hold state to be unheld */
|
|
|
|
static int remote_send_unhold(void *data)
|
|
|
|
{
|
|
|
|
return remote_send_hold_refresh(data, 0);
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
struct topology_change_refresh_data {
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
struct ast_sip_session_media_state *media_state;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void topology_change_refresh_data_free(struct topology_change_refresh_data *refresh_data)
|
|
|
|
{
|
|
|
|
ao2_cleanup(refresh_data->session);
|
|
|
|
|
|
|
|
ast_sip_session_media_state_free(refresh_data->media_state);
|
|
|
|
ast_free(refresh_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct topology_change_refresh_data *topology_change_refresh_data_alloc(
|
|
|
|
struct ast_sip_session *session, const struct ast_stream_topology *topology)
|
|
|
|
{
|
|
|
|
struct topology_change_refresh_data *refresh_data;
|
|
|
|
|
|
|
|
refresh_data = ast_calloc(1, sizeof(*refresh_data));
|
|
|
|
if (!refresh_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
refresh_data->session = ao2_bump(session);
|
|
|
|
refresh_data->media_state = ast_sip_session_media_state_alloc();
|
|
|
|
if (!refresh_data->media_state) {
|
|
|
|
topology_change_refresh_data_free(refresh_data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
refresh_data->media_state->topology = ast_stream_topology_clone(topology);
|
|
|
|
if (!refresh_data->media_state->topology) {
|
|
|
|
topology_change_refresh_data_free(refresh_data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return refresh_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int on_topology_change_response(struct ast_sip_session *session, pjsip_rx_data *rdata)
|
|
|
|
{
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s: Received response code %d. PT: %s AT: %s\n", ast_sip_session_get_name(session),
|
|
|
|
rdata->msg_info.msg->line.status.code,
|
|
|
|
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)));
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
|
2017-08-14 17:20:25 +00:00
|
|
|
if (PJSIP_IS_STATUS_IN_CLASS(rdata->msg_info.msg->line.status.code, 200)) {
|
2017-05-30 14:12:47 +00:00
|
|
|
/* The topology was changed to something new so give notice to what requested
|
|
|
|
* it so it queries the channel and updates accordingly.
|
|
|
|
*/
|
|
|
|
if (session->channel) {
|
|
|
|
ast_queue_control(session->channel, AST_CONTROL_STREAM_TOPOLOGY_CHANGED);
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s: Queued topology change frame\n", ast_sip_session_get_name(session));
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s: No channel? Can't queue topology change frame\n", ast_sip_session_get_name(session));
|
2017-08-14 17:20:25 +00:00
|
|
|
} else if (300 <= rdata->msg_info.msg->line.status.code) {
|
2017-05-30 14:12:47 +00:00
|
|
|
/* The topology change failed, so drop the current pending media state */
|
|
|
|
ast_sip_session_media_state_reset(session->pending_media_state);
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s: response code > 300. Resetting pending media state\n", ast_sip_session_get_name(session));
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s: Nothing to do\n", ast_sip_session_get_name(session));
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int send_topology_change_refresh(void *data)
|
|
|
|
{
|
|
|
|
struct topology_change_refresh_data *refresh_data = data;
|
2020-08-20 20:09:25 +00:00
|
|
|
struct ast_sip_session *session = refresh_data->session;
|
2023-05-25 15:14:47 +00:00
|
|
|
enum ast_channel_state state = ast_channel_state(session->channel);
|
|
|
|
enum ast_sip_session_refresh_method method = AST_SIP_SESSION_REFRESH_METHOD_INVITE;
|
2017-05-30 14:12:47 +00:00
|
|
|
int ret;
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s: %s\n", ast_sip_session_get_name(session),
|
|
|
|
ast_str_tmp(256, ast_stream_topology_to_str(refresh_data->media_state->topology, &STR_TMP)));
|
2017-05-30 14:12:47 +00:00
|
|
|
|
2023-05-25 15:14:47 +00:00
|
|
|
/* See RFC 6337, especially section 3.2: If the early media SDP was sent reliably, we are allowed
|
|
|
|
* to send UPDATEs. Only relevant for AST_STATE_RINGING and AST_STATE_RING - if the channel is UP,
|
|
|
|
* re-INVITES can be sent.
|
|
|
|
*/
|
|
|
|
if (session->early_confirmed && (state == AST_STATE_RINGING || state == AST_STATE_RING)) {
|
|
|
|
method = AST_SIP_SESSION_REFRESH_METHOD_UPDATE;
|
|
|
|
}
|
2020-08-20 20:09:25 +00:00
|
|
|
|
|
|
|
ret = ast_sip_session_refresh(session, NULL, NULL, on_topology_change_response,
|
2023-05-25 15:14:47 +00:00
|
|
|
method, 1, refresh_data->media_state);
|
2017-05-30 14:12:47 +00:00
|
|
|
refresh_data->media_state = NULL;
|
|
|
|
topology_change_refresh_data_free(refresh_data);
|
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(ret, "%s\n", ast_sip_session_get_name(session));
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_topology_request_change(struct ast_sip_session *session,
|
|
|
|
const struct ast_stream_topology *proposed)
|
|
|
|
{
|
|
|
|
struct topology_change_refresh_data *refresh_data;
|
|
|
|
int res;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1);
|
2017-05-30 14:12:47 +00:00
|
|
|
|
|
|
|
refresh_data = topology_change_refresh_data_alloc(session, proposed);
|
|
|
|
if (!refresh_data) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Couldn't create refresh_data\n");
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
res = ast_sip_push_task(session->serializer, send_topology_change_refresh, refresh_data);
|
|
|
|
if (res) {
|
|
|
|
topology_change_refresh_data_free(refresh_data);
|
|
|
|
}
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(res, "RC: %d\n", res);
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
|
2022-02-26 12:37:08 +00:00
|
|
|
/* Forward declarations */
|
|
|
|
static int transmit_info_dtmf(void *data);
|
|
|
|
static struct info_dtmf_data *info_dtmf_data_alloc(struct ast_sip_session *session, char digit, unsigned int duration);
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called by core to ask the channel to indicate some sort of condition */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2013-04-25 18:25:31 +00:00
|
|
|
struct ast_sip_session_media *media;
|
|
|
|
int response_code = 0;
|
2013-05-13 17:20:33 +00:00
|
|
|
int res = 0;
|
2014-01-20 18:18:25 +00:00
|
|
|
char *device_buf;
|
|
|
|
size_t device_buf_size;
|
2017-05-30 14:12:47 +00:00
|
|
|
int i;
|
|
|
|
const struct ast_stream_topology *topology;
|
2020-08-20 20:09:25 +00:00
|
|
|
struct ast_frame f = {
|
|
|
|
.frametype = AST_FRAME_CONTROL,
|
|
|
|
.subclass = {
|
|
|
|
.integer = condition
|
2021-01-11 20:25:09 +00:00
|
|
|
},
|
|
|
|
.datalen = datalen,
|
|
|
|
.data.ptr = (void *)data,
|
2020-08-20 20:09:25 +00:00
|
|
|
};
|
|
|
|
char condition_name[256];
|
2022-02-26 12:37:08 +00:00
|
|
|
unsigned int duration;
|
|
|
|
char digit;
|
|
|
|
struct info_dtmf_data *dtmf_data;
|
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s: Indicated %s\n", ast_channel_name(ast),
|
|
|
|
ast_frame_subclass2str(&f, condition_name, sizeof(condition_name), NULL, 0));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
switch (condition) {
|
|
|
|
case AST_CONTROL_RINGING:
|
|
|
|
if (ast_channel_state(ast) == AST_STATE_RING) {
|
2019-05-13 20:37:50 +00:00
|
|
|
if (channel->session->endpoint->inband_progress ||
|
|
|
|
(channel->session->inv_session && channel->session->inv_session->neg &&
|
|
|
|
pjmedia_sdp_neg_get_state(channel->session->inv_session->neg) == PJMEDIA_SDP_NEG_STATE_DONE)) {
|
2013-06-22 14:03:22 +00:00
|
|
|
res = -1;
|
2022-02-21 13:23:21 +00:00
|
|
|
if (ast_sip_get_allow_sending_180_after_183()) {
|
|
|
|
response_code = 180;
|
|
|
|
} else {
|
|
|
|
response_code = 183;
|
|
|
|
}
|
2013-06-22 14:03:22 +00:00
|
|
|
} else {
|
|
|
|
response_code = 180;
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "PJSIP/%s", ast_sorcery_object_get_id(channel->session->endpoint));
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_BUSY:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 486;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AST_CONTROL_CONGESTION:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 503;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AST_CONTROL_INCOMPLETE:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 484;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AST_CONTROL_PROCEEDING:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 100;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AST_CONTROL_PROGRESS:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 183;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
2017-06-07 20:19:05 +00:00
|
|
|
ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "PJSIP/%s", ast_sorcery_object_get_id(channel->session->endpoint));
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
2022-02-26 12:37:08 +00:00
|
|
|
case AST_CONTROL_FLASH:
|
|
|
|
duration = 300;
|
|
|
|
digit = '!';
|
|
|
|
dtmf_data = info_dtmf_data_alloc(channel->session, digit, duration);
|
|
|
|
|
|
|
|
if (!dtmf_data) {
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, transmit_info_dtmf, dtmf_data)) {
|
|
|
|
ast_log(LOG_WARNING, "Error sending FLASH via INFO on channel %s\n", ast_channel_name(ast));
|
|
|
|
ao2_ref(dtmf_data, -1); /* dtmf_data can't be null here */
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_CONTROL_VIDUPDATE:
|
2017-05-30 14:12:47 +00:00
|
|
|
for (i = 0; i < AST_VECTOR_SIZE(&channel->session->active_media_state->sessions); ++i) {
|
|
|
|
media = AST_VECTOR_GET(&channel->session->active_media_state->sessions, i);
|
|
|
|
if (!media || media->type != AST_MEDIA_TYPE_VIDEO) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (media->rtp) {
|
|
|
|
/* FIXME: Only use this for VP8. Additional work would have to be done to
|
|
|
|
* fully support other video codecs */
|
|
|
|
|
2017-07-10 23:17:44 +00:00
|
|
|
if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), ast_format_vp8) != AST_FORMAT_CMP_NOT_EQUAL ||
|
2017-07-24 18:30:59 +00:00
|
|
|
ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), ast_format_vp9) != AST_FORMAT_CMP_NOT_EQUAL ||
|
2019-08-22 12:44:07 +00:00
|
|
|
ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), ast_format_h265) != AST_FORMAT_CMP_NOT_EQUAL ||
|
2017-07-10 23:17:44 +00:00
|
|
|
(channel->session->endpoint->media.webrtc &&
|
|
|
|
ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), ast_format_h264) != AST_FORMAT_CMP_NOT_EQUAL)) {
|
2017-05-30 14:12:47 +00:00
|
|
|
/* FIXME Fake RTP write, this will be sent as an RTCP packet. Ideally the
|
|
|
|
* RTP engine would provide a way to externally write/schedule RTCP
|
|
|
|
* packets */
|
|
|
|
struct ast_frame fr;
|
|
|
|
fr.frametype = AST_FRAME_CONTROL;
|
|
|
|
fr.subclass.integer = AST_CONTROL_VIDUPDATE;
|
|
|
|
res = ast_rtp_instance_write(media->rtp, &fr);
|
2016-10-18 14:04:54 +00:00
|
|
|
} else {
|
2017-05-30 14:12:47 +00:00
|
|
|
ao2_ref(channel->session, +1);
|
2020-10-29 17:21:13 +00:00
|
|
|
if (ast_sip_push_task(channel->session->serializer, transmit_info_with_vidupdate, channel->session)) {
|
2016-10-18 14:04:54 +00:00
|
|
|
ao2_cleanup(channel->session);
|
2017-05-30 14:12:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ast_test_suite_event_notify("AST_CONTROL_VIDUPDATE", "Result: Success");
|
|
|
|
} else {
|
|
|
|
ast_test_suite_event_notify("AST_CONTROL_VIDUPDATE", "Result: Failure");
|
|
|
|
res = -1;
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
}
|
2017-05-30 14:12:47 +00:00
|
|
|
/* XXX If there were no video streams, then this should set
|
|
|
|
* res to -1
|
|
|
|
*/
|
2013-06-22 14:03:22 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_CONNECTED_LINE:
|
2013-07-23 12:27:03 +00:00
|
|
|
ao2_ref(channel->session, +1);
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, update_connected_line_information, channel->session)) {
|
|
|
|
ao2_cleanup(channel->session);
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_UPDATE_RTP_PEER:
|
2013-07-16 20:00:25 +00:00
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_CONTROL_PVT_CAUSE_CODE:
|
2013-07-16 20:00:25 +00:00
|
|
|
res = -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
2014-10-03 17:47:42 +00:00
|
|
|
case AST_CONTROL_MASQUERADE_NOTIFY:
|
|
|
|
ast_assert(datalen == sizeof(int));
|
|
|
|
if (*(int *) data) {
|
|
|
|
/*
|
|
|
|
* Masquerade is beginning:
|
|
|
|
* Wait for session serializer to get suspended.
|
|
|
|
*/
|
|
|
|
ast_channel_unlock(ast);
|
|
|
|
ast_sip_session_suspend(channel->session);
|
|
|
|
ast_channel_lock(ast);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Masquerade is complete:
|
|
|
|
* Unsuspend the session serializer.
|
|
|
|
*/
|
|
|
|
ast_sip_session_unsuspend(channel->session);
|
|
|
|
}
|
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_CONTROL_HOLD:
|
2014-01-20 18:18:25 +00:00
|
|
|
chan_pjsip_add_hold(ast_channel_uniqueid(ast));
|
|
|
|
device_buf_size = strlen(ast_channel_name(ast)) + 1;
|
|
|
|
device_buf = alloca(device_buf_size);
|
|
|
|
ast_channel_get_device_name(ast, device_buf, device_buf_size);
|
|
|
|
ast_devstate_changed_literal(AST_DEVICE_ONHOLD, 1, device_buf);
|
2019-09-19 08:56:26 +00:00
|
|
|
if (!channel->session->moh_passthrough) {
|
2014-11-03 14:45:01 +00:00
|
|
|
ast_moh_start(ast, data, NULL);
|
|
|
|
} else {
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, remote_send_hold, ao2_bump(channel->session))) {
|
|
|
|
ast_log(LOG_WARNING, "Could not queue task to remotely put session '%s' on hold with endpoint '%s'\n",
|
|
|
|
ast_sorcery_object_get_id(channel->session), ast_sorcery_object_get_id(channel->session->endpoint));
|
|
|
|
ao2_ref(channel->session, -1);
|
|
|
|
}
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_UNHOLD:
|
2014-01-20 18:18:25 +00:00
|
|
|
chan_pjsip_remove_hold(ast_channel_uniqueid(ast));
|
|
|
|
device_buf_size = strlen(ast_channel_name(ast)) + 1;
|
|
|
|
device_buf = alloca(device_buf_size);
|
|
|
|
ast_channel_get_device_name(ast, device_buf, device_buf_size);
|
|
|
|
ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, 1, device_buf);
|
2019-09-19 08:56:26 +00:00
|
|
|
if (!channel->session->moh_passthrough) {
|
2014-11-03 14:45:01 +00:00
|
|
|
ast_moh_stop(ast);
|
|
|
|
} else {
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, remote_send_unhold, ao2_bump(channel->session))) {
|
|
|
|
ast_log(LOG_WARNING, "Could not queue task to remotely take session '%s' off hold with endpoint '%s'\n",
|
|
|
|
ast_sorcery_object_get_id(channel->session), ast_sorcery_object_get_id(channel->session->endpoint));
|
|
|
|
ao2_ref(channel->session, -1);
|
|
|
|
}
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_SRCUPDATE:
|
|
|
|
break;
|
|
|
|
case AST_CONTROL_SRCCHANGE:
|
|
|
|
break;
|
2013-06-22 14:03:22 +00:00
|
|
|
case AST_CONTROL_REDIRECTING:
|
|
|
|
if (ast_channel_state(ast) != AST_STATE_UP) {
|
|
|
|
response_code = 181;
|
|
|
|
} else {
|
|
|
|
res = -1;
|
|
|
|
}
|
2013-07-30 14:16:41 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_T38_PARAMETERS:
|
|
|
|
res = 0;
|
|
|
|
|
|
|
|
if (channel->session->t38state == T38_PEER_REINVITE) {
|
|
|
|
const struct ast_control_t38_parameters *parameters = data;
|
|
|
|
|
|
|
|
if (parameters->request_response == AST_T38_REQUEST_PARMS) {
|
|
|
|
res = AST_T38_REQUEST_PARMS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
break;
|
|
|
|
case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
|
|
|
|
topology = data;
|
2020-08-20 20:09:25 +00:00
|
|
|
ast_trace(-1, "%s: New topology: %s\n", ast_channel_name(ast),
|
|
|
|
ast_str_tmp(256, ast_stream_topology_to_str(topology, &STR_TMP)));
|
2017-05-30 14:12:47 +00:00
|
|
|
res = handle_topology_request_change(channel->session, topology);
|
2013-06-22 14:03:22 +00:00
|
|
|
break;
|
2017-09-19 10:44:28 +00:00
|
|
|
case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
|
|
|
|
break;
|
2017-09-16 14:19:59 +00:00
|
|
|
case AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED:
|
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case -1:
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
if (response_code) {
|
2013-07-23 12:27:03 +00:00
|
|
|
struct indicate_data *ind_data = indicate_data_alloc(channel->session, condition, response_code, data, datalen);
|
2016-10-18 14:04:54 +00:00
|
|
|
|
|
|
|
if (!ind_data) {
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Couldn't alloc indicate data\n", ast_channel_name(ast));
|
2016-10-18 14:04:54 +00:00
|
|
|
}
|
2020-10-29 17:21:13 +00:00
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (ast_sip_push_task(channel->session->serializer, indicate, ind_data)) {
|
2020-08-20 20:09:25 +00:00
|
|
|
ast_log(LOG_ERROR, "%s: Cannot send response code %d to endpoint %s. Could not queue task properly\n",
|
|
|
|
ast_channel_name(ast), response_code, ast_sorcery_object_get_id(channel->session->endpoint));
|
2013-06-22 14:03:22 +00:00
|
|
|
ao2_cleanup(ind_data);
|
2013-04-25 18:25:31 +00:00
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_channel_name(ast));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
struct transfer_data {
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
char *target;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void transfer_data_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct transfer_data *trnf_data = obj;
|
|
|
|
|
|
|
|
ast_free(trnf_data->target);
|
|
|
|
ao2_cleanup(trnf_data->session);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct transfer_data *transfer_data_alloc(struct ast_sip_session *session, const char *target)
|
|
|
|
{
|
|
|
|
struct transfer_data *trnf_data = ao2_alloc(sizeof(*trnf_data), transfer_data_destroy);
|
|
|
|
|
|
|
|
if (!trnf_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(trnf_data->target = ast_strdup(target))) {
|
|
|
|
ao2_ref(trnf_data, -1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(session, +1);
|
|
|
|
trnf_data->session = session;
|
|
|
|
|
|
|
|
return trnf_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void transfer_redirect(struct ast_sip_session *session, const char *target)
|
|
|
|
{
|
|
|
|
pjsip_tx_data *packet;
|
|
|
|
enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
|
|
|
|
pjsip_contact_hdr *contact;
|
|
|
|
pj_str_t tmp;
|
|
|
|
|
2016-06-22 23:02:59 +00:00
|
|
|
if (pjsip_inv_end_session(session->inv_session, 302, NULL, &packet) != PJ_SUCCESS
|
|
|
|
|| !packet) {
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
ast_log(LOG_WARNING, "Failed to redirect PJSIP session for channel %s\n",
|
|
|
|
ast_channel_name(session->channel));
|
2013-06-22 14:03:22 +00:00
|
|
|
message = AST_TRANSFER_FAILED;
|
|
|
|
ast_queue_control_data(session->channel, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(contact = pjsip_msg_find_hdr(packet->msg, PJSIP_H_CONTACT, NULL))) {
|
|
|
|
contact = pjsip_contact_hdr_create(packet->pool);
|
|
|
|
}
|
|
|
|
|
|
|
|
pj_strdup2_with_null(packet->pool, &tmp, target);
|
|
|
|
if (!(contact->uri = pjsip_parse_uri(packet->pool, tmp.ptr, tmp.slen, PJSIP_PARSE_URI_AS_NAMEADDR))) {
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
ast_log(LOG_WARNING, "Failed to parse destination URI '%s' for channel %s\n",
|
|
|
|
target, ast_channel_name(session->channel));
|
2013-06-22 14:03:22 +00:00
|
|
|
message = AST_TRANSFER_FAILED;
|
|
|
|
ast_queue_control_data(session->channel, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
|
|
|
pjsip_tx_data_dec_ref(packet);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pjsip_msg_add_hdr(packet->msg, (pjsip_hdr *) contact);
|
|
|
|
|
|
|
|
ast_sip_session_send_response(session, packet);
|
|
|
|
ast_queue_control_data(session->channel, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
|
|
|
}
|
|
|
|
|
2019-04-02 19:42:44 +00:00
|
|
|
/*! \brief REFER Callback module, used to attach session data structure to subscription */
|
|
|
|
static pjsip_module refer_callback_module = {
|
|
|
|
.name = { "REFER Callback", 14 },
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Callback function to report status of implicit REFER-NOTIFY subscription.
|
|
|
|
*
|
|
|
|
* This function will be called on any state change in the REFER-NOTIFY subscription.
|
|
|
|
* Its primary purpose is to report SUCCESS/FAILURE of a transfer initiated via
|
|
|
|
* \ref transfer_refer as well as to terminate the subscription, if necessary.
|
|
|
|
*/
|
|
|
|
static void xfer_client_on_evsub_state(pjsip_evsub *sub, pjsip_event *event)
|
|
|
|
{
|
2020-12-07 22:59:51 +00:00
|
|
|
struct ast_channel *chan;
|
2019-04-02 19:42:44 +00:00
|
|
|
enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
if (!event) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-07 22:59:51 +00:00
|
|
|
chan = pjsip_evsub_get_mod_data(sub, refer_callback_module.id);
|
2019-04-02 19:42:44 +00:00
|
|
|
if (!chan) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pjsip_evsub_get_state(sub) == PJSIP_EVSUB_STATE_ACCEPTED) {
|
|
|
|
/* Check if subscription is suppressed and terminate and send completion code, if so. */
|
|
|
|
pjsip_rx_data *rdata;
|
|
|
|
pjsip_generic_string_hdr *refer_sub;
|
|
|
|
const pj_str_t REFER_SUB = { "Refer-Sub", 9 };
|
|
|
|
|
|
|
|
ast_debug(3, "Transfer accepted on channel %s\n", ast_channel_name(chan));
|
|
|
|
|
|
|
|
/* Check if response message */
|
|
|
|
if (event->type == PJSIP_EVENT_TSX_STATE && event->body.tsx_state.type == PJSIP_EVENT_RX_MSG) {
|
|
|
|
rdata = event->body.tsx_state.src.rdata;
|
|
|
|
|
|
|
|
/* Find Refer-Sub header */
|
|
|
|
refer_sub = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &REFER_SUB, NULL);
|
|
|
|
|
|
|
|
/* Check if subscription is suppressed. If it is, the far end will not terminate it,
|
|
|
|
* and the subscription will remain active until it times out. Terminating it here
|
|
|
|
* eliminates the unnecessary timeout.
|
|
|
|
*/
|
|
|
|
if (refer_sub && !pj_stricmp2(&refer_sub->hvalue, "false")) {
|
|
|
|
/* Since no subscription is desired, assume that call has been transferred successfully. */
|
2020-12-07 22:59:51 +00:00
|
|
|
/* Channel reference will be released at end of function */
|
2019-04-02 19:42:44 +00:00
|
|
|
/* Terminate subscription. */
|
2020-12-07 22:59:51 +00:00
|
|
|
pjsip_evsub_set_mod_data(sub, refer_callback_module.id, NULL);
|
2019-04-02 19:42:44 +00:00
|
|
|
pjsip_evsub_terminate(sub, PJ_TRUE);
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (pjsip_evsub_get_state(sub) == PJSIP_EVSUB_STATE_ACTIVE ||
|
|
|
|
pjsip_evsub_get_state(sub) == PJSIP_EVSUB_STATE_TERMINATED) {
|
|
|
|
/* Check for NOTIFY complete or error. */
|
|
|
|
pjsip_msg *msg;
|
|
|
|
pjsip_msg_body *body;
|
2020-06-22 20:27:32 +00:00
|
|
|
pjsip_status_line status_line = { .code = 0 };
|
2019-04-02 19:42:44 +00:00
|
|
|
pj_bool_t is_last;
|
|
|
|
pj_status_t status;
|
|
|
|
|
|
|
|
if (event->type == PJSIP_EVENT_TSX_STATE && event->body.tsx_state.type == PJSIP_EVENT_RX_MSG) {
|
|
|
|
pjsip_rx_data *rdata;
|
|
|
|
|
|
|
|
rdata = event->body.tsx_state.src.rdata;
|
|
|
|
msg = rdata->msg_info.msg;
|
|
|
|
|
2021-01-22 15:12:12 +00:00
|
|
|
if (msg->type == PJSIP_REQUEST_MSG) {
|
|
|
|
if (!pjsip_method_cmp(&msg->line.req.method, pjsip_get_notify_method())) {
|
|
|
|
body = msg->body;
|
|
|
|
if (body && !pj_stricmp2(&body->content_type.type, "message")
|
|
|
|
&& !pj_stricmp2(&body->content_type.subtype, "sipfrag")) {
|
|
|
|
pjsip_parse_status_line((char *)body->data, body->len, &status_line);
|
|
|
|
}
|
2019-04-02 19:42:44 +00:00
|
|
|
}
|
2021-01-22 15:12:12 +00:00
|
|
|
} else {
|
|
|
|
status_line.code = msg->line.status.code;
|
|
|
|
status_line.reason = msg->line.status.reason;
|
2019-04-02 19:42:44 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
status_line.code = 500;
|
|
|
|
status_line.reason = *pjsip_get_status_text(500);
|
|
|
|
}
|
|
|
|
|
|
|
|
is_last = (pjsip_evsub_get_state(sub) == PJSIP_EVSUB_STATE_TERMINATED);
|
|
|
|
/* If the status code is >= 200, the subscription is finished. */
|
|
|
|
if (status_line.code >= 200 || is_last) {
|
|
|
|
res = -1;
|
|
|
|
|
|
|
|
/* If the subscription has terminated, return AST_TRANSFER_SUCCESS for 2XX.
|
2021-01-22 15:12:12 +00:00
|
|
|
* Return AST_TRANSFER_FAILED for any code < 200.
|
|
|
|
* Otherwise, return the status code.
|
2019-04-02 19:42:44 +00:00
|
|
|
* The subscription should not terminate for any code < 200,
|
|
|
|
* but if it does, that constitutes a failure. */
|
2021-01-22 15:12:12 +00:00
|
|
|
if (status_line.code < 200) {
|
2019-04-02 19:42:44 +00:00
|
|
|
message = AST_TRANSFER_FAILED;
|
2021-01-22 15:12:12 +00:00
|
|
|
} else if (status_line.code >= 300) {
|
|
|
|
message = status_line.code;
|
2019-04-02 19:42:44 +00:00
|
|
|
}
|
2021-01-22 15:12:12 +00:00
|
|
|
|
2019-04-02 19:42:44 +00:00
|
|
|
/* If subscription not terminated and subscription is finished (status code >= 200)
|
|
|
|
* terminate it */
|
|
|
|
if (!is_last) {
|
|
|
|
pjsip_tx_data *tdata;
|
|
|
|
|
|
|
|
status = pjsip_evsub_initiate(sub, pjsip_get_subscribe_method(), 0, &tdata);
|
|
|
|
if (status == PJ_SUCCESS) {
|
|
|
|
pjsip_evsub_send_request(sub, tdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Finished. Remove session from subscription */
|
|
|
|
pjsip_evsub_set_mod_data(sub, refer_callback_module.id, NULL);
|
|
|
|
ast_debug(3, "Transfer channel %s completed: %d %.*s (%s)\n",
|
|
|
|
ast_channel_name(chan),
|
|
|
|
status_line.code,
|
|
|
|
(int)status_line.reason.slen, status_line.reason.ptr,
|
|
|
|
(message == AST_TRANSFER_SUCCESS) ? "Success" : "Failure");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res) {
|
2020-12-07 22:59:51 +00:00
|
|
|
ast_queue_control_data(chan, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
|
|
|
ao2_ref(chan, -1);
|
2019-04-02 19:42:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
static void transfer_refer(struct ast_sip_session *session, const char *target)
|
|
|
|
{
|
|
|
|
pjsip_evsub *sub;
|
|
|
|
enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
|
|
|
|
pj_str_t tmp;
|
|
|
|
pjsip_tx_data *packet;
|
2015-08-26 21:58:04 +00:00
|
|
|
const char *ref_by_val;
|
|
|
|
char local_info[pj_strlen(&session->inv_session->dlg->local.info_str) + 1];
|
2019-04-02 19:42:44 +00:00
|
|
|
struct pjsip_evsub_user xfer_cb;
|
2020-12-07 22:59:51 +00:00
|
|
|
struct ast_channel *chan = session->channel;
|
2019-04-02 19:42:44 +00:00
|
|
|
|
|
|
|
pj_bzero(&xfer_cb, sizeof(xfer_cb));
|
|
|
|
xfer_cb.on_evsub_state = &xfer_client_on_evsub_state;
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2019-04-02 19:42:44 +00:00
|
|
|
if (pjsip_xfer_create_uac(session->inv_session->dlg, &xfer_cb, &sub) != PJ_SUCCESS) {
|
2013-06-22 14:03:22 +00:00
|
|
|
message = AST_TRANSFER_FAILED;
|
2020-12-07 22:59:51 +00:00
|
|
|
ast_queue_control_data(chan, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
2013-06-22 14:03:22 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-07 22:59:51 +00:00
|
|
|
/* refer_callback_module requires a reference to chan
|
|
|
|
* which will be released in xfer_client_on_evsub_state()
|
|
|
|
* when the implicit REFER subscription terminates */
|
|
|
|
pjsip_evsub_set_mod_data(sub, refer_callback_module.id, chan);
|
|
|
|
ao2_ref(chan, +1);
|
2019-04-02 19:42:44 +00:00
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
if (pjsip_xfer_initiate(sub, pj_cstr(&tmp, target), &packet) != PJ_SUCCESS) {
|
2020-12-07 22:59:51 +00:00
|
|
|
goto failure;
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
2020-12-07 22:59:51 +00:00
|
|
|
ref_by_val = pbx_builtin_getvar_helper(chan, "SIPREFERREDBYHDR");
|
2015-08-26 21:58:04 +00:00
|
|
|
if (!ast_strlen_zero(ref_by_val)) {
|
|
|
|
ast_sip_add_header(packet, "Referred-By", ref_by_val);
|
|
|
|
} else {
|
|
|
|
ast_copy_pj_str(local_info, &session->inv_session->dlg->local.info_str, sizeof(local_info));
|
|
|
|
ast_sip_add_header(packet, "Referred-By", local_info);
|
|
|
|
}
|
|
|
|
|
2020-12-07 22:59:51 +00:00
|
|
|
if (pjsip_xfer_send_request(sub, packet) == PJ_SUCCESS) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
failure:
|
|
|
|
message = AST_TRANSFER_FAILED;
|
|
|
|
ast_queue_control_data(chan, AST_CONTROL_TRANSFER, &message, sizeof(message));
|
|
|
|
pjsip_evsub_set_mod_data(sub, refer_callback_module.id, NULL);
|
|
|
|
pjsip_evsub_terminate(sub, PJ_FALSE);
|
|
|
|
|
|
|
|
ao2_ref(chan, -1);
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int transfer(void *data)
|
|
|
|
{
|
|
|
|
struct transfer_data *trnf_data = data;
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
struct ast_sip_endpoint *endpoint = NULL;
|
|
|
|
struct ast_sip_contact *contact = NULL;
|
|
|
|
const char *target = trnf_data->target;
|
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (trnf_data->session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
trnf_data->session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(trnf_data->session->inv_session->cause)->ptr);
|
|
|
|
} else {
|
|
|
|
/* See if we have an endpoint; if so, use its contact */
|
|
|
|
endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", target);
|
|
|
|
if (endpoint) {
|
|
|
|
contact = ast_sip_location_retrieve_contact_from_aor_list(endpoint->aors);
|
|
|
|
if (contact && !ast_strlen_zero(contact->uri)) {
|
|
|
|
target = contact->uri;
|
|
|
|
}
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
}
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (ast_channel_state(trnf_data->session->channel) == AST_STATE_RING) {
|
|
|
|
transfer_redirect(trnf_data->session, target);
|
|
|
|
} else {
|
|
|
|
transfer_refer(trnf_data->session, target);
|
|
|
|
}
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(trnf_data, -1);
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
ao2_cleanup(endpoint);
|
|
|
|
ao2_cleanup(contact);
|
2013-06-22 14:03:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called by core for Asterisk initiated transfer */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_transfer(struct ast_channel *chan, const char *target)
|
2013-06-22 14:03:22 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
|
|
|
struct transfer_data *trnf_data = transfer_data_alloc(channel->session, target);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
|
|
|
if (!trnf_data) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-23 12:27:03 +00:00
|
|
|
if (ast_sip_push_task(channel->session->serializer, transfer, trnf_data)) {
|
2013-06-22 14:03:22 +00:00
|
|
|
ast_log(LOG_WARNING, "Error requesting transfer\n");
|
|
|
|
ao2_cleanup(trnf_data);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called by core to start a DTMF digit */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_digit_begin(struct ast_channel *chan, char digit)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session_media *media;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
media = channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
|
|
|
|
2017-06-26 12:52:52 +00:00
|
|
|
switch (channel->session->dtmf) {
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_SIP_DTMF_RFC_4733:
|
|
|
|
if (!media || !media->rtp) {
|
2020-04-08 19:33:47 +00:00
|
|
|
return 0;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ast_rtp_instance_dtmf_begin(media->rtp, digit);
|
2017-05-30 14:12:47 +00:00
|
|
|
break;
|
2015-04-10 17:56:47 +00:00
|
|
|
case AST_SIP_DTMF_AUTO:
|
2020-04-08 19:33:47 +00:00
|
|
|
if (!media || !media->rtp) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_rtp_instance_dtmf_mode_get(media->rtp) == AST_RTP_DTMF_MODE_INBAND) {
|
2017-05-30 14:12:47 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2015-04-10 17:56:47 +00:00
|
|
|
|
2017-06-15 08:12:41 +00:00
|
|
|
ast_rtp_instance_dtmf_begin(media->rtp, digit);
|
|
|
|
break;
|
|
|
|
case AST_SIP_DTMF_AUTO_INFO:
|
|
|
|
if (!media || !media->rtp || (ast_rtp_instance_dtmf_mode_get(media->rtp) == AST_RTP_DTMF_MODE_NONE)) {
|
2019-04-03 15:55:07 +00:00
|
|
|
return 0;
|
2017-06-15 08:12:41 +00:00
|
|
|
}
|
2017-05-30 14:12:47 +00:00
|
|
|
ast_rtp_instance_dtmf_begin(media->rtp, digit);
|
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_SIP_DTMF_NONE:
|
|
|
|
break;
|
|
|
|
case AST_SIP_DTMF_INBAND:
|
2020-04-08 19:33:47 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-04-08 19:33:47 +00:00
|
|
|
return 0;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct info_dtmf_data {
|
|
|
|
struct ast_sip_session *session;
|
|
|
|
char digit;
|
|
|
|
unsigned int duration;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void info_dtmf_data_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct info_dtmf_data *dtmf_data = obj;
|
|
|
|
ao2_ref(dtmf_data->session, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct info_dtmf_data *info_dtmf_data_alloc(struct ast_sip_session *session, char digit, unsigned int duration)
|
|
|
|
{
|
|
|
|
struct info_dtmf_data *dtmf_data = ao2_alloc(sizeof(*dtmf_data), info_dtmf_data_destroy);
|
|
|
|
if (!dtmf_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
ao2_ref(session, +1);
|
|
|
|
dtmf_data->session = session;
|
|
|
|
dtmf_data->digit = digit;
|
|
|
|
dtmf_data->duration = duration;
|
|
|
|
return dtmf_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int transmit_info_dtmf(void *data)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct info_dtmf_data *, dtmf_data, data, ao2_cleanup);
|
|
|
|
|
|
|
|
struct ast_sip_session *session = dtmf_data->session;
|
|
|
|
struct pjsip_tx_data *tdata;
|
|
|
|
|
|
|
|
RAII_VAR(struct ast_str *, body_text, NULL, ast_free_ptr);
|
|
|
|
|
|
|
|
struct ast_sip_body body = {
|
|
|
|
.type = "application",
|
|
|
|
.subtype = "dtmf-relay",
|
|
|
|
};
|
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(session->inv_session->cause)->ptr);
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2016-10-18 14:04:54 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!(body_text = ast_str_create(32))) {
|
|
|
|
ast_log(LOG_ERROR, "Could not allocate buffer for INFO DTMF.\n");
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
ast_str_set(&body_text, 0, "Signal=%c\r\nDuration=%u\r\n", dtmf_data->digit, dtmf_data->duration);
|
|
|
|
|
|
|
|
body.body_text = ast_str_buffer(body_text);
|
|
|
|
|
2014-01-15 13:16:10 +00:00
|
|
|
if (ast_sip_create_request("INFO", session->inv_session->dlg, session->endpoint, NULL, NULL, &tdata)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_log(LOG_ERROR, "Could not create DTMF INFO request\n");
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
if (ast_sip_add_body(tdata, &body)) {
|
|
|
|
ast_log(LOG_ERROR, "Could not add body to DTMF INFO request\n");
|
|
|
|
pjsip_tx_data_dec_ref(tdata);
|
2020-10-29 17:21:13 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
ast_sip_session_send_request(session, tdata);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called by core to stop a DTMF digit */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_sip_session_media *media;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2019-10-01 11:29:11 +00:00
|
|
|
if (!channel || !channel->session) {
|
|
|
|
/* This happens when the channel is hungup while a DTMF digit is playing. See ASTERISK-28086 */
|
|
|
|
ast_debug(3, "Channel %s disappeared while calling digit_end\n", ast_channel_name(ast));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
media = channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
|
|
|
|
2017-06-26 12:52:52 +00:00
|
|
|
switch (channel->session->dtmf) {
|
2017-06-15 08:12:41 +00:00
|
|
|
case AST_SIP_DTMF_AUTO_INFO:
|
|
|
|
{
|
|
|
|
if (!media || !media->rtp) {
|
2020-04-08 19:33:47 +00:00
|
|
|
return 0;
|
2017-06-15 08:12:41 +00:00
|
|
|
}
|
2020-04-08 19:33:47 +00:00
|
|
|
|
2017-06-15 08:12:41 +00:00
|
|
|
if (ast_rtp_instance_dtmf_mode_get(media->rtp) != AST_RTP_DTMF_MODE_NONE) {
|
|
|
|
ast_debug(3, "Told to send end of digit on Auto-Info channel %s RFC4733 negotiated so using it.\n", ast_channel_name(ast));
|
|
|
|
ast_rtp_instance_dtmf_end_with_duration(media->rtp, digit, duration);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* If RFC_4733 was not negotiated, fail through to the DTMF_INFO processing */
|
|
|
|
ast_debug(3, "Told to send end of digit on Auto-Info channel %s RFC4733 NOT negotiated using INFO instead.\n", ast_channel_name(ast));
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_SIP_DTMF_INFO:
|
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct info_dtmf_data *dtmf_data = info_dtmf_data_alloc(channel->session, digit, duration);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (!dtmf_data) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-23 12:27:03 +00:00
|
|
|
if (ast_sip_push_task(channel->session->serializer, transmit_info_dtmf, dtmf_data)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_log(LOG_WARNING, "Error sending DTMF via INFO.\n");
|
|
|
|
ao2_cleanup(dtmf_data);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AST_SIP_DTMF_RFC_4733:
|
|
|
|
if (!media || !media->rtp) {
|
2020-04-08 19:33:47 +00:00
|
|
|
return 0;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ast_rtp_instance_dtmf_end_with_duration(media->rtp, digit, duration);
|
2017-06-15 08:12:41 +00:00
|
|
|
break;
|
|
|
|
case AST_SIP_DTMF_AUTO:
|
2020-04-08 19:33:47 +00:00
|
|
|
if (!media || !media->rtp) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_rtp_instance_dtmf_mode_get(media->rtp) == AST_RTP_DTMF_MODE_INBAND) {
|
2017-06-15 08:12:41 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_rtp_instance_dtmf_end_with_duration(media->rtp, digit, duration);
|
|
|
|
break;
|
2013-04-25 18:25:31 +00:00
|
|
|
case AST_SIP_DTMF_NONE:
|
|
|
|
break;
|
|
|
|
case AST_SIP_DTMF_INBAND:
|
2020-04-08 19:33:47 +00:00
|
|
|
return -1;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2020-04-08 19:33:47 +00:00
|
|
|
return 0;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2014-06-05 11:59:09 +00:00
|
|
|
static void update_initial_connected_line(struct ast_sip_session *session)
|
|
|
|
{
|
|
|
|
struct ast_party_connected_line connected;
|
|
|
|
|
2014-08-19 16:16:03 +00:00
|
|
|
/*
|
|
|
|
* Use the channel CALLERID() as the initial connected line data.
|
|
|
|
* The core or a predial handler may have supplied missing values
|
|
|
|
* from the session->endpoint->id.self about who we are calling.
|
|
|
|
*/
|
|
|
|
ast_channel_lock(session->channel);
|
|
|
|
ast_party_id_copy(&session->id, &ast_channel_caller(session->channel)->id);
|
|
|
|
ast_channel_unlock(session->channel);
|
|
|
|
|
|
|
|
/* Supply initial connected line information if available. */
|
|
|
|
if (!session->id.number.valid && !session->id.name.valid) {
|
2014-06-05 11:59:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_party_connected_line_init(&connected);
|
2014-08-19 16:16:03 +00:00
|
|
|
connected.id = session->id;
|
2014-06-05 11:59:09 +00:00
|
|
|
connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
|
|
|
|
|
2014-08-19 16:16:03 +00:00
|
|
|
ast_channel_queue_connected_line_update(session->channel, &connected, NULL);
|
2014-06-05 11:59:09 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
static int call(void *data)
|
|
|
|
{
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = data;
|
|
|
|
struct ast_sip_session *session = channel->session;
|
2013-06-22 14:03:22 +00:00
|
|
|
pjsip_tx_data *tdata;
|
2020-07-06 19:23:24 +00:00
|
|
|
int res = 0;
|
|
|
|
SCOPE_ENTER(1, "%s Topology: %s\n",
|
|
|
|
ast_sip_session_get_name(session),
|
|
|
|
ast_str_tmp(256, ast_stream_topology_to_str(channel->session->pending_media_state->topology, &STR_TMP))
|
|
|
|
);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
|
|
|
|
res = ast_sip_session_create_invite(session, &tdata);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
if (res) {
|
2014-07-07 01:22:44 +00:00
|
|
|
ast_set_hangupsource(session->channel, ast_channel_name(session->channel), 0);
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_queue_hangup(session->channel);
|
|
|
|
} else {
|
2017-05-30 14:12:47 +00:00
|
|
|
set_channel_on_rtp_instance(session, ast_channel_uniqueid(session->channel));
|
2014-06-05 11:59:09 +00:00
|
|
|
update_initial_connected_line(session);
|
2013-06-22 14:03:22 +00:00
|
|
|
ast_sip_session_send_request(session, tdata);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
ao2_ref(channel, -1);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(res, "RC: %d\n", res);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called by core to actually start calling a remote party */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_call(struct ast_channel *ast, const char *dest, int timeout)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s Topology: %s\n", ast_sip_session_get_name(channel->session),
|
|
|
|
ast_str_tmp(256, ast_stream_topology_to_str(channel->session->pending_media_state->topology, &STR_TMP)));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
ao2_ref(channel, +1);
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, call, channel)) {
|
2014-08-19 16:16:03 +00:00
|
|
|
ast_log(LOG_WARNING, "Error attempting to place outbound call to '%s'\n", dest);
|
res_hep_rtcp: Add module that sends RTCP information to a Homer Server
This patch adds a new module to Asterisk, res_hep_rtcp. The module subscribes
to the RTCP topics in Stasis and receives RTCP information back from the
message bus. It encodes into HEPv3 packets and sends the information to the
res_hep module for transmission.
Using this, someone with a Homer server can get live call quality monitoring
for all RTP-based channels in their Asterisk 12+ systems.
In addition, there were a few bugs in the RTP engine, res_rtp_asterisk, and
chan_pjsip that were uncovered by the tests written for the Asterisk Test
Suite. This patch fixes the following:
1) chan_pjsip failed to set its channel unique ids on its RTP instance on
outbound calls. It now does this in the appropriate location, in the
serialized call callback.
2) The rtp_engine was overflowing some values when packed into JSON.
Specifically, some longs and unsigned ints can't be be packed into integer
values, for obvious reasons. Since libjansson only supports integers,
floats, strings, booleans, and objects, we print these values into strings.
3) res_rtp_asterisk had a few problems:
(a) it would emit a source IP address of 0.0.0.0 if bound to that IP
address. We now use ast_find_ourip to get a better IP address, and
properly marshal the result into an ast_strdupa'd string.
(b) Reports can be generated with no report bodies. In particular, this
occurs when a sender is transmitting information to a receiver (who
will send no RTP back to the sender). As such, the sender has no report
body for what it received. We now properly handle this case, and the
sender will emit SR reports with no body. Likewise, if we receive an
RTCP packet with no report body, we will still generate the appropriate
events.
ASTERISK-24119 #close
........
Merged revisions 419823 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419825 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-31 11:57:51 +00:00
|
|
|
ao2_cleanup(channel);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Couldn't push task\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "'call' task pushed\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Internal function which translates from Asterisk cause codes to SIP response codes */
|
|
|
|
static int hangup_cause2sip(int cause)
|
|
|
|
{
|
|
|
|
switch (cause) {
|
|
|
|
case AST_CAUSE_UNALLOCATED: /* 1 */
|
|
|
|
case AST_CAUSE_NO_ROUTE_DESTINATION: /* 3 IAX2: Can't find extension in context */
|
|
|
|
case AST_CAUSE_NO_ROUTE_TRANSIT_NET: /* 2 */
|
|
|
|
return 404;
|
|
|
|
case AST_CAUSE_CONGESTION: /* 34 */
|
|
|
|
case AST_CAUSE_SWITCH_CONGESTION: /* 42 */
|
|
|
|
return 503;
|
|
|
|
case AST_CAUSE_NO_USER_RESPONSE: /* 18 */
|
|
|
|
return 408;
|
|
|
|
case AST_CAUSE_NO_ANSWER: /* 19 */
|
|
|
|
case AST_CAUSE_UNREGISTERED: /* 20 */
|
|
|
|
return 480;
|
|
|
|
case AST_CAUSE_CALL_REJECTED: /* 21 */
|
|
|
|
return 403;
|
|
|
|
case AST_CAUSE_NUMBER_CHANGED: /* 22 */
|
|
|
|
return 410;
|
|
|
|
case AST_CAUSE_NORMAL_UNSPECIFIED: /* 31 */
|
|
|
|
return 480;
|
|
|
|
case AST_CAUSE_INVALID_NUMBER_FORMAT:
|
|
|
|
return 484;
|
|
|
|
case AST_CAUSE_USER_BUSY:
|
|
|
|
return 486;
|
|
|
|
case AST_CAUSE_FAILURE:
|
|
|
|
return 500;
|
|
|
|
case AST_CAUSE_FACILITY_REJECTED: /* 29 */
|
|
|
|
return 501;
|
|
|
|
case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
|
|
|
|
return 503;
|
|
|
|
case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
|
|
|
|
return 502;
|
|
|
|
case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL: /* Can't find codec to connect to host */
|
|
|
|
return 488;
|
|
|
|
case AST_CAUSE_INTERWORKING: /* Unspecified Interworking issues */
|
|
|
|
return 500;
|
|
|
|
case AST_CAUSE_NOTDEFINED:
|
|
|
|
default:
|
|
|
|
ast_debug(1, "AST hangup cause %d (no match found in PJSIP)\n", cause);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Never reached */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct hangup_data {
|
|
|
|
int cause;
|
|
|
|
struct ast_channel *chan;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void hangup_data_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct hangup_data *h_data = obj;
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
h_data->chan = ast_channel_unref(h_data->chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hangup_data *hangup_data_alloc(int cause, struct ast_channel *chan)
|
|
|
|
{
|
|
|
|
struct hangup_data *h_data = ao2_alloc(sizeof(*h_data), hangup_data_destroy);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!h_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
h_data->cause = cause;
|
|
|
|
h_data->chan = ast_channel_ref(chan);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
return h_data;
|
|
|
|
}
|
|
|
|
|
2013-07-05 17:33:33 +00:00
|
|
|
/*! \brief Clear a channel from a session along with its PVT */
|
2017-05-30 14:12:47 +00:00
|
|
|
static void clear_session_and_channel(struct ast_sip_session *session, struct ast_channel *ast)
|
2013-07-05 17:33:33 +00:00
|
|
|
{
|
|
|
|
session->channel = NULL;
|
2017-05-30 14:12:47 +00:00
|
|
|
set_channel_on_rtp_instance(session, "");
|
2013-07-05 17:33:33 +00:00
|
|
|
ast_channel_tech_pvt_set(ast, NULL);
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
static int hangup(void *data)
|
|
|
|
{
|
|
|
|
struct hangup_data *h_data = data;
|
|
|
|
struct ast_channel *ast = h_data->chan;
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_channel_name(ast));
|
|
|
|
|
2017-04-27 13:02:12 +00:00
|
|
|
/*
|
2019-06-06 12:48:18 +00:00
|
|
|
* Before cleaning we have to ensure that channel or its session is not NULL
|
|
|
|
* we have seen rare case when taskprocessor calls hangup but channel is NULL
|
|
|
|
* due to SIP session timeout and answer happening at the same time
|
2017-04-27 13:02:12 +00:00
|
|
|
*/
|
2019-06-06 12:48:18 +00:00
|
|
|
if (channel) {
|
|
|
|
struct ast_sip_session *session = channel->session;
|
|
|
|
if (session) {
|
|
|
|
int cause = h_data->cause;
|
|
|
|
|
2022-10-28 10:57:56 +00:00
|
|
|
if (channel->session->active_media_state &&
|
|
|
|
channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO]) {
|
|
|
|
struct ast_sip_session_media *media =
|
|
|
|
channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
|
|
|
if (media->rtp) {
|
|
|
|
ast_rtp_instance_set_stats_vars(ast, media->rtp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-06 12:48:18 +00:00
|
|
|
/*
|
|
|
|
* It's possible that session_terminate might cause the session to be destroyed
|
|
|
|
* immediately so we need to keep a reference to it so we can NULL session->channel
|
|
|
|
* afterwards.
|
|
|
|
*/
|
|
|
|
ast_sip_session_terminate(ao2_bump(session), cause);
|
|
|
|
clear_session_and_channel(session, ast);
|
|
|
|
ao2_cleanup(session);
|
|
|
|
}
|
|
|
|
ao2_cleanup(channel);
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
ao2_cleanup(h_data);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Function called by core to hang up a PJSIP session */
|
|
|
|
static int chan_pjsip_hangup(struct ast_channel *ast)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
2015-08-26 19:25:42 +00:00
|
|
|
int cause;
|
|
|
|
struct hangup_data *h_data;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_channel_name(ast));
|
2015-08-26 19:25:42 +00:00
|
|
|
|
|
|
|
if (!channel || !channel->session) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "No channel or session\n");
|
2015-08-26 19:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cause = hangup_cause2sip(ast_channel_hangupcause(channel->session->channel));
|
|
|
|
h_data = hangup_data_alloc(cause, ast);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!h_data) {
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
|
2013-07-23 12:27:03 +00:00
|
|
|
if (ast_sip_push_task(channel->session->serializer, hangup, h_data)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_log(LOG_WARNING, "Unable to push hangup task to the threadpool. Expect bad things\n");
|
|
|
|
goto failure;
|
|
|
|
}
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Cause: %d\n", cause);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
failure:
|
|
|
|
/* Go ahead and do our cleanup of the session and channel even if we're not going
|
|
|
|
* to be able to send our SIP request/response
|
|
|
|
*/
|
2017-05-30 14:12:47 +00:00
|
|
|
clear_session_and_channel(channel->session, ast);
|
2013-07-23 18:41:29 +00:00
|
|
|
ao2_cleanup(channel);
|
2013-07-05 17:33:33 +00:00
|
|
|
ao2_cleanup(h_data);
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Cause: %d\n", cause);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct request_data {
|
|
|
|
struct ast_sip_session *session;
|
2017-05-30 14:12:47 +00:00
|
|
|
struct ast_stream_topology *topology;
|
2013-04-25 18:25:31 +00:00
|
|
|
const char *dest;
|
|
|
|
int cause;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int request(void *obj)
|
|
|
|
{
|
|
|
|
struct request_data *req_data = obj;
|
2013-05-13 17:20:33 +00:00
|
|
|
struct ast_sip_session *session = NULL;
|
2013-04-25 18:25:31 +00:00
|
|
|
char *tmp = ast_strdupa(req_data->dest), *endpoint_name = NULL, *request_user = NULL;
|
2017-12-16 01:01:02 +00:00
|
|
|
struct ast_sip_endpoint *endpoint;
|
2013-05-13 17:20:33 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
AST_DECLARE_APP_ARGS(args,
|
|
|
|
AST_APP_ARG(endpoint);
|
|
|
|
AST_APP_ARG(aor);
|
|
|
|
);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n",tmp);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (ast_strlen_zero(tmp)) {
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel with empty destination\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
req_data->cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Empty destination\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
AST_NONSTANDARD_APP_ARGS(args, tmp, '/');
|
|
|
|
|
2017-01-13 17:21:36 +00:00
|
|
|
if (ast_sip_get_disable_multi_domain()) {
|
|
|
|
/* If a request user has been specified extract it from the endpoint name portion */
|
|
|
|
if ((endpoint_name = strchr(args.endpoint, '@'))) {
|
|
|
|
request_user = args.endpoint;
|
|
|
|
*endpoint_name++ = '\0';
|
|
|
|
} else {
|
|
|
|
endpoint_name = args.endpoint;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(endpoint_name)) {
|
2017-12-16 01:01:02 +00:00
|
|
|
if (request_user) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel with empty endpoint name: %s@<endpoint-name>\n",
|
|
|
|
request_user);
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel with empty endpoint name\n");
|
|
|
|
}
|
2017-01-13 17:21:36 +00:00
|
|
|
req_data->cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Empty endpoint name\n");
|
2017-12-16 01:01:02 +00:00
|
|
|
}
|
|
|
|
endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
|
|
|
|
endpoint_name);
|
|
|
|
if (!endpoint) {
|
2017-01-13 17:21:36 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel - endpoint '%s' was not found\n", endpoint_name);
|
|
|
|
req_data->cause = AST_CAUSE_NO_ROUTE_DESTINATION;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Endpoint not found\n");
|
2017-01-13 17:21:36 +00:00
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
} else {
|
2017-01-13 17:21:36 +00:00
|
|
|
/* First try to find an exact endpoint match, for single (user) or multi-domain (user@domain) */
|
2013-04-25 18:25:31 +00:00
|
|
|
endpoint_name = args.endpoint;
|
2017-01-13 17:21:36 +00:00
|
|
|
if (ast_strlen_zero(endpoint_name)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel with empty endpoint name\n");
|
|
|
|
req_data->cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Empty endpoint name\n");
|
2017-12-16 01:01:02 +00:00
|
|
|
}
|
|
|
|
endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
|
|
|
|
endpoint_name);
|
|
|
|
if (!endpoint) {
|
2017-01-13 17:21:36 +00:00
|
|
|
/* It seems it's not a multi-domain endpoint or single endpoint exact match,
|
|
|
|
* it's possible that it's a SIP trunk with a specified user (user@trunkname),
|
|
|
|
* so extract the user before @ sign.
|
|
|
|
*/
|
2017-12-16 01:01:02 +00:00
|
|
|
endpoint_name = strchr(args.endpoint, '@');
|
|
|
|
if (!endpoint_name) {
|
|
|
|
/*
|
|
|
|
* Couldn't find an '@' so it had to be an endpoint
|
|
|
|
* name that doesn't exist.
|
|
|
|
*/
|
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel - endpoint '%s' was not found\n",
|
|
|
|
args.endpoint);
|
|
|
|
req_data->cause = AST_CAUSE_NO_ROUTE_DESTINATION;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Endpoint not found\n");
|
2017-01-13 17:21:36 +00:00
|
|
|
}
|
2017-12-16 01:01:02 +00:00
|
|
|
request_user = args.endpoint;
|
|
|
|
*endpoint_name++ = '\0';
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-01-13 17:21:36 +00:00
|
|
|
if (ast_strlen_zero(endpoint_name)) {
|
2017-12-16 01:01:02 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel with empty endpoint name: %s@<endpoint-name>\n",
|
|
|
|
request_user);
|
2017-01-13 17:21:36 +00:00
|
|
|
req_data->cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Empty endpoint name\n");
|
2017-01-13 17:21:36 +00:00
|
|
|
}
|
|
|
|
|
2017-12-16 01:01:02 +00:00
|
|
|
endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
|
|
|
|
endpoint_name);
|
|
|
|
if (!endpoint) {
|
2017-01-13 17:21:36 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to create PJSIP channel - endpoint '%s' was not found\n", endpoint_name);
|
|
|
|
req_data->cause = AST_CAUSE_NO_ROUTE_DESTINATION;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Endpoint not found\n");
|
2017-01-13 17:21:36 +00:00
|
|
|
}
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2017-12-16 01:01:02 +00:00
|
|
|
session = ast_sip_session_create_outgoing(endpoint, NULL, args.aor, request_user,
|
|
|
|
req_data->topology);
|
|
|
|
ao2_ref(endpoint, -1);
|
|
|
|
if (!session) {
|
2014-11-15 21:36:44 +00:00
|
|
|
ast_log(LOG_ERROR, "Failed to create outgoing session to endpoint '%s'\n", endpoint_name);
|
2013-04-25 18:25:31 +00:00
|
|
|
req_data->cause = AST_CAUSE_NO_ROUTE_DESTINATION;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "Couldn't create session\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
req_data->session = session;
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Function called by core to create a new outgoing PJSIP session */
|
2017-05-30 14:12:47 +00:00
|
|
|
static struct ast_channel *chan_pjsip_request_with_stream_topology(const char *type, struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
|
|
|
struct request_data req_data;
|
2013-07-25 00:44:24 +00:00
|
|
|
RAII_VAR(struct ast_sip_session *, session, NULL, ao2_cleanup);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s Topology: %s\n", data,
|
|
|
|
ast_str_tmp(256, ast_stream_topology_to_str(topology, &STR_TMP)));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
req_data.topology = topology;
|
2013-04-25 18:25:31 +00:00
|
|
|
req_data.dest = data;
|
2018-03-27 16:04:42 +00:00
|
|
|
/* Default failure value in case ast_sip_push_task_wait_servant() itself fails. */
|
2017-03-30 01:46:56 +00:00
|
|
|
req_data.cause = AST_CAUSE_FAILURE;
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2018-03-27 16:04:42 +00:00
|
|
|
if (ast_sip_push_task_wait_servant(NULL, request, &req_data)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
*cause = req_data.cause;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't push task\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
session = req_data.session;
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (!(session->channel = chan_pjsip_new(session, AST_STATE_DOWN, NULL, NULL, assignedids, requestor, NULL))) {
|
2013-04-25 18:25:31 +00:00
|
|
|
/* Session needs to be terminated prematurely */
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(NULL, "Couldn't create channel\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(session->channel, "Channel: %s\n", ast_channel_name(session->channel));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2017-05-30 14:12:47 +00:00
|
|
|
static struct ast_channel *chan_pjsip_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
|
|
|
|
{
|
|
|
|
struct ast_stream_topology *topology;
|
|
|
|
struct ast_channel *chan;
|
|
|
|
|
|
|
|
topology = ast_stream_topology_create_from_format_cap(cap);
|
|
|
|
if (!topology) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
chan = chan_pjsip_request_with_stream_topology(type, topology, assignedids, requestor, data, cause);
|
|
|
|
|
|
|
|
ast_stream_topology_free(topology);
|
|
|
|
|
|
|
|
return chan;
|
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
struct sendtext_data {
|
|
|
|
struct ast_sip_session *session;
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
struct ast_msg_data *msg;
|
2013-06-22 14:03:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void sendtext_data_destroy(void *obj)
|
|
|
|
{
|
|
|
|
struct sendtext_data *data = obj;
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
ao2_cleanup(data->session);
|
|
|
|
ast_free(data->msg);
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
static struct sendtext_data* sendtext_data_create(struct ast_channel *chan,
|
|
|
|
struct ast_msg_data *msg)
|
2013-06-22 14:03:22 +00:00
|
|
|
{
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
|
|
|
|
struct sendtext_data *data = ao2_alloc(sizeof(*data), sendtext_data_destroy);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
|
|
|
if (!data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
data->msg = ast_msg_data_dup(msg);
|
|
|
|
if (!data->msg) {
|
|
|
|
ao2_cleanup(data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
data->session = channel->session;
|
2013-06-22 14:03:22 +00:00
|
|
|
ao2_ref(data->session, +1);
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sendtext(void *obj)
|
|
|
|
{
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
struct sendtext_data *data = obj;
|
2013-06-22 14:03:22 +00:00
|
|
|
pjsip_tx_data *tdata;
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
const char *body_text = ast_msg_data_get_attribute(data->msg, AST_MSG_DATA_ATTR_BODY);
|
|
|
|
const char *content_type = ast_msg_data_get_attribute(data->msg, AST_MSG_DATA_ATTR_CONTENT_TYPE);
|
|
|
|
char *sep;
|
|
|
|
struct ast_sip_body body = {
|
2013-06-22 14:03:22 +00:00
|
|
|
.type = "text",
|
|
|
|
.subtype = "plain",
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
.body_text = body_text,
|
2013-06-22 14:03:22 +00:00
|
|
|
};
|
|
|
|
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
if (!ast_strlen_zero(content_type)) {
|
|
|
|
sep = strchr(content_type, '/');
|
|
|
|
if (sep) {
|
|
|
|
*sep = '\0';
|
|
|
|
body.type = content_type;
|
|
|
|
body.subtype = ++sep;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (data->session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
|
|
|
|
ast_log(LOG_ERROR, "Session already DISCONNECTED [reason=%d (%s)]\n",
|
|
|
|
data->session->inv_session->cause,
|
|
|
|
pjsip_get_status_text(data->session->inv_session->cause)->ptr);
|
|
|
|
} else {
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
pjsip_from_hdr *hdr;
|
|
|
|
pjsip_name_addr *name_addr;
|
|
|
|
const char *from = ast_msg_data_get_attribute(data->msg, AST_MSG_DATA_ATTR_FROM);
|
|
|
|
const char *to = ast_msg_data_get_attribute(data->msg, AST_MSG_DATA_ATTR_TO);
|
|
|
|
int invalidate_tdata = 0;
|
2016-10-18 14:04:54 +00:00
|
|
|
|
|
|
|
ast_sip_create_request("MESSAGE", data->session->inv_session->dlg, data->session->endpoint, NULL, NULL, &tdata);
|
|
|
|
ast_sip_add_body(tdata, &body);
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a 'from' in the msg, set the display name in the From
|
|
|
|
* header to it.
|
|
|
|
*/
|
|
|
|
if (!ast_strlen_zero(from)) {
|
|
|
|
hdr = PJSIP_MSG_FROM_HDR(tdata->msg);
|
|
|
|
name_addr = (pjsip_name_addr *) hdr->uri;
|
|
|
|
pj_strdup2(tdata->pool, &name_addr->display, from);
|
|
|
|
invalidate_tdata = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a 'to' in the msg, set the display name in the To
|
|
|
|
* header to it.
|
|
|
|
*/
|
|
|
|
if (!ast_strlen_zero(to)) {
|
|
|
|
hdr = PJSIP_MSG_TO_HDR(tdata->msg);
|
|
|
|
name_addr = (pjsip_name_addr *) hdr->uri;
|
|
|
|
pj_strdup2(tdata->pool, &name_addr->display, to);
|
|
|
|
invalidate_tdata = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (invalidate_tdata) {
|
|
|
|
pjsip_tx_data_invalidate_msg(tdata);
|
|
|
|
}
|
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
ast_sip_send_request(tdata, data->session->inv_session->dlg, data->session->endpoint, NULL, NULL);
|
|
|
|
}
|
2013-10-30 17:54:26 +00:00
|
|
|
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
ao2_cleanup(data);
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Function called by core to send text on PJSIP session */
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
static int chan_pjsip_sendtext_data(struct ast_channel *ast, struct ast_msg_data *msg)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-07-23 12:27:03 +00:00
|
|
|
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast);
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
struct sendtext_data *data = sendtext_data_create(ast, msg);
|
|
|
|
|
|
|
|
ast_debug(1, "Sending MESSAGE from '%s' to '%s:%s': %s\n",
|
|
|
|
ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_FROM),
|
|
|
|
ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_TO),
|
|
|
|
ast_channel_name(ast),
|
|
|
|
ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_BODY));
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2016-10-18 14:04:54 +00:00
|
|
|
if (!data) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_sip_push_task(channel->session->serializer, sendtext, data)) {
|
2013-06-22 14:03:22 +00:00
|
|
|
ao2_ref(data, -1);
|
|
|
|
return -1;
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
bridge_softmix: Forward TEXT frames
Core bridging and, more specifically, bridge_softmix have been
enhanced to relay received frames of type TEXT or TEXT_DATA to all
participants in a softmix bridge. res_pjsip_messaging and
chan_pjsip have been enhanced to take advantage of this so when
res_pjsip_messaging receives an in-dialog MESSAGE message from a
user in a conference call, it's relayed to all other participants
in the call.
res_pjsip_messaging already queues TEXT frames to the channel when
it receives an in-dialog MESSAGE from an endpoint and chan_pjsip
will send an MESSAGE when it gets a TEXT frame. On a normal
point-to-point call, the frames are forwarded between the two
correctly. bridge_softmix was not though so messages weren't
getting forwarded to conference bridge participants. Even if they
were, the bridging code had no way to tell the participants who
sent the message so it would look like it came from the bridge
itself.
* The TEXT frame type doesn't allow storage of any meta data, such
as sender, on the frame so a new TEXT_DATA frame type was added that
uses the new ast_msg_data structure as its payload. A channel
driver can queue a frame of that type when it receives a message
from outside. A channel driver can use it for sending messages
by implementing the new send_text_data channel tech callback and
setting the new AST_CHAN_TP_SEND_TEXT_DATA flag in its tech
properties. If set, the bridging/channel core will use it instead
of the original send_text callback and it will get the ast_msg_data
structure. Channel drivers aren't required to implement this. Even
if a TEXT_DATA enabled driver uses it for incoming messages, an
outgoing channel driver that doesn't will still have it's send_text
callback called with only the message text just as before.
* res_pjsip_messaging now creates a TEXT_DATA frame for incoming
in-dialog messages and sets the "from" to the display name in the
"From" header, or if that's empty, the caller id name from the
channel. This allows the chat client user to set a friendly name
for the chat.
* bridge_softmix now forwards TEXT and TEXT_DATA frames to all
participants (except the sender).
* A new function "ast_sendtext_data" was added to channel which
takes an ast_msg_data structure and calls a channel's
send_text_data callback, or if that's not defined, the original
send_text callback.
* bridge_channel now calls ast_sendtext_data for TEXT_DATA frame
types and ast_sendtext for TEXT frame types.
* chan_pjsip now uses the "from" name in the ast_msg_data structure
(if it exists) to set the "From" header display name on outgoing text
messages.
Change-Id: Idacf5900bfd5f22ab8cd235aa56dfad090d18489
2017-09-27 16:44:53 +00:00
|
|
|
static int chan_pjsip_sendtext(struct ast_channel *ast, const char *text)
|
|
|
|
{
|
|
|
|
struct ast_msg_data *msg;
|
|
|
|
int rc;
|
|
|
|
struct ast_msg_data_attribute attrs[] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
.type = AST_MSG_DATA_ATTR_BODY,
|
|
|
|
.value = (char *)text,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
msg = ast_msg_data_alloc(AST_MSG_DATA_SOURCE_TYPE_UNKNOWN, attrs, ARRAY_LEN(attrs));
|
|
|
|
if (!msg) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
rc = chan_pjsip_sendtext_data(ast, msg);
|
|
|
|
ast_free(msg);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static void chan_pjsip_session_begin(struct ast_sip_session *session)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-30 15:17:56 +00:00
|
|
|
if (session->endpoint->media.direct_media.glare_mitigation ==
|
2013-04-25 18:25:31 +00:00
|
|
|
AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_NONE) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN("Direct media no glare mitigation\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
datastore = ast_sip_session_alloc_datastore(&direct_media_mitigation_info,
|
|
|
|
"direct_media_glare_mitigation");
|
|
|
|
|
|
|
|
if (!datastore) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN("Couldn't create datastore\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ast_sip_session_add_datastore(session, datastore);
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN();
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called when the session ends */
|
2013-07-30 18:14:50 +00:00
|
|
|
static void chan_pjsip_session_end(struct ast_sip_session *session)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!session->channel) {
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN("No channel\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2022-10-28 10:57:56 +00:00
|
|
|
|
|
|
|
if (session->active_media_state &&
|
|
|
|
session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO]) {
|
|
|
|
struct ast_sip_session_media *media =
|
|
|
|
session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
|
|
|
|
if (media->rtp) {
|
|
|
|
ast_rtp_instance_set_stats_vars(session->channel, media->rtp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-20 18:18:25 +00:00
|
|
|
chan_pjsip_remove_hold(ast_channel_uniqueid(session->channel));
|
|
|
|
|
2014-07-07 01:22:44 +00:00
|
|
|
ast_set_hangupsource(session->channel, ast_channel_name(session->channel), 0);
|
2013-04-25 18:25:31 +00:00
|
|
|
if (!ast_channel_hangupcause(session->channel) && session->inv_session) {
|
2022-11-18 02:16:50 +00:00
|
|
|
int cause = ast_sip_hangup_sip2cause(session->inv_session->cause);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
ast_queue_hangup_with_cause(session->channel, cause);
|
|
|
|
} else {
|
|
|
|
ast_queue_hangup(session->channel);
|
|
|
|
}
|
2020-07-06 19:23:24 +00:00
|
|
|
|
|
|
|
SCOPE_EXIT_RTN();
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2020-12-29 18:16:00 +00:00
|
|
|
static void set_sipdomain_variable(struct ast_sip_session *session)
|
|
|
|
{
|
2022-08-02 17:15:36 +00:00
|
|
|
const pj_str_t *host = ast_sip_pjsip_uri_get_hostname(session->request_uri);
|
|
|
|
size_t size = pj_strlen(host) + 1;
|
2020-12-29 18:16:00 +00:00
|
|
|
char *domain = ast_alloca(size);
|
|
|
|
|
2022-08-02 17:15:36 +00:00
|
|
|
ast_copy_pj_str(domain, host, size);
|
2020-12-29 18:16:00 +00:00
|
|
|
|
|
|
|
pbx_builtin_setvar_helper(session->channel, "SIPDOMAIN", domain);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called when a request is received on the session */
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2013-12-11 13:06:30 +00:00
|
|
|
RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
|
|
|
|
struct transport_info_data *transport_data;
|
2013-04-25 18:25:31 +00:00
|
|
|
pjsip_tx_data *packet = NULL;
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (session->channel) {
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s: No channel\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2015-10-05 21:53:44 +00:00
|
|
|
/* Check for a to-tag to determine if this is a reinvite */
|
|
|
|
if (rdata->msg_info.to->tag.slen) {
|
2015-01-16 22:13:23 +00:00
|
|
|
/* Weird case. We've received a reinvite but we don't have a channel. The most
|
|
|
|
* typical case for this happening is that a blind transfer fails, and so the
|
|
|
|
* transferer attempts to reinvite himself back into the call. We already got
|
|
|
|
* rid of that channel, and the other side of the call is unrecoverable.
|
|
|
|
*
|
|
|
|
* We treat this as a failure, so our best bet is to just hang this call
|
|
|
|
* up and not create a new channel. Clearing defer_terminate here ensures that
|
|
|
|
* calling ast_sip_session_terminate() can result in a BYE being sent ASAP.
|
|
|
|
*/
|
|
|
|
session->defer_terminate = 0;
|
|
|
|
ast_sip_session_terminate(session, 400);
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(-1, "%s: We have a To tag but no channel. Terminating session\n", ast_sip_session_get_name(session));
|
2015-01-16 22:13:23 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 13:06:30 +00:00
|
|
|
datastore = ast_sip_session_alloc_datastore(&transport_info, "transport_info");
|
|
|
|
if (!datastore) {
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Couldn't alloc transport_info datastore\n", ast_sip_session_get_name(session));
|
2013-12-11 13:06:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
transport_data = ast_calloc(1, sizeof(*transport_data));
|
|
|
|
if (!transport_data) {
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Couldn't alloc transport_info\n", ast_sip_session_get_name(session));
|
2013-12-11 13:06:30 +00:00
|
|
|
}
|
|
|
|
pj_sockaddr_cp(&transport_data->local_addr, &rdata->tp_info.transport->local_addr);
|
|
|
|
pj_sockaddr_cp(&transport_data->remote_addr, &rdata->pkt_info.src_addr);
|
|
|
|
datastore->data = transport_data;
|
|
|
|
ast_sip_session_add_datastore(session, datastore);
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (!(session->channel = chan_pjsip_new(session, AST_STATE_RING, session->exten, NULL, NULL, NULL, NULL))) {
|
2016-06-22 23:02:59 +00:00
|
|
|
if (pjsip_inv_end_session(session->inv_session, 503, NULL, &packet) == PJ_SUCCESS
|
|
|
|
&& packet) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_sip_session_send_response(session, packet);
|
|
|
|
}
|
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_ERROR, "%s: Failed to allocate new PJSIP channel on incoming SIP INVITE\n",
|
|
|
|
ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
2020-12-29 18:16:00 +00:00
|
|
|
|
|
|
|
set_sipdomain_variable(session);
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
/* channel gets created on incoming request, but we wait to call start
|
|
|
|
so other supplements have a chance to run */
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s\n", ast_sip_session_get_name(session));
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
2014-04-30 12:32:12 +00:00
|
|
|
static int call_pickup_incoming_request(struct ast_sip_session *session, pjsip_rx_data *rdata)
|
|
|
|
{
|
2015-01-30 16:49:59 +00:00
|
|
|
struct ast_features_pickup_config *pickup_cfg;
|
2014-04-30 12:32:12 +00:00
|
|
|
struct ast_channel *chan;
|
|
|
|
|
2015-10-05 21:53:44 +00:00
|
|
|
/* Check for a to-tag to determine if this is a reinvite */
|
|
|
|
if (rdata->msg_info.to->tag.slen) {
|
|
|
|
/* We don't care about reinvites */
|
2014-09-02 20:29:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-30 16:49:59 +00:00
|
|
|
pickup_cfg = ast_get_chan_features_pickup_config(session->channel);
|
2014-04-30 12:32:12 +00:00
|
|
|
if (!pickup_cfg) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to retrieve pickup configuration options. Unable to detect call pickup extension.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(session->exten, pickup_cfg->pickupexten)) {
|
|
|
|
ao2_ref(pickup_cfg, -1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
ao2_ref(pickup_cfg, -1);
|
|
|
|
|
|
|
|
/* We can't directly use session->channel because the pickup operation will cause a masquerade to occur,
|
|
|
|
* changing the channel pointer in session to a different channel. To ensure we work on the right channel
|
|
|
|
* we store a pointer locally before we begin and keep a reference so it remains valid no matter what.
|
|
|
|
*/
|
|
|
|
chan = ast_channel_ref(session->channel);
|
|
|
|
if (ast_pickup_call(chan)) {
|
|
|
|
ast_channel_hangupcause_set(chan, AST_CAUSE_CALL_REJECTED);
|
|
|
|
} else {
|
|
|
|
ast_channel_hangupcause_set(chan, AST_CAUSE_NORMAL_CLEARING);
|
|
|
|
}
|
|
|
|
/* A hangup always occurs because the pickup operation will have either failed resulting in the call
|
|
|
|
* needing to be hung up OR the pickup operation was a success and the channel we now have is actually
|
|
|
|
* the channel that was replaced, which should be hung up since it is literally in limbo not connected
|
|
|
|
* to anything at all.
|
|
|
|
*/
|
|
|
|
ast_hangup(chan);
|
|
|
|
ast_channel_unref(chan);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_sip_session_supplement call_pickup_supplement = {
|
|
|
|
.method = "INVITE",
|
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_LAST - 1,
|
|
|
|
.incoming_request = call_pickup_incoming_request,
|
|
|
|
};
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
static int pbx_start_incoming_request(struct ast_sip_session *session, pjsip_rx_data *rdata)
|
|
|
|
{
|
|
|
|
int res;
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_ENTER(1, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2015-10-05 21:53:44 +00:00
|
|
|
/* Check for a to-tag to determine if this is a reinvite */
|
|
|
|
if (rdata->msg_info.to->tag.slen) {
|
|
|
|
/* We don't care about reinvites */
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "Reinvite\n");
|
2014-09-02 20:29:58 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
res = ast_pbx_start(session->channel);
|
|
|
|
|
|
|
|
switch (res) {
|
|
|
|
case AST_PBX_FAILED:
|
|
|
|
ast_log(LOG_WARNING, "Failed to start PBX ;(\n");
|
|
|
|
ast_channel_hangupcause_set(session->channel, AST_CAUSE_SWITCH_CONGESTION);
|
|
|
|
ast_hangup(session->channel);
|
|
|
|
break;
|
|
|
|
case AST_PBX_CALL_LIMIT:
|
|
|
|
ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
|
|
|
|
ast_channel_hangupcause_set(session->channel, AST_CAUSE_SWITCH_CONGESTION);
|
|
|
|
ast_hangup(session->channel);
|
|
|
|
break;
|
|
|
|
case AST_PBX_SUCCESS:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_debug(3, "Started PBX on new PJSIP channel %s\n", ast_channel_name(session->channel));
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2020-07-06 19:23:24 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE((res == AST_PBX_SUCCESS) ? 0 : -1, "RC: %d\n", res);
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
static struct ast_sip_session_supplement pbx_start_supplement = {
|
|
|
|
.method = "INVITE",
|
2014-01-15 13:16:10 +00:00
|
|
|
.priority = AST_SIP_SUPPLEMENT_PRIORITY_LAST,
|
2013-06-22 14:03:22 +00:00
|
|
|
.incoming_request = pbx_start_incoming_request,
|
|
|
|
};
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*! \brief Function called when a response is received on the session */
|
2020-12-31 11:53:34 +00:00
|
|
|
static void chan_pjsip_incoming_response_update_cause(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
|
|
|
struct pjsip_status_line status = rdata->msg_info.msg->line.status;
|
2014-07-07 01:22:44 +00:00
|
|
|
struct ast_control_pvt_cause_code *cause_code;
|
|
|
|
int data_size = sizeof(*cause_code);
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s: Status: %d\n", ast_sip_session_get_name(session), status.code);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
if (!session->channel) {
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN("%s: No channel\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2016-09-22 06:40:45 +00:00
|
|
|
/* Build and send the tech-specific cause information */
|
|
|
|
/* size of the string making up the cause code is "SIP " number + " " + reason length */
|
|
|
|
data_size += 4 + 4 + pj_strlen(&status.reason);
|
|
|
|
cause_code = ast_alloca(data_size);
|
|
|
|
memset(cause_code, 0, data_size);
|
|
|
|
|
|
|
|
ast_copy_string(cause_code->chan_name, ast_channel_name(session->channel), AST_CHANNEL_NAME);
|
|
|
|
|
|
|
|
snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "SIP %d %.*s", status.code,
|
|
|
|
(int) pj_strlen(&status.reason), pj_strbuf(&status.reason));
|
|
|
|
|
2022-11-18 02:16:50 +00:00
|
|
|
cause_code->ast_cause = ast_sip_hangup_sip2cause(status.code);
|
2016-09-22 06:40:45 +00:00
|
|
|
ast_queue_control_data(session->channel, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
|
|
|
|
ast_channel_hangupcause_hash_set(session->channel, cause_code, data_size);
|
|
|
|
|
2020-12-31 11:53:34 +00:00
|
|
|
SCOPE_EXIT_RTN("%s\n", ast_sip_session_get_name(session));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Function called when a response is received on the session */
|
|
|
|
static void chan_pjsip_incoming_response(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
|
|
|
{
|
|
|
|
struct pjsip_status_line status = rdata->msg_info.msg->line.status;
|
|
|
|
SCOPE_ENTER(3, "%s: Status: %d\n", ast_sip_session_get_name(session), status.code);
|
|
|
|
|
|
|
|
if (!session->channel) {
|
|
|
|
SCOPE_EXIT_RTN("%s: No channel\n", ast_sip_session_get_name(session));
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
switch (status.code) {
|
2021-01-07 14:25:05 +00:00
|
|
|
case 180: {
|
|
|
|
pjsip_rdata_sdp_info *sdp = pjsip_rdata_get_sdp_info(rdata);
|
|
|
|
if (sdp && sdp->body.ptr) {
|
|
|
|
ast_trace(-1, "%s: Queueing PROGRESS\n", ast_sip_session_get_name(session));
|
2023-05-25 15:14:47 +00:00
|
|
|
session->early_confirmed = pjsip_100rel_is_reliable(rdata) == PJ_TRUE;
|
2021-01-07 14:25:05 +00:00
|
|
|
ast_queue_control(session->channel, AST_CONTROL_PROGRESS);
|
|
|
|
} else {
|
|
|
|
ast_trace(-1, "%s: Queueing RINGING\n", ast_sip_session_get_name(session));
|
|
|
|
ast_queue_control(session->channel, AST_CONTROL_RINGING);
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:33:37 +00:00
|
|
|
ast_channel_lock(session->channel);
|
2013-04-25 18:25:31 +00:00
|
|
|
if (ast_channel_state(session->channel) != AST_STATE_UP) {
|
|
|
|
ast_setstate(session->channel, AST_STATE_RINGING);
|
|
|
|
}
|
2013-12-18 20:33:37 +00:00
|
|
|
ast_channel_unlock(session->channel);
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
2021-01-07 14:25:05 +00:00
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
case 183:
|
2019-03-04 07:50:18 +00:00
|
|
|
if (session->endpoint->ignore_183_without_sdp) {
|
|
|
|
pjsip_rdata_sdp_info *sdp = pjsip_rdata_get_sdp_info(rdata);
|
|
|
|
if (sdp && sdp->body.ptr) {
|
2021-05-13 02:20:23 +00:00
|
|
|
ast_trace(-1, "%s: Queueing PROGRESS\n", ast_sip_session_get_name(session));
|
2020-07-06 19:23:24 +00:00
|
|
|
ast_trace(1, "%s Method: %.*s Status: %d Queueing PROGRESS with SDP\n", ast_sip_session_get_name(session),
|
|
|
|
(int)rdata->msg_info.cseq->method.name.slen, rdata->msg_info.cseq->method.name.ptr, status.code);
|
2023-05-25 15:14:47 +00:00
|
|
|
session->early_confirmed = pjsip_100rel_is_reliable(rdata) == PJ_TRUE;
|
2019-03-04 07:50:18 +00:00
|
|
|
ast_queue_control(session->channel, AST_CONTROL_PROGRESS);
|
|
|
|
}
|
|
|
|
} else {
|
2021-05-13 02:20:23 +00:00
|
|
|
ast_trace(-1, "%s: Queueing PROGRESS\n", ast_sip_session_get_name(session));
|
2020-07-06 19:23:24 +00:00
|
|
|
ast_trace(1, "%s Method: %.*s Status: %d Queueing PROGRESS without SDP\n", ast_sip_session_get_name(session),
|
|
|
|
(int)rdata->msg_info.cseq->method.name.slen, rdata->msg_info.cseq->method.name.ptr, status.code);
|
2019-03-04 07:50:18 +00:00
|
|
|
ast_queue_control(session->channel, AST_CONTROL_PROGRESS);
|
|
|
|
}
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
case 200:
|
2020-08-20 20:09:25 +00:00
|
|
|
ast_trace(-1, "%s: Queueing ANSWER\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_queue_control(session->channel, AST_CONTROL_ANSWER);
|
|
|
|
break;
|
|
|
|
default:
|
2020-08-20 20:09:25 +00:00
|
|
|
ast_trace(-1, "%s: Not queueing anything\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-07-06 19:23:24 +00:00
|
|
|
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN("%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
static int chan_pjsip_incoming_ack(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
2013-04-25 18:25:31 +00:00
|
|
|
{
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
|
2020-07-06 19:23:24 +00:00
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
if (rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD) {
|
2013-10-26 12:56:08 +00:00
|
|
|
if (session->endpoint->media.direct_media.enabled && session->channel) {
|
2020-08-20 20:09:25 +00:00
|
|
|
ast_trace(-1, "%s: Queueing SRCCHANGE\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_queue_control(session->channel, AST_CONTROL_SRCCHANGE);
|
|
|
|
}
|
|
|
|
}
|
2020-08-20 20:09:25 +00:00
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s\n", ast_sip_session_get_name(session));
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2023-05-25 15:14:47 +00:00
|
|
|
static int chan_pjsip_incoming_prack(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
|
|
|
{
|
|
|
|
SCOPE_ENTER(3, "%s\n", ast_sip_session_get_name(session));
|
|
|
|
|
|
|
|
if (pj_strcmp2(&rdata->msg_info.msg->line.req.method.name, "PRACK") == 0 &&
|
|
|
|
pjmedia_sdp_neg_get_state(session->inv_session->neg) == PJMEDIA_SDP_NEG_STATE_DONE) {
|
|
|
|
|
|
|
|
session->early_confirmed = 1;
|
|
|
|
}
|
|
|
|
SCOPE_EXIT_RTN_VALUE(0, "%s\n", ast_sip_session_get_name(session));
|
|
|
|
}
|
|
|
|
|
2014-01-16 16:46:00 +00:00
|
|
|
static int update_devstate(void *obj, void *arg, int flags)
|
|
|
|
{
|
|
|
|
ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE,
|
|
|
|
"PJSIP/%s", ast_sorcery_object_get_id(obj));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-11 13:06:30 +00:00
|
|
|
static struct ast_custom_function chan_pjsip_dial_contacts_function = {
|
|
|
|
.name = "PJSIP_DIAL_CONTACTS",
|
|
|
|
.read = pjsip_acf_dial_contacts_read,
|
|
|
|
};
|
|
|
|
|
2018-11-13 15:28:28 +00:00
|
|
|
static struct ast_custom_function chan_pjsip_parse_uri_function = {
|
|
|
|
.name = "PJSIP_PARSE_URI",
|
|
|
|
.read = pjsip_acf_parse_uri_read,
|
|
|
|
};
|
|
|
|
|
2013-12-11 13:06:30 +00:00
|
|
|
static struct ast_custom_function media_offer_function = {
|
|
|
|
.name = "PJSIP_MEDIA_OFFER",
|
|
|
|
.read = pjsip_acf_media_offer_read,
|
|
|
|
.write = pjsip_acf_media_offer_write
|
|
|
|
};
|
|
|
|
|
2017-06-26 12:52:52 +00:00
|
|
|
static struct ast_custom_function dtmf_mode_function = {
|
|
|
|
.name = "PJSIP_DTMF_MODE",
|
|
|
|
.read = pjsip_acf_dtmf_mode_read,
|
|
|
|
.write = pjsip_acf_dtmf_mode_write
|
|
|
|
};
|
|
|
|
|
2019-09-19 08:56:26 +00:00
|
|
|
static struct ast_custom_function moh_passthrough_function = {
|
|
|
|
.name = "PJSIP_MOH_PASSTHROUGH",
|
|
|
|
.read = pjsip_acf_moh_passthrough_read,
|
|
|
|
.write = pjsip_acf_moh_passthrough_write
|
|
|
|
};
|
|
|
|
|
2016-08-07 14:58:59 +00:00
|
|
|
static struct ast_custom_function session_refresh_function = {
|
|
|
|
.name = "PJSIP_SEND_SESSION_REFRESH",
|
|
|
|
.write = pjsip_acf_session_refresh_write,
|
|
|
|
};
|
|
|
|
|
2023-10-31 21:08:14 +00:00
|
|
|
static char *app_pjsip_hangup = "PJSIPHangup";
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
/*!
|
|
|
|
* \brief Load the module
|
|
|
|
*
|
|
|
|
* Module loading including tests for configuration or dependencies.
|
|
|
|
* This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
|
|
|
|
* or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
|
2013-07-05 17:33:33 +00:00
|
|
|
* tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
|
|
|
|
* configuration file or other non-critical problem return
|
2013-04-25 18:25:31 +00:00
|
|
|
* AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
|
|
|
|
*/
|
|
|
|
static int load_module(void)
|
|
|
|
{
|
2014-01-16 16:46:00 +00:00
|
|
|
struct ao2_container *endpoints;
|
|
|
|
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
if (!(chan_pjsip_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
2013-04-25 18:25:31 +00:00
|
|
|
return AST_MODULE_LOAD_DECLINE;
|
|
|
|
}
|
|
|
|
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ast_format_cap_append_by_type(chan_pjsip_tech.capabilities, AST_MEDIA_TYPE_AUDIO);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_rtp_glue_register(&chan_pjsip_rtp_glue);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
if (ast_channel_register(&chan_pjsip_tech)) {
|
2013-04-25 18:25:31 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to register channel class %s\n", channel_type);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
if (ast_custom_function_register(&chan_pjsip_dial_contacts_function)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to register PJSIP_DIAL_CONTACTS dialplan function\n");
|
2013-04-25 18:25:31 +00:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2018-11-13 15:28:28 +00:00
|
|
|
if (ast_custom_function_register(&chan_pjsip_parse_uri_function)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to register PJSIP_PARSE_URI dialplan function\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2013-06-22 14:03:22 +00:00
|
|
|
if (ast_custom_function_register(&media_offer_function)) {
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_log(LOG_WARNING, "Unable to register PJSIP_MEDIA_OFFER dialplan function\n");
|
2013-12-11 13:06:30 +00:00
|
|
|
goto end;
|
2013-06-22 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
2017-06-26 12:52:52 +00:00
|
|
|
if (ast_custom_function_register(&dtmf_mode_function)) {
|
|
|
|
ast_log(LOG_WARNING, "Unable to register PJSIP_DTMF_MODE dialplan function\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2019-09-19 08:56:26 +00:00
|
|
|
if (ast_custom_function_register(&moh_passthrough_function)) {
|
|
|
|
ast_log(LOG_WARNING, "Unable to register PJSIP_MOH_PASSTHROUGH dialplan function\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2016-08-07 14:58:59 +00:00
|
|
|
if (ast_custom_function_register(&session_refresh_function)) {
|
|
|
|
ast_log(LOG_WARNING, "Unable to register PJSIP_SEND_SESSION_REFRESH dialplan function\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2023-10-31 21:08:14 +00:00
|
|
|
if (ast_register_application_xml(app_pjsip_hangup, pjsip_app_hangup)) {
|
|
|
|
ast_log(LOG_WARNING, "Unable to register PJSIPHangup dialplan application\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
ast_manager_register_xml(app_pjsip_hangup, EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL, pjsip_action_hangup);
|
|
|
|
|
|
|
|
|
2019-04-02 19:42:44 +00:00
|
|
|
ast_sip_register_service(&refer_callback_module);
|
|
|
|
|
2017-12-29 08:57:17 +00:00
|
|
|
ast_sip_session_register_supplement(&chan_pjsip_supplement);
|
2018-06-07 13:46:03 +00:00
|
|
|
ast_sip_session_register_supplement(&chan_pjsip_supplement_response);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2014-01-20 18:18:25 +00:00
|
|
|
if (!(pjsip_uids_onhold = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK,
|
|
|
|
AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, 37, uid_hold_hash_fn,
|
|
|
|
uid_hold_sort_fn, NULL))) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to create held channels container\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2017-12-29 08:57:17 +00:00
|
|
|
ast_sip_session_register_supplement(&call_pickup_supplement);
|
|
|
|
ast_sip_session_register_supplement(&pbx_start_supplement);
|
|
|
|
ast_sip_session_register_supplement(&chan_pjsip_ack_supplement);
|
2023-05-25 15:14:47 +00:00
|
|
|
ast_sip_session_register_supplement(&chan_pjsip_prack_supplement);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2016-03-27 03:33:14 +00:00
|
|
|
if (pjsip_channel_cli_register()) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to register PJSIP Channel CLI\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2014-01-16 16:46:00 +00:00
|
|
|
/* since endpoints are loaded before the channel driver their device
|
|
|
|
states get set to 'invalid', so they need to be updated */
|
|
|
|
if ((endpoints = ast_sip_get_endpoints())) {
|
|
|
|
ao2_callback(endpoints, OBJ_NODATA, update_devstate, NULL);
|
|
|
|
ao2_ref(endpoints, -1);
|
|
|
|
}
|
|
|
|
|
2013-04-25 18:25:31 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
end:
|
2014-01-20 18:18:25 +00:00
|
|
|
ao2_cleanup(pjsip_uids_onhold);
|
|
|
|
pjsip_uids_onhold = NULL;
|
2018-06-07 13:46:03 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_ack_supplement);
|
2023-05-25 15:14:47 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_prack_supplement);
|
2018-06-07 13:46:03 +00:00
|
|
|
ast_sip_session_unregister_supplement(&pbx_start_supplement);
|
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_supplement_response);
|
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_supplement);
|
|
|
|
ast_sip_session_unregister_supplement(&call_pickup_supplement);
|
2019-04-02 19:42:44 +00:00
|
|
|
ast_sip_unregister_service(&refer_callback_module);
|
2017-06-26 12:52:52 +00:00
|
|
|
ast_custom_function_unregister(&dtmf_mode_function);
|
2019-09-19 08:56:26 +00:00
|
|
|
ast_custom_function_unregister(&moh_passthrough_function);
|
2013-06-22 14:03:22 +00:00
|
|
|
ast_custom_function_unregister(&media_offer_function);
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_custom_function_unregister(&chan_pjsip_dial_contacts_function);
|
2018-11-13 15:28:28 +00:00
|
|
|
ast_custom_function_unregister(&chan_pjsip_parse_uri_function);
|
2016-08-07 14:58:59 +00:00
|
|
|
ast_custom_function_unregister(&session_refresh_function);
|
2023-10-31 21:08:14 +00:00
|
|
|
ast_unregister_application(app_pjsip_hangup);
|
|
|
|
ast_manager_unregister(app_pjsip_hangup);
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_channel_unregister(&chan_pjsip_tech);
|
|
|
|
ast_rtp_glue_unregister(&chan_pjsip_rtp_glue);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
2017-04-11 16:07:39 +00:00
|
|
|
return AST_MODULE_LOAD_DECLINE;
|
2013-04-25 18:25:31 +00:00
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
/*! \brief Unload the PJSIP channel from Asterisk */
|
2013-04-25 18:25:31 +00:00
|
|
|
static int unload_module(void)
|
|
|
|
{
|
2014-01-20 18:18:25 +00:00
|
|
|
ao2_cleanup(pjsip_uids_onhold);
|
|
|
|
pjsip_uids_onhold = NULL;
|
|
|
|
|
2016-03-27 03:33:14 +00:00
|
|
|
pjsip_channel_cli_unregister();
|
|
|
|
|
2018-06-07 13:46:03 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_supplement_response);
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_supplement);
|
2013-06-22 14:03:22 +00:00
|
|
|
ast_sip_session_unregister_supplement(&pbx_start_supplement);
|
2013-09-20 16:18:42 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_ack_supplement);
|
2023-05-25 15:14:47 +00:00
|
|
|
ast_sip_session_unregister_supplement(&chan_pjsip_prack_supplement);
|
2014-04-30 12:32:12 +00:00
|
|
|
ast_sip_session_unregister_supplement(&call_pickup_supplement);
|
2013-06-22 14:03:22 +00:00
|
|
|
|
2019-04-02 19:42:44 +00:00
|
|
|
ast_sip_unregister_service(&refer_callback_module);
|
|
|
|
|
2017-06-26 12:52:52 +00:00
|
|
|
ast_custom_function_unregister(&dtmf_mode_function);
|
2019-09-19 08:56:26 +00:00
|
|
|
ast_custom_function_unregister(&moh_passthrough_function);
|
2013-12-11 13:06:30 +00:00
|
|
|
ast_custom_function_unregister(&media_offer_function);
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_custom_function_unregister(&chan_pjsip_dial_contacts_function);
|
2018-11-13 15:28:28 +00:00
|
|
|
ast_custom_function_unregister(&chan_pjsip_parse_uri_function);
|
2016-08-07 14:58:59 +00:00
|
|
|
ast_custom_function_unregister(&session_refresh_function);
|
2023-10-31 21:08:14 +00:00
|
|
|
ast_unregister_application(app_pjsip_hangup);
|
|
|
|
ast_manager_unregister(app_pjsip_hangup);
|
2013-12-11 13:06:30 +00:00
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_channel_unregister(&chan_pjsip_tech);
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
ao2_ref(chan_pjsip_tech.capabilities, -1);
|
2013-07-30 18:14:50 +00:00
|
|
|
ast_rtp_glue_unregister(&chan_pjsip_rtp_glue);
|
2013-04-25 18:25:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-30 18:14:50 +00:00
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Channel Driver",
|
2015-05-06 00:49:04 +00:00
|
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
|
|
|
.load = load_module,
|
|
|
|
.unload = unload_module,
|
|
|
|
.load_pri = AST_MODPRI_CHANNEL_DRIVER,
|
2019-04-02 19:42:44 +00:00
|
|
|
.requires = "res_pjsip,res_pjsip_session,res_pjsip_pubsub",
|
2015-05-06 00:49:04 +00:00
|
|
|
);
|