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