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