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