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