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