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