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