6 * Copyright (C) 2011-12 SIPE Project <http://sipe.sourceforge.net/>
7 * Copyright (C) 2010 Jakub Adam <jakub.adam@ktknet.cz>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #include "sipe-common.h"
36 #include "sip-transport.h"
37 #include "sipe-backend.h"
39 #include "sipe-chat.h"
40 #include "sipe-core.h"
41 #include "sipe-core-private.h"
42 #include "sipe-dialog.h"
43 #include "sipe-media.h"
44 #include "sipe-ocs2007.h"
45 #include "sipe-session.h"
46 #include "sipe-utils.h"
48 #include "sipe-schedule.h"
51 struct sipe_media_call_private
{
52 struct sipe_media_call
public;
54 /* private part starts here */
55 struct sipe_core_private
*sipe_private
;
58 struct sipmsg
*invitation
;
59 SipeIceVersion ice_version
;
60 gboolean encryption_compatible
;
65 #define SIPE_MEDIA_CALL ((struct sipe_media_call *) call_private)
66 #define SIPE_MEDIA_CALL_PRIVATE ((struct sipe_media_call_private *) call)
68 static void sipe_media_codec_list_free(GList
*codecs
)
70 for (; codecs
; codecs
= g_list_delete_link(codecs
, codecs
))
71 sipe_backend_codec_free(codecs
->data
);
74 static void sipe_media_candidate_list_free(GList
*candidates
)
76 for (; candidates
; candidates
= g_list_delete_link(candidates
, candidates
))
77 sipe_backend_candidate_free(candidates
->data
);
81 sipe_media_call_free(struct sipe_media_call_private
*call_private
)
84 struct sip_session
*session
;
85 sipe_backend_media_free(call_private
->public.backend_private
);
87 session
= sipe_session_find_call(call_private
->sipe_private
,
90 sipe_session_remove(call_private
->sipe_private
, session
);
92 if (call_private
->invitation
)
93 sipmsg_free(call_private
->invitation
);
95 sdpmsg_free(call_private
->smsg
);
96 g_slist_free_full(call_private
->failed_media
,
97 (GDestroyNotify
)sdpmedia_free
);
98 g_free(call_private
->with
);
104 backend_candidates_to_sdpcandidate(GList
*candidates
)
106 GSList
*result
= NULL
;
109 for (i
= candidates
; i
; i
= i
->next
) {
110 struct sipe_backend_candidate
*candidate
= i
->data
;
111 struct sdpcandidate
*c
= g_new(struct sdpcandidate
, 1);
113 c
->foundation
= sipe_backend_candidate_get_foundation(candidate
);
114 c
->component
= sipe_backend_candidate_get_component_type(candidate
);
115 c
->type
= sipe_backend_candidate_get_type(candidate
);
116 c
->protocol
= sipe_backend_candidate_get_protocol(candidate
);
117 c
->ip
= sipe_backend_candidate_get_ip(candidate
);
118 c
->port
= sipe_backend_candidate_get_port(candidate
);
119 c
->base_ip
= sipe_backend_candidate_get_base_ip(candidate
);
120 c
->base_port
= sipe_backend_candidate_get_base_port(candidate
);
121 c
->priority
= sipe_backend_candidate_get_priority(candidate
);
122 c
->username
= sipe_backend_candidate_get_username(candidate
);
123 c
->password
= sipe_backend_candidate_get_password(candidate
);
125 result
= g_slist_append(result
, c
);
132 get_stream_ip_and_ports(GSList
*candidates
,
133 gchar
**ip
, guint
*rtp_port
, guint
*rtcp_port
,
134 SipeCandidateType type
)
139 for (; candidates
; candidates
= candidates
->next
) {
140 struct sdpcandidate
*candidate
= candidates
->data
;
142 if (type
== SIPE_CANDIDATE_TYPE_ANY
|| candidate
->type
== type
) {
143 if (candidate
->component
== SIPE_COMPONENT_RTP
) {
144 *rtp_port
= candidate
->port
;
145 *ip
= g_strdup(candidate
->ip
);
146 } else if (candidate
->component
== SIPE_COMPONENT_RTCP
)
147 *rtcp_port
= candidate
->port
;
150 if (*rtp_port
!= 0 && *rtcp_port
!= 0)
155 static struct sdpmedia
*
156 backend_stream_to_sdpmedia(struct sipe_backend_media
*backend_media
,
157 struct sipe_backend_stream
*backend_stream
)
159 struct sdpmedia
*media
= g_new0(struct sdpmedia
, 1);
160 GList
*codecs
= sipe_backend_get_local_codecs(backend_media
,
164 GSList
*attributes
= NULL
;
168 media
->name
= g_strdup(sipe_backend_stream_get_id(backend_stream
));
170 if (sipe_strequal(media
->name
, "audio"))
171 type
= SIPE_MEDIA_AUDIO
;
172 else if (sipe_strequal(media
->name
, "video"))
173 type
= SIPE_MEDIA_VIDEO
;
175 // TODO: incompatible media, should not happen here
178 sipe_media_codec_list_free(codecs
);
183 for (i
= codecs
; i
; i
= i
->next
) {
184 struct sipe_backend_codec
*codec
= i
->data
;
185 struct sdpcodec
*c
= g_new0(struct sdpcodec
, 1);
188 c
->id
= sipe_backend_codec_get_id(codec
);
189 c
->name
= sipe_backend_codec_get_name(codec
);
190 c
->clock_rate
= sipe_backend_codec_get_clock_rate(codec
);
193 params
= sipe_backend_codec_get_optional_parameters(codec
);
194 for (; params
; params
= params
->next
) {
195 struct sipnameval
*param
= params
->data
;
196 struct sipnameval
*copy
= g_new0(struct sipnameval
, 1);
198 copy
->name
= g_strdup(param
->name
);
199 copy
->value
= g_strdup(param
->value
);
201 c
->parameters
= g_slist_append(c
->parameters
, copy
);
204 media
->codecs
= g_slist_append(media
->codecs
, c
);
207 sipe_media_codec_list_free(codecs
);
209 // Process local candidates
210 // If we have established candidate pairs, send them in SDP response.
211 // Otherwise send all available local candidates.
212 candidates
= sipe_backend_media_get_active_local_candidates(backend_media
,
215 candidates
= sipe_backend_get_local_candidates(backend_media
,
218 media
->candidates
= backend_candidates_to_sdpcandidate(candidates
);
220 sipe_media_candidate_list_free(candidates
);
222 get_stream_ip_and_ports(media
->candidates
, &media
->ip
, &media
->port
,
223 &rtcp_port
, SIPE_CANDIDATE_TYPE_HOST
);
224 // No usable HOST candidates, use any candidate
225 if (media
->ip
== NULL
&& media
->candidates
) {
226 get_stream_ip_and_ports(media
->candidates
, &media
->ip
, &media
->port
,
227 &rtcp_port
, SIPE_CANDIDATE_TYPE_ANY
);
230 if (sipe_backend_stream_is_held(backend_stream
))
231 attributes
= sipe_utils_nameval_add(attributes
, "inactive", "");
234 gchar
*tmp
= g_strdup_printf("%u", rtcp_port
);
235 attributes
= sipe_utils_nameval_add(attributes
, "rtcp", tmp
);
239 attributes
= sipe_utils_nameval_add(attributes
, "encryption", "rejected");
241 media
->attributes
= attributes
;
243 // Process remote candidates
244 candidates
= sipe_backend_media_get_active_remote_candidates(backend_media
,
246 media
->remote_candidates
= backend_candidates_to_sdpcandidate(candidates
);
247 sipe_media_candidate_list_free(candidates
);
252 static struct sdpmsg
*
253 sipe_media_to_sdpmsg(struct sipe_media_call_private
*call_private
)
255 struct sipe_backend_media
*backend_media
= call_private
->public.backend_private
;
256 struct sdpmsg
*msg
= g_new0(struct sdpmsg
, 1);
257 GSList
*streams
= sipe_backend_media_get_streams(backend_media
);
259 for (; streams
; streams
= streams
->next
) {
260 struct sdpmedia
*media
= backend_stream_to_sdpmedia(backend_media
, streams
->data
);
262 msg
->media
= g_slist_append(msg
->media
, media
);
265 msg
->ip
= g_strdup(media
->ip
);
269 msg
->media
= g_slist_concat(msg
->media
, call_private
->failed_media
);
270 call_private
->failed_media
= NULL
;
272 msg
->ice_version
= call_private
->ice_version
;
278 sipe_invite_call(struct sipe_core_private
*sipe_private
, TransCallback tc
)
283 struct sipe_media_call_private
*call_private
= sipe_private
->media_call
;
284 struct sip_session
*session
;
285 struct sip_dialog
*dialog
;
287 gboolean add_2007_fallback
= FALSE
;
289 session
= sipe_session_find_call(sipe_private
, call_private
->with
);
290 dialog
= session
->dialogs
->data
;
291 add_2007_fallback
= dialog
->cseq
== 0 &&
292 call_private
->ice_version
== SIPE_ICE_RFC_5245
&&
293 !sipe_strequal(call_private
->with
, sipe_private
->test_call_bot_uri
);
295 contact
= get_contact(sipe_private
);
296 hdr
= g_strdup_printf(
297 "ms-keep-alive: UAC;hop-hop=yes\r\n"
299 "Content-Type: %s\r\n",
302 "multipart/alternative;boundary=\"----=_NextPart_000_001E_01CB4397.0B5EB570\""
303 : "application/sdp");
306 msg
= sipe_media_to_sdpmsg(call_private
);
307 body
= sdpmsg_to_string(msg
);
309 if (add_2007_fallback
) {
311 tmp
= g_strdup_printf(
312 "------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
313 "Content-Type: application/sdp\r\n"
314 "Content-Transfer-Encoding: 7bit\r\n"
315 "Content-Disposition: session; handling=optional; ms-proxy-2007fallback\r\n"
317 "o=- 0 0 IN IP4 %s\r\n"
320 "m=audio 0 RTP/AVP\r\n"
322 "------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
323 "Content-Type: application/sdp\r\n"
324 "Content-Transfer-Encoding: 7bit\r\n"
325 "Content-Disposition: session; handling=optional\r\n"
329 "------=_NextPart_000_001E_01CB4397.0B5EB570--\r\n",
330 msg
->ip
, msg
->ip
, body
);
337 dialog
->outgoing_invite
= sip_transport_invite(sipe_private
,
347 static struct sip_dialog
*
348 sipe_media_dialog_init(struct sip_session
* session
, struct sipmsg
*msg
)
350 gchar
*newTag
= gentag();
351 const gchar
*oldHeader
;
353 struct sip_dialog
*dialog
;
355 oldHeader
= sipmsg_find_header(msg
, "To");
356 newHeader
= g_strdup_printf("%s;tag=%s", oldHeader
, newTag
);
357 sipmsg_remove_header_now(msg
, "To");
358 sipmsg_add_header_now(msg
, "To", newHeader
);
361 dialog
= sipe_dialog_add(session
);
362 dialog
->callid
= g_strdup(sipmsg_find_header(msg
, "Call-ID"));
363 dialog
->with
= parse_from(sipmsg_find_header(msg
, "From"));
364 sipe_dialog_parse(dialog
, msg
, FALSE
);
370 send_response_with_session_description(struct sipe_media_call_private
*call_private
, int code
, gchar
*text
)
372 struct sdpmsg
*msg
= sipe_media_to_sdpmsg(call_private
);
373 gchar
*body
= sdpmsg_to_string(msg
);
375 sipmsg_add_header(call_private
->invitation
, "Content-Type", "application/sdp");
376 sip_transport_response(call_private
->sipe_private
, call_private
->invitation
, code
, text
, body
);
381 encryption_levels_compatible(struct sdpmsg
*msg
)
385 for (i
= msg
->media
; i
; i
= i
->next
) {
386 const gchar
*enc_level
;
387 struct sdpmedia
*m
= i
->data
;
389 enc_level
= sipe_utils_nameval_find(m
->attributes
, "encryption");
391 // Decline call if peer requires encryption as we don't support it yet.
392 if (sipe_strequal(enc_level
, "required"))
400 process_invite_call_response(struct sipe_core_private
*sipe_private
,
402 struct transaction
*trans
);
405 update_remote_media(struct sipe_media_call_private
* call_private
,
406 struct sdpmedia
*media
)
408 struct sipe_backend_media
*backend_media
= SIPE_MEDIA_CALL
->backend_private
;
409 struct sipe_backend_stream
*backend_stream
;
410 GList
*backend_candidates
= NULL
;
411 GList
*backend_codecs
= NULL
;
413 gboolean result
= TRUE
;
415 backend_stream
= sipe_backend_media_get_stream_by_id(backend_media
,
417 if (media
->port
== 0) {
419 sipe_backend_media_remove_stream(backend_media
, backend_stream
);
426 for (i
= media
->codecs
; i
; i
= i
->next
) {
427 struct sdpcodec
*c
= i
->data
;
428 struct sipe_backend_codec
*codec
;
431 codec
= sipe_backend_codec_new(c
->id
,
436 for (j
= c
->parameters
; j
; j
= j
->next
) {
437 struct sipnameval
*attr
= j
->data
;
439 sipe_backend_codec_add_optional_parameter(codec
,
444 backend_codecs
= g_list_append(backend_codecs
, codec
);
447 result
= sipe_backend_set_remote_codecs(backend_media
,
450 sipe_media_codec_list_free(backend_codecs
);
452 if (result
== FALSE
) {
453 sipe_backend_media_remove_stream(backend_media
, backend_stream
);
457 for (i
= media
->candidates
; i
; i
= i
->next
) {
458 struct sdpcandidate
*c
= i
->data
;
459 struct sipe_backend_candidate
*candidate
;
460 candidate
= sipe_backend_candidate_new(c
->foundation
,
468 sipe_backend_candidate_set_priority(candidate
, c
->priority
);
470 backend_candidates
= g_list_append(backend_candidates
, candidate
);
473 sipe_backend_media_add_remote_candidates(backend_media
,
476 sipe_media_candidate_list_free(backend_candidates
);
478 if (sipe_utils_nameval_find(media
->attributes
, "inactive")) {
479 sipe_backend_stream_hold(backend_media
, backend_stream
, FALSE
);
480 } else if (sipe_backend_stream_is_held(backend_stream
)) {
481 sipe_backend_stream_unhold(backend_media
, backend_stream
, FALSE
);
488 apply_remote_message(struct sipe_media_call_private
* call_private
,
493 g_slist_free_full(call_private
->failed_media
, (GDestroyNotify
)sdpmedia_free
);
494 call_private
->failed_media
= NULL
;
496 for (i
= msg
->media
; i
; i
= i
->next
) {
497 struct sdpmedia
*media
= i
->data
;
498 if (!update_remote_media(call_private
, media
)) {
500 call_private
->failed_media
=
501 g_slist_append(call_private
->failed_media
, media
);
505 /* We need to keep failed medias until response is sent, remove them
506 * from sdpmsg that is to be freed. */
507 for (i
= call_private
->failed_media
; i
; i
= i
->next
) {
508 msg
->media
= g_slist_remove(msg
->media
, i
->data
);
511 call_private
->encryption_compatible
= encryption_levels_compatible(msg
);
515 call_initialized(struct sipe_media_call
*call
)
518 sipe_backend_media_get_streams(call
->backend_private
);
520 for (; streams
; streams
= streams
->next
) {
521 if (!sipe_backend_stream_initialized(call
->backend_private
,
530 // Sends an invite response when the call is accepted and local candidates were
531 // prepared, otherwise does nothing. If error response is sent, call_private is
532 // disposed before function returns. Returns true when response was sent.
534 send_invite_response_if_ready(struct sipe_media_call_private
*call_private
)
536 struct sipe_backend_media
*backend_media
;
538 backend_media
= call_private
->public.backend_private
;
540 if (!sipe_backend_media_accepted(backend_media
) ||
541 !call_initialized(&call_private
->public))
544 if (!call_private
->encryption_compatible
) {
545 struct sipe_core_private
*sipe_private
= call_private
->sipe_private
;
547 sipmsg_add_header(call_private
->invitation
, "Warning",
548 "308 lcs.microsoft.com \"Encryption Levels not compatible\"");
549 sip_transport_response(sipe_private
,
550 call_private
->invitation
,
551 488, "Encryption Levels not compatible",
553 sipe_backend_media_reject(backend_media
, FALSE
);
554 sipe_backend_notify_error(SIPE_CORE_PUBLIC
,
555 _("Unable to establish a call"),
556 _("Encryption settings of peer are incompatible with ours."));
558 send_response_with_session_description(call_private
, 200, "OK");
565 stream_initialized_cb(struct sipe_media_call
*call
,
566 struct sipe_backend_stream
*stream
)
568 if (call_initialized(call
)) {
569 struct sipe_media_call_private
*call_private
= SIPE_MEDIA_CALL_PRIVATE
;
570 struct sipe_backend_media
*backend_private
= call
->backend_private
;
572 if (sipe_backend_media_is_initiator(backend_private
, stream
)) {
573 sipe_invite_call(call_private
->sipe_private
,
574 process_invite_call_response
);
575 } else if (call_private
->smsg
) {
576 struct sdpmsg
*smsg
= call_private
->smsg
;
577 call_private
->smsg
= NULL
;
579 apply_remote_message(call_private
, smsg
);
580 send_invite_response_if_ready(call_private
);
586 static void phone_state_publish(struct sipe_core_private
*sipe_private
)
588 if (SIPE_CORE_PRIVATE_FLAG_IS(OCS2007
)) {
589 sipe_ocs2007_phone_state_publish(sipe_private
);
591 // TODO: OCS 2005 support. Is anyone still using it at all?
596 media_end_cb(struct sipe_media_call
*call
)
598 g_return_if_fail(call
);
600 SIPE_MEDIA_CALL_PRIVATE
->sipe_private
->media_call
= NULL
;
601 phone_state_publish(SIPE_MEDIA_CALL_PRIVATE
->sipe_private
);
602 sipe_media_call_free(SIPE_MEDIA_CALL_PRIVATE
);
606 call_accept_cb(struct sipe_media_call
*call
, gboolean local
)
609 send_invite_response_if_ready(SIPE_MEDIA_CALL_PRIVATE
);
611 phone_state_publish(SIPE_MEDIA_CALL_PRIVATE
->sipe_private
);
615 call_reject_cb(struct sipe_media_call
*call
, gboolean local
)
618 struct sipe_media_call_private
*call_private
= SIPE_MEDIA_CALL_PRIVATE
;
619 sip_transport_response(call_private
->sipe_private
,
620 call_private
->invitation
,
621 603, "Decline", NULL
);
626 sipe_media_send_ack(struct sipe_core_private
*sipe_private
, struct sipmsg
*msg
,
627 struct transaction
*trans
);
629 static void call_hold_cb(struct sipe_media_call
*call
,
631 SIPE_UNUSED_PARAMETER gboolean state
)
634 sipe_invite_call(SIPE_MEDIA_CALL_PRIVATE
->sipe_private
,
635 sipe_media_send_ack
);
638 static void call_hangup_cb(struct sipe_media_call
*call
, gboolean local
)
641 struct sipe_media_call_private
*call_private
= SIPE_MEDIA_CALL_PRIVATE
;
642 struct sip_session
*session
;
643 session
= sipe_session_find_call(call_private
->sipe_private
,
647 sipe_session_close(call_private
->sipe_private
, session
);
653 error_cb(struct sipe_media_call
*call
, gchar
*message
)
655 struct sipe_media_call_private
*call_private
= SIPE_MEDIA_CALL_PRIVATE
;
656 struct sipe_core_private
*sipe_private
= call_private
->sipe_private
;
657 gboolean initiator
= sipe_backend_media_is_initiator(call
->backend_private
, NULL
);
658 gboolean accepted
= sipe_backend_media_accepted(call
->backend_private
);
660 gchar
*title
= g_strdup_printf("Call with %s failed", call_private
->with
);
661 sipe_backend_notify_error(SIPE_CORE_PUBLIC
, title
, message
);
664 if (!initiator
&& !accepted
) {
665 sip_transport_response(sipe_private
,
666 call_private
->invitation
,
667 488, "Not Acceptable Here", NULL
);
670 sipe_backend_media_hangup(call
->backend_private
, initiator
|| accepted
);
673 static struct sipe_media_call_private
*
674 sipe_media_call_new(struct sipe_core_private
*sipe_private
,
675 const gchar
* with
, gboolean initiator
, SipeIceVersion ice_version
)
677 struct sipe_media_call_private
*call_private
= g_new0(struct sipe_media_call_private
, 1);
680 call_private
->sipe_private
= sipe_private
;
682 cname
= g_strdup(sipe_private
->contact
+ 1);
683 cname
[strlen(cname
) - 1] = '\0';
685 call_private
->public.backend_private
= sipe_backend_media_new(SIPE_CORE_PUBLIC
,
689 sipe_backend_media_set_cname(call_private
->public.backend_private
, cname
);
691 call_private
->ice_version
= ice_version
;
692 call_private
->encryption_compatible
= TRUE
;
694 call_private
->public.stream_initialized_cb
= stream_initialized_cb
;
695 call_private
->public.media_end_cb
= media_end_cb
;
696 call_private
->public.call_accept_cb
= call_accept_cb
;
697 call_private
->public.call_reject_cb
= call_reject_cb
;
698 call_private
->public.call_hold_cb
= call_hold_cb
;
699 call_private
->public.call_hangup_cb
= call_hangup_cb
;
700 call_private
->public.error_cb
= error_cb
;
707 void sipe_media_hangup(struct sipe_media_call_private
*call_private
)
710 sipe_backend_media_hangup(call_private
->public.backend_private
,
716 sipe_media_initiate_call(struct sipe_core_private
*sipe_private
,
717 const char *with
, SipeIceVersion ice_version
,
720 struct sipe_media_call_private
*call_private
;
721 struct sipe_backend_media
*backend_media
;
722 struct sipe_backend_media_relays
*backend_media_relays
;
723 struct sip_session
*session
;
724 struct sip_dialog
*dialog
;
726 if (sipe_private
->media_call
)
729 call_private
= sipe_media_call_new(sipe_private
, with
, TRUE
, ice_version
);
731 session
= sipe_session_add_call(sipe_private
, with
);
732 dialog
= sipe_dialog_add(session
);
733 dialog
->callid
= gencallid();
734 dialog
->with
= g_strdup(session
->with
);
735 dialog
->ourtag
= gentag();
737 call_private
->with
= g_strdup(session
->with
);
739 backend_media
= call_private
->public.backend_private
;
741 backend_media_relays
=
742 sipe_backend_media_relays_convert(sipe_private
->media_relays
,
743 sipe_private
->media_relay_username
,
744 sipe_private
->media_relay_password
);
746 if (!sipe_backend_media_add_stream(backend_media
,
747 "audio", with
, SIPE_MEDIA_AUDIO
,
748 call_private
->ice_version
, TRUE
,
749 backend_media_relays
)) {
750 sipe_backend_notify_error(SIPE_CORE_PUBLIC
,
752 _("Error creating audio stream"));
753 sipe_media_call_free(call_private
);
754 sipe_backend_media_relays_free(backend_media_relays
);
759 && !sipe_backend_media_add_stream(backend_media
,
760 "video", with
, SIPE_MEDIA_VIDEO
,
761 call_private
->ice_version
, TRUE
,
762 backend_media_relays
)) {
763 sipe_backend_notify_error(SIPE_CORE_PUBLIC
,
765 _("Error creating video stream"));
766 sipe_media_call_free(call_private
);
767 sipe_backend_media_relays_free(backend_media_relays
);
771 sipe_private
->media_call
= call_private
;
773 sipe_backend_media_relays_free(backend_media_relays
);
775 // Processing continues in candidates_prepared_cb
779 sipe_core_media_initiate_call(struct sipe_core_public
*sipe_public
,
783 sipe_media_initiate_call(SIPE_CORE_PRIVATE
, with
,
784 SIPE_ICE_RFC_5245
, with_video
);
787 void sipe_core_media_connect_conference(struct sipe_core_public
*sipe_public
,
788 struct sipe_chat_session
*chat_session
)
790 struct sipe_core_private
*sipe_private
= SIPE_CORE_PRIVATE
;
791 struct sipe_backend_media_relays
*backend_media_relays
;
792 struct sip_session
*session
;
793 struct sip_dialog
*dialog
;
797 session
= sipe_session_find_chat(sipe_private
, chat_session
);
799 if (sipe_private
->media_call
|| !session
)
802 session
->is_call
= TRUE
;
804 parts
= g_strsplit(chat_session
->id
, "app:conf:focus:", 2);
805 av_uri
= g_strjoinv("app:conf:audio-video:", parts
);
808 sipe_private
->media_call
= sipe_media_call_new(sipe_private
, av_uri
,
809 TRUE
, SIPE_ICE_DRAFT_6
);
811 session
= sipe_session_add_call(sipe_private
, av_uri
);
812 dialog
= sipe_dialog_add(session
);
813 dialog
->callid
= gencallid();
814 dialog
->with
= g_strdup(session
->with
);
815 dialog
->ourtag
= gentag();
819 sipe_private
->media_call
->with
= g_strdup(session
->with
);
821 backend_media_relays
=
822 sipe_backend_media_relays_convert(sipe_private
->media_relays
,
823 sipe_private
->media_relay_username
,
824 sipe_private
->media_relay_password
);
826 if (!sipe_backend_media_add_stream(sipe_private
->media_call
->public.backend_private
,
827 "audio", dialog
->with
,
829 sipe_private
->media_call
->ice_version
,
830 TRUE
, backend_media_relays
)) {
831 sipe_backend_notify_error(sipe_public
,
833 _("Error creating audio stream"));
834 sipe_media_call_free(sipe_private
->media_call
);
835 sipe_private
->media_call
= NULL
;
838 sipe_backend_media_relays_free(backend_media_relays
);
840 // Processing continues in candidates_prepared_cb
843 gboolean
sipe_core_media_in_call(struct sipe_core_public
*sipe_public
)
846 return SIPE_CORE_PRIVATE
->media_call
!= NULL
;
851 void sipe_core_media_test_call(struct sipe_core_public
*sipe_public
)
853 struct sipe_core_private
*sipe_private
= SIPE_CORE_PRIVATE
;
854 if (!sipe_private
->test_call_bot_uri
) {
855 sipe_backend_notify_error(sipe_public
,
856 _("Unable to establish a call"),
857 _("Audio Test Service is not available."));
861 sipe_core_media_initiate_call(sipe_public
,
862 sipe_private
->test_call_bot_uri
, FALSE
);
866 process_incoming_invite_call(struct sipe_core_private
*sipe_private
,
869 struct sipe_media_call_private
*call_private
= sipe_private
->media_call
;
870 struct sipe_backend_media
*backend_media
;
871 struct sipe_backend_media_relays
*backend_media_relays
= NULL
;
873 gboolean has_new_media
= FALSE
;
876 if (call_private
&& !is_media_session_msg(call_private
, msg
)) {
877 sip_transport_response(sipe_private
, msg
, 486, "Busy Here", NULL
);
881 smsg
= sdpmsg_parse_msg(msg
->body
);
883 sip_transport_response(sipe_private
, msg
,
884 488, "Not Acceptable Here", NULL
);
885 sipe_media_hangup(call_private
);
890 gchar
*with
= parse_from(sipmsg_find_header(msg
, "From"));
891 struct sip_session
*session
;
893 call_private
= sipe_media_call_new(sipe_private
, with
, FALSE
, smsg
->ice_version
);
894 session
= sipe_session_add_call(sipe_private
, with
);
895 sipe_media_dialog_init(session
, msg
);
897 call_private
->with
= g_strdup(session
->with
);
898 sipe_private
->media_call
= call_private
;
902 backend_media
= call_private
->public.backend_private
;
904 if (call_private
->invitation
)
905 sipmsg_free(call_private
->invitation
);
906 call_private
->invitation
= sipmsg_copy(msg
);
909 backend_media_relays
= sipe_backend_media_relays_convert(
910 sipe_private
->media_relays
,
911 sipe_private
->media_relay_username
,
912 sipe_private
->media_relay_password
);
914 // Create any new media streams
915 for (i
= smsg
->media
; i
; i
= i
->next
) {
916 struct sdpmedia
*media
= i
->data
;
917 gchar
*id
= media
->name
;
920 if ( media
->port
!= 0
921 && !sipe_backend_media_get_stream_by_id(backend_media
, id
)) {
924 if (sipe_strequal(id
, "audio"))
925 type
= SIPE_MEDIA_AUDIO
;
926 else if (sipe_strequal(id
, "video"))
927 type
= SIPE_MEDIA_VIDEO
;
931 with
= parse_from(sipmsg_find_header(msg
, "From"));
932 sipe_backend_media_add_stream(backend_media
, id
, with
,
936 backend_media_relays
);
937 has_new_media
= TRUE
;
942 sipe_backend_media_relays_free(backend_media_relays
);
945 sdpmsg_free(call_private
->smsg
);
946 call_private
->smsg
= smsg
;
947 sip_transport_response(sipe_private
, call_private
->invitation
,
948 180, "Ringing", NULL
);
949 // Processing continues in candidates_prepared_cb
951 apply_remote_message(call_private
, smsg
);
952 send_response_with_session_description(call_private
, 200, "OK");
958 void process_incoming_cancel_call(struct sipe_core_private
*sipe_private
,
961 struct sipe_media_call_private
*call_private
= sipe_private
->media_call
;
963 // We respond to the CANCEL request with 200 OK response and
964 // with 487 Request Terminated to the remote INVITE in progress.
965 sip_transport_response(sipe_private
, msg
, 200, "OK", NULL
);
967 if (call_private
->invitation
) {
968 sip_transport_response(sipe_private
, call_private
->invitation
,
969 487, "Request Terminated", NULL
);
972 sipe_media_hangup(call_private
);
976 sipe_media_send_ack(struct sipe_core_private
*sipe_private
,
978 struct transaction
*trans
)
980 struct sipe_media_call_private
*call_private
= sipe_private
->media_call
;
981 struct sip_session
*session
;
982 struct sip_dialog
*dialog
;
985 if (!is_media_session_msg(call_private
, msg
))
988 session
= sipe_session_find_call(sipe_private
, call_private
->with
);
989 dialog
= session
->dialogs
->data
;
993 tmp_cseq
= dialog
->cseq
;
995 dialog
->cseq
= sip_transaction_cseq(trans
) - 1;
996 sip_transport_ack(sipe_private
, dialog
);
997 dialog
->cseq
= tmp_cseq
;
999 dialog
->outgoing_invite
= NULL
;
1005 sipe_media_send_final_ack(struct sipe_core_private
*sipe_private
,
1007 struct transaction
*trans
)
1009 if (!sipe_media_send_ack(sipe_private
, msg
, trans
))
1012 sipe_backend_media_accept(sipe_private
->media_call
->public.backend_private
,
1019 reinvite_on_candidate_pair_cb(struct sipe_core_public
*sipe_public
)
1021 struct sipe_core_private
*sipe_private
= SIPE_CORE_PRIVATE
;
1022 struct sipe_media_call_private
*media_call
= sipe_private
->media_call
;
1023 struct sipe_backend_media
*backend_media
;
1029 backend_media
= media_call
->public.backend_private
;
1030 streams
= sipe_backend_media_get_streams(backend_media
);
1032 for (; streams
; streams
= streams
->next
) {
1033 struct sipe_backend_stream
*s
= streams
->data
;
1034 GList
*remote_candidates
= sipe_backend_media_get_active_remote_candidates(backend_media
, s
);
1035 guint components
= g_list_length(remote_candidates
);
1037 sipe_media_candidate_list_free(remote_candidates
);
1039 // We must have candidates for both (RTP + RTCP) components ready
1040 if (components
< 2) {
1041 sipe_schedule_mseconds(sipe_private
,
1042 "<+media-reinvite-on-candidate-pair>",
1045 (sipe_schedule_action
) reinvite_on_candidate_pair_cb
,
1051 sipe_invite_call(sipe_private
, sipe_media_send_final_ack
);
1055 process_invite_call_response(struct sipe_core_private
*sipe_private
,
1057 struct transaction
*trans
)
1060 struct sipe_media_call_private
*call_private
= sipe_private
->media_call
;
1061 struct sipe_backend_media
*backend_private
;
1062 struct sip_session
*session
;
1063 struct sip_dialog
*dialog
;
1064 struct sdpmsg
*smsg
;
1066 if (!is_media_session_msg(call_private
, msg
))
1069 session
= sipe_session_find_call(sipe_private
, call_private
->with
);
1070 dialog
= session
->dialogs
->data
;
1072 backend_private
= call_private
->public.backend_private
;
1073 with
= dialog
->with
;
1075 dialog
->outgoing_invite
= NULL
;
1077 if (msg
->response
>= 400) {
1078 // Call rejected by remote peer or an error occurred
1080 GString
*desc
= g_string_new("");
1081 gboolean append_responsestr
= FALSE
;
1083 switch (msg
->response
) {
1085 title
= _("User unavailable");
1087 if (sipmsg_parse_warning(msg
, NULL
) == 391) {
1088 g_string_append_printf(desc
, _("%s does not want to be disturbed"), with
);
1090 g_string_append_printf(desc
, _("User %s is not available"), with
);
1095 title
= _("Call rejected");
1096 g_string_append_printf(desc
, _("User %s rejected call"), with
);
1099 /* Check for incompatible encryption levels error.
1102 * 488 Not Acceptable Here
1103 * ms-client-diagnostics: 52017;reason="Encryption levels dont match"
1105 * older clients (and SIPE itself):
1106 * 488 Encryption Levels not compatible
1108 const gchar
*ms_diag
= sipmsg_find_header(msg
, "ms-client-diagnostics");
1110 if (sipe_strequal(msg
->responsestr
, "Encryption Levels not compatible") ||
1111 (ms_diag
&& g_str_has_prefix(ms_diag
, "52017;"))) {
1112 title
= _("Unable to establish a call");
1113 g_string_append(desc
, _("Encryption settings of peer are incompatible with ours."));
1117 if (call_private
->ice_version
== SIPE_ICE_RFC_5245
&&
1118 sip_transaction_cseq(trans
) == 1) {
1119 gchar
*with
= g_strdup(call_private
->with
);
1120 gboolean with_video
= sipe_backend_media_get_stream_by_id(backend_private
, "video") != NULL
;
1122 sipe_media_hangup(call_private
);
1123 // We might be calling to OC 2007 instance, retry with ICEv6
1124 sipe_media_initiate_call(sipe_private
, with
,
1125 SIPE_ICE_DRAFT_6
, with_video
);
1130 // Break intentionally omitted
1133 title
= _("Error occured");
1134 g_string_append(desc
, _("Unable to establish a call"));
1135 append_responsestr
= TRUE
;
1139 if (append_responsestr
)
1140 g_string_append_printf(desc
, "\n%d %s",
1141 msg
->response
, msg
->responsestr
);
1143 sipe_backend_notify_error(SIPE_CORE_PUBLIC
, title
, desc
->str
);
1144 g_string_free(desc
, TRUE
);
1146 sipe_media_send_ack(sipe_private
, msg
, trans
);
1147 sipe_media_hangup(call_private
);
1152 sipe_dialog_parse(dialog
, msg
, TRUE
);
1153 smsg
= sdpmsg_parse_msg(msg
->body
);
1155 sip_transport_response(sipe_private
, msg
,
1156 488, "Not Acceptable Here", NULL
);
1157 sipe_media_hangup(call_private
);
1161 apply_remote_message(call_private
, smsg
);
1164 sipe_media_send_ack(sipe_private
, msg
, trans
);
1165 reinvite_on_candidate_pair_cb(SIPE_CORE_PUBLIC
);
1170 gboolean
is_media_session_msg(struct sipe_media_call_private
*call_private
,
1174 const gchar
*callid
= sipmsg_find_header(msg
, "Call-ID");
1175 struct sip_session
*session
;
1177 session
= sipe_session_find_call(call_private
->sipe_private
,
1178 call_private
->with
);
1180 struct sip_dialog
*dialog
= session
->dialogs
->data
;
1181 return sipe_strequal(dialog
->callid
, callid
);
1187 void sipe_media_handle_going_offline(struct sipe_media_call_private
*call_private
)
1189 struct sipe_backend_media
*backend_private
;
1191 backend_private
= call_private
->public.backend_private
;
1193 if ( !sipe_backend_media_is_initiator(backend_private
, NULL
)
1194 && !sipe_backend_media_accepted(backend_private
)) {
1195 sip_transport_response(call_private
->sipe_private
,
1196 call_private
->invitation
,
1197 480, "Temporarily Unavailable", NULL
);
1199 struct sip_session
*session
;
1201 session
= sipe_session_find_call(call_private
->sipe_private
,
1202 call_private
->with
);
1204 sipe_session_close(call_private
->sipe_private
, session
);
1207 sipe_media_hangup(call_private
);
1210 gboolean
sipe_media_is_conference_call(struct sipe_media_call_private
*call_private
)
1212 return g_strstr_len(call_private
->with
, -1, "app:conf:audio-video:") != NULL
;
1216 sipe_media_relay_free(struct sipe_media_relay
*relay
)
1218 g_free(relay
->hostname
);
1219 if (relay
->dns_query
)
1220 sipe_backend_dns_query_cancel(relay
->dns_query
);
1225 sipe_media_relay_list_free(GSList
*list
)
1227 for (; list
; list
= g_slist_delete_link(list
, list
))
1228 sipe_media_relay_free(list
->data
);
1232 relay_ip_resolved_cb(struct sipe_media_relay
* relay
,
1233 const gchar
*ip
, SIPE_UNUSED_PARAMETER guint port
)
1235 gchar
*hostname
= relay
->hostname
;
1236 relay
->dns_query
= NULL
;
1239 relay
->hostname
= g_strdup(ip
);
1240 SIPE_DEBUG_INFO("Media relay %s resolved to %s.", hostname
, ip
);
1242 relay
->hostname
= NULL
;
1243 SIPE_DEBUG_INFO("Unable to resolve media relay %s.", hostname
);
1250 process_get_av_edge_credentials_response(struct sipe_core_private
*sipe_private
,
1252 SIPE_UNUSED_PARAMETER
struct transaction
*trans
)
1254 g_free(sipe_private
->media_relay_username
);
1255 g_free(sipe_private
->media_relay_password
);
1256 sipe_media_relay_list_free(sipe_private
->media_relays
);
1257 sipe_private
->media_relay_username
= NULL
;
1258 sipe_private
->media_relay_password
= NULL
;
1259 sipe_private
->media_relays
= NULL
;
1261 if (msg
->response
>= 400) {
1262 SIPE_DEBUG_INFO_NOFORMAT("process_get_av_edge_credentials_response: SERVICE response is not 200. "
1263 "Failed to obtain A/V Edge credentials.");
1267 if (msg
->response
== 200) {
1268 sipe_xml
*xn_response
= sipe_xml_parse(msg
->body
, msg
->bodylen
);
1270 if (sipe_strequal("OK", sipe_xml_attribute(xn_response
, "reasonPhrase"))) {
1271 const sipe_xml
*xn_credentials
= sipe_xml_child(xn_response
, "credentialsResponse/credentials");
1272 const sipe_xml
*xn_relays
= sipe_xml_child(xn_response
, "credentialsResponse/mediaRelayList");
1273 const sipe_xml
*item
;
1274 GSList
*relays
= NULL
;
1276 item
= sipe_xml_child(xn_credentials
, "username");
1277 sipe_private
->media_relay_username
= sipe_xml_data(item
);
1278 item
= sipe_xml_child(xn_credentials
, "password");
1279 sipe_private
->media_relay_password
= sipe_xml_data(item
);
1281 for (item
= sipe_xml_child(xn_relays
, "mediaRelay"); item
; item
= sipe_xml_twin(item
)) {
1282 struct sipe_media_relay
*relay
= g_new0(struct sipe_media_relay
, 1);
1283 const sipe_xml
*node
;
1286 node
= sipe_xml_child(item
, "hostName");
1287 relay
->hostname
= sipe_xml_data(node
);
1289 node
= sipe_xml_child(item
, "udpPort");
1291 relay
->udp_port
= atoi(tmp
= sipe_xml_data(node
));
1295 node
= sipe_xml_child(item
, "tcpPort");
1297 relay
->tcp_port
= atoi(tmp
= sipe_xml_data(node
));
1301 relays
= g_slist_append(relays
, relay
);
1303 relay
->dns_query
= sipe_backend_dns_query_a(
1307 (sipe_dns_resolved_cb
) relay_ip_resolved_cb
,
1310 SIPE_DEBUG_INFO("Media relay: %s TCP: %d UDP: %d",
1312 relay
->tcp_port
, relay
->udp_port
);
1315 sipe_private
->media_relays
= relays
;
1318 sipe_xml_free(xn_response
);
1325 sipe_media_get_av_edge_credentials(struct sipe_core_private
*sipe_private
)
1327 // TODO: re-request credentials after duration expires?
1328 const char CRED_REQUEST_XML
[] =
1329 "<request requestID=\"%d\" "
1333 "xmlns=\"http://schemas.microsoft.com/2006/09/sip/mrasp\" "
1334 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
1335 "<credentialsRequest credentialsRequestID=\"%d\">"
1336 "<identity>%s</identity>"
1337 "<location>%s</location>"
1338 "<duration>480</duration>"
1339 "</credentialsRequest>"
1342 int request_id
= rand();
1346 if (!sipe_private
->mras_uri
)
1349 self
= sip_uri_self(sipe_private
);
1351 body
= g_strdup_printf(
1355 sipe_private
->mras_uri
,
1358 SIPE_CORE_PRIVATE_FLAG_IS(REMOTE_USER
) ? "internet" : "intranet");
1361 sip_transport_service(sipe_private
,
1362 sipe_private
->mras_uri
,
1363 "Content-Type: application/msrtc-media-relay-auth+xml\r\n",
1365 process_get_av_edge_credentials_response
);