?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
purple: add support for latest appstreamcli
[siplcs.git] / src / core / sipe-media.c
blob8b05d67e3c0d18216f34d813a548f67e0a1b01cd
1 /**
2 * @file sipe-media.c
3 *
4 * pidgin-sipe
5 *
6 * Copyright (C) 2011-2021 SIPE Project <http://sipe.sourceforge.net/>
7 * Copyright (C) 2010 Jakub Adam <jakub.adam@ktknet.cz>
8 *
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.
13 *
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.
18 *
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
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include <glib.h>
33
34 #include "sipe-common.h"
35 #include "sipmsg.h"
36 #include "sip-transport.h"
37 #include "sipe-backend.h"
38 #include "sdpmsg.h"
39 #include "sipe-conf.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"
47 #include "sipe-nls.h"
48 #include "sipe-schedule.h"
49 #include "sipe-xml.h"
50
51 /* [MS-SDPEXT] 3.1.5.31.2 says a range size of 100 SHOULD be used for video and
52 * some clients really demand this. */
53 #define VIDEO_SSRC_COUNT 100
54
55 struct sipe_media_call_private {
56 struct sipe_media_call public;
57
58 /* private part starts here */
59 struct sipe_core_private *sipe_private;
60
61 struct sip_session *session;
62 struct sip_session *conference_session;
63
64 GSList *streams;
65
66 struct sipmsg *invitation;
67 SipeIceVersion ice_version;
68 gboolean encryption_compatible;
69 gchar *extra_invite_section;
70 gchar *invite_content_type;
71
72 GSList *ssrc_ranges;
73
74 struct sdpmsg *smsg;
75 GSList *failed_media;
76 gchar *ringing_key;
77 gchar *timeout_key;
78 };
79 #define SIPE_MEDIA_CALL ((struct sipe_media_call *) call_private)
80 #define SIPE_MEDIA_CALL_PRIVATE ((struct sipe_media_call_private *) call)
81
82 struct sipe_media_stream_private {
83 struct sipe_media_stream public;
84
85 gchar *timeout_key;
86
87 guchar *encryption_key;
88 int encryption_key_id;
89 gboolean remote_candidates_and_codecs_set;
90 gboolean established;
91 #ifdef HAVE_XDATA
92 gboolean sdp_negotiation_concluded;
93 gboolean writable;
94 #endif
95
96 GSList *extra_sdp;
97
98 GQueue *write_queue;
99 GQueue *async_reads;
100 gssize read_pos;
101
102 /* User data associated with the stream. */
103 gpointer data;
104 GDestroyNotify data_free_func;
105 };
106 #define SIPE_MEDIA_STREAM ((struct sipe_media_stream *) stream_private)
107 #define SIPE_MEDIA_STREAM_PRIVATE ((struct sipe_media_stream_private *) stream)
108
109 #define SIPE_MEDIA_STREAM_CONNECTION_TIMEOUT_SECONDS 30
110 #define SIPE_MEDIA_CALL_RINGING_TIMEOUT_SECONDS 60
111 #define SIPE_MEDIA_CALL_TIMEOUT_SECONDS 120
112
113 struct async_read_data {
114 guint8 *buffer;
115 gssize len;
116 sipe_media_stream_read_callback callback;
117 };
118
119 static void stream_schedule_cancel_timeout(struct sipe_media_call *call,
120 struct sipe_media_stream_private *stream_private);
121
122 static void call_schedule_cancel_request_timeout(struct sipe_media_call *call);
123 static void call_schedule_cancel_ringing_timeout(struct sipe_media_call *call);
124
125 static void sipe_media_codec_list_free(GList *codecs)
126 {
127 for (; codecs; codecs = g_list_delete_link(codecs, codecs))
128 sipe_backend_codec_free(codecs->data);
129 }
130
131 static void sipe_media_candidate_list_free(GList *candidates)
132 {
133 for (; candidates; candidates = g_list_delete_link(candidates, candidates))
134 sipe_backend_candidate_free(candidates->data);
135 }
136
137 static void
138 sipe_media_stream_free(struct sipe_media_stream_private *stream_private)
139 {
140 struct sipe_media_call_private *call_private;
141
142 call_private = (struct sipe_media_call_private *)SIPE_MEDIA_STREAM->call;
143
144 stream_schedule_cancel_timeout(SIPE_MEDIA_CALL, stream_private);
145
146 sipe_media_stream_set_data(SIPE_MEDIA_STREAM, NULL, NULL);
147
148 if (call_private) {
149 call_private->streams = g_slist_remove(call_private->streams,
150 stream_private);
151
152 if (SIPE_MEDIA_STREAM->ssrc_range) {
153 call_private->ssrc_ranges =
154 g_slist_remove(call_private->ssrc_ranges,
155 SIPE_MEDIA_STREAM->ssrc_range);
156 g_free(SIPE_MEDIA_STREAM->ssrc_range);
157 }
158 }
159
160 if (SIPE_MEDIA_STREAM->backend_private) {
161 sipe_backend_media_stream_free(SIPE_MEDIA_STREAM->backend_private);
162 }
163 g_free(SIPE_MEDIA_STREAM->id);
164 g_free(stream_private->encryption_key);
165 g_queue_free_full(stream_private->write_queue,
166 (GDestroyNotify)g_byte_array_unref);
167 g_queue_free_full(stream_private->async_reads, g_free);
168 sipe_utils_nameval_free(stream_private->extra_sdp);
169 g_free(stream_private);
170 }
171
172 static gboolean
173 call_private_equals(SIPE_UNUSED_PARAMETER const gchar *callid,
174 struct sipe_media_call_private *call_private1,
175 struct sipe_media_call_private *call_private2)
176 {
177 return call_private1 == call_private2;
178 }
179
180 static void
181 sipe_media_call_free(struct sipe_media_call_private *call_private)
182 {
183 if (call_private) {
184 g_hash_table_foreach_remove(call_private->sipe_private->media_calls,
185 (GHRFunc) call_private_equals, call_private);
186
187 call_schedule_cancel_request_timeout(SIPE_MEDIA_CALL);
188 call_schedule_cancel_ringing_timeout(SIPE_MEDIA_CALL);
189
190 while (call_private->streams) {
191 sipe_media_stream_free(call_private->streams->data);
192 }
193
194 sipe_backend_media_free(call_private->public.backend_private);
195
196 if (call_private->session) {
197 sipe_session_remove(call_private->sipe_private,
198 call_private->session);
199 }
200
201 if (call_private->invitation)
202 sipmsg_free(call_private->invitation);
203
204 // Frees any referenced extra invite data.
205 sipe_media_add_extra_invite_section(SIPE_MEDIA_CALL, NULL, NULL);
206
207 sipe_utils_slist_free_full(call_private->ssrc_ranges, g_free);
208
209 sdpmsg_free(call_private->smsg);
210 sipe_utils_slist_free_full(call_private->failed_media,
211 (GDestroyNotify)sdpmedia_free);
212 g_free(SIPE_MEDIA_CALL->with);
213 g_free(call_private);
214 }
215 }
216
217 static gint
218 candidate_sort_cb(struct sdpcandidate *c1, struct sdpcandidate *c2)
219 {
220 int cmp = g_strcmp0(c1->foundation, c2->foundation);
221 if (cmp == 0) {
222 cmp = g_strcmp0(c1->username, c2->username);
223 if (cmp == 0)
224 cmp = c1->component - c2->component;
225 }
226
227 return cmp;
228 }
229
230 static GSList *
231 backend_candidates_to_sdpcandidate(GList *candidates)
232 {
233 GSList *result = NULL;
234 GList *i;
235
236 for (i = candidates; i; i = i->next) {
237 struct sipe_backend_candidate *candidate = i->data;
238 struct sdpcandidate *c;
239
240 gchar *ip = sipe_backend_candidate_get_ip(candidate);
241 gchar *base_ip = sipe_backend_candidate_get_base_ip(candidate);
242 if (is_empty(ip) || strchr(ip, ':') ||
243 (base_ip && strchr(base_ip, ':'))) {
244 /* Ignore IPv6 candidates. */
245 g_free(ip);
246 g_free(base_ip);
247 continue;
248 }
249
250 c = g_new(struct sdpcandidate, 1);
251 c->foundation = sipe_backend_candidate_get_foundation(candidate);
252 c->component = sipe_backend_candidate_get_component_type(candidate);
253 c->type = sipe_backend_candidate_get_type(candidate);
254 c->protocol = sipe_backend_candidate_get_protocol(candidate);
255 c->ip = ip;
256 c->port = sipe_backend_candidate_get_port(candidate);
257 c->base_ip = base_ip;
258 c->base_port = sipe_backend_candidate_get_base_port(candidate);
259 c->priority = sipe_backend_candidate_get_priority(candidate);
260 c->username = sipe_backend_candidate_get_username(candidate);
261 c->password = sipe_backend_candidate_get_password(candidate);
262
263 result = g_slist_insert_sorted(result, c,
264 (GCompareFunc)candidate_sort_cb);
265 }
266
267 return result;
268 }
269
270 static void
271 get_stream_ip_and_ports(GSList *candidates,
272 gchar **ip, guint *rtp_port, guint *rtcp_port)
273 {
274 guint32 rtp_max_priority = 0;
275 guint32 rtcp_max_priority = 0;
276
277 *ip = 0;
278 *rtp_port = 0;
279 *rtcp_port = 0;
280
281 for (; candidates; candidates = candidates->next) {
282 struct sdpcandidate *candidate = candidates->data;
283
284 if (candidate->component == SIPE_COMPONENT_RTP &&
285 candidate->priority > rtp_max_priority) {
286 rtp_max_priority = candidate->priority;
287 *rtp_port = candidate->port;
288
289 g_free(*ip);
290 *ip = g_strdup(candidate->ip);
291 } else if (candidate->component == SIPE_COMPONENT_RTCP &&
292 candidate->priority > rtcp_max_priority) {
293 rtcp_max_priority = candidate->priority;
294 *rtcp_port = candidate->port;
295 }
296 }
297 }
298
299 static gint
300 sdpcodec_compare(gconstpointer a, gconstpointer b)
301 {
302 return ((const struct sdpcodec *)a)->id -
303 ((const struct sdpcodec *)b)->id;
304 }
305
306 static GList *
307 remove_wrong_farstream_0_1_tcp_candidates(GList *candidates)
308 {
309 GList *i = candidates;
310 GHashTable *foundation_to_candidate = g_hash_table_new_full(g_str_hash,
311 g_str_equal,
312 g_free,
313 NULL);
314
315 while (i) {
316 GList *next = i->next;
317 struct sipe_backend_candidate *c1 = i->data;
318
319 if (sipe_backend_candidate_get_protocol(c1) == SIPE_NETWORK_PROTOCOL_UDP) {
320 gchar *foundation = sipe_backend_candidate_get_foundation(c1);
321 struct sipe_backend_candidate *c2 = g_hash_table_lookup(foundation_to_candidate,
322 foundation);
323
324 if (c2) {
325 g_free(foundation);
326
327 if (sipe_backend_candidate_get_port(c1) ==
328 sipe_backend_candidate_get_port(c2) ||
329 (sipe_backend_candidate_get_type(c1) !=
330 SIPE_CANDIDATE_TYPE_HOST &&
331 sipe_backend_candidate_get_base_port(c1) ==
332 sipe_backend_candidate_get_base_port(c2))) {
333 /*
334 * We assume that RTP+RTCP UDP pairs
335 * that share the same port are
336 * actually mistagged TCP candidates.
337 */
338 candidates = g_list_remove(candidates, c2);
339 candidates = g_list_delete_link(candidates, i);
340 sipe_backend_candidate_free(c1);
341 sipe_backend_candidate_free(c2);
342 }
343 } else
344 /* hash table takes ownership of "foundation" */
345 g_hash_table_insert(foundation_to_candidate, foundation, c1);
346 }
347
348 i = next;
349 }
350
351 g_hash_table_destroy(foundation_to_candidate);
352
353 return candidates;
354 }
355
356 static void
357 fill_zero_tcp_act_ports_from_tcp_pass(GSList *candidates, GSList *all_candidates)
358 {
359 GSList *i;
360 GHashTable *ip_to_port = g_hash_table_new(g_str_hash, g_str_equal);
361
362 for (i = candidates; i; i = i->next) {
363 struct sdpcandidate *c = i->data;
364 GSList *j;
365
366 if (c->protocol != SIPE_NETWORK_PROTOCOL_TCP_ACTIVE) {
367 continue;
368 }
369
370 for (j = all_candidates; j; j = j->next) {
371 struct sdpcandidate *passive = j->data;
372 if (passive->protocol != SIPE_NETWORK_PROTOCOL_TCP_PASSIVE ||
373 c->type != passive->type) {
374 continue;
375 }
376
377 if (sipe_strequal(c->ip, passive->ip) &&
378 sipe_strequal(c->base_ip, passive->base_ip)) {
379 if (c->port == 0) {
380 c->port = passive->port;
381 }
382
383 if (c->base_port == 0) {
384 c->base_port = passive->base_port;
385 }
386 break;
387 }
388 }
389 }
390
391 for (i = all_candidates; i; i = i->next) {
392 struct sdpcandidate *c = i->data;
393
394 if (c->protocol == SIPE_NETWORK_PROTOCOL_TCP_PASSIVE &&
395 c->type == SIPE_CANDIDATE_TYPE_HOST) {
396 g_hash_table_insert(ip_to_port, c->ip, &c->port);
397 }
398 }
399
400 /* Fill base ports of all TCP relay candidates using what we have
401 * collected from host candidates. */
402 for (i = candidates; i; i = i->next) {
403 struct sdpcandidate *c = i->data;
404 if (c->type == SIPE_CANDIDATE_TYPE_RELAY && c->base_port == 0) {
405 guint *base_port = (guint*)g_hash_table_lookup(ip_to_port, c->base_ip);
406 if (base_port) {
407 c->base_port = *base_port;
408 } else {
409 SIPE_DEBUG_WARNING("Couldn't determine base port for candidate "
410 "with foundation %s", c->foundation);
411 }
412 }
413 }
414
415 g_hash_table_destroy(ip_to_port);
416 }
417
418 static SipeEncryptionPolicy
419 get_encryption_policy(struct sipe_core_private *sipe_private)
420 {
421 SipeEncryptionPolicy result =
422 sipe_backend_media_get_encryption_policy(SIPE_CORE_PUBLIC);
423 if (result == SIPE_ENCRYPTION_POLICY_OBEY_SERVER) {
424 result = sipe_private->server_av_encryption_policy;
425 }
426
427 return result;
428 }
429
430 static struct sdpmedia *
431 media_stream_to_sdpmedia(struct sipe_media_call_private *call_private,
432 struct sipe_media_stream_private *stream_private)
433 {
434 struct sdpmedia *sdpmedia = g_new0(struct sdpmedia, 1);
435 GList *codecs = sipe_backend_get_local_codecs(SIPE_MEDIA_CALL,
436 SIPE_MEDIA_STREAM);
437 SipeEncryptionPolicy encryption_policy =
438 get_encryption_policy(call_private->sipe_private);
439 guint rtcp_port = 0;
440 SipeMediaType type;
441 GSList *attributes = NULL;
442 GSList *sdpcandidates;
443 GSList *all_sdpcandidates;
444 GList *candidates;
445 GList *i;
446 GSList *j;
447
448 sdpmedia->name = g_strdup(SIPE_MEDIA_STREAM->id);
449
450 if (sipe_strequal(sdpmedia->name, "audio"))
451 type = SIPE_MEDIA_AUDIO;
452 else if (sipe_strequal(sdpmedia->name, "video"))
453 type = SIPE_MEDIA_VIDEO;
454 else if (sipe_strequal(sdpmedia->name, "data"))
455 type = SIPE_MEDIA_APPLICATION;
456 else if (sipe_strequal(sdpmedia->name, "applicationsharing"))
457 type = SIPE_MEDIA_APPLICATION;
458 else {
459 // TODO: incompatible media, should not happen here
460 g_free(sdpmedia->name);
461 g_free(sdpmedia);
462 sipe_media_codec_list_free(codecs);
463 return(NULL);
464 }
465
466 // Process codecs
467 for (i = codecs; i; i = i->next) {
468 struct sipe_backend_codec *codec = i->data;
469 struct sdpcodec *c = g_new0(struct sdpcodec, 1);
470 GList *params;
471
472 c->id = sipe_backend_codec_get_id(codec);
473 c->name = sipe_backend_codec_get_name(codec);
474 c->clock_rate = sipe_backend_codec_get_clock_rate(codec);
475 c->type = type;
476
477 params = sipe_backend_codec_get_optional_parameters(codec);
478 for (; params; params = params->next) {
479 struct sipnameval *param = params->data;
480 struct sipnameval *copy = g_new0(struct sipnameval, 1);
481
482 copy->name = g_strdup(param->name);
483 copy->value = g_strdup(param->value);
484
485 c->parameters = g_slist_append(c->parameters, copy);
486 }
487
488 /* Buggy(?) codecs may report non-unique id (a.k.a. payload
489 * type) that must not appear in SDP messages we send. Thus,
490 * let's ignore any codec having the same id as one we already
491 * have in the converted list. */
492 if (g_slist_find_custom(sdpmedia->codecs, c, sdpcodec_compare)) {
493 sdpcodec_free(c);
494 } else {
495 sdpmedia->codecs = g_slist_append(sdpmedia->codecs, c);
496 }
497 }
498
499 sipe_media_codec_list_free(codecs);
500
501 // Process local candidates
502 // If we have established candidate pairs, send them in SDP response.
503 // Otherwise send all available local candidates.
504 candidates = sipe_backend_media_stream_get_active_local_candidates(SIPE_MEDIA_STREAM);
505 sdpcandidates = backend_candidates_to_sdpcandidate(candidates);
506 sipe_media_candidate_list_free(candidates);
507
508 candidates = sipe_backend_get_local_candidates(SIPE_MEDIA_CALL,
509 SIPE_MEDIA_STREAM);
510 candidates = remove_wrong_farstream_0_1_tcp_candidates(candidates);
511 all_sdpcandidates = backend_candidates_to_sdpcandidate(candidates);
512 sipe_media_candidate_list_free(candidates);
513
514 if (!sdpcandidates) {
515 sdpcandidates = all_sdpcandidates;
516 }
517
518 fill_zero_tcp_act_ports_from_tcp_pass(sdpcandidates, all_sdpcandidates);
519
520 sdpmedia->candidates = sdpcandidates;
521
522 if (all_sdpcandidates != sdpcandidates) {
523 sipe_utils_slist_free_full(all_sdpcandidates,
524 (GDestroyNotify)sdpcandidate_free);
525 }
526
527 get_stream_ip_and_ports(sdpmedia->candidates, &sdpmedia->ip,
528 &sdpmedia->port, &rtcp_port);
529
530 if (sipe_backend_stream_is_held(SIPE_MEDIA_STREAM))
531 attributes = sipe_utils_nameval_add(attributes, "inactive", "");
532
533 if (rtcp_port) {
534 gchar *tmp = g_strdup_printf("%u", rtcp_port);
535 attributes = sipe_utils_nameval_add(attributes, "rtcp", tmp);
536 g_free(tmp);
537 }
538
539 if (encryption_policy != call_private->sipe_private->server_av_encryption_policy) {
540 const gchar *encryption = NULL;
541 switch (encryption_policy) {
542 case SIPE_ENCRYPTION_POLICY_REJECTED:
543 encryption = "rejected";
544 break;
545 case SIPE_ENCRYPTION_POLICY_OPTIONAL:
546 encryption = "optional";
547 break;
548 case SIPE_ENCRYPTION_POLICY_REQUIRED:
549 default:
550 encryption = "required";
551 break;
552 }
553
554 attributes = sipe_utils_nameval_add(attributes, "encryption", encryption);
555 }
556
557 if (SIPE_MEDIA_STREAM->ssrc_range) {
558 gchar *tmp;
559
560 tmp = g_strdup_printf("%u-%u",
561 SIPE_MEDIA_STREAM->ssrc_range->begin,
562 SIPE_MEDIA_STREAM->ssrc_range->end);
563 attributes = sipe_utils_nameval_add(attributes,
564 "x-ssrc-range", tmp);
565 g_free(tmp);
566 }
567
568 // Process remote candidates
569 candidates = sipe_backend_media_stream_get_active_remote_candidates(SIPE_MEDIA_STREAM);
570 sdpmedia->remote_candidates = backend_candidates_to_sdpcandidate(candidates);
571 sipe_media_candidate_list_free(candidates);
572
573 sdpmedia->encryption_active = stream_private->encryption_key &&
574 call_private->encryption_compatible &&
575 stream_private->remote_candidates_and_codecs_set &&
576 encryption_policy != SIPE_ENCRYPTION_POLICY_REJECTED;
577
578 // Set our key if encryption is enabled.
579 if (stream_private->encryption_key &&
580 encryption_policy != SIPE_ENCRYPTION_POLICY_REJECTED) {
581 sdpmedia->encryption_key = sipe_utils_memdup(stream_private->encryption_key,
582 SIPE_SRTP_KEY_LEN);
583 sdpmedia->encryption_key_id = stream_private->encryption_key_id;
584 }
585
586 // Append extra attributes assigned to the stream.
587 for (j = stream_private->extra_sdp; j; j = g_slist_next(j)) {
588 struct sipnameval *attr = j->data;
589 attributes = sipe_utils_nameval_add(attributes,
590 attr->name, attr->value);
591 }
592
593 sdpmedia->attributes = attributes;
594
595 return sdpmedia;
596 }
597
598 static struct sdpmsg *
599 sipe_media_to_sdpmsg(struct sipe_media_call_private *call_private)
600 {
601 struct sdpmsg *msg = g_new0(struct sdpmsg, 1);
602 GSList *streams = call_private->streams;
603
604 for (; streams; streams = streams->next) {
605 struct sdpmedia *media = media_stream_to_sdpmedia(call_private,
606 streams->data);
607 if (media) {
608 msg->media = g_slist_append(msg->media, media);
609
610 if (msg->ip == NULL)
611 msg->ip = g_strdup(media->ip);
612 }
613 }
614
615 msg->media = g_slist_concat(msg->media, call_private->failed_media);
616 call_private->failed_media = NULL;
617
618 msg->ice_version = call_private->ice_version;
619
620 return msg;
621 }
622
623 static void
624 sipe_invite_call(struct sipe_media_call_private *call_private, TransCallback tc)
625 {
626 struct sipe_core_private *sipe_private = call_private->sipe_private;
627 gchar *hdr;
628 gchar *contact;
629 gchar *p_preferred_identity = NULL;
630 gchar *body;
631 struct sip_dialog *dialog;
632 struct sdpmsg *msg;
633
634 dialog = sipe_media_get_sip_dialog(SIPE_MEDIA_CALL);
635
636 contact = get_contact(sipe_private);
637
638 if (sipe_private->uc_line_uri) {
639 gchar *self = sip_uri_self(sipe_private);
640 p_preferred_identity = g_strdup_printf(
641 "P-Preferred-Identity: <%s>, <%s>\r\n",
642 self, sipe_private->uc_line_uri);
643 g_free(self);
644 }
645
646 hdr = g_strdup_printf(
647 "ms-keep-alive: UAC;hop-hop=yes\r\n"
648 "Contact: %s\r\n"
649 "%s"
650 "Content-Type: %s%s\r\n",
651 contact,
652 p_preferred_identity ? p_preferred_identity : "",
653 call_private->invite_content_type ?
654 call_private->invite_content_type : "application/sdp",
655 call_private->invite_content_type ?
656 ";boundary=\"----=_NextPart_000_001E_01CB4397.0B5EB570\"" : "");
657
658 g_free(contact);
659 g_free(p_preferred_identity);
660
661 msg = sipe_media_to_sdpmsg(call_private);
662 body = sdpmsg_to_string(msg);
663
664 if (call_private->extra_invite_section) {
665 gchar *tmp;
666 tmp = g_strdup_printf(
667 "------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
668 "%s"
669 "\r\n"
670 "------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
671 "Content-Type: application/sdp\r\n"
672 "Content-Transfer-Encoding: 7bit\r\n"
673 "Content-Disposition: session; handling=optional\r\n"
674 "\r\n"
675 "%s"
676 "\r\n"
677 "------=_NextPart_000_001E_01CB4397.0B5EB570--\r\n",
678 call_private->extra_invite_section, body);
679 g_free(body);
680 body = tmp;
681 sipe_media_add_extra_invite_section(SIPE_MEDIA_CALL, NULL, NULL);
682 }
683
684 sdpmsg_free(msg);
685
686 dialog->outgoing_invite = sip_transport_invite(sipe_private,
687 hdr,
688 body,
689 dialog,
690 tc);
691
692 g_free(body);
693 g_free(hdr);
694 }
695
696 static void
697 send_response_with_session_description(struct sipe_media_call_private *call_private, int code, const gchar *text)
698 {
699 struct sdpmsg *msg = sipe_media_to_sdpmsg(call_private);
700 gchar *body = sdpmsg_to_string(msg);
701 sdpmsg_free(msg);
702 sipmsg_add_header(call_private->invitation, "Content-Type", "application/sdp");
703 sip_transport_response(call_private->sipe_private, call_private->invitation, code, text, body);
704 g_free(body);
705 }
706
707 static gboolean
708 process_invite_call_response(struct sipe_core_private *sipe_private,
709 struct sipmsg *msg,
710 struct transaction *trans);
711
712 struct sipe_media_stream *
713 sipe_core_media_get_stream_by_id(struct sipe_media_call *call, const gchar *id)
714 {
715 GSList *i;
716 for (i = SIPE_MEDIA_CALL_PRIVATE->streams; i; i = i->next) {
717 struct sipe_media_stream *stream = i->data;
718 if (sipe_strequal(stream->id, id))
719 return stream;
720 }
721 return NULL;
722 }
723
724 static gboolean
725 update_call_from_remote_sdp(struct sipe_media_call_private* call_private,
726 struct sdpmedia *media)
727 {
728 struct sipe_media_stream *stream;
729 GList *backend_candidates = NULL;
730 GList *backend_codecs = NULL;
731 GSList *i;
732 gboolean result = TRUE;
733
734 stream = sipe_core_media_get_stream_by_id(SIPE_MEDIA_CALL, media->name);
735 if (media->port == 0) {
736 if (stream) {
737 sipe_backend_media_stream_end(SIPE_MEDIA_CALL, stream);
738 }
739 return FALSE;
740 }
741
742 if (!stream)
743 return FALSE;
744
745 if (sipe_utils_nameval_find(media->attributes, "inactive")) {
746 sipe_backend_stream_hold(SIPE_MEDIA_CALL, stream, FALSE);
747 } else if (sipe_backend_stream_is_held(stream)) {
748 sipe_backend_stream_unhold(SIPE_MEDIA_CALL, stream, FALSE);
749 }
750
751 if (SIPE_MEDIA_STREAM_PRIVATE->remote_candidates_and_codecs_set) {
752 return TRUE;
753 }
754
755 for (i = media->codecs; i; i = i->next) {
756 struct sdpcodec *c = i->data;
757 struct sipe_backend_codec *codec;
758 GSList *j;
759
760 codec = sipe_backend_codec_new(c->id,
761 c->name,
762 c->type,
763 c->clock_rate,
764 c->channels);
765
766 for (j = c->parameters; j; j = j->next) {
767 struct sipnameval *attr = j->data;
768
769 sipe_backend_codec_add_optional_parameter(codec,
770 attr->name,
771 attr->value);
772 }
773
774 backend_codecs = g_list_append(backend_codecs, codec);
775 }
776
777 if (media->encryption_key && SIPE_MEDIA_STREAM_PRIVATE->encryption_key) {
778 sipe_backend_media_set_encryption_keys(SIPE_MEDIA_CALL, stream,
779 SIPE_MEDIA_STREAM_PRIVATE->encryption_key,
780 media->encryption_key);
781 SIPE_MEDIA_STREAM_PRIVATE->encryption_key_id = media->encryption_key_id;
782 } else {
783 // We now know that the stream won't be encrypted.
784 // Allow unencrypted data to pass srtpdec freely
785 sipe_backend_media_set_require_encryption(SIPE_MEDIA_CALL,
786 stream,
787 FALSE);
788 }
789
790 result = sipe_backend_set_remote_codecs(SIPE_MEDIA_CALL, stream,
791 backend_codecs);
792 sipe_media_codec_list_free(backend_codecs);
793
794 if (result == FALSE) {
795 sipe_backend_media_stream_end(SIPE_MEDIA_CALL, stream);
796 return FALSE;
797 }
798
799 for (i = media->candidates; i; i = i->next) {
800 struct sdpcandidate *c = i->data;
801 struct sipe_backend_candidate *candidate;
802 candidate = sipe_backend_candidate_new(c->foundation,
803 c->component,
804 c->type,
805 c->protocol,
806 c->ip,
807 c->port,
808 c->username,
809 c->password);
810 sipe_backend_candidate_set_priority(candidate, c->priority);
811
812 backend_candidates = g_list_append(backend_candidates, candidate);
813 }
814
815 sipe_backend_media_add_remote_candidates(SIPE_MEDIA_CALL, stream,
816 backend_candidates);
817 sipe_media_candidate_list_free(backend_candidates);
818
819 SIPE_MEDIA_STREAM_PRIVATE->remote_candidates_and_codecs_set = TRUE;
820
821 return TRUE;
822 }
823
824 static void
825 apply_remote_message(struct sipe_media_call_private* call_private,
826 struct sdpmsg* msg)
827 {
828 GSList *i;
829
830 sipe_utils_slist_free_full(call_private->failed_media, (GDestroyNotify)sdpmedia_free);
831 call_private->failed_media = NULL;
832 call_private->encryption_compatible = TRUE;
833
834 for (i = msg->media; i; i = i->next) {
835 struct sdpmedia *media = i->data;
836 const gchar *enc_level =
837 sipe_utils_nameval_find(media->attributes, "encryption");
838 if (sipe_strequal(enc_level, "rejected") &&
839 get_encryption_policy(call_private->sipe_private) == SIPE_ENCRYPTION_POLICY_REQUIRED) {
840 call_private->encryption_compatible = FALSE;
841 }
842
843 if (!update_call_from_remote_sdp(call_private, media)) {
844 media->port = 0;
845 call_private->failed_media =
846 g_slist_append(call_private->failed_media, media);
847 }
848 }
849
850 /* We need to keep failed medias until response is sent, remove them
851 * from sdpmsg that is to be freed. */
852 for (i = call_private->failed_media; i; i = i->next) {
853 msg->media = g_slist_remove(msg->media, i->data);
854 }
855 }
856
857 static gboolean
858 call_initialized(struct sipe_media_call *call)
859 {
860 GSList *streams = SIPE_MEDIA_CALL_PRIVATE->streams;
861 for (; streams; streams = streams->next) {
862 if (!sipe_backend_stream_initialized(call, streams->data)) {
863 return FALSE;
864 }
865 }
866
867 return TRUE;
868 }
869
870 static void
871 stream_connection_timeout_cb(struct sipe_core_private *sipe_private,
872 gpointer data)
873 {
874 struct sipe_media_call_private *call_private = data;
875
876 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
877 _("Couldn't create stream"),
878 _("Connection timed out"));
879 sipe_backend_media_hangup(SIPE_MEDIA_CALL->backend_private, TRUE);
880 }
881
882 static void
883 stream_schedule_timeout(struct sipe_media_call *call)
884 {
885 GSList *i;
886 for (i = SIPE_MEDIA_CALL_PRIVATE->streams; i; i = i->next) {
887 struct sipe_media_stream_private *stream_private = i->data;
888
889 if (stream_private->established)
890 continue;
891 stream_private->timeout_key =
892 g_strdup_printf("<media-stream-connect><%s><%s>",
893 sipe_media_get_sip_dialog(call)->callid,
894 SIPE_MEDIA_STREAM->id);
895
896 sipe_schedule_seconds(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
897 stream_private->timeout_key,
898 SIPE_MEDIA_CALL_PRIVATE,
899 SIPE_MEDIA_STREAM_CONNECTION_TIMEOUT_SECONDS,
900 stream_connection_timeout_cb,
901 NULL);
902 }
903 }
904
905 static void
906 stream_schedule_cancel_timeout(struct sipe_media_call *call,
907 struct sipe_media_stream_private *stream_private)
908 {
909 if (stream_private->timeout_key) {
910 sipe_schedule_cancel(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
911 stream_private->timeout_key);
912 g_free(stream_private->timeout_key);
913 }
914 stream_private->timeout_key = NULL;
915 }
916
917 static void
918 call_request_timeout_cb(struct sipe_core_private *sipe_private,
919 gpointer data)
920 {
921 struct sipe_media_call_private *call_private = data;
922
923 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
924 _("Request timed out"),
925 _("Call could not be answered"));
926 sipe_backend_media_hangup(SIPE_MEDIA_CALL->backend_private, TRUE);
927 }
928
929 static void
930 call_schedule_request_timeout(struct sipe_media_call *call)
931 {
932 SIPE_MEDIA_CALL_PRIVATE->timeout_key =
933 g_strdup_printf("<media-call-request><%s>", sipe_media_get_sip_dialog(call)->callid);
934
935 sipe_schedule_seconds(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
936 SIPE_MEDIA_CALL_PRIVATE->timeout_key,
937 SIPE_MEDIA_CALL_PRIVATE,
938 SIPE_MEDIA_CALL_TIMEOUT_SECONDS,
939 call_request_timeout_cb,
940 NULL);
941 }
942
943 static void
944 call_schedule_cancel_request_timeout(struct sipe_media_call *call)
945 {
946 if (SIPE_MEDIA_CALL_PRIVATE->timeout_key) {
947 sipe_schedule_cancel(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
948 SIPE_MEDIA_CALL_PRIVATE->timeout_key);
949 g_free(SIPE_MEDIA_CALL_PRIVATE->timeout_key);
950 }
951 SIPE_MEDIA_CALL_PRIVATE->timeout_key = NULL;
952 }
953
954
955 static void
956 call_ringing_timeout_cb(struct sipe_core_private *sipe_private,
957 gpointer data)
958 {
959 struct sipe_media_call_private *call_private = data;
960
961 sip_transport_response(sipe_private, call_private->invitation,
962 408, "Request Timeout", NULL);
963 sipe_backend_media_hangup(SIPE_MEDIA_CALL->backend_private, FALSE);
964 }
965
966 static void
967 call_schedule_ringing_timeout(struct sipe_media_call *call)
968 {
969 SIPE_MEDIA_CALL_PRIVATE->ringing_key =
970 g_strdup_printf("<media-call-ringing><%s>", sipe_media_get_sip_dialog(call)->callid);
971
972 sipe_schedule_seconds(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
973 SIPE_MEDIA_CALL_PRIVATE->ringing_key,
974 SIPE_MEDIA_CALL_PRIVATE,
975 SIPE_MEDIA_CALL_RINGING_TIMEOUT_SECONDS,
976 call_ringing_timeout_cb,
977 NULL);
978 }
979
980 static void
981 call_schedule_cancel_ringing_timeout(struct sipe_media_call *call)
982 {
983 if (SIPE_MEDIA_CALL_PRIVATE->ringing_key) {
984 sipe_schedule_cancel(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
985 SIPE_MEDIA_CALL_PRIVATE->ringing_key);
986 g_free(SIPE_MEDIA_CALL_PRIVATE->ringing_key);
987 }
988 SIPE_MEDIA_CALL_PRIVATE->ringing_key = NULL;
989 }
990
991 // Sends an invite response when the call is accepted and local candidates were
992 // prepared, otherwise does nothing. If error response is sent, call_private is
993 // disposed before function returns.
994 static void
995 maybe_send_first_invite_response(struct sipe_media_call_private *call_private)
996 {
997 struct sipe_backend_media *backend_media;
998
999 backend_media = call_private->public.backend_private;
1000
1001 if (!sipe_backend_media_accepted(backend_media) ||
1002 !call_initialized(&call_private->public))
1003 return;
1004
1005 if (!call_private->encryption_compatible) {
1006 struct sipe_core_private *sipe_private = call_private->sipe_private;
1007
1008 sipmsg_add_header(call_private->invitation, "Warning",
1009 "308 lcs.microsoft.com \"Encryption Levels not compatible\"");
1010 sip_transport_response(sipe_private,
1011 call_private->invitation,
1012 488, "Encryption Levels not compatible",
1013 NULL);
1014 sipe_backend_media_reject(backend_media, FALSE);
1015 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
1016 _("Unable to establish a call"),
1017 _("Encryption settings of peer are incompatible with ours."));
1018 } else {
1019 send_response_with_session_description(call_private, 200, "OK");
1020 stream_schedule_timeout(SIPE_MEDIA_CALL);
1021 call_schedule_cancel_ringing_timeout(SIPE_MEDIA_CALL);
1022 sipmsg_free(call_private->invitation);
1023 call_private->invitation = NULL;
1024 }
1025 }
1026
1027 static void
1028 stream_initialized_cb(struct sipe_media_call *call,
1029 struct sipe_media_stream *stream)
1030 {
1031 if (call_initialized(call)) {
1032 struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
1033
1034 if (sipe_backend_media_is_initiator(call, stream)) {
1035 sipe_invite_call(call_private,
1036 process_invite_call_response);
1037 } else if (call_private->smsg) {
1038 struct sdpmsg *smsg = call_private->smsg;
1039 call_private->smsg = NULL;
1040
1041 apply_remote_message(call_private, smsg);
1042 maybe_send_first_invite_response(call_private);
1043 sdpmsg_free(smsg);
1044 }
1045 }
1046 }
1047
1048 static void phone_state_publish(struct sipe_core_private *sipe_private)
1049 {
1050 if (SIPE_CORE_PRIVATE_FLAG_IS(OCS2007)) {
1051 sipe_ocs2007_phone_state_publish(sipe_private);
1052 } else {
1053 // TODO: OCS 2005 support. Is anyone still using it at all?
1054 }
1055 }
1056
1057 void
1058 sipe_core_media_stream_end(struct sipe_media_stream *stream)
1059 {
1060 sipe_media_stream_free(SIPE_MEDIA_STREAM_PRIVATE);
1061 }
1062
1063 static void
1064 media_end_cb(struct sipe_media_call *call)
1065 {
1066 struct sipe_core_private *sipe_private;
1067
1068 g_return_if_fail(call);
1069
1070 sipe_private = SIPE_MEDIA_CALL_PRIVATE->sipe_private;
1071
1072 sipe_media_call_free(SIPE_MEDIA_CALL_PRIVATE);
1073 phone_state_publish(sipe_private);
1074 }
1075
1076 static void
1077 call_accept_cb(struct sipe_media_call *call, gboolean local)
1078 {
1079 if (local) {
1080 maybe_send_first_invite_response(SIPE_MEDIA_CALL_PRIVATE);
1081 }
1082 phone_state_publish(SIPE_MEDIA_CALL_PRIVATE->sipe_private);
1083 }
1084
1085 static void
1086 call_reject_cb(struct sipe_media_call *call, gboolean local)
1087 {
1088 if (local) {
1089 struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
1090
1091 sip_transport_response(call_private->sipe_private,
1092 call_private->invitation,
1093 603, "Decline", NULL);
1094
1095 if (call_private->session) {
1096 sipe_session_remove(call_private->sipe_private,
1097 call_private->session);
1098 call_private->session = NULL;
1099 }
1100 }
1101 }
1102
1103 static void
1104 av_call_reject_cb(struct sipe_media_call *call, gboolean local)
1105 {
1106 if (!local) {
1107 struct sipe_core_private *sipe_private;
1108 gchar *desc;
1109
1110 sipe_private = SIPE_MEDIA_CALL_PRIVATE->sipe_private;
1111
1112 desc = g_strdup_printf(_("User %s rejected call"), call->with);
1113 sipe_backend_notify_error(SIPE_CORE_PUBLIC, _("Call rejected"),
1114 desc);
1115 g_free(desc);
1116 }
1117
1118 call_reject_cb(call, local);
1119 }
1120
1121 static gboolean
1122 sipe_media_send_ack(struct sipe_core_private *sipe_private, struct sipmsg *msg,
1123 struct transaction *trans);
1124
1125 static void call_hold_cb(struct sipe_media_call *call,
1126 gboolean local,
1127 SIPE_UNUSED_PARAMETER gboolean state)
1128 {
1129 if (local) {
1130 sipe_invite_call(SIPE_MEDIA_CALL_PRIVATE, sipe_media_send_ack);
1131 }
1132 }
1133
1134 static void call_hangup_cb(struct sipe_media_call *call, gboolean local)
1135 {
1136 if (local) {
1137 struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
1138
1139 if (call_private->session) {
1140 sipe_session_close(call_private->sipe_private,
1141 call_private->session);
1142 call_private->session = NULL;
1143 }
1144 }
1145 }
1146
1147 static void
1148 error_cb(struct sipe_media_call *call, gchar *message)
1149 {
1150 struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
1151 struct sipe_core_private *sipe_private = call_private->sipe_private;
1152 gboolean initiator = sipe_backend_media_is_initiator(call, NULL);
1153 gboolean accepted = sipe_backend_media_accepted(call->backend_private);
1154
1155 gchar *title = g_strdup_printf("Call with %s failed", call->with);
1156 sipe_backend_notify_error(SIPE_CORE_PUBLIC, title, message);
1157 g_free(title);
1158
1159 if (!initiator && !accepted && call_private->invitation) {
1160 sip_transport_response(sipe_private,
1161 call_private->invitation,
1162 488, "Not Acceptable Here", NULL);
1163 }
1164 }
1165
1166 struct sipe_media_call *
1167 sipe_media_call_new(struct sipe_core_private *sipe_private, const gchar* with,
1168 struct sipmsg *msg, SipeIceVersion ice_version,
1169 SipeMediaCallFlags flags)
1170 {
1171 struct sipe_media_call_private *call_private;
1172 struct sip_session *session;
1173 struct sip_dialog *dialog;
1174 gchar *cname;
1175
1176 session = sipe_session_add_call(sipe_private, with);
1177
1178 dialog = sipe_dialog_add(session);
1179 dialog->with = g_strdup(with);
1180
1181 if (msg) {
1182 sipmsg_update_to_header_tag(msg);
1183 dialog->callid = g_strdup(sipmsg_find_call_id_header(msg));
1184 sipe_dialog_parse(dialog, msg, FALSE);
1185 } else {
1186 dialog->callid = gencallid();
1187 dialog->ourtag = gentag();
1188 flags |= SIPE_MEDIA_CALL_INITIATOR;
1189 }
1190
1191 if (g_hash_table_lookup(sipe_private->media_calls, dialog->callid)) {
1192 SIPE_DEBUG_ERROR("sipe_media_call_new: call already exists for "
1193 "Call-ID %s", dialog->callid);
1194 sipe_session_remove(sipe_private, session);
1195 return NULL;
1196 }
1197
1198 call_private = g_new0(struct sipe_media_call_private, 1);
1199 call_private->sipe_private = sipe_private;
1200 call_private->session = session;
1201 SIPE_MEDIA_CALL->with = g_strdup(with);
1202
1203 g_hash_table_insert(sipe_private->media_calls,
1204 g_strdup(dialog->callid), call_private);
1205
1206 cname = g_strdup(sipe_private->contact + 1);
1207 cname[strlen(cname) - 1] = '\0';
1208
1209 call_private->public.backend_private = sipe_backend_media_new(SIPE_CORE_PUBLIC,
1210 SIPE_MEDIA_CALL,
1211 with,
1212 flags);
1213 sipe_backend_media_set_cname(call_private->public.backend_private, cname);
1214
1215 call_private->ice_version = ice_version;
1216 call_private->encryption_compatible = TRUE;
1217
1218 call_private->public.stream_initialized_cb = stream_initialized_cb;
1219 call_private->public.media_end_cb = media_end_cb;
1220 call_private->public.call_accept_cb = call_accept_cb;
1221 call_private->public.call_reject_cb = call_reject_cb;
1222 call_private->public.call_hold_cb = call_hold_cb;
1223 call_private->public.call_hangup_cb = call_hangup_cb;
1224 call_private->public.error_cb = error_cb;
1225
1226 g_free(cname);
1227
1228 return SIPE_MEDIA_CALL;
1229 }
1230
1231 static gboolean
1232 find_call_cb(SIPE_UNUSED_PARAMETER const gchar *callid,
1233 struct sipe_media_call *call,
1234 const gchar *with)
1235 {
1236 return sipe_strequal(call->with, with);
1237 }
1238
1239 struct sipe_media_call *
1240 sipe_media_call_find(struct sipe_core_private *sipe_private, const gchar *with)
1241 {
1242 return g_hash_table_find(sipe_private->media_calls,
1243 (GHRFunc)find_call_cb,
1244 (gpointer)with);
1245 }
1246
1247 void sipe_media_hangup(struct sipe_media_call_private *call_private)
1248 {
1249 if (call_private) {
1250 sipe_backend_media_hangup(call_private->public.backend_private,
1251 FALSE);
1252 }
1253 }
1254
1255 static gint
1256 ssrc_range_compare(const struct ssrc_range *a, const struct ssrc_range *b)
1257 {
1258 if (a->begin < b->begin) {
1259 return -1;
1260 }
1261 if (a->begin > b->begin) {
1262 return 1;
1263 }
1264 return 0;
1265 }
1266
1267 static void
1268 ssrc_range_update(GSList **ranges, GSList *media)
1269 {
1270 for (; media; media = media->next) {
1271 struct sdpmedia *m;
1272 const char *ssrc_range;
1273 gchar **parts;
1274
1275 m = media->data;
1276 ssrc_range = sipe_utils_nameval_find(m->attributes,
1277 "x-ssrc-range");
1278 if (!ssrc_range) {
1279 continue;
1280 }
1281
1282 parts = g_strsplit(ssrc_range, "-", 2);
1283
1284 if (parts[0] && parts[1]) {
1285 struct ssrc_range *range;
1286
1287 range = g_new0(struct ssrc_range, 1);
1288 range->begin = atoi(parts[0]);
1289 range->end = atoi(parts[1]);
1290
1291 *ranges = sipe_utils_slist_insert_unique_sorted(
1292 *ranges, range,
1293 (GCompareFunc)ssrc_range_compare,
1294 g_free);
1295 }
1296
1297 g_strfreev(parts);
1298 }
1299 }
1300
1301 static struct ssrc_range *
1302 ssrc_range_allocate(GSList **ranges, guint32 len)
1303 {
1304 struct ssrc_range *range;
1305 GSList *i;
1306
1307 range = g_new0(struct ssrc_range, 1);
1308 range->begin = 1;
1309 range->end = range->begin + (len - 1);
1310
1311 for (i = *ranges; i; i = i->next) {
1312 struct ssrc_range *r = i->data;
1313
1314 if (range->begin < r->begin && range->end < r->begin) {
1315 break;
1316 }
1317
1318 range->begin = r->end + 1;
1319 range->end = range->begin + (len - 1);
1320 }
1321
1322 /* As per [MS-SDPEXT] 3.1.5.31.1, a SSRC MUST be from 1 to 4294967040
1323 * inclusive. */
1324 if (range->begin > range->end || range->end > 0xFFFFFF00) {
1325 g_free(range);
1326 SIPE_DEBUG_ERROR("Couldn't allocate SSRC range of %u", len);
1327 return NULL;
1328 }
1329
1330 *ranges = g_slist_insert_sorted(*ranges, range,
1331 (GCompareFunc)ssrc_range_compare);
1332
1333 return range;
1334 }
1335
1336 struct sipe_media_stream *
1337 sipe_media_stream_add(struct sipe_media_call *call, const gchar *id,
1338 SipeMediaType type, SipeIceVersion ice_version,
1339 gboolean initiator, guint32 ssrc_count)
1340 {
1341 struct sipe_core_private *sipe_private;
1342 struct sipe_media_stream_private *stream_private;
1343 struct sipe_backend_media_relays *backend_media_relays;
1344 guint min_port;
1345 guint max_port;
1346
1347 sipe_private = SIPE_MEDIA_CALL_PRIVATE->sipe_private;
1348
1349 backend_media_relays = sipe_backend_media_relays_convert(
1350 sipe_private->media_relays,
1351 sipe_private->media_relay_username,
1352 sipe_private->media_relay_password);
1353
1354 min_port = sipe_private->min_media_port;
1355 max_port = sipe_private->max_media_port;
1356 switch (type) {
1357 case SIPE_MEDIA_AUDIO:
1358 min_port = sipe_private->min_audio_port;
1359 max_port = sipe_private->max_audio_port;
1360 break;
1361 case SIPE_MEDIA_VIDEO:
1362 min_port = sipe_private->min_video_port;
1363 max_port = sipe_private->max_audio_port;
1364 break;
1365 case SIPE_MEDIA_APPLICATION:
1366 if (sipe_strequal(id, "data")) {
1367 min_port = sipe_private->min_filetransfer_port;
1368 max_port = sipe_private->max_filetransfer_port;
1369 } else if (sipe_strequal(id, "applicationsharing")) {
1370 min_port = sipe_private->min_appsharing_port;
1371 max_port = sipe_private->max_appsharing_port;
1372 }
1373 break;
1374 }
1375
1376 stream_private = g_new0(struct sipe_media_stream_private, 1);
1377 SIPE_MEDIA_STREAM->call = call;
1378 SIPE_MEDIA_STREAM->id = g_strdup(id);
1379 stream_private->write_queue = g_queue_new();
1380 stream_private->async_reads = g_queue_new();
1381
1382 if (ssrc_count > 0) {
1383 SIPE_MEDIA_STREAM->ssrc_range =
1384 ssrc_range_allocate(&SIPE_MEDIA_CALL_PRIVATE->ssrc_ranges,
1385 ssrc_count);
1386 }
1387
1388 SIPE_MEDIA_STREAM->backend_private =
1389 sipe_backend_media_add_stream(SIPE_MEDIA_STREAM,
1390 type, ice_version,
1391 initiator,
1392 backend_media_relays,
1393 min_port, max_port);
1394
1395 sipe_backend_media_relays_free(backend_media_relays);
1396
1397 if (!SIPE_MEDIA_STREAM->backend_private) {
1398 sipe_media_stream_free(stream_private);
1399 return NULL;
1400 }
1401
1402 if (type == SIPE_MEDIA_VIDEO) {
1403 /* Declare that we can send and receive Video Source Requests
1404 * as per [MS-SDPEXT] 3.1.5.30.2. */
1405 sipe_media_stream_add_extra_attribute(SIPE_MEDIA_STREAM,
1406 "rtcp-fb", "* x-message app send:src recv:src");
1407
1408 sipe_media_stream_add_extra_attribute(SIPE_MEDIA_STREAM,
1409 "rtcp-rsize", NULL);
1410 sipe_media_stream_add_extra_attribute(SIPE_MEDIA_STREAM,
1411 "label", "main-video");
1412 sipe_media_stream_add_extra_attribute(SIPE_MEDIA_STREAM,
1413 "x-source", "main-video");
1414 }
1415
1416 #ifdef HAVE_SRTP
1417 if (get_encryption_policy(sipe_private) != SIPE_ENCRYPTION_POLICY_REJECTED) {
1418 int i;
1419 stream_private->encryption_key = g_new0(guchar, SIPE_SRTP_KEY_LEN);
1420 for (i = 0; i != SIPE_SRTP_KEY_LEN; ++i) {
1421 stream_private->encryption_key[i] = rand() & 0xff;
1422 }
1423 stream_private->encryption_key_id = 1;
1424 // We don't know yet whether the stream will be
1425 // encrypted or not. Enable the require-encryption
1426 // property at stream creation time anyway, we may
1427 // disable it later if we don't receive encryption keys.
1428 sipe_backend_media_set_require_encryption(call,
1429 SIPE_MEDIA_STREAM,
1430 TRUE);
1431 }
1432 #endif
1433
1434 SIPE_MEDIA_CALL_PRIVATE->streams =
1435 g_slist_append(SIPE_MEDIA_CALL_PRIVATE->streams,
1436 stream_private);
1437
1438 return SIPE_MEDIA_STREAM;
1439 }
1440
1441 static void
1442 append_2007_fallback_if_needed(struct sipe_media_call_private *call_private)
1443 {
1444 struct sipe_core_private *sipe_private = call_private->sipe_private;
1445 const gchar *marker = sip_transport_sdp_address_marker(sipe_private);
1446 const gchar *ip = sip_transport_ip_address(sipe_private);
1447 gchar *body;
1448
1449 if (SIPE_CORE_PRIVATE_FLAG_IS(SFB) ||
1450 sipe_media_get_sip_dialog(SIPE_MEDIA_CALL)->cseq != 0 ||
1451 call_private->ice_version != SIPE_ICE_RFC_5245 ||
1452 sipe_strequal(SIPE_MEDIA_CALL->with, sipe_private->test_call_bot_uri)) {
1453 return;
1454 }
1455
1456 body = g_strdup_printf("Content-Type: application/sdp\r\n"
1457 "Content-Transfer-Encoding: 7bit\r\n"
1458 "Content-Disposition: session; handling=optional; ms-proxy-2007fallback\r\n"
1459 "\r\n"
1460 "o=- 0 0 IN %s %s\r\n"
1461 "s=session\r\n"
1462 "c=IN %s %s\r\n"
1463 "m=audio 0 RTP/AVP\r\n",
1464 marker, ip,
1465 marker, ip);
1466 sipe_media_add_extra_invite_section(SIPE_MEDIA_CALL,
1467 "multipart/alternative", body);
1468 }
1469
1470 static void
1471 sipe_media_initiate_call(struct sipe_core_private *sipe_private,
1472 const char *with, SipeIceVersion ice_version,
1473 gboolean with_video)
1474 {
1475 struct sipe_media_call_private *call_private;
1476
1477 if (sipe_core_media_get_call(SIPE_CORE_PUBLIC)) {
1478 return;
1479 }
1480
1481 call_private = (struct sipe_media_call_private *)
1482 sipe_media_call_new(sipe_private, with, NULL,
1483 ice_version, 0);
1484
1485 SIPE_MEDIA_CALL->call_reject_cb = av_call_reject_cb;
1486
1487 if (!sipe_media_stream_add(SIPE_MEDIA_CALL, "audio", SIPE_MEDIA_AUDIO,
1488 call_private->ice_version,
1489 TRUE, 0)) {
1490 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
1491 _("Error occurred"),
1492 _("Error creating audio stream"));
1493 sipe_media_hangup(call_private);
1494 return;
1495 }
1496
1497 if (with_video &&
1498 !sipe_media_stream_add(SIPE_MEDIA_CALL, "video", SIPE_MEDIA_VIDEO,
1499 call_private->ice_version,
1500 TRUE, VIDEO_SSRC_COUNT)) {
1501 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
1502 _("Error occurred"),
1503 _("Error creating video stream"));
1504 sipe_media_hangup(call_private);
1505 return;
1506 }
1507
1508 append_2007_fallback_if_needed(call_private);
1509
1510 call_schedule_request_timeout(SIPE_MEDIA_CALL);
1511 // Processing continues in stream_initialized_cb
1512 }
1513
1514 void
1515 sipe_core_media_initiate_call(struct sipe_core_public *sipe_public,
1516 const char *with,
1517 gboolean with_video)
1518 {
1519 sipe_media_initiate_call(SIPE_CORE_PRIVATE, with,
1520 SIPE_ICE_RFC_5245, with_video);
1521 }
1522
1523 static void
1524 conference_audio_muted_cb(struct sipe_media_stream *stream, gboolean is_muted)
1525 {
1526 struct sipe_media_call *call = stream->call;
1527
1528 if (!SIPE_MEDIA_CALL_PRIVATE->conference_session) {
1529 return;
1530 }
1531
1532 sipe_conf_announce_audio_mute_state(SIPE_MEDIA_CALL_PRIVATE->sipe_private,
1533 SIPE_MEDIA_CALL_PRIVATE->conference_session,
1534 is_muted);
1535 }
1536
1537 void sipe_core_media_connect_conference(struct sipe_core_public *sipe_public,
1538 struct sipe_chat_session *chat_session)
1539 {
1540 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1541 struct sipe_media_call_private *call_private;
1542 struct sipe_media_stream *stream;
1543 struct sip_session *session;
1544 SipeIceVersion ice_version;
1545 gchar *av_uri;
1546
1547 if (!sipe_conf_supports_mcu_type(sipe_private, "audio-video")) {
1548 sipe_backend_notify_error(sipe_public, _("Join conference call"),
1549 _("Conference calls are not supported on this server."));
1550 return;
1551 }
1552
1553 session = sipe_session_find_chat(sipe_private, chat_session);
1554
1555 if (sipe_core_media_get_call(sipe_public) || !session) {
1556 return;
1557 }
1558
1559 av_uri = sipe_conf_build_uri(sipe_core_chat_id(sipe_public, chat_session),
1560 "audio-video");
1561 if (!av_uri) {
1562 return;
1563 }
1564
1565 session->is_call = TRUE;
1566
1567 ice_version = SIPE_CORE_PRIVATE_FLAG_IS(LYNC2013) ? SIPE_ICE_RFC_5245 :
1568 SIPE_ICE_DRAFT_6;
1569
1570 call_private = (struct sipe_media_call_private *)
1571 sipe_media_call_new(sipe_private, av_uri, NULL,
1572 ice_version, 0);
1573 call_private->conference_session = session;
1574 SIPE_MEDIA_CALL->call_reject_cb = av_call_reject_cb;
1575
1576 stream = sipe_media_stream_add(SIPE_MEDIA_CALL, "audio",
1577 SIPE_MEDIA_AUDIO,
1578 call_private->ice_version,
1579 TRUE, 0);
1580 if (!stream) {
1581 sipe_backend_notify_error(sipe_public,
1582 _("Error occurred"),
1583 _("Error creating audio stream"));
1584
1585 sipe_media_hangup(call_private);
1586 }
1587
1588 stream->mute_cb = conference_audio_muted_cb;
1589
1590 g_free(av_uri);
1591
1592 // Processing continues in stream_initialized_cb
1593 }
1594
1595 struct sipe_media_call *
1596 sipe_core_media_get_call(struct sipe_core_public *sipe_public)
1597 {
1598 struct sipe_media_call * result = NULL;
1599 GList *calls = g_hash_table_get_values(SIPE_CORE_PRIVATE->media_calls);
1600 GList *entry = calls;
1601
1602 while (entry) {
1603 if (sipe_core_media_get_stream_by_id(entry->data, "audio")) {
1604 result = entry->data;
1605 break;
1606 }
1607 entry = entry->next;
1608 }
1609 g_list_free(calls);
1610
1611 return result;
1612 }
1613
1614 static gboolean phone_number_is_valid(const gchar *phone_number)
1615 {
1616 if (!phone_number || sipe_strequal(phone_number, "")) {
1617 return FALSE;
1618 }
1619
1620 if (*phone_number == '+') {
1621 ++phone_number;
1622 }
1623
1624 while (*phone_number != '\0') {
1625 if (!g_ascii_isdigit(*phone_number)) {
1626 return FALSE;
1627 }
1628 ++phone_number;
1629 }
1630
1631 return TRUE;
1632 }
1633
1634 void sipe_core_media_phone_call(struct sipe_core_public *sipe_public,
1635 const gchar *phone_number)
1636 {
1637 g_return_if_fail(sipe_public);
1638
1639 SIPE_DEBUG_INFO("sipe_core_media_phone_call: %s", phone_number ? phone_number : "(null)");
1640
1641 if (phone_number_is_valid(phone_number)) {
1642 gchar *phone_uri = g_strdup_printf("sip:%s@%s;user=phone",
1643 phone_number, sipe_public->sip_domain);
1644
1645 sipe_core_media_initiate_call(sipe_public, phone_uri, FALSE);
1646
1647 g_free(phone_uri);
1648 } else {
1649 sipe_backend_notify_error(sipe_public,
1650 _("Unable to establish a call"),
1651 _("Invalid phone number"));
1652 }
1653 }
1654
1655 void sipe_core_media_test_call(struct sipe_core_public *sipe_public)
1656 {
1657 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1658 if (!sipe_private->test_call_bot_uri) {
1659 sipe_backend_notify_error(sipe_public,
1660 _("Unable to establish a call"),
1661 _("Audio Test Service is not available."));
1662 return;
1663 }
1664
1665 sipe_core_media_initiate_call(sipe_public,
1666 sipe_private->test_call_bot_uri, FALSE);
1667 }
1668
1669 static struct sipe_media_call_private *
1670 sipe_media_from_sipmsg(struct sipe_core_private *sipe_private,
1671 struct sipmsg *msg)
1672 {
1673 return g_hash_table_lookup(sipe_private->media_calls,
1674 sipmsg_find_call_id_header(msg));
1675 }
1676
1677 static void
1678 transport_response_unsupported_sdp(struct sipe_core_private *sipe_private,
1679 struct sipmsg *msg)
1680 {
1681 sipmsg_add_header(msg, "ms-client-diagnostics",
1682 "52063;reason=\"Unsupported session description\"");
1683 sip_transport_response(sipe_private, msg,
1684 488, "Not Acceptable Here", NULL);
1685 }
1686
1687 static void
1688 maybe_send_second_invite_response(struct sipe_media_call_private *call_private)
1689 {
1690 GSList *it;
1691
1692 /* Second INVITE request had to be received and all streams must have
1693 * established candidate pairs before the response can be sent. */
1694
1695 if (!call_private->invitation) {
1696 return;
1697 }
1698
1699 for (it = call_private->streams; it; it = it->next) {
1700 struct sipe_media_stream_private *stream_private = it->data;
1701 if (!stream_private->established) {
1702 return;
1703 }
1704 }
1705
1706 send_response_with_session_description(call_private, 200, "OK");
1707
1708 #ifdef HAVE_XDATA
1709 for (it = call_private->streams; it; it = it->next) {
1710 struct sipe_media_stream_private *stream_private = it->data;
1711
1712 stream_private->sdp_negotiation_concluded = TRUE;
1713 if (stream_private->writable) {
1714 // We've become writable.
1715 sipe_core_media_stream_writable(SIPE_MEDIA_STREAM, TRUE);
1716 }
1717 }
1718 #endif
1719 }
1720
1721 struct sipe_media_call *
1722 process_incoming_invite_call(struct sipe_core_private *sipe_private,
1723 struct sipmsg *msg,
1724 const gchar *sdp)
1725 {
1726 return(process_incoming_invite_call_parsed_sdp(sipe_private,
1727 msg,
1728 sdpmsg_parse_msg(sdp)));
1729 }
1730
1731 struct sipe_media_call *
1732 process_incoming_invite_call_parsed_sdp(struct sipe_core_private *sipe_private,
1733 struct sipmsg *msg,
1734 struct sdpmsg *smsg)
1735 {
1736 struct sipe_media_call_private *call_private;
1737 gboolean has_new_media = FALSE;
1738 GSList *i;
1739
1740 // Don't allow two voice calls in parallel.
1741 if (!strstr(msg->body, "m=data") &&
1742 !strstr(msg->body, "m=applicationsharing")) {
1743 struct sipe_media_call *call =
1744 sipe_core_media_get_call(SIPE_CORE_PUBLIC);
1745 if (call && !is_media_session_msg(SIPE_MEDIA_CALL_PRIVATE, msg)) {
1746 sip_transport_response(sipe_private, msg,
1747 486, "Busy Here", NULL);
1748 sdpmsg_free(smsg);
1749 return NULL;
1750 }
1751 }
1752
1753 call_private = sipe_media_from_sipmsg(sipe_private, msg);
1754
1755 if (call_private) {
1756 char *self = sip_uri_self(sipe_private);
1757 if (sipe_strequal(SIPE_MEDIA_CALL->with, self)) {
1758 g_free(self);
1759 sip_transport_response(sipe_private, msg, 488, "Not Acceptable Here", NULL);
1760 sdpmsg_free(smsg);
1761 return NULL;
1762 }
1763 g_free(self);
1764 }
1765
1766 if (!smsg) {
1767 transport_response_unsupported_sdp(sipe_private, msg);
1768 if (call_private) {
1769 sipe_media_hangup(call_private);
1770 }
1771 return NULL;
1772 }
1773
1774 if (!call_private) {
1775 gchar *with = sipmsg_parse_from_address(msg);
1776 SipeMediaCallFlags flags = 0;
1777
1778 if (strstr(msg->body, "m=data") ||
1779 strstr(msg->body, "m=applicationsharing")) {
1780 flags |= SIPE_MEDIA_CALL_NO_UI;
1781 }
1782
1783 call_private = (struct sipe_media_call_private *)
1784 sipe_media_call_new(sipe_private, with,
1785 msg, smsg->ice_version,
1786 flags);
1787
1788 if (!(flags & SIPE_MEDIA_CALL_NO_UI)) {
1789 SIPE_MEDIA_CALL->call_reject_cb = av_call_reject_cb;
1790 }
1791 g_free(with);
1792 }
1793
1794 if (call_private->invitation)
1795 sipmsg_free(call_private->invitation);
1796 call_private->invitation = sipmsg_copy(msg);
1797
1798 ssrc_range_update(&call_private->ssrc_ranges, smsg->media);
1799
1800 // Create any new media streams
1801 for (i = smsg->media; i; i = i->next) {
1802 struct sdpmedia *media = i->data;
1803 gchar *id = media->name;
1804 SipeMediaType type;
1805
1806 if ( media->port != 0
1807 && !sipe_core_media_get_stream_by_id(SIPE_MEDIA_CALL, id)) {
1808 guint32 ssrc_count = 0;
1809
1810 if (sipe_strequal(id, "audio"))
1811 type = SIPE_MEDIA_AUDIO;
1812 else if (sipe_strequal(id, "video")) {
1813 type = SIPE_MEDIA_VIDEO;
1814 ssrc_count = VIDEO_SSRC_COUNT;
1815 } else if (sipe_strequal(id, "data"))
1816 type = SIPE_MEDIA_APPLICATION;
1817 else if (sipe_strequal(id, "applicationsharing"))
1818 type = SIPE_MEDIA_APPLICATION;
1819 else
1820 continue;
1821
1822 sipe_media_stream_add(SIPE_MEDIA_CALL, id, type,
1823 smsg->ice_version, FALSE,
1824 ssrc_count);
1825 has_new_media = TRUE;
1826 }
1827 }
1828
1829 if (has_new_media) {
1830 sdpmsg_free(call_private->smsg);
1831 call_private->smsg = smsg;
1832 sip_transport_response(sipe_private, call_private->invitation,
1833 180, "Ringing", NULL);
1834 call_schedule_ringing_timeout(SIPE_MEDIA_CALL);
1835 // Processing continues in stream_initialized_cb
1836 } else {
1837 apply_remote_message(call_private, smsg);
1838 sdpmsg_free(smsg);
1839 maybe_send_second_invite_response(call_private);
1840 }
1841
1842 return SIPE_MEDIA_CALL;
1843 }
1844
1845 void process_incoming_cancel_call(struct sipe_media_call_private *call_private,
1846 struct sipmsg *msg)
1847 {
1848 // We respond to the CANCEL request with 200 OK response and
1849 // with 487 Request Terminated to the remote INVITE in progress.
1850 sip_transport_response(call_private->sipe_private, msg, 200, "OK", NULL);
1851
1852 if (call_private->invitation) {
1853 sip_transport_response(call_private->sipe_private,
1854 call_private->invitation,
1855 487, "Request Terminated", NULL);
1856 }
1857
1858 sipe_backend_media_reject(SIPE_MEDIA_CALL->backend_private, FALSE);
1859 }
1860
1861 static gboolean
1862 sipe_media_send_ack(struct sipe_core_private *sipe_private,
1863 struct sipmsg *msg,
1864 struct transaction *trans)
1865 {
1866 struct sipe_media_call_private *call_private;
1867 struct sip_dialog *dialog;
1868 int tmp_cseq;
1869
1870 call_private = sipe_media_from_sipmsg(sipe_private, msg);
1871
1872 if (!is_media_session_msg(call_private, msg))
1873 return FALSE;
1874
1875 dialog = sipe_media_get_sip_dialog(SIPE_MEDIA_CALL);
1876 if (!dialog)
1877 return FALSE;
1878
1879 tmp_cseq = dialog->cseq;
1880
1881 dialog->cseq = sip_transaction_cseq(trans) - 1;
1882 sip_transport_ack(sipe_private, dialog);
1883 dialog->cseq = tmp_cseq;
1884
1885 dialog->outgoing_invite = NULL;
1886
1887 return TRUE;
1888 }
1889
1890 static gboolean
1891 sipe_media_send_final_ack(struct sipe_core_private *sipe_private,
1892 struct sipmsg *msg,
1893 struct transaction *trans)
1894 {
1895 struct sipe_media_call_private *call_private;
1896 #ifdef HAVE_XDATA
1897 GSList *it;
1898 #endif
1899
1900 if (!sipe_media_send_ack(sipe_private, msg, trans))
1901 return FALSE;
1902
1903 call_private = sipe_media_from_sipmsg(sipe_private, msg);
1904
1905 sipe_backend_media_accept(SIPE_MEDIA_CALL->backend_private, FALSE);
1906
1907 #ifdef HAVE_XDATA
1908 for (it = call_private->streams; it; it = it->next) {
1909 struct sipe_media_stream_private *stream_private = it->data;
1910
1911 stream_private->sdp_negotiation_concluded = TRUE;
1912 if (stream_private->writable) {
1913 // We've become writable.
1914 sipe_core_media_stream_writable(SIPE_MEDIA_STREAM, TRUE);
1915 }
1916 }
1917 #endif
1918
1919 return TRUE;
1920 }
1921
1922 void
1923 sipe_core_media_stream_candidate_pair_established(struct sipe_media_stream *stream)
1924 {
1925 struct sipe_media_call *call = stream->call;
1926
1927 GList *active_candidates =
1928 sipe_backend_media_stream_get_active_local_candidates(stream);
1929 guint ready_components = g_list_length(active_candidates);
1930
1931 sipe_media_candidate_list_free(active_candidates);
1932
1933 if (ready_components != 2) {
1934 // We must have both RTP+RTCP candidate pairs established first.
1935 return;
1936 }
1937
1938 if (SIPE_MEDIA_STREAM_PRIVATE->established) {
1939 return;
1940 }
1941 SIPE_MEDIA_STREAM_PRIVATE->established = TRUE;
1942
1943 stream_schedule_cancel_timeout(call, SIPE_MEDIA_STREAM_PRIVATE);
1944
1945 if (stream->candidate_pairs_established_cb) {
1946 stream->candidate_pairs_established_cb(stream);
1947 }
1948
1949 if (sipe_backend_media_is_initiator(stream->call, NULL)) {
1950 GSList *streams = SIPE_MEDIA_CALL_PRIVATE->streams;
1951 for (; streams; streams = streams->next) {
1952 struct sipe_media_stream_private *s = streams->data;
1953 if (!s->established) {
1954 break;
1955 }
1956 }
1957
1958 if (streams == NULL) {
1959 // All call streams have been established.
1960 sipe_invite_call(SIPE_MEDIA_CALL_PRIVATE,
1961 sipe_media_send_final_ack);
1962 }
1963 } else {
1964 maybe_send_second_invite_response(SIPE_MEDIA_CALL_PRIVATE);
1965 }
1966 }
1967
1968 static gboolean
1969 maybe_retry_call_with_ice_version(struct sipe_core_private *sipe_private,
1970 struct sipe_media_call_private *call_private,
1971 SipeIceVersion ice_version,
1972 struct transaction *trans)
1973 {
1974 if (call_private->ice_version != ice_version &&
1975 sip_transaction_cseq(trans) == 1) {
1976 GSList *i;
1977 gchar *with;
1978 gboolean with_video = FALSE;
1979
1980 for (i = call_private->streams; i; i = i->next) {
1981 struct sipe_media_stream *stream = i->data;
1982
1983 if (sipe_strequal(stream->id, "video")) {
1984 with_video = TRUE;
1985 } else if (!sipe_strequal(stream->id, "audio")) {
1986 /* Don't retry calls which are neither audio
1987 * nor video. */
1988 return FALSE;
1989 }
1990 }
1991
1992 with = g_strdup(SIPE_MEDIA_CALL->with);
1993
1994 sipe_media_hangup(call_private);
1995 SIPE_DEBUG_INFO("Retrying call with ICEv%d.",
1996 ice_version == SIPE_ICE_DRAFT_6 ? 6 : 19);
1997 sipe_media_initiate_call(sipe_private,
1998 with,
1999 ice_version,
2000 with_video);
2001
2002 g_free(with);
2003 return TRUE;
2004 }
2005
2006 return FALSE;
2007 }
2008
2009 static gboolean
2010 process_invite_call_response(struct sipe_core_private *sipe_private,
2011 struct sipmsg *msg,
2012 struct transaction *trans)
2013 {
2014 const gchar *with;
2015 struct sipe_media_call_private *call_private;
2016 struct sip_dialog *dialog;
2017 struct sdpmsg *smsg;
2018
2019 call_private = sipe_media_from_sipmsg(sipe_private,msg);
2020
2021 if (!is_media_session_msg(call_private, msg))
2022 return FALSE;
2023
2024 dialog = sipe_media_get_sip_dialog(SIPE_MEDIA_CALL);
2025
2026 with = dialog->with;
2027
2028 dialog->outgoing_invite = NULL;
2029
2030 if (msg->response == 603 || msg->response == 605) {
2031 // Call rejected by remote peer
2032 sipe_media_send_ack(sipe_private, msg, trans);
2033 sipe_backend_media_reject(SIPE_MEDIA_CALL->backend_private, FALSE);
2034
2035 return TRUE;
2036 }
2037
2038 if (msg->response >= 400) {
2039 // An error occurred
2040 const gchar *title;
2041 GString *desc = g_string_new("");
2042 gboolean append_responsestr = FALSE;
2043
2044 switch (msg->response) {
2045 case 480: {
2046 title = _("User unavailable");
2047
2048 if (sipmsg_parse_warning(msg, NULL) == 391) {
2049 g_string_append_printf(desc, _("%s does not want to be disturbed"), with);
2050 } else
2051 g_string_append_printf(desc, _("User %s is not available"), with);
2052 break;
2053 }
2054 case 415:
2055 // OCS/Lync really sends response string with 'Mutipart' typo.
2056 if (sipe_strequal(msg->responsestr, "Mutipart mime in content type not supported by Archiving CDR service") &&
2057 maybe_retry_call_with_ice_version(sipe_private,
2058 call_private,
2059 SIPE_ICE_DRAFT_6,
2060 trans)) {
2061 return TRUE;
2062 }
2063 title = _("Unsupported media type");
2064 break;
2065 case 488: {
2066 /* Check for incompatible encryption levels error.
2067 *
2068 * MS Lync 2010:
2069 * 488 Not Acceptable Here
2070 * ms-client-diagnostics: 52017;reason="Encryption levels dont match"
2071 *
2072 * older clients (and SIPE itself):
2073 * 488 Encryption Levels not compatible
2074 */
2075 const gchar *ms_diag = sipmsg_find_header(msg, "ms-client-diagnostics");
2076 SipeIceVersion retry_ice_version = SIPE_ICE_DRAFT_6;
2077
2078 if (sipe_strequal(msg->responsestr, "Encryption Levels not compatible") ||
2079 (ms_diag && g_str_has_prefix(ms_diag, "52017;"))) {
2080 title = _("Unable to establish a call");
2081 g_string_append(desc, _("Encryption settings of peer are incompatible with ours."));
2082 break;
2083 }
2084
2085 /* Check if this is failed conference using
2086 * ICEv6 with reason "Error parsing SDP" and
2087 * retry using ICEv19. */
2088 ms_diag = sipmsg_find_header(msg, "ms-diagnostics");
2089 if (ms_diag && g_str_has_prefix(ms_diag, "7008;")) {
2090 retry_ice_version = SIPE_ICE_RFC_5245;
2091 }
2092
2093 if (maybe_retry_call_with_ice_version(sipe_private,
2094 call_private,
2095 retry_ice_version,
2096 trans)) {
2097 return TRUE;
2098 }
2099 SIPE_FALLTHROUGH
2100 }
2101 default:
2102 title = _("Error occurred");
2103 g_string_append(desc, _("Unable to establish a call"));
2104 append_responsestr = TRUE;
2105 break;
2106 }
2107
2108 if (append_responsestr) {
2109 gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
2110
2111 g_string_append_printf(desc, "\n%d %s",
2112 msg->response, msg->responsestr);
2113 if (reason) {
2114 g_string_append_printf(desc, "\n\n%s", reason);
2115 g_free(reason);
2116 }
2117 }
2118
2119 sipe_backend_notify_error(SIPE_CORE_PUBLIC, title, desc->str);
2120 g_string_free(desc, TRUE);
2121
2122 sipe_media_send_ack(sipe_private, msg, trans);
2123 sipe_media_hangup(call_private);
2124
2125 return TRUE;
2126 }
2127
2128 sipe_dialog_parse(dialog, msg, TRUE);
2129 smsg = sdpmsg_parse_msg(msg->body);
2130 if (!smsg) {
2131 transport_response_unsupported_sdp(sipe_private, msg);
2132 sipe_media_hangup(call_private);
2133 return FALSE;
2134 }
2135
2136 ssrc_range_update(&call_private->ssrc_ranges, smsg->media);
2137 apply_remote_message(call_private, smsg);
2138 sdpmsg_free(smsg);
2139
2140 stream_schedule_timeout(SIPE_MEDIA_CALL);
2141 call_schedule_cancel_request_timeout(SIPE_MEDIA_CALL);
2142 sipe_media_send_ack(sipe_private, msg, trans);
2143
2144 return TRUE;
2145
2146 // Waits until sipe_core_media_candidate_pair_established() is invoked.
2147 }
2148
2149 gboolean is_media_session_msg(struct sipe_media_call_private *call_private,
2150 struct sipmsg *msg)
2151 {
2152 if (!call_private) {
2153 return FALSE;
2154 }
2155
2156 return sipe_media_from_sipmsg(call_private->sipe_private, msg) == call_private;
2157 }
2158
2159 static void
2160 end_call(SIPE_UNUSED_PARAMETER gpointer key,
2161 struct sipe_media_call_private *call_private,
2162 SIPE_UNUSED_PARAMETER gpointer user_data)
2163 {
2164 struct sipe_backend_media *backend_private;
2165
2166 backend_private = call_private->public.backend_private;
2167
2168 if (!sipe_backend_media_is_initiator(SIPE_MEDIA_CALL, NULL) &&
2169 !sipe_backend_media_accepted(backend_private)) {
2170 sip_transport_response(call_private->sipe_private,
2171 call_private->invitation,
2172 480, "Temporarily Unavailable", NULL);
2173 } else if (call_private->session) {
2174 sipe_session_close(call_private->sipe_private,
2175 call_private->session);
2176 call_private->session = NULL;
2177 }
2178
2179 sipe_media_hangup(call_private);
2180 }
2181
2182 void
2183 sipe_media_handle_going_offline(struct sipe_core_private *sipe_private)
2184 {
2185 g_hash_table_foreach(sipe_private->media_calls, (GHFunc) end_call, NULL);
2186 }
2187
2188 gboolean sipe_media_is_conference_call(struct sipe_media_call_private *call_private)
2189 {
2190 return g_strstr_len(SIPE_MEDIA_CALL->with, -1, "app:conf:audio-video:") != NULL;
2191 }
2192
2193 struct sipe_core_private *
2194 sipe_media_get_sipe_core_private(struct sipe_media_call *call)
2195 {
2196 g_return_val_if_fail(call, NULL);
2197
2198 return SIPE_MEDIA_CALL_PRIVATE->sipe_private;
2199 }
2200
2201 struct sip_dialog *
2202 sipe_media_get_sip_dialog(struct sipe_media_call *call)
2203 {
2204 struct sip_session *session;
2205
2206 g_return_val_if_fail(call, NULL);
2207
2208 session = SIPE_MEDIA_CALL_PRIVATE->session;
2209
2210 if (!session || !session->dialogs) {
2211 return NULL;
2212 }
2213
2214 return session->dialogs->data;
2215 }
2216
2217 static void
2218 sipe_media_relay_free(struct sipe_media_relay *relay)
2219 {
2220 g_free(relay->hostname);
2221 if (relay->dns_query)
2222 sipe_backend_dns_query_cancel(relay->dns_query);
2223 g_free(relay);
2224 }
2225
2226 void
2227 sipe_media_relay_list_free(GSList *list)
2228 {
2229 for (; list; list = g_slist_delete_link(list, list))
2230 sipe_media_relay_free(list->data);
2231 }
2232
2233 static void
2234 relay_ip_resolved_cb(struct sipe_media_relay* relay,
2235 const gchar *ip, SIPE_UNUSED_PARAMETER guint port)
2236 {
2237 gchar *hostname = relay->hostname;
2238 relay->dns_query = NULL;
2239
2240 if (ip && port) {
2241 relay->hostname = g_strdup(ip);
2242 SIPE_DEBUG_INFO("Media relay %s resolved to %s.", hostname, ip);
2243 } else {
2244 relay->hostname = NULL;
2245 SIPE_DEBUG_INFO("Unable to resolve media relay %s.", hostname);
2246 }
2247
2248 g_free(hostname);
2249 }
2250
2251 static gboolean
2252 process_get_av_edge_credentials_response(struct sipe_core_private *sipe_private,
2253 struct sipmsg *msg,
2254 SIPE_UNUSED_PARAMETER struct transaction *trans)
2255 {
2256 g_free(sipe_private->media_relay_username);
2257 g_free(sipe_private->media_relay_password);
2258 sipe_media_relay_list_free(sipe_private->media_relays);
2259 sipe_private->media_relay_username = NULL;
2260 sipe_private->media_relay_password = NULL;
2261 sipe_private->media_relays = NULL;
2262
2263 if (msg->response >= 400) {
2264 SIPE_DEBUG_INFO_NOFORMAT("process_get_av_edge_credentials_response: SERVICE response is not 200. "
2265 "Failed to obtain A/V Edge credentials.");
2266 return FALSE;
2267 }
2268
2269 if (msg->response == 200) {
2270 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
2271
2272 if (sipe_strequal("OK", sipe_xml_attribute(xn_response, "reasonPhrase"))) {
2273 const sipe_xml *xn_credentials = sipe_xml_child(xn_response, "credentialsResponse/credentials");
2274 const sipe_xml *xn_relays = sipe_xml_child(xn_response, "credentialsResponse/mediaRelayList");
2275 const sipe_xml *item;
2276 GSList *relays = NULL;
2277
2278 item = sipe_xml_child(xn_credentials, "username");
2279 sipe_private->media_relay_username = sipe_xml_data(item);
2280 item = sipe_xml_child(xn_credentials, "password");
2281 sipe_private->media_relay_password = sipe_xml_data(item);
2282
2283 for (item = sipe_xml_child(xn_relays, "mediaRelay"); item; item = sipe_xml_twin(item)) {
2284 struct sipe_media_relay *relay = g_new0(struct sipe_media_relay, 1);
2285 const sipe_xml *node;
2286 gchar *tmp;
2287
2288 node = sipe_xml_child(item, "hostName");
2289 relay->hostname = sipe_xml_data(node);
2290
2291 node = sipe_xml_child(item, "udpPort");
2292 if (node) {
2293 tmp = sipe_xml_data(node);
2294 if (tmp) {
2295 relay->udp_port = atoi(tmp);
2296 g_free(tmp);
2297 }
2298 }
2299
2300 node = sipe_xml_child(item, "tcpPort");
2301 if (node) {
2302 tmp = sipe_xml_data(node);
2303 if (tmp) {
2304 relay->tcp_port = atoi(tmp);
2305 g_free(tmp);
2306 }
2307 }
2308
2309 relays = g_slist_append(relays, relay);
2310
2311 relay->dns_query = sipe_backend_dns_query_a(
2312 SIPE_CORE_PUBLIC,
2313 relay->hostname,
2314 relay->udp_port,
2315 (sipe_dns_resolved_cb) relay_ip_resolved_cb,
2316 relay);
2317
2318 SIPE_DEBUG_INFO("Media relay: %s TCP: %d UDP: %d",
2319 relay->hostname,
2320 relay->tcp_port, relay->udp_port);
2321 }
2322
2323 sipe_private->media_relays = relays;
2324 }
2325
2326 sipe_xml_free(xn_response);
2327 }
2328
2329 return TRUE;
2330 }
2331
2332 void
2333 sipe_media_get_av_edge_credentials(struct sipe_core_private *sipe_private)
2334 {
2335 // TODO: re-request credentials after duration expires?
2336 static const char CRED_REQUEST_XML[] =
2337 "<request requestID=\"%d\" "
2338 "from=\"%s\" "
2339 "version=\"1.0\" "
2340 "to=\"%s\" "
2341 "xmlns=\"http://schemas.microsoft.com/2006/09/sip/mrasp\" "
2342 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
2343 "<credentialsRequest credentialsRequestID=\"%d\">"
2344 "<identity>%s</identity>"
2345 "<location>%s</location>"
2346 "<duration>480</duration>"
2347 "</credentialsRequest>"
2348 "</request>";
2349
2350 int request_id = rand();
2351 gchar *self;
2352 gchar *body;
2353
2354 if (!sipe_private->mras_uri)
2355 return;
2356
2357 self = sip_uri_self(sipe_private);
2358
2359 body = g_strdup_printf(
2360 CRED_REQUEST_XML,
2361 request_id,
2362 self,
2363 sipe_private->mras_uri,
2364 request_id,
2365 self,
2366 SIPE_CORE_PRIVATE_FLAG_IS(REMOTE_USER) ? "internet" : "intranet");
2367 g_free(self);
2368
2369 sip_transport_service(sipe_private,
2370 sipe_private->mras_uri,
2371 "Content-Type: application/msrtc-media-relay-auth+xml\r\n",
2372 body,
2373 process_get_av_edge_credentials_response);
2374
2375 g_free(body);
2376 }
2377
2378 void
2379 sipe_media_add_extra_invite_section(struct sipe_media_call *call,
2380 const gchar *invite_content_type,
2381 gchar *body)
2382 {
2383 g_free(SIPE_MEDIA_CALL_PRIVATE->extra_invite_section);
2384 g_free(SIPE_MEDIA_CALL_PRIVATE->invite_content_type);
2385 SIPE_MEDIA_CALL_PRIVATE->extra_invite_section = body;
2386 SIPE_MEDIA_CALL_PRIVATE->invite_content_type =
2387 g_strdup(invite_content_type);
2388 }
2389
2390 void
2391 sipe_media_stream_add_extra_attribute(struct sipe_media_stream *stream,
2392 const gchar *name, const gchar *value)
2393 {
2394 SIPE_MEDIA_STREAM_PRIVATE->extra_sdp =
2395 sipe_utils_nameval_add(SIPE_MEDIA_STREAM_PRIVATE->extra_sdp,
2396 name, value);
2397 }
2398
2399 #ifdef HAVE_XDATA
2400 void
2401 sipe_core_media_stream_readable(struct sipe_media_stream *stream)
2402 {
2403 g_return_if_fail(stream);
2404
2405 if (g_queue_is_empty(SIPE_MEDIA_STREAM_PRIVATE->async_reads) &&
2406 stream->read_cb) {
2407 stream->read_cb(stream);
2408 }
2409
2410 while (!g_queue_is_empty(SIPE_MEDIA_STREAM_PRIVATE->async_reads)) {
2411 struct async_read_data *data;
2412 guint8 *pos;
2413 gssize len;
2414 gssize bytes_read;
2415
2416 data = g_queue_peek_head(SIPE_MEDIA_STREAM_PRIVATE->async_reads);
2417 pos = data->buffer + SIPE_MEDIA_STREAM_PRIVATE->read_pos;
2418 len = data->len - SIPE_MEDIA_STREAM_PRIVATE->read_pos;
2419
2420 bytes_read = sipe_backend_media_stream_read(stream, pos, len);
2421 if (bytes_read == -1) {
2422 struct sipe_media_call *call = stream->call;
2423 struct sipe_core_private *sipe_private =
2424 SIPE_MEDIA_CALL_PRIVATE->sipe_private;
2425
2426 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
2427 _("Media error"),
2428 _("Error while reading from stream"));
2429 sipe_media_hangup(SIPE_MEDIA_CALL_PRIVATE);
2430 return;
2431 }
2432
2433 SIPE_MEDIA_STREAM_PRIVATE->read_pos += bytes_read;
2434
2435 if (SIPE_MEDIA_STREAM_PRIVATE->read_pos == data->len) {
2436 data->callback(stream, data->buffer, data->len);
2437 SIPE_MEDIA_STREAM_PRIVATE->read_pos = 0;
2438 g_queue_pop_head(SIPE_MEDIA_STREAM_PRIVATE->async_reads);
2439 g_free(data);
2440 } else {
2441 // Still not enough data to finish the read.
2442 return;
2443 }
2444 }
2445 }
2446
2447 void
2448 sipe_media_stream_read_async(struct sipe_media_stream *stream,
2449 gpointer buffer, gsize len,
2450 sipe_media_stream_read_callback callback)
2451 {
2452 struct async_read_data *data;
2453
2454 g_return_if_fail(stream && buffer && callback);
2455
2456 data = g_new0(struct async_read_data, 1);
2457 data->buffer = buffer;
2458 data->len = len;
2459 data->callback = callback;
2460
2461 g_queue_push_tail(SIPE_MEDIA_STREAM_PRIVATE->async_reads, data);
2462 }
2463
2464 static void
2465 stream_append_buffer(struct sipe_media_stream *stream,
2466 guint8 *buffer, guint len)
2467 {
2468 GByteArray *b = g_byte_array_sized_new(len);
2469 g_byte_array_append(b, buffer, len);
2470 g_queue_push_tail(SIPE_MEDIA_STREAM_PRIVATE->write_queue, b);
2471 }
2472
2473 gboolean
2474 sipe_media_stream_write(struct sipe_media_stream *stream,
2475 gpointer buffer, gsize len)
2476 {
2477 if (!sipe_media_stream_is_writable(stream)) {
2478 stream_append_buffer(stream, buffer, len);
2479 return FALSE;
2480 } else {
2481 guint written;
2482
2483 written = sipe_backend_media_stream_write(stream, buffer, len);
2484 if (written == len) {
2485 return TRUE;
2486 }
2487
2488 stream_append_buffer(stream,
2489 (guint8 *)buffer + written, len - written);
2490 return FALSE;
2491 }
2492 }
2493
2494 void
2495 sipe_core_media_stream_writable(struct sipe_media_stream *stream,
2496 gboolean writable)
2497 {
2498 SIPE_MEDIA_STREAM_PRIVATE->writable = writable;
2499
2500 if (!writable) {
2501 return;
2502 }
2503
2504 while (!g_queue_is_empty(SIPE_MEDIA_STREAM_PRIVATE->write_queue)) {
2505 GByteArray *b;
2506 guint written;
2507
2508 b = g_queue_peek_head(SIPE_MEDIA_STREAM_PRIVATE->write_queue);
2509
2510 written = sipe_backend_media_stream_write(stream, b->data, b->len);
2511 if (written != b->len) {
2512 g_byte_array_remove_range(b, 0, written);
2513 return;
2514 }
2515
2516 g_byte_array_unref(b);
2517 g_queue_pop_head(SIPE_MEDIA_STREAM_PRIVATE->write_queue);
2518 }
2519
2520 if (sipe_media_stream_is_writable(stream) && stream->writable_cb) {
2521 stream->writable_cb(stream);
2522 }
2523 }
2524
2525 gboolean
2526 sipe_media_stream_is_writable(struct sipe_media_stream *stream)
2527 {
2528 return SIPE_MEDIA_STREAM_PRIVATE->writable &&
2529 SIPE_MEDIA_STREAM_PRIVATE->sdp_negotiation_concluded &&
2530 g_queue_is_empty(SIPE_MEDIA_STREAM_PRIVATE->write_queue);
2531 }
2532 #endif
2533
2534 void
2535 sipe_media_stream_set_data(struct sipe_media_stream *stream, gpointer data,
2536 GDestroyNotify free_func)
2537 {
2538 struct sipe_media_stream_private *stream_private =
2539 SIPE_MEDIA_STREAM_PRIVATE;
2540
2541 g_return_if_fail(stream_private);
2542
2543 if (stream_private->data && stream_private->data_free_func) {
2544 stream_private->data_free_func(stream_private->data);
2545 }
2546
2547 stream_private->data = data;
2548 stream_private->data_free_func = free_func;
2549 }
2550
2551 gpointer
2552 sipe_media_stream_get_data(struct sipe_media_stream *stream)
2553 {
2554 g_return_val_if_fail(stream, NULL);
2555
2556 return SIPE_MEDIA_STREAM_PRIVATE->data;
2557 }
2558
2559 /*
2560 Local Variables:
2561 mode: c
2562 c-file-style: "bsd"
2563 indent-tabs-mode: t
2564 tab-width: 8
2565 End:
2566 */
A third-party Pidgin plugin for Microsoft LCS/OCS