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