The large GULP->PJSIP renaming effort.
[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/rtp_engine.h"
45 #include "asterisk/netsock2.h"
46 #include "asterisk/channel.h"
47 #include "asterisk/causes.h"
48 #include "asterisk/sched.h"
49 #include "asterisk/acl.h"
50 #include "asterisk/sdp_srtp.h"
51
52 #include "asterisk/res_pjsip.h"
53 #include "asterisk/res_pjsip_session.h"
54
55 /*! \brief Scheduler for RTCP purposes */
56 static struct ast_sched_context *sched;
57
58 /*! \brief Address for IPv4 RTP */
59 static struct ast_sockaddr address_ipv4;
60
61 /*! \brief Address for IPv6 RTP */
62 static struct ast_sockaddr address_ipv6;
63
64 static const char STR_AUDIO[] = "audio";
65 static const int FD_AUDIO = 0;
66
67 static const char STR_VIDEO[] = "video";
68 static const int FD_VIDEO = 2;
69
70 /*! \brief Retrieves an ast_format_type based on the given stream_type */
71 static enum ast_format_type stream_to_media_type(const char *stream_type)
72 {
73         if (!strcasecmp(stream_type, STR_AUDIO)) {
74                 return AST_FORMAT_TYPE_AUDIO;
75         } else if (!strcasecmp(stream_type, STR_VIDEO)) {
76                 return AST_FORMAT_TYPE_VIDEO;
77         }
78
79         return 0;
80 }
81
82 /*! \brief Get the starting descriptor for a media type */
83 static int media_type_to_fdno(enum ast_format_type media_type)
84 {
85         switch (media_type) {
86         case AST_FORMAT_TYPE_AUDIO: return FD_AUDIO;
87         case AST_FORMAT_TYPE_VIDEO: return FD_VIDEO;
88         case AST_FORMAT_TYPE_TEXT:
89         case AST_FORMAT_TYPE_IMAGE: break;
90         }
91         return -1;
92 }
93
94 /*! \brief Remove all other cap types but the one given */
95 static void format_cap_only_type(struct ast_format_cap *caps, enum ast_format_type media_type)
96 {
97         int i = AST_FORMAT_INC;
98         while (i <= AST_FORMAT_TYPE_TEXT) {
99                 if (i != media_type) {
100                         ast_format_cap_remove_bytype(caps, i);
101                 }
102                 i += AST_FORMAT_INC;
103         }
104 }
105
106 /*! \brief Internal function which creates an RTP instance */
107 static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_media *session_media, unsigned int ipv6)
108 {
109         struct ast_rtp_engine_ice *ice;
110
111         if (!(session_media->rtp = ast_rtp_instance_new(session->endpoint->media.rtp.engine, sched, ipv6 ? &address_ipv6 : &address_ipv4, NULL))) {
112                 ast_log(LOG_ERROR, "Unable to create RTP instance using RTP engine '%s'\n", session->endpoint->media.rtp.engine);
113                 return -1;
114         }
115
116         ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_RTCP, 1);
117         ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_NAT, session->endpoint->media.rtp.symmetric);
118
119         ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session_media->rtp),
120                                          session_media->rtp, &session->endpoint->media.prefs);
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                                 ast_copy_pj_str(fmt_param, &fmtp.fmt_param, sizeof(fmt_param));
189                                 ast_format_sdp_parse(format, fmt_param);
190                         }
191                 }
192         }
193 }
194
195 static int set_caps(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
196                     const struct pjmedia_sdp_media *stream)
197 {
198         RAII_VAR(struct ast_format_cap *, caps, NULL, ast_format_cap_destroy);
199         RAII_VAR(struct ast_format_cap *, peer, NULL, ast_format_cap_destroy);
200         RAII_VAR(struct ast_format_cap *, joint, NULL, ast_format_cap_destroy);
201         enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
202         struct ast_rtp_codecs codecs;
203         struct ast_format fmt;
204         int fmts = 0;
205         int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
206                 !ast_format_cap_is_empty(session->direct_media_cap);
207
208         if (!(caps = ast_format_cap_alloc_nolock()) ||
209             !(peer = ast_format_cap_alloc_nolock())) {
210                 ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
211                 return -1;
212         }
213
214         /* get the endpoint capabilities */
215         if (direct_media_enabled) {
216                 ast_format_cap_joint_copy(session->endpoint->media.codecs, session->direct_media_cap, caps);
217         } else {
218                 ast_format_cap_copy(caps, session->endpoint->media.codecs);
219         }
220         format_cap_only_type(caps, media_type);
221
222         /* get the capabilities on the peer */
223         get_codecs(session, stream, &codecs);
224         ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
225
226         /* get the joint capabilities between peer and endpoint */
227         if (!(joint = ast_format_cap_joint(caps, peer))) {
228                 char usbuf[64], thembuf[64];
229
230                 ast_rtp_codecs_payloads_destroy(&codecs);
231
232                 ast_getformatname_multiple(usbuf, sizeof(usbuf), caps);
233                 ast_getformatname_multiple(thembuf, sizeof(thembuf), peer);
234                 ast_log(LOG_WARNING, "No joint capabilities between our configuration(%s) and incoming SDP(%s)\n", usbuf, thembuf);
235                 return -1;
236         }
237
238         ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
239                                      session_media->rtp);
240
241         ast_format_cap_copy(caps, session->req_caps);
242         ast_format_cap_remove_bytype(caps, media_type);
243         ast_format_cap_append(caps, joint);
244         ast_format_cap_append(session->req_caps, caps);
245
246         if (session->channel) {
247                 ast_format_cap_copy(caps, ast_channel_nativeformats(session->channel));
248                 ast_format_cap_remove_bytype(caps, media_type);
249                 ast_codec_choose(&session->endpoint->media.prefs, joint, 1, &fmt);
250                 ast_format_cap_add(caps, &fmt);
251
252                 /* Apply the new formats to the channel, potentially changing read/write formats while doing so */
253                 ast_format_cap_copy(ast_channel_nativeformats(session->channel), caps);
254                 ast_format_copy(ast_channel_rawwriteformat(session->channel), &fmt);
255                 ast_format_copy(ast_channel_rawreadformat(session->channel), &fmt);
256                 ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
257                 ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
258         }
259
260         ast_rtp_codecs_payloads_destroy(&codecs);
261         return 1;
262 }
263
264 static pjmedia_sdp_attr* generate_rtpmap_attr(pjmedia_sdp_media *media, pj_pool_t *pool, int rtp_code,
265                                               int asterisk_format, struct ast_format *format, int code)
266 {
267         pjmedia_sdp_rtpmap rtpmap;
268         pjmedia_sdp_attr *attr = NULL;
269         char tmp[64];
270
271         snprintf(tmp, sizeof(tmp), "%d", rtp_code);
272         pj_strdup2(pool, &media->desc.fmt[media->desc.fmt_count++], tmp);
273         rtpmap.pt = media->desc.fmt[media->desc.fmt_count - 1];
274         rtpmap.clock_rate = ast_rtp_lookup_sample_rate2(asterisk_format, format, code);
275         pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, 0));
276         rtpmap.param.slen = 0;
277
278         pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
279
280         return attr;
281 }
282
283 static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *format, int rtp_code)
284 {
285         struct ast_str *fmtp0 = ast_str_alloca(256);
286         pj_str_t fmtp1;
287         pjmedia_sdp_attr *attr = NULL;
288         char *tmp;
289
290         ast_format_sdp_generate(format, rtp_code, &fmtp0);
291         if (ast_str_strlen(fmtp0)) {
292                 tmp = ast_str_buffer(fmtp0) + ast_str_strlen(fmtp0) - 1;
293                 /* remove any carriage return line feeds */
294                 while (*tmp == '\r' || *tmp == '\n') --tmp;
295                 *++tmp = '\0';
296                 /* ast...generate gives us everything, just need value */
297                 tmp = strchr(ast_str_buffer(fmtp0), ':');
298                 if (tmp && tmp + 1) {
299                         fmtp1 = pj_str(tmp + 1);
300                 } else {
301                         fmtp1 = pj_str(ast_str_buffer(fmtp0));
302                 }
303                 attr = pjmedia_sdp_attr_create(pool, "fmtp", &fmtp1);
304         }
305         return attr;
306 }
307
308 static int codec_pref_has_type(struct ast_codec_pref *prefs, enum ast_format_type media_type)
309 {
310         int i;
311         struct ast_format fmt;
312         for (i = 0; ast_codec_pref_index(prefs, i, &fmt); ++i) {
313                 if (AST_FORMAT_GET_TYPE(fmt.id) == media_type) {
314                         return 1;
315                 }
316         }
317         return 0;
318 }
319
320 /*! \brief Function which adds ICE attributes to a media stream */
321 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)
322 {
323         struct ast_rtp_engine_ice *ice;
324         struct ao2_container *candidates;
325         const char *username, *password;
326         pj_str_t stmp;
327         pjmedia_sdp_attr *attr;
328         struct ao2_iterator it_candidates;
329         struct ast_rtp_engine_ice_candidate *candidate;
330
331         if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp)) ||
332                 !(candidates = ice->get_local_candidates(session_media->rtp))) {
333                 return;
334         }
335
336         if ((username = ice->get_ufrag(session_media->rtp))) {
337                 attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", pj_cstr(&stmp, username));
338                 media->attr[media->attr_count++] = attr;
339         }
340
341         if ((password = ice->get_password(session_media->rtp))) {
342                 attr = pjmedia_sdp_attr_create(pool, "ice-pwd", pj_cstr(&stmp, password));
343                 media->attr[media->attr_count++] = attr;
344         }
345
346         it_candidates = ao2_iterator_init(candidates, 0);
347         for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) {
348                 struct ast_str *attr_candidate = ast_str_create(128);
349
350                 ast_str_set(&attr_candidate, -1, "%s %d %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
351                                         candidate->priority, ast_sockaddr_stringify_host(&candidate->address));
352                 ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address));
353
354                 switch (candidate->type) {
355                         case AST_RTP_ICE_CANDIDATE_TYPE_HOST:
356                                 ast_str_append(&attr_candidate, -1, "host");
357                                 break;
358                         case AST_RTP_ICE_CANDIDATE_TYPE_SRFLX:
359                                 ast_str_append(&attr_candidate, -1, "srflx");
360                                 break;
361                         case AST_RTP_ICE_CANDIDATE_TYPE_RELAYED:
362                                 ast_str_append(&attr_candidate, -1, "relay");
363                                 break;
364                 }
365
366                 if (!ast_sockaddr_isnull(&candidate->relay_address)) {
367                         ast_str_append(&attr_candidate, -1, " raddr %s rport ", ast_sockaddr_stringify_host(&candidate->relay_address));
368                         ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address));
369                 }
370
371                 attr = pjmedia_sdp_attr_create(pool, "candidate", pj_cstr(&stmp, ast_str_buffer(attr_candidate)));
372                 media->attr[media->attr_count++] = attr;
373
374                 ast_free(attr_candidate);
375         }
376
377         ao2_iterator_destroy(&it_candidates);
378 }
379
380 /*! \brief Function which processes ICE attributes in an audio stream */
381 static void process_ice_attributes(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
382                                    const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
383 {
384         struct ast_rtp_engine_ice *ice;
385         const pjmedia_sdp_attr *attr;
386         char attr_value[256];
387         unsigned int attr_i;
388
389         /* If ICE support is not enabled or available exit early */
390         if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp))) {
391                 return;
392         }
393
394         if ((attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-ufrag", NULL))) {
395                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
396                 ice->set_authentication(session_media->rtp, attr_value, NULL);
397         }
398
399         if ((attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-pwd", NULL))) {
400                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
401                 ice->set_authentication(session_media->rtp, NULL, attr_value);
402         }
403
404         if (pjmedia_sdp_media_find_attr2(remote_stream, "ice-lite", NULL)) {
405                 ice->ice_lite(session_media->rtp);
406         }
407
408         /* Find all of the candidates */
409         for (attr_i = 0; attr_i < remote_stream->attr_count; ++attr_i) {
410                 char foundation[32], transport[32], address[PJ_INET6_ADDRSTRLEN + 1], cand_type[6], relay_address[PJ_INET6_ADDRSTRLEN + 1] = "";
411                 int port, relay_port = 0;
412                 struct ast_rtp_engine_ice_candidate candidate = { 0, };
413
414                 attr = remote_stream->attr[attr_i];
415
416                 /* If this is not a candidate line skip it */
417                 if (pj_strcmp2(&attr->name, "candidate")) {
418                         continue;
419                 }
420
421                 ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
422
423                 if (sscanf(attr_value, "%31s %30u %31s %30u %46s %30u typ %5s %*s %23s %*s %30u", foundation, &candidate.id, transport,
424                         &candidate.priority, address, &port, cand_type, relay_address, &relay_port) < 7) {
425                         /* Candidate did not parse properly */
426                         continue;
427                 }
428
429                 candidate.foundation = foundation;
430                 candidate.transport = transport;
431
432                 ast_sockaddr_parse(&candidate.address, address, PARSE_PORT_FORBID);
433                 ast_sockaddr_set_port(&candidate.address, port);
434
435                 if (!strcasecmp(cand_type, "host")) {
436                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
437                 } else if (!strcasecmp(cand_type, "srflx")) {
438                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
439                 } else if (!strcasecmp(cand_type, "relay")) {
440                         candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
441                 } else {
442                         continue;
443                 }
444
445                 if (!ast_strlen_zero(relay_address)) {
446                         ast_sockaddr_parse(&candidate.relay_address, relay_address, PARSE_PORT_FORBID);
447                 }
448
449                 if (relay_port) {
450                         ast_sockaddr_set_port(&candidate.relay_address, relay_port);
451                 }
452
453                 ice->add_remote_candidate(session_media->rtp, &candidate);
454         }
455
456         ice->start(session_media->rtp);
457 }
458
459 static void apply_packetization(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
460                          const struct pjmedia_sdp_media *remote_stream)
461 {
462         pjmedia_sdp_attr *attr;
463         pj_str_t value;
464         unsigned long framing;
465         int codec;
466         struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(session_media->rtp)->pref;
467
468         /* Apply packetization if available and configured to do so */
469         if (!session->endpoint->media.rtp.use_ptime || !(attr = pjmedia_sdp_media_find_attr2(remote_stream, "ptime", NULL))) {
470                 return;
471         }
472
473         value = attr->value;
474         framing = pj_strtoul(pj_strltrim(&value));
475
476         for (codec = 0; codec < AST_RTP_MAX_PT; codec++) {
477                 struct ast_rtp_payload_type format = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(
478                                                                                            session_media->rtp), codec);
479
480                 if (!format.asterisk_format) {
481                         continue;
482                 }
483
484                 ast_codec_pref_setsize(pref, &format.format, framing);
485         }
486
487         ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session_media->rtp),
488                                          session_media->rtp, pref);
489 }
490
491 /*! \brief figure out media transport encryption type from the media transport string */
492 static enum ast_sip_session_media_encryption get_media_encryption_type(pj_str_t transport)
493 {
494         RAII_VAR(char *, transport_str, ast_strndup(transport.ptr, transport.slen), ast_free);
495         if (strstr(transport_str, "UDP/TLS")) {
496                 return AST_SIP_MEDIA_ENCRYPT_DTLS;
497         } else if (strstr(transport_str, "SAVP")) {
498                 return AST_SIP_MEDIA_ENCRYPT_SDES;
499         } else {
500                 return AST_SIP_MEDIA_ENCRYPT_NONE;
501         }
502 }
503
504 /*!
505  * \brief Checks whether the encryption offered in SDP is compatible with the endpoint's configuration
506  * \internal
507  *
508  * \param endpoint_encryption Media encryption configured for the endpoint
509  * \param stream pjmedia_sdp_media stream description
510  *
511  * \retval AST_SIP_MEDIA_TRANSPORT_INVALID on encryption mismatch
512  * \retval The encryption requested in the SDP
513  */
514 static enum ast_sip_session_media_encryption check_endpoint_media_transport(
515         struct ast_sip_endpoint *endpoint,
516         const struct pjmedia_sdp_media *stream)
517 {
518         enum ast_sip_session_media_encryption incoming_encryption;
519
520         if (endpoint->media.rtp.use_avpf) {
521                 char transport_end = stream->desc.transport.ptr[stream->desc.transport.slen - 1];
522                 if (transport_end != 'F') {
523                         return AST_SIP_MEDIA_TRANSPORT_INVALID;
524                 }
525         }
526
527         incoming_encryption = get_media_encryption_type(stream->desc.transport);
528
529         if (incoming_encryption == endpoint->media.rtp.encryption) {
530                 return incoming_encryption;
531         }
532
533         return AST_SIP_MEDIA_TRANSPORT_INVALID;
534 }
535
536 static int setup_srtp(struct ast_sip_session_media *session_media)
537 {
538         if (!session_media->srtp) {
539                 session_media->srtp = ast_sdp_srtp_alloc();
540                 if (!session_media->srtp) {
541                         return -1;
542                 }
543         }
544
545         if (!session_media->srtp->crypto) {
546                 session_media->srtp->crypto = ast_sdp_crypto_alloc();
547                 if (!session_media->srtp->crypto) {
548                         return -1;
549                 }
550         }
551
552         return 0;
553 }
554
555 static int setup_dtls_srtp(struct ast_sip_session *session,
556         struct ast_sip_session_media *session_media)
557 {
558         struct ast_rtp_engine_dtls *dtls;
559
560         if (!session->endpoint->media.rtp.dtls_cfg.enabled || !session_media->rtp) {
561                 return -1;
562         }
563
564         dtls = ast_rtp_instance_get_dtls(session_media->rtp);
565         if (!dtls) {
566                 return -1;
567         }
568
569         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);
570         if (dtls->set_configuration(session_media->rtp, &session->endpoint->media.rtp.dtls_cfg)) {
571                 ast_log(LOG_ERROR, "Attempted to set an invalid DTLS-SRTP configuration on RTP instance '%p'\n",
572                         session_media->rtp);
573                 return -1;
574         }
575
576         if (setup_srtp(session_media)) {
577                 return -1;
578         }
579         return 0;
580 }
581
582 static int parse_dtls_attrib(struct ast_sip_session_media *session_media,
583         const struct pjmedia_sdp_media *stream)
584 {
585         int i;
586         struct ast_rtp_engine_dtls *dtls = ast_rtp_instance_get_dtls(session_media->rtp);
587
588         for (i = 0; i < stream->attr_count; i++) {
589                 pjmedia_sdp_attr *attr = stream->attr[i];
590                 pj_str_t *value;
591
592                 if (!attr->value.ptr) {
593                         continue;
594                 }
595
596                 value = pj_strtrim(&attr->value);
597
598                 if (!pj_strcmp2(&attr->name, "setup")) {
599                         if (!pj_stricmp2(value, "active")) {
600                                 dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTIVE);
601                         } else if (!pj_stricmp2(value, "passive")) {
602                                 dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_PASSIVE);
603                         } else if (!pj_stricmp2(value, "actpass")) {
604                                 dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTPASS);
605                         } else if (!pj_stricmp2(value, "holdconn")) {
606                                 dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_HOLDCONN);
607                         } else {
608                                 ast_log(LOG_WARNING, "Unsupported setup attribute value '%*s'\n", (int)value->slen, value->ptr);
609                         }
610                 } else if (!pj_strcmp2(&attr->name, "connection")) {
611                         if (!pj_stricmp2(value, "new")) {
612                                 dtls->reset(session_media->rtp);
613                         } else if (!pj_stricmp2(value, "existing")) {
614                                 /* Do nothing */
615                         } else {
616                                 ast_log(LOG_WARNING, "Unsupported connection attribute value '%*s'\n", (int)value->slen, value->ptr);
617                         }
618                 } else if (!pj_strcmp2(&attr->name, "fingerprint")) {
619                         char hash_value[256], hash[6];
620                         char fingerprint_text[value->slen + 1];
621                         ast_copy_pj_str(fingerprint_text, value, sizeof(fingerprint_text));
622
623                         if (sscanf(fingerprint_text, "%5s %255s", hash, hash_value) == 2) {
624                                 if (!strcasecmp(hash, "sha-1")) {
625                                         dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1, hash_value);
626                                 } else {
627                                         ast_log(LOG_WARNING, "Unsupported fingerprint hash type '%s'\n",
628                                         hash);
629                                 }
630                         }
631                 }
632         }
633         ast_set_flag(session_media->srtp, AST_SRTP_CRYPTO_OFFER_OK);
634
635         return 0;
636 }
637
638 static int setup_sdes_srtp(struct ast_sip_session_media *session_media,
639         const struct pjmedia_sdp_media *stream)
640 {
641         int i;
642
643         for (i = 0; i < stream->attr_count; i++) {
644                 pjmedia_sdp_attr *attr;
645                 RAII_VAR(char *, crypto_str, NULL, ast_free);
646
647                 /* check the stream for the required crypto attribute */
648                 attr = stream->attr[i];
649                 if (pj_strcmp2(&attr->name, "crypto")) {
650                         continue;
651                 }
652
653                 crypto_str = ast_strndup(attr->value.ptr, attr->value.slen);
654                 if (!crypto_str) {
655                         return -1;
656                 }
657
658                 if (setup_srtp(session_media)) {
659                         return -1;
660                 }
661
662                 if (!ast_sdp_crypto_process(session_media->rtp, session_media->srtp, crypto_str)) {
663                         /* found a valid crypto attribute */
664                         return 0;
665                 }
666
667                 ast_debug(1, "Ignoring crypto offer with unsupported parameters: %s\n", crypto_str);
668         }
669
670         /* no usable crypto attributes found */
671         return -1;
672 }
673
674 static int setup_media_encryption(struct ast_sip_session *session,
675         struct ast_sip_session_media *session_media,
676         const struct pjmedia_sdp_media *stream)
677 {
678         switch (session->endpoint->media.rtp.encryption) {
679         case AST_SIP_MEDIA_ENCRYPT_SDES:
680                 if (setup_sdes_srtp(session_media, stream)) {
681                         return -1;
682                 }
683                 break;
684         case AST_SIP_MEDIA_ENCRYPT_DTLS:
685                 if (setup_dtls_srtp(session, session_media)) {
686                         return -1;
687                 }
688                 if (parse_dtls_attrib(session_media, stream)) {
689                         return -1;
690                 }
691                 break;
692         case AST_SIP_MEDIA_TRANSPORT_INVALID:
693         case AST_SIP_MEDIA_ENCRYPT_NONE:
694                 break;
695         }
696
697         return 0;
698 }
699
700 /*! \brief Function which negotiates an incoming media stream */
701 static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
702                                          const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
703 {
704         char host[NI_MAXHOST];
705         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
706         enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
707
708         /* If no type formats have been configured reject this stream */
709         if (!ast_format_cap_has_type(session->endpoint->media.codecs, media_type)) {
710                 return 0;
711         }
712
713         /* Ensure incoming transport is compatible with the endpoint's configuration */
714         if (check_endpoint_media_transport(session->endpoint, stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
715                 return -1;
716         }
717
718         ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
719
720         /* Ensure that the address provided is valid */
721         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
722                 /* The provided host was actually invalid so we error out this negotiation */
723                 return -1;
724         }
725
726         /* Using the connection information create an appropriate RTP instance */
727         if (!session_media->rtp && create_rtp(session, session_media, ast_sockaddr_is_ipv6(addrs))) {
728                 return -1;
729         }
730
731         if (setup_media_encryption(session, session_media, stream)) {
732                 return -1;
733         }
734
735         return set_caps(session, session_media, stream);
736 }
737
738 static int add_crypto_to_stream(struct ast_sip_session *session,
739         struct ast_sip_session_media *session_media,
740         pj_pool_t *pool, pjmedia_sdp_media *media)
741 {
742         pj_str_t stmp;
743         pjmedia_sdp_attr *attr;
744         const char *crypto_attribute;
745         struct ast_rtp_engine_dtls *dtls;
746         static const pj_str_t STR_NEW = { "new", 3 };
747         static const pj_str_t STR_EXISTING = { "existing", 8 };
748         static const pj_str_t STR_ACTIVE = { "active", 6 };
749         static const pj_str_t STR_PASSIVE = { "passive", 7 };
750         static const pj_str_t STR_ACTPASS = { "actpass", 7 };
751         static const pj_str_t STR_HOLDCONN = { "holdconn", 8 };
752
753         switch (session->endpoint->media.rtp.encryption) {
754         case AST_SIP_MEDIA_ENCRYPT_NONE:
755         case AST_SIP_MEDIA_TRANSPORT_INVALID:
756                 break;
757         case AST_SIP_MEDIA_ENCRYPT_SDES:
758                 if (!session_media->srtp) {
759                         session_media->srtp = ast_sdp_srtp_alloc();
760                         if (!session_media->srtp) {
761                                 return -1;
762                         }
763                 }
764
765                 crypto_attribute = ast_sdp_srtp_get_attrib(session_media->srtp,
766                         0 /* DTLS running? No */,
767                         session->endpoint->media.rtp.srtp_tag_32 /* 32 byte tag length? */);
768                 if (!crypto_attribute) {
769                         /* No crypto attribute to add, bad news */
770                         return -1;
771                 }
772
773                 attr = pjmedia_sdp_attr_create(pool, "crypto", pj_cstr(&stmp, crypto_attribute));
774                 media->attr[media->attr_count++] = attr;
775                 break;
776         case AST_SIP_MEDIA_ENCRYPT_DTLS:
777                 if (setup_dtls_srtp(session, session_media)) {
778                         return -1;
779                 }
780
781                 dtls = ast_rtp_instance_get_dtls(session_media->rtp);
782                 if (!dtls) {
783                         return -1;
784                 }
785
786                 switch (dtls->get_connection(session_media->rtp)) {
787                 case AST_RTP_DTLS_CONNECTION_NEW:
788                         attr = pjmedia_sdp_attr_create(pool, "connection", &STR_NEW);
789                         media->attr[media->attr_count++] = attr;
790                         break;
791                 case AST_RTP_DTLS_CONNECTION_EXISTING:
792                         attr = pjmedia_sdp_attr_create(pool, "connection", &STR_EXISTING);
793                         media->attr[media->attr_count++] = attr;
794                         break;
795                 default:
796                         break;
797                 }
798
799                 switch (dtls->get_setup(session_media->rtp)) {
800                 case AST_RTP_DTLS_SETUP_ACTIVE:
801                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTIVE);
802                         media->attr[media->attr_count++] = attr;
803                         break;
804                 case AST_RTP_DTLS_SETUP_PASSIVE:
805                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_PASSIVE);
806                         media->attr[media->attr_count++] = attr;
807                         break;
808                 case AST_RTP_DTLS_SETUP_ACTPASS:
809                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTPASS);
810                         media->attr[media->attr_count++] = attr;
811                         break;
812                 case AST_RTP_DTLS_SETUP_HOLDCONN:
813                         attr = pjmedia_sdp_attr_create(pool, "setup", &STR_HOLDCONN);
814                         media->attr[media->attr_count++] = attr;
815                         break;
816                 default:
817                         break;
818                 }
819
820                 if ((crypto_attribute = dtls->get_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1))) {
821                         RAII_VAR(struct ast_str *, fingerprint, ast_str_create(64), ast_free);
822                         if (!fingerprint) {
823                                 return -1;
824                         }
825
826                         ast_str_set(&fingerprint, 0, "SHA-1 %s", crypto_attribute);
827
828                         attr = pjmedia_sdp_attr_create(pool, "fingerprint", pj_cstr(&stmp, ast_str_buffer(fingerprint)));
829                         media->attr[media->attr_count++] = attr;
830                 }
831                 break;
832         }
833
834         return 0;
835 }
836
837 /*! \brief Function which creates an outgoing stream */
838 static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
839                                       struct pjmedia_sdp_session *sdp)
840 {
841         pj_pool_t *pool = session->inv_session->pool_prov;
842         static const pj_str_t STR_IN = { "IN", 2 };
843         static const pj_str_t STR_IP4 = { "IP4", 3};
844         static const pj_str_t STR_IP6 = { "IP6", 3};
845         static const pj_str_t STR_SENDRECV = { "sendrecv", 8 };
846         pjmedia_sdp_media *media;
847         char hostip[PJ_INET6_ADDRSTRLEN+2];
848         struct ast_sockaddr addr;
849         char tmp[512];
850         pj_str_t stmp;
851         pjmedia_sdp_attr *attr;
852         int index = 0, min_packet_size = 0, noncodec = (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733) ? AST_RTP_DTMF : 0;
853         int rtp_code;
854         struct ast_format format;
855         RAII_VAR(struct ast_format_cap *, caps, NULL, ast_format_cap_destroy);
856         enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
857
858         int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
859                 !ast_format_cap_is_empty(session->direct_media_cap);
860
861         int use_override_prefs = session->override_prefs.formats[0].id;
862         struct ast_codec_pref *prefs = use_override_prefs ?
863                 &session->override_prefs : &session->endpoint->media.prefs;
864
865         if ((use_override_prefs && !codec_pref_has_type(&session->override_prefs, media_type)) ||
866             (!use_override_prefs && !ast_format_cap_has_type(session->endpoint->media.codecs, media_type))) {
867                 /* If no type formats are configured don't add a stream */
868                 return 0;
869         } else if (!session_media->rtp && create_rtp(session, session_media, session->endpoint->media.rtp.ipv6)) {
870                 return -1;
871         }
872
873         if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
874                 !(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
875                 return -1;
876         }
877
878         if (add_crypto_to_stream(session, session_media, pool, media)) {
879                 return -1;
880         }
881
882         media->desc.media = pj_str(session_media->stream_type);
883         media->desc.transport = pj_str(ast_sdp_get_rtp_profile(
884                 session->endpoint->media.rtp.encryption == AST_SIP_MEDIA_ENCRYPT_SDES,
885                 session_media->rtp, session->endpoint->media.rtp.use_avpf));
886
887         /* Add connection level details */
888         if (direct_media_enabled) {
889                 ast_copy_string(hostip, ast_sockaddr_stringify_fmt(&session_media->direct_media_addr, AST_SOCKADDR_STR_ADDR), sizeof(hostip));
890         } else if (ast_strlen_zero(session->endpoint->media.external_address)) {
891                 pj_sockaddr localaddr;
892
893                 if (pj_gethostip(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET(), &localaddr)) {
894                         return -1;
895                 }
896                 pj_sockaddr_print(&localaddr, hostip, sizeof(hostip), 2);
897         } else {
898                 ast_copy_string(hostip, session->endpoint->media.external_address, sizeof(hostip));
899         }
900
901         media->conn->net_type = STR_IN;
902         media->conn->addr_type = session->endpoint->media.rtp.ipv6 ? STR_IP6 : STR_IP4;
903         pj_strdup2(pool, &media->conn->addr, hostip);
904         ast_rtp_instance_get_local_address(session_media->rtp, &addr);
905         media->desc.port = direct_media_enabled ? ast_sockaddr_port(&session_media->direct_media_addr) : (pj_uint16_t) ast_sockaddr_port(&addr);
906         media->desc.port_count = 1;
907
908         /* Add ICE attributes and candidates */
909         add_ice_to_stream(session, session_media, pool, media);
910
911         if (!(caps = ast_format_cap_alloc_nolock())) {
912                 ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
913                 return -1;
914         }
915
916         if (direct_media_enabled) {
917                 ast_format_cap_joint_copy(session->endpoint->media.codecs, session->direct_media_cap, caps);
918         } else if (ast_format_cap_is_empty(session->req_caps) || !ast_format_cap_has_joint(session->req_caps, session->endpoint->media.codecs)) {
919                 ast_format_cap_copy(caps, session->endpoint->media.codecs);
920         } else {
921                 ast_format_cap_copy(caps, session->req_caps);
922         }
923
924         for (index = 0; ast_codec_pref_index(prefs, index, &format); ++index) {
925                 struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(session_media->rtp)->pref;
926
927                 if (AST_FORMAT_GET_TYPE(format.id) != media_type) {
928                         continue;
929                 }
930
931                 if (!use_override_prefs && !ast_format_cap_get_compatible_format(caps, &format, &format)) {
932                         continue;
933                 }
934
935                 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp), 1, &format, 0)) == -1) {
936                         return -1;
937                 }
938
939                 if (!(attr = generate_rtpmap_attr(media, pool, rtp_code, 1, &format, 0))) {
940                         continue;
941                 }
942
943                 media->attr[media->attr_count++] = attr;
944
945                 if ((attr = generate_fmtp_attr(pool, &format, rtp_code))) {
946                         media->attr[media->attr_count++] = attr;
947                 }
948
949                 if (pref && media_type != AST_FORMAT_TYPE_VIDEO) {
950                         struct ast_format_list fmt = ast_codec_pref_getsize(pref, &format);
951                         if (fmt.cur_ms && ((fmt.cur_ms < min_packet_size) || !min_packet_size)) {
952                                 min_packet_size = fmt.cur_ms;
953                         }
954                 }
955         }
956
957         /* Add non-codec formats */
958         if (media_type != AST_FORMAT_TYPE_VIDEO) {
959                 for (index = 1LL; index <= AST_RTP_MAX; index <<= 1) {
960                         if (!(noncodec & index) || (rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp),
961                                                                                            0, NULL, index)) == -1) {
962                                 continue;
963                         }
964
965                         if (!(attr = generate_rtpmap_attr(media, pool, rtp_code, 0, NULL, index))) {
966                                 continue;
967                         }
968
969                         media->attr[media->attr_count++] = attr;
970
971                         if (index == AST_RTP_DTMF) {
972                                 snprintf(tmp, sizeof(tmp), "%d 0-16", rtp_code);
973                                 attr = pjmedia_sdp_attr_create(pool, "fmtp", pj_cstr(&stmp, tmp));
974                                 media->attr[media->attr_count++] = attr;
975                         }
976                 }
977         }
978
979         /* If ptime is set add it as an attribute */
980         if (min_packet_size) {
981                 snprintf(tmp, sizeof(tmp), "%d", min_packet_size);
982                 attr = pjmedia_sdp_attr_create(pool, "ptime", pj_cstr(&stmp, tmp));
983                 media->attr[media->attr_count++] = attr;
984         }
985
986         /* Add the sendrecv attribute - we purposely don't keep track because pjmedia-sdp will automatically change our offer for us */
987         attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
988         attr->name = STR_SENDRECV;
989         media->attr[media->attr_count++] = attr;
990
991         /* Add the media stream to the SDP */
992         sdp->media[sdp->media_count++] = media;
993
994         return 1;
995 }
996
997 static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
998                                        const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
999                                        const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
1000 {
1001         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
1002         enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
1003         char host[NI_MAXHOST];
1004         int fdno;
1005
1006         if (!session->channel) {
1007                 return 1;
1008         }
1009
1010         /* Ensure incoming transport is compatible with the endpoint's configuration */
1011         if (check_endpoint_media_transport(session->endpoint, remote_stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
1012                 return -1;
1013         }
1014
1015         /* Create an RTP instance if need be */
1016         if (!session_media->rtp && create_rtp(session, session_media, session->endpoint->media.rtp.ipv6)) {
1017                 return -1;
1018         }
1019
1020         if (setup_media_encryption(session, session_media, remote_stream)) {
1021                 return -1;
1022         }
1023
1024         ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
1025
1026         /* Ensure that the address provided is valid */
1027         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
1028                 /* The provided host was actually invalid so we error out this negotiation */
1029                 return -1;
1030         }
1031
1032         /* Apply connection information to the RTP instance */
1033         ast_sockaddr_set_port(addrs, remote_stream->desc.port);
1034         ast_rtp_instance_set_remote_address(session_media->rtp, addrs);
1035
1036         if (set_caps(session, session_media, local_stream) < 1) {
1037                 return -1;
1038         }
1039
1040         if (media_type == AST_FORMAT_TYPE_AUDIO) {
1041                 apply_packetization(session, session_media, remote_stream);
1042         }
1043
1044         if ((fdno = media_type_to_fdno(media_type)) < 0) {
1045                 return -1;
1046         }
1047         ast_channel_set_fd(session->channel, fdno, ast_rtp_instance_fd(session_media->rtp, 0));
1048         ast_channel_set_fd(session->channel, fdno + 1, ast_rtp_instance_fd(session_media->rtp, 1));
1049
1050         /* If ICE support is enabled find all the needed attributes */
1051         process_ice_attributes(session, session_media, remote, remote_stream);
1052
1053         /* audio stream handles music on hold */
1054         if (media_type != AST_FORMAT_TYPE_AUDIO) {
1055                 return 1;
1056         }
1057
1058         /* Music on hold for audio streams only */
1059         if (session_media->held &&
1060             (!ast_sockaddr_isnull(addrs) ||
1061              !pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL))) {
1062                 /* The remote side has taken us off hold */
1063                 ast_queue_unhold(session->channel);
1064                 ast_queue_frame(session->channel, &ast_null_frame);
1065                 session_media->held = 0;
1066         } else if (ast_sockaddr_isnull(addrs) ||
1067                    ast_sockaddr_is_any(addrs) ||
1068                    pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL)) {
1069                 /* The remote side has put us on hold */
1070                 ast_queue_hold(session->channel, session->endpoint->mohsuggest);
1071                 ast_rtp_instance_stop(session_media->rtp);
1072                 ast_queue_frame(session->channel, &ast_null_frame);
1073                 session_media->held = 1;
1074         } else {
1075                 /* The remote side has not changed state, but make sure the instance is active */
1076                 ast_rtp_instance_activate(session_media->rtp);
1077         }
1078
1079         return 1;
1080 }
1081
1082 /*! \brief Function which updates the media stream with external media address, if applicable */
1083 static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
1084 {
1085         char host[NI_MAXHOST];
1086         struct ast_sockaddr addr = { { 0, } };
1087
1088         ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
1089         ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
1090
1091         /* Is the address within the SDP inside the same network? */
1092         if (ast_apply_ha(transport->localnet, &addr) == AST_SENSE_ALLOW) {
1093                 return;
1094         }
1095
1096         pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
1097 }
1098
1099 /*! \brief Function which destroys the RTP instance when session ends */
1100 static void stream_destroy(struct ast_sip_session_media *session_media)
1101 {
1102         if (session_media->rtp) {
1103                 ast_rtp_instance_stop(session_media->rtp);
1104                 ast_rtp_instance_destroy(session_media->rtp);
1105         }
1106 }
1107
1108 /*! \brief SDP handler for 'audio' media stream */
1109 static struct ast_sip_session_sdp_handler audio_sdp_handler = {
1110         .id = STR_AUDIO,
1111         .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
1112         .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
1113         .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
1114         .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
1115         .stream_destroy = stream_destroy,
1116 };
1117
1118 /*! \brief SDP handler for 'video' media stream */
1119 static struct ast_sip_session_sdp_handler video_sdp_handler = {
1120         .id = STR_VIDEO,
1121         .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
1122         .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
1123         .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
1124         .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
1125         .stream_destroy = stream_destroy,
1126 };
1127
1128 static int video_info_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
1129 {
1130         struct pjsip_transaction *tsx = pjsip_rdata_get_tsx(rdata);
1131         pjsip_tx_data *tdata;
1132
1133         if (!ast_sip_is_content_type(&rdata->msg_info.msg->body->content_type,
1134                                      "application",
1135                                      "media_control+xml")) {
1136                 return 0;
1137         }
1138
1139         ast_queue_control(session->channel, AST_CONTROL_VIDUPDATE);
1140
1141         if (pjsip_dlg_create_response(session->inv_session->dlg, rdata, 200, NULL, &tdata) == PJ_SUCCESS) {
1142                 pjsip_dlg_send_response(session->inv_session->dlg, tsx, tdata);
1143         }
1144
1145         return 0;
1146 }
1147
1148 static struct ast_sip_session_supplement video_info_supplement = {
1149         .method = "INFO",
1150         .incoming_request = video_info_incoming_request,
1151 };
1152
1153 /*! \brief Unloads the sdp RTP/AVP module from Asterisk */
1154 static int unload_module(void)
1155 {
1156         ast_sip_session_unregister_supplement(&video_info_supplement);
1157         ast_sip_session_unregister_sdp_handler(&video_sdp_handler, STR_VIDEO);
1158         ast_sip_session_unregister_sdp_handler(&audio_sdp_handler, STR_AUDIO);
1159
1160         if (sched) {
1161                 ast_sched_context_destroy(sched);
1162         }
1163
1164         return 0;
1165 }
1166
1167 /*!
1168  * \brief Load the module
1169  *
1170  * Module loading including tests for configuration or dependencies.
1171  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
1172  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
1173  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
1174  * configuration file or other non-critical problem return
1175  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
1176  */
1177 static int load_module(void)
1178 {
1179         ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
1180         ast_sockaddr_parse(&address_ipv6, "::", 0);
1181
1182         if (!(sched = ast_sched_context_create())) {
1183                 ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
1184                 goto end;
1185         }
1186
1187         if (ast_sched_start_thread(sched)) {
1188                 ast_log(LOG_ERROR, "Unable to create scheduler context thread.\n");
1189                 goto end;
1190         }
1191
1192         if (ast_sip_session_register_sdp_handler(&audio_sdp_handler, STR_AUDIO)) {
1193                 ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_AUDIO);
1194                 goto end;
1195         }
1196
1197         if (ast_sip_session_register_sdp_handler(&video_sdp_handler, STR_VIDEO)) {
1198                 ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_VIDEO);
1199                 goto end;
1200         }
1201
1202         ast_sip_session_register_supplement(&video_info_supplement);
1203
1204         return AST_MODULE_LOAD_SUCCESS;
1205 end:
1206         unload_module();
1207
1208         return AST_MODULE_LOAD_FAILURE;
1209 }
1210
1211 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP SDP RTP/AVP stream handler",
1212                 .load = load_module,
1213                 .unload = unload_module,
1214                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1215         );