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