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