Merge "res_pjsip_sdp_rtp.c: Fix cut-n-paste error"
[asterisk/asterisk.git] / res / res_pjsip_sdp_rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  * Kevin Harwell <kharwell@digium.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19
20 /*! \file
21  *
22  * \author Joshua Colp <jcolp@digium.com>
23  *
24  * \brief SIP SDP media stream handling
25  */
26
27 /*** MODULEINFO
28         <depend>pjproject</depend>
29         <depend>res_pjsip</depend>
30         <depend>res_pjsip_session</depend>
31         <support_level>core</support_level>
32  ***/
33
34 #include "asterisk.h"
35
36 #include <pjsip.h>
37 #include <pjsip_ua.h>
38 #include <pjmedia.h>
39 #include <pjlib.h>
40
41 #include "asterisk/utils.h"
42 #include "asterisk/module.h"
43 #include "asterisk/format.h"
44 #include "asterisk/format_cap.h"
45 #include "asterisk/rtp_engine.h"
46 #include "asterisk/netsock2.h"
47 #include "asterisk/channel.h"
48 #include "asterisk/causes.h"
49 #include "asterisk/sched.h"
50 #include "asterisk/acl.h"
51 #include "asterisk/sdp_srtp.h"
52 #include "asterisk/dsp.h"
53 #include "asterisk/linkedlists.h"       /* for AST_LIST_NEXT */
54
55 #include "asterisk/res_pjsip.h"
56 #include "asterisk/res_pjsip_session.h"
57
58 /*! \brief Scheduler for RTCP purposes */
59 static struct ast_sched_context *sched;
60
61 /*! \brief Address for RTP */
62 static struct ast_sockaddr address_rtp;
63
64 static const char STR_AUDIO[] = "audio";
65 static const int FD_AUDIO = 0;
66
67 static const char STR_VIDEO[] = "video";
68 static const int FD_VIDEO = 2;
69
70 /*! \brief Retrieves an ast_format_type based on the given stream_type */
71 static enum ast_media_type stream_to_media_type(const char *stream_type)
72 {
73         if (!strcasecmp(stream_type, STR_AUDIO)) {
74                 return AST_MEDIA_TYPE_AUDIO;
75         } else if (!strcasecmp(stream_type, STR_VIDEO)) {
76                 return AST_MEDIA_TYPE_VIDEO;
77         }
78
79         return 0;
80 }
81
82 /*! \brief Get the starting descriptor for a media type */
83 static int media_type_to_fdno(enum ast_media_type media_type)
84 {
85         switch (media_type) {
86         case AST_MEDIA_TYPE_AUDIO: return FD_AUDIO;
87         case AST_MEDIA_TYPE_VIDEO: return FD_VIDEO;
88         case AST_MEDIA_TYPE_TEXT:
89         case AST_MEDIA_TYPE_UNKNOWN:
90         case AST_MEDIA_TYPE_IMAGE:
91         case AST_MEDIA_TYPE_END: break;
92         }
93         return -1;
94 }
95
96 /*! \brief Remove all other cap types but the one given */
97 static void format_cap_only_type(struct ast_format_cap *caps, enum ast_media_type media_type)
98 {
99         int i = 0;
100         while (i <= AST_MEDIA_TYPE_TEXT) {
101                 if (i != media_type && i != AST_MEDIA_TYPE_UNKNOWN) {
102                         ast_format_cap_remove_by_type(caps, i);
103                 }
104                 i += 1;
105         }
106 }
107
108 static int send_keepalive(const void *data)
109 {
110         struct ast_sip_session_media *session_media = (struct ast_sip_session_media *) data;
111         struct ast_rtp_instance *rtp = session_media->rtp;
112         int keepalive;
113         time_t interval;
114         int send_keepalive;
115
116         if (!rtp) {
117                 return 0;
118         }
119
120         keepalive = ast_rtp_instance_get_keepalive(rtp);
121
122         if (!ast_sockaddr_isnull(&session_media->direct_media_addr)) {
123                 ast_debug(3, "Not sending RTP keepalive on RTP instance %p since direct media is in use\n", rtp);
124                 return keepalive * 1000;
125         }
126
127         interval = time(NULL) - ast_rtp_instance_get_last_tx(rtp);
128         send_keepalive = interval >= keepalive;
129
130         ast_debug(3, "It has been %d seconds since RTP was last sent on instance %p. %sending keepalive\n",
131                         (int) interval, rtp, send_keepalive ? "S" : "Not s");
132
133         if (send_keepalive) {
134                 ast_rtp_instance_sendcng(rtp, 0);
135                 return keepalive * 1000;
136         }
137
138         return (keepalive - interval) * 1000;
139 }
140
141 /*! \brief Check whether RTP is being received or not */
142 static int rtp_check_timeout(const void *data)
143 {
144         struct ast_sip_session_media *session_media = (struct ast_sip_session_media *)data;
145         struct ast_rtp_instance *rtp = session_media->rtp;
146         int elapsed;
147         struct ast_channel *chan;
148
149         if (!rtp) {
150                 return 0;
151         }
152
153         elapsed = time(NULL) - ast_rtp_instance_get_last_rx(rtp);
154         if (elapsed < ast_rtp_instance_get_timeout(rtp)) {
155                 return (ast_rtp_instance_get_timeout(rtp) - elapsed) * 1000;
156         }
157
158         chan = ast_channel_get_by_name(ast_rtp_instance_get_channel_id(rtp));
159         if (!chan) {
160                 return 0;
161         }
162
163         ast_log(LOG_NOTICE, "Disconnecting channel '%s' for lack of RTP activity in %d seconds\n",
164                 ast_channel_name(chan), elapsed);
165
166         ast_softhangup(chan, AST_SOFTHANGUP_DEV);
167         ast_channel_unref(chan);
168
169         return 0;
170 }
171
172 /*!
173  * \brief Enable RTCP on an RTP session.
174  */
175 static void enable_rtcp(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
176         const struct pjmedia_sdp_media *remote_media)
177 {
178         enum ast_rtp_instance_rtcp rtcp_type;
179
180         if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux) {
181                 rtcp_type = AST_RTP_INSTANCE_RTCP_MUX;
182         } else {
183                 rtcp_type = AST_RTP_INSTANCE_RTCP_STANDARD;
184         }
185
186         ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_RTCP, rtcp_type);
187 }
188
189 /*! \brief Internal function which creates an RTP instance */
190 static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
191 {
192         struct ast_rtp_engine_ice *ice;
193         struct ast_sockaddr temp_media_address;
194         struct ast_sockaddr *media_address =  &address_rtp;
195
196         if (session->endpoint->media.bind_rtp_to_media_address && !ast_strlen_zero(session->endpoint->media.address)) {
197                 ast_sockaddr_parse(&temp_media_address, session->endpoint->media.address, 0);
198                 media_address = &temp_media_address;
199         } else {
200                 struct ast_sip_transport *transport =
201                         ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport",
202                                                                            session->endpoint->transport);
203
204                 if (transport && transport->state) {
205                         char hoststr[PJ_INET6_ADDRSTRLEN];
206
207                         pj_sockaddr_print(&transport->state->host, hoststr, sizeof(hoststr), 0);
208                         ast_debug(1, "Transport: %s bound to host: %s, using this for media.\n",
209                                           session->endpoint->transport, hoststr);
210                         ast_sockaddr_parse(media_address, hoststr, 0);
211                 }
212                 ao2_cleanup(transport);
213         }
214
215         if (!(session_media->rtp = ast_rtp_instance_new(session->endpoint->media.rtp.engine, sched, media_address, NULL))) {
216                 ast_log(LOG_ERROR, "Unable to create RTP instance using RTP engine '%s'\n", session->endpoint->media.rtp.engine);
217                 return -1;
218         }
219
220         ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_NAT, session->endpoint->media.rtp.symmetric);
221
222         if (!session->endpoint->media.rtp.ice_support && (ice = ast_rtp_instance_get_ice(session_media->rtp))) {
223                 ice->stop(session_media->rtp);
224         }
225
226         if (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) {
227                 ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_RFC2833);
228                 ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_DTMF, 1);
229         } else if (session->endpoint->dtmf == AST_SIP_DTMF_INBAND) {
230                 ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
231         }
232
233         if (!strcmp(session_media->stream_type, STR_AUDIO) &&
234                         (session->endpoint->media.tos_audio || session->endpoint->media.cos_audio)) {
235                 ast_rtp_instance_set_qos(session_media->rtp, session->endpoint->media.tos_audio,
236                                 session->endpoint->media.cos_audio, "SIP RTP Audio");
237         } else if (!strcmp(session_media->stream_type, STR_VIDEO) &&
238                         (session->endpoint->media.tos_video || session->endpoint->media.cos_video)) {
239                 ast_rtp_instance_set_qos(session_media->rtp, session->endpoint->media.tos_video,
240                                 session->endpoint->media.cos_video, "SIP RTP Video");
241         }
242
243         ast_rtp_instance_set_last_rx(session_media->rtp, time(NULL));
244
245         return 0;
246 }
247
248 static void get_codecs(struct ast_sip_session *session, const struct pjmedia_sdp_media *stream, struct ast_rtp_codecs *codecs,
249        struct ast_sip_session_media *session_media)
250 {
251         pjmedia_sdp_attr *attr;
252         pjmedia_sdp_rtpmap *rtpmap;
253         pjmedia_sdp_fmtp fmtp;
254         struct ast_format *format;
255         int i, num = 0, tel_event = 0;
256         char name[256];
257         char media[20];
258         char fmt_param[256];
259         enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
260                 AST_RTP_OPT_G726_NONSTANDARD : 0;
261
262         ast_rtp_codecs_payloads_initialize(codecs);
263
264         /* Iterate through provided formats */
265         for (i = 0; i < stream->desc.fmt_count; ++i) {
266                 /* The payload is kept as a string for things like t38 but for video it is always numerical */
267                 ast_rtp_codecs_payloads_set_m_type(codecs, NULL, pj_strtoul(&stream->desc.fmt[i]));
268                 /* Look for the optional rtpmap attribute */
269                 if (!(attr = pjmedia_sdp_media_find_attr2(stream, "rtpmap", &stream->desc.fmt[i]))) {
270                         continue;
271                 }
272
273                 /* Interpret the attribute as an rtpmap */
274                 if ((pjmedia_sdp_attr_to_rtpmap(session->inv_session->pool_prov, attr, &rtpmap)) != PJ_SUCCESS) {
275                         continue;
276                 }
277
278                 ast_copy_pj_str(name, &rtpmap->enc_name, sizeof(name));
279                 if (strcmp(name, "telephone-event") == 0) {
280                         tel_event++;
281                 }
282
283                 ast_copy_pj_str(media, (pj_str_t*)&stream->desc.media, sizeof(media));
284                 ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, NULL,
285                         pj_strtoul(&stream->desc.fmt[i]), media, name, options, rtpmap->clock_rate);
286                 /* Look for an optional associated fmtp attribute */
287                 if (!(attr = pjmedia_sdp_media_find_attr2(stream, "fmtp", &rtpmap->pt))) {
288                         continue;
289                 }
290
291                 if ((pjmedia_sdp_attr_get_fmtp(attr, &fmtp)) == PJ_SUCCESS) {
292                         ast_copy_pj_str(fmt_param, &fmtp.fmt, sizeof(fmt_param));
293                         if (sscanf(fmt_param, "%30d", &num) != 1) {
294                                 continue;
295                         }
296
297                         if ((format = ast_rtp_codecs_get_payload_format(codecs, num))) {
298                                 struct ast_format *format_parsed;
299
300                                 ast_copy_pj_str(fmt_param, &fmtp.fmt_param, sizeof(fmt_param));
301
302                                 format_parsed = ast_format_parse_sdp_fmtp(format, fmt_param);
303                                 if (format_parsed) {
304                                         ast_rtp_codecs_payload_replace_format(codecs, num, format_parsed);
305                                         ao2_ref(format_parsed, -1);
306                                 }
307
308                                 ao2_ref(format, -1);
309                         }
310                 }
311         }
312         if (!tel_event && (session->endpoint->dtmf == AST_SIP_DTMF_AUTO)) {
313                 ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
314         }
315         /* Get the packetization, if it exists */
316         if ((attr = pjmedia_sdp_media_find_attr2(stream, "ptime", NULL))) {
317                 unsigned long framing = pj_strtoul(pj_strltrim(&attr->value));
318                 if (framing && session->endpoint->media.rtp.use_ptime) {
319                         ast_rtp_codecs_set_framing(codecs, framing);
320                 }
321         }
322 }
323
324 static int set_caps(struct ast_sip_session *session,
325         struct ast_sip_session_media *session_media,
326         const struct pjmedia_sdp_media *stream,
327         int is_offer)
328 {
329         RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
330         RAII_VAR(struct ast_format_cap *, peer, NULL, ao2_cleanup);
331         RAII_VAR(struct ast_format_cap *, joint, NULL, ao2_cleanup);
332         enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
333         struct ast_rtp_codecs codecs = AST_RTP_CODECS_NULL_INIT;
334         int fmts = 0;
335         int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
336                 ast_format_cap_count(session->direct_media_cap);
337         int dsp_features = 0;
338
339         if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
340             !(peer = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
341             !(joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
342                 ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
343                 return -1;
344         }
345
346         /* get the endpoint capabilities */
347         if (direct_media_enabled) {
348                 ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
349                 format_cap_only_type(caps, media_type);
350         } else {
351                 ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
352         }
353
354         /* get the capabilities on the peer */
355         get_codecs(session, stream, &codecs,  session_media);
356         ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
357
358         /* get the joint capabilities between peer and endpoint */
359         ast_format_cap_get_compatible(caps, peer, joint);
360         if (!ast_format_cap_count(joint)) {
361                 struct ast_str *usbuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
362                 struct ast_str *thembuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
363
364                 ast_rtp_codecs_payloads_destroy(&codecs);
365                 ast_log(LOG_NOTICE, "No joint capabilities for '%s' media stream between our configuration(%s) and incoming SDP(%s)\n",
366                         session_media->stream_type,
367                         ast_format_cap_get_names(caps, &usbuf),
368                         ast_format_cap_get_names(peer, &thembuf));
369                 return -1;
370         }
371
372         if (is_offer) {
373                 /*
374                  * Setup rx payload type mapping to prefer the mapping
375                  * from the peer that the RFC says we SHOULD use.
376                  */
377                 ast_rtp_codecs_payloads_xover(&codecs, &codecs, NULL);
378         }
379         ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
380                 session_media->rtp);
381
382         ast_format_cap_append_from_cap(session->req_caps, joint, AST_MEDIA_TYPE_UNKNOWN);
383
384         if (session->channel) {
385                 ast_channel_lock(session->channel);
386                 ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
387                 ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel),
388                         AST_MEDIA_TYPE_UNKNOWN);
389                 ast_format_cap_remove_by_type(caps, media_type);
390                 if (session->endpoint->preferred_codec_only){
391                         struct ast_format *preferred_fmt = ast_format_cap_get_format(joint, 0);
392                         ast_format_cap_append(caps, preferred_fmt, 0);
393                         ao2_ref(preferred_fmt, -1);
394                 } else {
395                         ast_format_cap_append_from_cap(caps, joint, media_type);
396                 }
397                 /*
398                  * Apply the new formats to the channel, potentially changing
399                  * raw read/write formats and translation path while doing so.
400                  */
401                 ast_channel_nativeformats_set(session->channel, caps);
402                 if (media_type == AST_MEDIA_TYPE_AUDIO) {
403                         ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
404                         ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
405                 }
406                 if ((session->endpoint->dtmf == AST_SIP_DTMF_AUTO)
407                     && (ast_rtp_instance_dtmf_mode_get(session_media->rtp) == AST_RTP_DTMF_MODE_RFC2833)
408                     && (session->dsp)) {
409                         dsp_features = ast_dsp_get_features(session->dsp);
410                         dsp_features &= ~DSP_FEATURE_DIGIT_DETECT;
411                         if (dsp_features) {
412                                 ast_dsp_set_features(session->dsp, dsp_features);
413                         } else {
414                                 ast_dsp_free(session->dsp);
415                                 session->dsp = NULL;
416                         }
417                 }
418
419                 if (ast_channel_is_bridged(session->channel)) {
420                         ast_channel_set_unbridged_nolock(session->channel, 1);
421                 }
422
423                 ast_channel_unlock(session->channel);
424         }
425
426         ast_rtp_codecs_payloads_destroy(&codecs);
427         return 0;
428 }
429
430 static pjmedia_sdp_attr* generate_rtpmap_attr(struct ast_sip_session *session, pjmedia_sdp_media *media, pj_pool_t *pool,
431                                               int rtp_code, int asterisk_format, struct ast_format *format, int code)
432 {
433         pjmedia_sdp_rtpmap rtpmap;
434         pjmedia_sdp_attr *attr = NULL;
435         char tmp[64];
436         enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
437                 AST_RTP_OPT_G726_NONSTANDARD : 0;
438
439         snprintf(tmp, sizeof(tmp), "%d", rtp_code);
440         pj_strdup2(pool, &media->desc.fmt[media->desc.fmt_count++], tmp);
441         rtpmap.pt = media->desc.fmt[media->desc.fmt_count - 1];
442         rtpmap.clock_rate = ast_rtp_lookup_sample_rate2(asterisk_format, format, code);
443         pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, options));
444         if (!pj_stricmp2(&rtpmap.enc_name, "opus")) {
445                 pj_cstr(&rtpmap.param, "2");
446         } else {
447                 pj_cstr(&rtpmap.param, NULL);
448         }
449
450         pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
451
452         return attr;
453 }
454
455 static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *format, int rtp_code)
456 {
457         struct ast_str *fmtp0 = ast_str_alloca(256);
458         pj_str_t fmtp1;
459         pjmedia_sdp_attr *attr = NULL;
460         char *tmp;
461
462         ast_format_generate_sdp_fmtp(format, rtp_code, &fmtp0);
463         if (ast_str_strlen(fmtp0)) {
464                 tmp = ast_str_buffer(fmtp0) + ast_str_strlen(fmtp0) - 1;
465                 /* remove any carriage return line feeds */
466                 while (*tmp == '\r' || *tmp == '\n') --tmp;
467                 *++tmp = '\0';
468                 /* ast...generate gives us everything, just need value */
469                 tmp = strchr(ast_str_buffer(fmtp0), ':');
470                 if (tmp && tmp[1] != '\0') {
471                         fmtp1 = pj_str(tmp + 1);
472                 } else {
473                         fmtp1 = pj_str(ast_str_buffer(fmtp0));
474                 }
475                 attr = pjmedia_sdp_attr_create(pool, "fmtp", &fmtp1);
476         }
477         return attr;
478 }
479
480 /*! \brief Function which adds ICE attributes to a media stream */
481 static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media, pj_pool_t *pool, pjmedia_sdp_media *media)
482 {
483         struct ast_rtp_engine_ice *ice;
484         struct ao2_container *candidates;
485         const char *username, *password;
486         pj_str_t stmp;
487         pjmedia_sdp_attr *attr;
488         struct ao2_iterator it_candidates;
489         struct ast_rtp_engine_ice_candidate *candidate;
490
491         if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp)) ||
492                 !(candidates = ice->get_local_candidates(session_media->rtp))) {
493                 return;
494         }
495
496         if ((username = ice->get_ufrag(session_media->rtp))) {
497                 attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", pj_cstr(&stmp, username));
498                 media->attr[media->attr_count++] = attr;
499         }
500
501         if ((password = ice->get_password(session_media->rtp))) {
502                 attr = pjmedia_sdp_attr_create(pool, "ice-pwd", pj_cstr(&stmp, password));
503                 media->attr[media->attr_count++] = attr;
504         }
505
506         it_candidates = ao2_iterator_init(candidates, 0);
507         for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) {
508                 struct ast_str *attr_candidate = ast_str_create(128);
509
510                 ast_str_set(&attr_candidate, -1, "%s %u %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
511                                         candidate->priority, ast_sockaddr_stringify_addr_remote(&candidate->address));
512                 ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address));
513
514                 switch (candidate->type) {
515                         case AST_RTP_ICE_CANDIDATE_TYPE_HOST:
516                                 ast_str_append(&attr_candidate, -1, "host");
517                                 break;
518                         case AST_RTP_ICE_CANDIDATE_TYPE_SRFLX:
519                                 ast_str_append(&attr_candidate, -1, "srflx");
520                                 break;
521                         case AST_RTP_ICE_CANDIDATE_TYPE_RELAYED:
522                                 ast_str_append(&attr_candidate, -1, "relay");
523                                 break;
524                 }
525
526                 if (!ast_sockaddr_isnull(&candidate->relay_address)) {
527                         ast_str_append(&attr_candidate, -1, " raddr %s rport", ast_sockaddr_stringify_addr_remote(&candidate->relay_address));
528                         ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address));
529                 }
530
531                 attr = pjmedia_sdp_attr_create(pool, "candidate", pj_cstr(&stmp, ast_str_buffer(attr_candidate)));
532                 media->attr[media->attr_count++] = attr;
533
534                 ast_free(attr_candidate);
535         }
536
537         ao2_iterator_destroy(&it_candidates);
538         ao2_ref(candidates, -1);
539 }
540
541 /*! \brief Function which processes ICE attributes in an audio stream */
542 static void process_ice_attributes(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
543                                    const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
544 {
545         struct ast_rtp_engine_ice *ice;
546         const pjmedia_sdp_attr *attr;
547         char attr_value[256];
548         unsigned int attr_i;
549
550         /* If ICE support is not enabled or available exit early */
551         if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp))) {
552                 return;
553         }
554
555         attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-ufrag", NULL);
556         if (!attr) {
557                 attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-ufrag", NULL);
558         }
559         if (attr) {
560                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
561                 ice->set_authentication(session_media->rtp, attr_value, NULL);
562         } else {
563                 return;
564         }
565
566         attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-pwd", NULL);
567         if (!attr) {
568                 attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-pwd", NULL);
569         }
570         if (attr) {
571                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
572                 ice->set_authentication(session_media->rtp, NULL, attr_value);
573         } else {
574                 return;
575         }
576
577         if (pjmedia_sdp_media_find_attr2(remote_stream, "ice-lite", NULL)) {
578                 ice->ice_lite(session_media->rtp);
579         }
580
581         /* Find all of the candidates */
582         for (attr_i = 0; attr_i < remote_stream->attr_count; ++attr_i) {
583                 char foundation[32], transport[32], address[PJ_INET6_ADDRSTRLEN + 1], cand_type[6], relay_address[PJ_INET6_ADDRSTRLEN + 1] = "";
584                 unsigned int port, relay_port = 0;
585                 struct ast_rtp_engine_ice_candidate candidate = { 0, };
586
587                 attr = remote_stream->attr[attr_i];
588
589                 /* If this is not a candidate line skip it */
590                 if (pj_strcmp2(&attr->name, "candidate")) {
591                         continue;
592                 }
593
594                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
595
596                 if (sscanf(attr_value, "%31s %30u %31s %30u %46s %30u typ %5s %*s %23s %*s %30u", foundation, &candidate.id, transport,
597                         (unsigned *)&candidate.priority, address, &port, cand_type, relay_address, &relay_port) < 7) {
598                         /* Candidate did not parse properly */
599                         continue;
600                 }
601
602                 if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux && candidate.id > 1) {
603                         /* Remote side may have offered RTP and RTCP candidates. However, if we're using RTCP MUX,
604                          * then we should ignore RTCP candidates.
605                          */
606                         continue;
607                 }
608
609                 candidate.foundation = foundation;
610                 candidate.transport = transport;
611
612                 ast_sockaddr_parse(&candidate.address, address, PARSE_PORT_FORBID);
613                 ast_sockaddr_set_port(&candidate.address, port);
614
615                 if (!strcasecmp(cand_type, "host")) {
616                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
617                 } else if (!strcasecmp(cand_type, "srflx")) {
618                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
619                 } else if (!strcasecmp(cand_type, "relay")) {
620                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
621                 } else {
622                         continue;
623                 }
624
625                 if (!ast_strlen_zero(relay_address)) {
626                         ast_sockaddr_parse(&candidate.relay_address, relay_address, PARSE_PORT_FORBID);
627                 }
628
629                 if (relay_port) {
630                         ast_sockaddr_set_port(&candidate.relay_address, relay_port);
631                 }
632
633                 ice->add_remote_candidate(session_media->rtp, &candidate);
634         }
635
636         ice->set_role(session_media->rtp, pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_TRUE ?
637                 AST_RTP_ICE_ROLE_CONTROLLING : AST_RTP_ICE_ROLE_CONTROLLED);
638         ice->start(session_media->rtp);
639 }
640
641 /*! \brief figure out if media stream has crypto lines for sdes */
642 static int media_stream_has_crypto(const struct pjmedia_sdp_media *stream)
643 {
644         int i;
645
646         for (i = 0; i < stream->attr_count; i++) {
647                 pjmedia_sdp_attr *attr;
648
649                 /* check the stream for the required crypto attribute */
650                 attr = stream->attr[i];
651                 if (pj_strcmp2(&attr->name, "crypto")) {
652                         continue;
653                 }
654
655                 return 1;
656         }
657
658         return 0;
659 }
660
661 /*! \brief figure out media transport encryption type from the media transport string */
662 static enum ast_sip_session_media_encryption get_media_encryption_type(pj_str_t transport,
663         const struct pjmedia_sdp_media *stream, unsigned int *optimistic)
664 {
665         RAII_VAR(char *, transport_str, ast_strndup(transport.ptr, transport.slen), ast_free);
666
667         *optimistic = 0;
668
669         if (!transport_str) {
670                 return AST_SIP_MEDIA_TRANSPORT_INVALID;
671         }
672         if (strstr(transport_str, "UDP/TLS")) {
673                 return AST_SIP_MEDIA_ENCRYPT_DTLS;
674         } else if (strstr(transport_str, "SAVP")) {
675                 return AST_SIP_MEDIA_ENCRYPT_SDES;
676         } else if (media_stream_has_crypto(stream)) {
677                 *optimistic = 1;
678                 return AST_SIP_MEDIA_ENCRYPT_SDES;
679         } else {
680                 return AST_SIP_MEDIA_ENCRYPT_NONE;
681         }
682 }
683
684 /*!
685  * \brief Checks whether the encryption offered in SDP is compatible with the endpoint's configuration
686  * \internal
687  *
688  * \param endpoint_encryption Media encryption configured for the endpoint
689  * \param stream pjmedia_sdp_media stream description
690  *
691  * \retval AST_SIP_MEDIA_TRANSPORT_INVALID on encryption mismatch
692  * \retval The encryption requested in the SDP
693  */
694 static enum ast_sip_session_media_encryption check_endpoint_media_transport(
695         struct ast_sip_endpoint *endpoint,
696         const struct pjmedia_sdp_media *stream)
697 {
698         enum ast_sip_session_media_encryption incoming_encryption;
699         char transport_end = stream->desc.transport.ptr[stream->desc.transport.slen - 1];
700         unsigned int optimistic;
701
702         if ((transport_end == 'F' && !endpoint->media.rtp.use_avpf)
703                 || (transport_end != 'F' && endpoint->media.rtp.use_avpf)) {
704                 return AST_SIP_MEDIA_TRANSPORT_INVALID;
705         }
706
707         incoming_encryption = get_media_encryption_type(stream->desc.transport, stream, &optimistic);
708
709         if (incoming_encryption == endpoint->media.rtp.encryption) {
710                 return incoming_encryption;
711         }
712
713         if (endpoint->media.rtp.force_avp ||
714                 endpoint->media.rtp.encryption_optimistic) {
715                 return incoming_encryption;
716         }
717
718         /* If an optimistic offer has been made but encryption is not enabled consider it as having
719          * no offer of crypto at all instead of invalid so the session proceeds.
720          */
721         if (optimistic) {
722                 return AST_SIP_MEDIA_ENCRYPT_NONE;
723         }
724
725         return AST_SIP_MEDIA_TRANSPORT_INVALID;
726 }
727
728 static int setup_srtp(struct ast_sip_session_media *session_media)
729 {
730         if (!session_media->srtp) {
731                 session_media->srtp = ast_sdp_srtp_alloc();
732                 if (!session_media->srtp) {
733                         return -1;
734                 }
735         }
736
737         if (!session_media->srtp->crypto) {
738                 session_media->srtp->crypto = ast_sdp_crypto_alloc();
739                 if (!session_media->srtp->crypto) {
740                         return -1;
741                 }
742         }
743
744         return 0;
745 }
746
747 static int setup_dtls_srtp(struct ast_sip_session *session,
748         struct ast_sip_session_media *session_media)
749 {
750         struct ast_rtp_engine_dtls *dtls;
751
752         if (!session->endpoint->media.rtp.dtls_cfg.enabled || !session_media->rtp) {
753                 return -1;
754         }
755
756         dtls = ast_rtp_instance_get_dtls(session_media->rtp);
757         if (!dtls) {
758                 return -1;
759         }
760
761         session->endpoint->media.rtp.dtls_cfg.suite = ((session->endpoint->media.rtp.srtp_tag_32) ? AST_AES_CM_128_HMAC_SHA1_32 : AST_AES_CM_128_HMAC_SHA1_80);
762         if (dtls->set_configuration(session_media->rtp, &session->endpoint->media.rtp.dtls_cfg)) {
763                 ast_log(LOG_ERROR, "Attempted to set an invalid DTLS-SRTP configuration on RTP instance '%p'\n",
764                         session_media->rtp);
765                 return -1;
766         }
767
768         if (setup_srtp(session_media)) {
769                 return -1;
770         }
771         return 0;
772 }
773
774 static void apply_dtls_attrib(struct ast_sip_session_media *session_media,
775         pjmedia_sdp_attr *attr)
776 {
777         struct ast_rtp_engine_dtls *dtls = ast_rtp_instance_get_dtls(session_media->rtp);
778         pj_str_t *value;
779
780         if (!attr->value.ptr) {
781                 return;
782         }
783
784         value = pj_strtrim(&attr->value);
785
786         if (!pj_strcmp2(&attr->name, "setup")) {
787                 if (!pj_stricmp2(value, "active")) {
788                         dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTIVE);
789                 } else if (!pj_stricmp2(value, "passive")) {
790                         dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_PASSIVE);
791                 } else if (!pj_stricmp2(value, "actpass")) {
792                         dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTPASS);
793                 } else if (!pj_stricmp2(value, "holdconn")) {
794                         dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_HOLDCONN);
795                 } else {
796                         ast_log(LOG_WARNING, "Unsupported setup attribute value '%*s'\n", (int)value->slen, value->ptr);
797                 }
798         } else if (!pj_strcmp2(&attr->name, "connection")) {
799                 if (!pj_stricmp2(value, "new")) {
800                         dtls->reset(session_media->rtp);
801                 } else if (!pj_stricmp2(value, "existing")) {
802                         /* Do nothing */
803                 } else {
804                         ast_log(LOG_WARNING, "Unsupported connection attribute value '%*s'\n", (int)value->slen, value->ptr);
805                 }
806         } else if (!pj_strcmp2(&attr->name, "fingerprint")) {
807                 char hash_value[256], hash[32];
808                 char fingerprint_text[value->slen + 1];
809                 ast_copy_pj_str(fingerprint_text, value, sizeof(fingerprint_text));
810                         if (sscanf(fingerprint_text, "%31s %255s", hash, hash_value) == 2) {
811                         if (!strcasecmp(hash, "sha-1")) {
812                                 dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1, hash_value);
813                         } else if (!strcasecmp(hash, "sha-256")) {
814                                 dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA256, hash_value);
815                         } else {
816                                 ast_log(LOG_WARNING, "Unsupported fingerprint hash type '%s'\n",
817                                 hash);
818                         }
819                 }
820         }
821 }
822
823 static int parse_dtls_attrib(struct ast_sip_session_media *session_media,
824         const struct pjmedia_sdp_session *sdp,
825         const struct pjmedia_sdp_media *stream)
826 {
827         int i;
828
829         for (i = 0; i < sdp->attr_count; i++) {
830                 apply_dtls_attrib(session_media, sdp->attr[i]);
831         }
832
833         for (i = 0; i < stream->attr_count; i++) {
834                 apply_dtls_attrib(session_media, stream->attr[i]);
835         }
836
837         ast_set_flag(session_media->srtp, AST_SRTP_CRYPTO_OFFER_OK);
838
839         return 0;
840 }
841
842 static int setup_sdes_srtp(struct ast_sip_session_media *session_media,
843         const struct pjmedia_sdp_media *stream)
844 {
845         int i;
846
847         for (i = 0; i < stream->attr_count; i++) {
848                 pjmedia_sdp_attr *attr;
849                 RAII_VAR(char *, crypto_str, NULL, ast_free);
850
851                 /* check the stream for the required crypto attribute */
852                 attr = stream->attr[i];
853                 if (pj_strcmp2(&attr->name, "crypto")) {
854                         continue;
855                 }
856
857                 crypto_str = ast_strndup(attr->value.ptr, attr->value.slen);
858                 if (!crypto_str) {
859                         return -1;
860                 }
861
862                 if (setup_srtp(session_media)) {
863                         return -1;
864                 }
865
866                 if (!ast_sdp_crypto_process(session_media->rtp, session_media->srtp, crypto_str)) {
867                         /* found a valid crypto attribute */
868                         return 0;
869                 }
870
871                 ast_debug(1, "Ignoring crypto offer with unsupported parameters: %s\n", crypto_str);
872         }
873
874         /* no usable crypto attributes found */
875         return -1;
876 }
877
878 static int setup_media_encryption(struct ast_sip_session *session,
879         struct ast_sip_session_media *session_media,
880         const struct pjmedia_sdp_session *sdp,
881         const struct pjmedia_sdp_media *stream)
882 {
883         switch (session_media->encryption) {
884         case AST_SIP_MEDIA_ENCRYPT_SDES:
885                 if (setup_sdes_srtp(session_media, stream)) {
886                         return -1;
887                 }
888                 break;
889         case AST_SIP_MEDIA_ENCRYPT_DTLS:
890                 if (setup_dtls_srtp(session, session_media)) {
891                         return -1;
892                 }
893                 if (parse_dtls_attrib(session_media, sdp, stream)) {
894                         return -1;
895                 }
896                 break;
897         case AST_SIP_MEDIA_TRANSPORT_INVALID:
898         case AST_SIP_MEDIA_ENCRYPT_NONE:
899                 break;
900         }
901
902         return 0;
903 }
904
905 static void set_ice_components(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
906 {
907         struct ast_rtp_engine_ice *ice;
908
909         ast_assert(session_media->rtp != NULL);
910
911         ice = ast_rtp_instance_get_ice(session_media->rtp);
912         if (!session->endpoint->media.rtp.ice_support || !ice) {
913                 return;
914         }
915
916         if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux) {
917                 /* We both support RTCP mux. Only one ICE component necessary */
918                 ice->change_components(session_media->rtp, 1);
919         } else {
920                 /* They either don't support RTCP mux or we don't know if they do yet. */
921                 ice->change_components(session_media->rtp, 2);
922         }
923 }
924
925 /*! \brief Function which negotiates an incoming media stream */
926 static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
927                                          const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
928 {
929         char host[NI_MAXHOST];
930         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
931         enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
932         enum ast_sip_session_media_encryption encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
933         int res;
934
935         /* If port is 0, ignore this media stream */
936         if (!stream->desc.port) {
937                 ast_debug(3, "Media stream '%s' is already declined\n", session_media->stream_type);
938                 return 0;
939         }
940
941         /* If no type formats have been configured reject this stream */
942         if (!ast_format_cap_has_type(session->endpoint->media.codecs, media_type)) {
943                 ast_debug(3, "Endpoint has no codecs for media type '%s', declining stream\n", session_media->stream_type);
944                 return 0;
945         }
946
947         /* Ensure incoming transport is compatible with the endpoint's configuration */
948         if (!session->endpoint->media.rtp.use_received_transport) {
949                 encryption = check_endpoint_media_transport(session->endpoint, stream);
950
951                 if (encryption == AST_SIP_MEDIA_TRANSPORT_INVALID) {
952                         return -1;
953                 }
954         }
955
956         ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
957
958         /* Ensure that the address provided is valid */
959         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
960                 /* The provided host was actually invalid so we error out this negotiation */
961                 return -1;
962         }
963
964         /* Using the connection information create an appropriate RTP instance */
965         if (!session_media->rtp && create_rtp(session, session_media)) {
966                 return -1;
967         }
968
969         session_media->remote_rtcp_mux = (pjmedia_sdp_media_find_attr2(stream, "rtcp-mux", NULL) != NULL);
970         set_ice_components(session, session_media);
971
972         enable_rtcp(session, session_media, stream);
973
974         res = setup_media_encryption(session, session_media, sdp, stream);
975         if (res) {
976                 if (!session->endpoint->media.rtp.encryption_optimistic ||
977                         !pj_strncmp2(&stream->desc.transport, "RTP/SAVP", 8)) {
978                         /* If optimistic encryption is disabled and crypto should have been enabled
979                          * but was not this session must fail. This must also fail if crypto was
980                          * required in the offer but could not be set up.
981                          */
982                         return -1;
983                 }
984                 /* There is no encryption, sad. */
985                 session_media->encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
986         }
987
988         /* If we've been explicitly configured to use the received transport OR if
989          * encryption is on and crypto is present use the received transport.
990          * This is done in case of optimistic because it may come in as RTP/AVP or RTP/SAVP depending
991          * on the configuration of the remote endpoint (optimistic themselves or mandatory).
992          */
993         if ((session->endpoint->media.rtp.use_received_transport) ||
994                 ((encryption == AST_SIP_MEDIA_ENCRYPT_SDES) && !res)) {
995                 pj_strdup(session->inv_session->pool, &session_media->transport, &stream->desc.transport);
996         }
997
998         if (set_caps(session, session_media, stream, 1)) {
999                 return 0;
1000         }
1001         return 1;
1002 }
1003
1004 static int add_crypto_to_stream(struct ast_sip_session *session,
1005         struct ast_sip_session_media *session_media,
1006         pj_pool_t *pool, pjmedia_sdp_media *media)
1007 {
1008         pj_str_t stmp;
1009         pjmedia_sdp_attr *attr;
1010         enum ast_rtp_dtls_hash hash;
1011         const char *crypto_attribute;
1012         struct ast_rtp_engine_dtls *dtls;
1013         struct ast_sdp_srtp *tmp;
1014         static const pj_str_t STR_NEW = { "new", 3 };
1015         static const pj_str_t STR_EXISTING = { "existing", 8 };
1016         static const pj_str_t STR_ACTIVE = { "active", 6 };
1017         static const pj_str_t STR_PASSIVE = { "passive", 7 };
1018         static const pj_str_t STR_ACTPASS = { "actpass", 7 };
1019         static const pj_str_t STR_HOLDCONN = { "holdconn", 8 };
1020
1021         switch (session_media->encryption) {
1022         case AST_SIP_MEDIA_ENCRYPT_NONE:
1023         case AST_SIP_MEDIA_TRANSPORT_INVALID:
1024                 break;
1025         case AST_SIP_MEDIA_ENCRYPT_SDES:
1026                 if (!session_media->srtp) {
1027                         session_media->srtp = ast_sdp_srtp_alloc();
1028                         if (!session_media->srtp) {
1029                                 return -1;
1030                         }
1031                 }
1032
1033                 tmp = session_media->srtp;
1034
1035                 do {
1036                         crypto_attribute = ast_sdp_srtp_get_attrib(tmp,
1037                                 0 /* DTLS running? No */,
1038                                 session->endpoint->media.rtp.srtp_tag_32 /* 32 byte tag length? */);
1039                         if (!crypto_attribute) {
1040                                 /* No crypto attribute to add, bad news */
1041                                 return -1;
1042                         }
1043
1044                         attr = pjmedia_sdp_attr_create(pool, "crypto",
1045                                 pj_cstr(&stmp, crypto_attribute));
1046                         media->attr[media->attr_count++] = attr;
1047                 } while ((tmp = AST_LIST_NEXT(tmp, sdp_srtp_list)));
1048
1049                 break;
1050         case AST_SIP_MEDIA_ENCRYPT_DTLS:
1051                 if (setup_dtls_srtp(session, session_media)) {
1052                         return -1;
1053                 }
1054
1055                 dtls = ast_rtp_instance_get_dtls(session_media->rtp);
1056                 if (!dtls) {
1057                         return -1;
1058                 }
1059
1060                 switch (dtls->get_connection(session_media->rtp)) {
1061                 case AST_RTP_DTLS_CONNECTION_NEW:
1062                         attr = pjmedia_sdp_attr_create(pool, "connection", &STR_NEW);
1063                         media->attr[media->attr_count++] = attr;
1064                         break;
1065                 case AST_RTP_DTLS_CONNECTION_EXISTING:
1066                         attr = pjmedia_sdp_attr_create(pool, "connection", &STR_EXISTING);
1067                         media->attr[media->attr_count++] = attr;
1068                         break;
1069                 default:
1070                         break;
1071                 }
1072
1073                 switch (dtls->get_setup(session_media->rtp)) {
1074                 case AST_RTP_DTLS_SETUP_ACTIVE:
1075                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTIVE);
1076                         media->attr[media->attr_count++] = attr;
1077                         break;
1078                 case AST_RTP_DTLS_SETUP_PASSIVE:
1079                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_PASSIVE);
1080                         media->attr[media->attr_count++] = attr;
1081                         break;
1082                 case AST_RTP_DTLS_SETUP_ACTPASS:
1083                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTPASS);
1084                         media->attr[media->attr_count++] = attr;
1085                         break;
1086                 case AST_RTP_DTLS_SETUP_HOLDCONN:
1087                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_HOLDCONN);
1088                         media->attr[media->attr_count++] = attr;
1089                         break;
1090                 default:
1091                         break;
1092                 }
1093
1094                 hash = dtls->get_fingerprint_hash(session_media->rtp);
1095                 crypto_attribute = dtls->get_fingerprint(session_media->rtp);
1096                 if (crypto_attribute && (hash == AST_RTP_DTLS_HASH_SHA1 || hash == AST_RTP_DTLS_HASH_SHA256)) {
1097                         RAII_VAR(struct ast_str *, fingerprint, ast_str_create(64), ast_free);
1098                         if (!fingerprint) {
1099                                 return -1;
1100                         }
1101
1102                         if (hash == AST_RTP_DTLS_HASH_SHA1) {
1103                                 ast_str_set(&fingerprint, 0, "SHA-1 %s", crypto_attribute);
1104                         } else {
1105                                 ast_str_set(&fingerprint, 0, "SHA-256 %s", crypto_attribute);
1106                         }
1107
1108                         attr = pjmedia_sdp_attr_create(pool, "fingerprint", pj_cstr(&stmp, ast_str_buffer(fingerprint)));
1109                         media->attr[media->attr_count++] = attr;
1110                 }
1111                 break;
1112         }
1113
1114         return 0;
1115 }
1116
1117 /*! \brief Function which creates an outgoing stream */
1118 static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
1119                                       struct pjmedia_sdp_session *sdp)
1120 {
1121         pj_pool_t *pool = session->inv_session->pool_prov;
1122         static const pj_str_t STR_IN = { "IN", 2 };
1123         static const pj_str_t STR_IP4 = { "IP4", 3};
1124         static const pj_str_t STR_IP6 = { "IP6", 3};
1125         static const pj_str_t STR_SENDRECV = { "sendrecv", 8 };
1126         static const pj_str_t STR_SENDONLY = { "sendonly", 8 };
1127         pjmedia_sdp_media *media;
1128         const char *hostip = NULL;
1129         struct ast_sockaddr addr;
1130         char tmp[512];
1131         pj_str_t stmp;
1132         pjmedia_sdp_attr *attr;
1133         int index = 0;
1134         int noncodec = (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) ? AST_RTP_DTMF : 0;
1135         int min_packet_size = 0, max_packet_size = 0;
1136         int rtp_code;
1137         RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
1138         enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
1139         int use_override_prefs = ast_format_cap_count(session->req_caps);
1140
1141         int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
1142                 ast_format_cap_count(session->direct_media_cap);
1143
1144         if ((use_override_prefs && !ast_format_cap_has_type(session->req_caps, media_type)) ||
1145             (!use_override_prefs && !ast_format_cap_has_type(session->endpoint->media.codecs, media_type))) {
1146                 /* If no type formats are configured don't add a stream */
1147                 return 0;
1148         } else if (!session_media->rtp && create_rtp(session, session_media)) {
1149                 return -1;
1150         }
1151
1152         set_ice_components(session, session_media);
1153         enable_rtcp(session, session_media, NULL);
1154
1155         if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
1156                 !(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
1157                 return -1;
1158         }
1159
1160         if (add_crypto_to_stream(session, session_media, pool, media)) {
1161                 return -1;
1162         }
1163
1164         media->desc.media = pj_str(session_media->stream_type);
1165         if (pj_strlen(&session_media->transport)) {
1166                 /* If a transport has already been specified use it */
1167                 media->desc.transport = session_media->transport;
1168         } else {
1169                 media->desc.transport = pj_str(ast_sdp_get_rtp_profile(
1170                         /* Optimistic encryption places crypto in the normal RTP/AVP profile */
1171                         !session->endpoint->media.rtp.encryption_optimistic &&
1172                                 (session_media->encryption == AST_SIP_MEDIA_ENCRYPT_SDES),
1173                         session_media->rtp, session->endpoint->media.rtp.use_avpf,
1174                         session->endpoint->media.rtp.force_avp));
1175         }
1176
1177         /* Add connection level details */
1178         if (direct_media_enabled) {
1179                 hostip = ast_sockaddr_stringify_fmt(&session_media->direct_media_addr, AST_SOCKADDR_STR_ADDR);
1180         } else if (ast_strlen_zero(session->endpoint->media.address)) {
1181                 hostip = ast_sip_get_host_ip_string(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET());
1182         } else {
1183                 hostip = session->endpoint->media.address;
1184         }
1185
1186         if (ast_strlen_zero(hostip)) {
1187                 ast_log(LOG_ERROR, "No local host IP available for stream %s\n", session_media->stream_type);
1188                 return -1;
1189         }
1190
1191         media->conn->net_type = STR_IN;
1192         /* Assume that the connection will use IPv4 until proven otherwise */
1193         media->conn->addr_type = STR_IP4;
1194         pj_strdup2(pool, &media->conn->addr, hostip);
1195
1196         if (!ast_strlen_zero(session->endpoint->media.address)) {
1197                 pj_sockaddr ip;
1198
1199                 if ((pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &media->conn->addr, &ip) == PJ_SUCCESS) &&
1200                         (ip.addr.sa_family == pj_AF_INET6())) {
1201                         media->conn->addr_type = STR_IP6;
1202                 }
1203         }
1204
1205         ast_rtp_instance_get_local_address(session_media->rtp, &addr);
1206         media->desc.port = direct_media_enabled ? ast_sockaddr_port(&session_media->direct_media_addr) : (pj_uint16_t) ast_sockaddr_port(&addr);
1207         media->desc.port_count = 1;
1208
1209         /* Add ICE attributes and candidates */
1210         add_ice_to_stream(session, session_media, pool, media);
1211
1212         if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
1213                 ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
1214                 return -1;
1215         }
1216
1217         if (direct_media_enabled) {
1218                 ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
1219         } else if (!ast_format_cap_count(session->req_caps) ||
1220                 !ast_format_cap_iscompatible(session->req_caps, session->endpoint->media.codecs)) {
1221                 ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
1222         } else {
1223                 ast_format_cap_append_from_cap(caps, session->req_caps, media_type);
1224         }
1225
1226         for (index = 0; index < ast_format_cap_count(caps); ++index) {
1227                 struct ast_format *format = ast_format_cap_get_format(caps, index);
1228
1229                 if (ast_format_get_type(format) != media_type) {
1230                         ao2_ref(format, -1);
1231                         continue;
1232                 }
1233
1234                 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp), 1, format, 0)) == -1) {
1235                         ast_log(LOG_WARNING,"Unable to get rtp codec payload code for %s\n", ast_format_get_name(format));
1236                         ao2_ref(format, -1);
1237                         continue;
1238                 }
1239
1240                 if (!(attr = generate_rtpmap_attr(session, media, pool, rtp_code, 1, format, 0))) {
1241                         ao2_ref(format, -1);
1242                         continue;
1243                 }
1244                 media->attr[media->attr_count++] = attr;
1245
1246                 if ((attr = generate_fmtp_attr(pool, format, rtp_code))) {
1247                         media->attr[media->attr_count++] = attr;
1248                 }
1249
1250                 if (ast_format_get_maximum_ms(format) &&
1251                         ((ast_format_get_maximum_ms(format) < max_packet_size) || !max_packet_size)) {
1252                         max_packet_size = ast_format_get_maximum_ms(format);
1253                 }
1254                 ao2_ref(format, -1);
1255
1256                 if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
1257                         break;
1258                 }
1259         }
1260
1261         /* Add non-codec formats */
1262         if (media_type != AST_MEDIA_TYPE_VIDEO && media->desc.fmt_count < PJMEDIA_MAX_SDP_FMT) {
1263                 for (index = 1LL; index <= AST_RTP_MAX; index <<= 1) {
1264                         if (!(noncodec & index)) {
1265                                 continue;
1266                         }
1267                         rtp_code = ast_rtp_codecs_payload_code(
1268                                 ast_rtp_instance_get_codecs(session_media->rtp), 0, NULL, index);
1269                         if (rtp_code == -1) {
1270                                 continue;
1271                         }
1272
1273                         if (!(attr = generate_rtpmap_attr(session, media, pool, rtp_code, 0, NULL, index))) {
1274                                 continue;
1275                         }
1276
1277                         media->attr[media->attr_count++] = attr;
1278
1279                         if (index == AST_RTP_DTMF) {
1280                                 snprintf(tmp, sizeof(tmp), "%d 0-16", rtp_code);
1281                                 attr = pjmedia_sdp_attr_create(pool, "fmtp", pj_cstr(&stmp, tmp));
1282                                 media->attr[media->attr_count++] = attr;
1283                         }
1284
1285                         if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
1286                                 break;
1287                         }
1288                 }
1289         }
1290
1291         /* If no formats were actually added to the media stream don't add it to the SDP */
1292         if (!media->desc.fmt_count) {
1293                 return 1;
1294         }
1295
1296         /* If ptime is set add it as an attribute */
1297         min_packet_size = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(session_media->rtp));
1298         if (!min_packet_size) {
1299                 min_packet_size = ast_format_cap_get_framing(caps);
1300         }
1301         if (min_packet_size) {
1302                 snprintf(tmp, sizeof(tmp), "%d", min_packet_size);
1303                 attr = pjmedia_sdp_attr_create(pool, "ptime", pj_cstr(&stmp, tmp));
1304                 media->attr[media->attr_count++] = attr;
1305         }
1306
1307         if (max_packet_size) {
1308                 snprintf(tmp, sizeof(tmp), "%d", max_packet_size);
1309                 attr = pjmedia_sdp_attr_create(pool, "maxptime", pj_cstr(&stmp, tmp));
1310                 media->attr[media->attr_count++] = attr;
1311         }
1312
1313         /* Add the sendrecv attribute - we purposely don't keep track because pjmedia-sdp will automatically change our offer for us */
1314         attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
1315         attr->name = !session_media->locally_held ? STR_SENDRECV : STR_SENDONLY;
1316         media->attr[media->attr_count++] = attr;
1317
1318         /* If we've got rtcp-mux enabled, just unconditionally offer it in all SDPs */
1319         if (session->endpoint->media.rtcp_mux) {
1320                 attr = pjmedia_sdp_attr_create(pool, "rtcp-mux", NULL);
1321                 pjmedia_sdp_attr_add(&media->attr_count, media->attr, attr);
1322         }
1323
1324         /* Add the media stream to the SDP */
1325         sdp->media[sdp->media_count++] = media;
1326
1327         return 1;
1328 }
1329
1330 static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
1331                                        const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
1332                                        const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
1333 {
1334         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
1335         enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
1336         char host[NI_MAXHOST];
1337         int fdno, res;
1338
1339         if (!session->channel) {
1340                 return 1;
1341         }
1342
1343         if (!local_stream->desc.port || !remote_stream->desc.port) {
1344                 return 1;
1345         }
1346
1347         /* Ensure incoming transport is compatible with the endpoint's configuration */
1348         if (!session->endpoint->media.rtp.use_received_transport &&
1349                 check_endpoint_media_transport(session->endpoint, remote_stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
1350                 return -1;
1351         }
1352
1353         /* Create an RTP instance if need be */
1354         if (!session_media->rtp && create_rtp(session, session_media)) {
1355                 return -1;
1356         }
1357
1358         session_media->remote_rtcp_mux = (pjmedia_sdp_media_find_attr2(remote_stream, "rtcp-mux", NULL) != NULL);
1359         set_ice_components(session, session_media);
1360
1361         enable_rtcp(session, session_media, remote_stream);
1362
1363         res = setup_media_encryption(session, session_media, remote, remote_stream);
1364         if (!session->endpoint->media.rtp.encryption_optimistic && res) {
1365                 /* If optimistic encryption is disabled and crypto should have been enabled but was not
1366                  * this session must fail.
1367                  */
1368                 return -1;
1369         }
1370
1371         if (!remote_stream->conn && !remote->conn) {
1372                 return 1;
1373         }
1374
1375         ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
1376
1377         /* Ensure that the address provided is valid */
1378         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
1379                 /* The provided host was actually invalid so we error out this negotiation */
1380                 return -1;
1381         }
1382
1383         /* Apply connection information to the RTP instance */
1384         ast_sockaddr_set_port(addrs, remote_stream->desc.port);
1385         ast_rtp_instance_set_remote_address(session_media->rtp, addrs);
1386         if (set_caps(session, session_media, remote_stream, 0)) {
1387                 return 1;
1388         }
1389
1390         if ((fdno = media_type_to_fdno(media_type)) < 0) {
1391                 return -1;
1392         }
1393         ast_channel_set_fd(session->channel, fdno, ast_rtp_instance_fd(session_media->rtp, 0));
1394         if (!session->endpoint->media.rtcp_mux || !session_media->remote_rtcp_mux) {
1395                 ast_channel_set_fd(session->channel, fdno + 1, ast_rtp_instance_fd(session_media->rtp, 1));
1396         }
1397
1398         /* If ICE support is enabled find all the needed attributes */
1399         process_ice_attributes(session, session_media, remote, remote_stream);
1400
1401         /* Ensure the RTP instance is active */
1402         ast_rtp_instance_activate(session_media->rtp);
1403
1404         /* audio stream handles music on hold */
1405         if (media_type != AST_MEDIA_TYPE_AUDIO) {
1406                 if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
1407                         && (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
1408                         ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
1409                 }
1410                 return 1;
1411         }
1412
1413         if (ast_sockaddr_isnull(addrs) ||
1414                 ast_sockaddr_is_any(addrs) ||
1415                 pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL) ||
1416                 pjmedia_sdp_media_find_attr2(remote_stream, "inactive", NULL)) {
1417                 if (!session_media->remotely_held) {
1418                         /* The remote side has put us on hold */
1419                         ast_queue_hold(session->channel, session->endpoint->mohsuggest);
1420                         ast_rtp_instance_stop(session_media->rtp);
1421                         ast_queue_frame(session->channel, &ast_null_frame);
1422                         session_media->remotely_held = 1;
1423                 }
1424         } else if (session_media->remotely_held) {
1425                 /* The remote side has taken us off hold */
1426                 ast_queue_unhold(session->channel);
1427                 ast_queue_frame(session->channel, &ast_null_frame);
1428                 session_media->remotely_held = 0;
1429         } else if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
1430                 && (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
1431                 ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
1432         }
1433
1434         /* This purposely resets the encryption to the configured in case it gets added later */
1435         session_media->encryption = session->endpoint->media.rtp.encryption;
1436
1437         if (session->endpoint->media.rtp.keepalive > 0 &&
1438                         stream_to_media_type(session_media->stream_type) == AST_MEDIA_TYPE_AUDIO) {
1439                 ast_rtp_instance_set_keepalive(session_media->rtp, session->endpoint->media.rtp.keepalive);
1440                 /* Schedule the initial keepalive early in case this is being used to punch holes through
1441                  * a NAT. This way there won't be an awkward delay before media starts flowing in some
1442                  * scenarios.
1443                  */
1444                 AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
1445                 session_media->keepalive_sched_id = ast_sched_add_variable(sched, 500, send_keepalive,
1446                         session_media, 1);
1447         }
1448
1449         /* As the channel lock is not held during this process the scheduled item won't block if
1450          * it is hanging up the channel at the same point we are applying this negotiated SDP.
1451          */
1452         AST_SCHED_DEL(sched, session_media->timeout_sched_id);
1453
1454         /* Due to the fact that we only ever have one scheduled timeout item for when we are both
1455          * off hold and on hold we don't need to store the two timeouts differently on the RTP
1456          * instance itself.
1457          */
1458         ast_rtp_instance_set_timeout(session_media->rtp, 0);
1459         if (session->endpoint->media.rtp.timeout && !session_media->remotely_held) {
1460                 ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout);
1461         } else if (session->endpoint->media.rtp.timeout_hold && session_media->remotely_held) {
1462                 ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout_hold);
1463         }
1464
1465         if (ast_rtp_instance_get_timeout(session_media->rtp)) {
1466                 session_media->timeout_sched_id = ast_sched_add_variable(sched,
1467                         ast_rtp_instance_get_timeout(session_media->rtp) * 1000, rtp_check_timeout,
1468                         session_media, 1);
1469         }
1470
1471         return 1;
1472 }
1473
1474 /*! \brief Function which updates the media stream with external media address, if applicable */
1475 static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
1476 {
1477         RAII_VAR(struct ast_sip_transport_state *, transport_state, ast_sip_get_transport_state(ast_sorcery_object_get_id(transport)), ao2_cleanup);
1478         char host[NI_MAXHOST];
1479         struct ast_sockaddr addr = { { 0, } };
1480
1481         /* If the stream has been rejected there will be no connection line */
1482         if (!stream->conn || !transport_state) {
1483                 return;
1484         }
1485
1486         ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
1487         ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
1488
1489         /* Is the address within the SDP inside the same network? */
1490         if (ast_apply_ha(transport_state->localnet, &addr) == AST_SENSE_ALLOW) {
1491                 return;
1492         }
1493
1494         pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
1495 }
1496
1497 /*! \brief Function which stops the RTP instance */
1498 static void stream_stop(struct ast_sip_session_media *session_media)
1499 {
1500         if (!session_media->rtp) {
1501                 return;
1502         }
1503
1504         AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
1505         AST_SCHED_DEL(sched, session_media->timeout_sched_id);
1506         ast_rtp_instance_stop(session_media->rtp);
1507 }
1508
1509 /*! \brief Function which destroys the RTP instance when session ends */
1510 static void stream_destroy(struct ast_sip_session_media *session_media)
1511 {
1512         if (session_media->rtp) {
1513                 stream_stop(session_media);
1514                 ast_rtp_instance_destroy(session_media->rtp);
1515         }
1516         session_media->rtp = NULL;
1517 }
1518
1519 /*! \brief SDP handler for 'audio' media stream */
1520 static struct ast_sip_session_sdp_handler audio_sdp_handler = {
1521         .id = STR_AUDIO,
1522         .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
1523         .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
1524         .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
1525         .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
1526         .stream_stop = stream_stop,
1527         .stream_destroy = stream_destroy,
1528 };
1529
1530 /*! \brief SDP handler for 'video' media stream */
1531 static struct ast_sip_session_sdp_handler video_sdp_handler = {
1532         .id = STR_VIDEO,
1533         .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
1534         .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
1535         .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
1536         .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
1537         .stream_stop = stream_stop,
1538         .stream_destroy = stream_destroy,
1539 };
1540
1541 static int video_info_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
1542 {
1543         struct pjsip_transaction *tsx;
1544         pjsip_tx_data *tdata;
1545
1546         if (!session->channel
1547                 || !ast_sip_is_content_type(&rdata->msg_info.msg->body->content_type,
1548                         "application",
1549                         "media_control+xml")) {
1550                 return 0;
1551         }
1552
1553         tsx = pjsip_rdata_get_tsx(rdata);
1554
1555         ast_queue_control(session->channel, AST_CONTROL_VIDUPDATE);
1556
1557         if (pjsip_dlg_create_response(session->inv_session->dlg, rdata, 200, NULL, &tdata) == PJ_SUCCESS) {
1558                 pjsip_dlg_send_response(session->inv_session->dlg, tsx, tdata);
1559         }
1560
1561         return 0;
1562 }
1563
1564 static struct ast_sip_session_supplement video_info_supplement = {
1565         .method = "INFO",
1566         .incoming_request = video_info_incoming_request,
1567 };
1568
1569 /*! \brief Unloads the sdp RTP/AVP module from Asterisk */
1570 static int unload_module(void)
1571 {
1572         ast_sip_session_unregister_supplement(&video_info_supplement);
1573         ast_sip_session_unregister_sdp_handler(&video_sdp_handler, STR_VIDEO);
1574         ast_sip_session_unregister_sdp_handler(&audio_sdp_handler, STR_AUDIO);
1575
1576         if (sched) {
1577                 ast_sched_context_destroy(sched);
1578         }
1579
1580         return 0;
1581 }
1582
1583 /*!
1584  * \brief Load the module
1585  *
1586  * Module loading including tests for configuration or dependencies.
1587  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
1588  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
1589  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
1590  * configuration file or other non-critical problem return
1591  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
1592  */
1593 static int load_module(void)
1594 {
1595         CHECK_PJSIP_SESSION_MODULE_LOADED();
1596
1597         if (ast_check_ipv6()) {
1598                 ast_sockaddr_parse(&address_rtp, "::", 0);
1599         } else {
1600                 ast_sockaddr_parse(&address_rtp, "0.0.0.0", 0);
1601         }
1602
1603         if (!(sched = ast_sched_context_create())) {
1604                 ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
1605                 goto end;
1606         }
1607
1608         if (ast_sched_start_thread(sched)) {
1609                 ast_log(LOG_ERROR, "Unable to create scheduler context thread.\n");
1610                 goto end;
1611         }
1612
1613         if (ast_sip_session_register_sdp_handler(&audio_sdp_handler, STR_AUDIO)) {
1614                 ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_AUDIO);
1615                 goto end;
1616         }
1617
1618         if (ast_sip_session_register_sdp_handler(&video_sdp_handler, STR_VIDEO)) {
1619                 ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_VIDEO);
1620                 goto end;
1621         }
1622
1623         ast_sip_session_register_supplement(&video_info_supplement);
1624
1625         return AST_MODULE_LOAD_SUCCESS;
1626 end:
1627         unload_module();
1628
1629         return AST_MODULE_LOAD_FAILURE;
1630 }
1631
1632 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP SDP RTP/AVP stream handler",
1633         .support_level = AST_MODULE_SUPPORT_CORE,
1634         .load = load_module,
1635         .unload = unload_module,
1636         .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1637 );