src/purple/purple-media.c

   1 /**
   2  * @file purple-media.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-15 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "glib.h"
  28 #include "glib/gstdio.h"
  29 #include <fcntl.h>
  30 #include <string.h>
  31 #ifdef HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34
  35 #include "sipe-common.h"
  36
  37 #include "mediamanager.h"
  38 #include "agent.h"
  39
  40 #ifdef _WIN32
  41 /* wrappers for write() & friends for socket handling */
  42 #include "win32/win32dep.h"
  43 #endif
  44
  45 #include "sipe-backend.h"
  46 #include "sipe-core.h"
  47
  48 #include "purple-private.h"
  49
  50 /*
  51  * GStreamer interfaces fail to compile on ARM architecture with -Wcast-align
  52  *
  53  * Diagnostic #pragma was added in GCC 4.2.0
  54  */
  55 #if defined(__GNUC__)
  56 #if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2)) || (__GNUC__ >= 5)
  57 #if defined(__ARMEL__) || defined(__ARMEB__) || defined(__mips__) || defined(__sparc__) || (defined(__powerpc__) && defined(__NO_FPRS__))
  58 #pragma GCC diagnostic ignored "-Wcast-align"
  59 #endif
  60 #endif
  61 #endif
  62
  63 #include "media-gst.h"
  64
  65 struct sipe_backend_media {
  66         PurpleMedia *m;
  67         GSList *streams;
  68         /**
  69          * Number of media streams that were not yet locally accepted or rejected.
  70          */
  71         guint unconfirmed_streams;
  72 };
  73
  74 struct sipe_backend_stream {
  75         gchar *sessionid;
  76         gchar *participant;
  77         gboolean local_on_hold;
  78         gboolean remote_on_hold;
  79         gboolean accepted;
  80         gboolean initialized_cb_was_fired;
  81 };
  82
  83 #if PURPLE_VERSION_CHECK(3,0,0)
  84 #define SIPE_RELAYS_G_TYPE G_TYPE_PTR_ARRAY
  85 #else
  86 #define SIPE_RELAYS_G_TYPE G_TYPE_VALUE_ARRAY
  87 #endif
  88
  89 static void
  90 backend_stream_free(struct sipe_backend_stream *stream)
  91 {
  92         if (stream) {
  93                 g_free(stream->sessionid);
  94                 g_free(stream->participant);
  95                 g_free(stream);
  96         }
  97 }
  98
  99 static PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type);
 100 static PurpleMediaCandidateType sipe_candidate_type_to_purple(SipeCandidateType type);
 101 static SipeCandidateType purple_candidate_type_to_sipe(PurpleMediaCandidateType type);
 102 static PurpleMediaNetworkProtocol sipe_network_protocol_to_purple(SipeNetworkProtocol proto);
 103 static SipeNetworkProtocol purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto);
 104
 105 static void
 106 maybe_signal_stream_initialized(struct sipe_media_call *call, gchar *sessionid)
 107 {
 108         if (call->stream_initialized_cb) {
 109                 struct sipe_backend_stream *stream;
 110                 stream = sipe_backend_media_get_stream_by_id(call->backend_private, sessionid);
 111
 112                 if (sipe_backend_stream_initialized(call->backend_private, stream) &&
 113                     !stream->initialized_cb_was_fired) {
 114                         call->stream_initialized_cb(call, stream);
 115                         stream->initialized_cb_was_fired = TRUE;
 116                 }
 117         }
 118 }
 119
 120 static void
 121 on_candidates_prepared_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 122                           gchar *sessionid,
 123                           SIPE_UNUSED_PARAMETER gchar *participant,
 124                           struct sipe_media_call *call)
 125 {
 126         maybe_signal_stream_initialized(call, sessionid);
 127 }
 128
 129 static void
 130 on_codecs_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 131                     gchar *sessionid,
 132                     struct sipe_media_call *call)
 133 {
 134         maybe_signal_stream_initialized(call, sessionid);
 135 }
 136
 137 static void
 138 on_state_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 139                     PurpleMediaState state,
 140                     gchar *sessionid,
 141                     gchar *participant,
 142                     struct sipe_media_call *call)
 143 {
 144         SIPE_DEBUG_INFO("sipe_media_state_changed_cb: %d %s %s\n", state, sessionid, participant);
 145         if (state == PURPLE_MEDIA_STATE_END &&
 146             !sessionid && !participant && call->media_end_cb)
 147                 call->media_end_cb(call);
 148 }
 149
 150 void
 151 capture_pipeline(const gchar *label) {
 152         PurpleMediaManager *manager = purple_media_manager_get();
 153         GstElement *pipeline = purple_media_manager_get_pipeline(manager);
 154         GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, label);
 155 }
 156
 157 static void
 158 on_error_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar *message,
 159             struct sipe_media_call *call)
 160 {
 161         capture_pipeline("ERROR");
 162
 163         if (call->error_cb)
 164                 call->error_cb(call, message);
 165 }
 166
 167 static void
 168 on_stream_info_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 169                   PurpleMediaInfoType type,
 170                   gchar *sessionid,
 171                   gchar *participant,
 172                   gboolean local,
 173                   struct sipe_media_call *call)
 174 {
 175         if (type == PURPLE_MEDIA_INFO_ACCEPT) {
 176                 if (call->call_accept_cb && !sessionid && !participant)
 177                         call->call_accept_cb(call, local);
 178                 else if (sessionid && participant) {
 179                         struct sipe_backend_stream *stream;
 180                         stream = sipe_backend_media_get_stream_by_id(call->backend_private,
 181                                                                      sessionid);
 182                         if (stream) {
 183                                 if (!stream->accepted && local)
 184                                          --call->backend_private->unconfirmed_streams;
 185                                 stream->accepted = TRUE;
 186                         }
 187                 }
 188         } else if (type == PURPLE_MEDIA_INFO_HOLD || type == PURPLE_MEDIA_INFO_UNHOLD) {
 189
 190                 gboolean state = (type == PURPLE_MEDIA_INFO_HOLD);
 191
 192                 if (sessionid) {
 193                         // Hold specific stream
 194                         struct sipe_backend_stream *stream;
 195                         stream = sipe_backend_media_get_stream_by_id(call->backend_private,
 196                                                                      sessionid);
 197
 198                         if (local)
 199                                 stream->local_on_hold = state;
 200                         else
 201                                 stream->remote_on_hold = state;
 202                 } else {
 203                         // Hold all streams
 204                         GSList *i = sipe_backend_media_get_streams(call->backend_private);
 205                         for (; i; i = i->next) {
 206                                 struct sipe_backend_stream *stream = i->data;
 207
 208                                 if (local)
 209                                         stream->local_on_hold = state;
 210                                 else
 211                                         stream->remote_on_hold = state;
 212                         }
 213                 }
 214
 215                 if (call->call_hold_cb)
 216                         call->call_hold_cb(call, local, state);
 217         } else if (type == PURPLE_MEDIA_INFO_HANGUP || type == PURPLE_MEDIA_INFO_REJECT) {
 218                 if (!sessionid && !participant) {
 219                         if (type == PURPLE_MEDIA_INFO_HANGUP && call->call_hangup_cb)
 220                                 call->call_hangup_cb(call, local);
 221                         else if (type == PURPLE_MEDIA_INFO_REJECT && call->call_reject_cb && !local)
 222                                 call->call_reject_cb(call, local);
 223                 } else if (sessionid && participant) {
 224                         struct sipe_backend_stream *stream;
 225                         stream = sipe_backend_media_get_stream_by_id(call->backend_private,
 226                                                                      sessionid);
 227
 228                         if (stream) {
 229                                 call->backend_private->streams = g_slist_remove(call->backend_private->streams, stream);
 230                                 backend_stream_free(stream);
 231                                 if (local && --call->backend_private->unconfirmed_streams == 0 &&
 232                                     call->call_reject_cb)
 233                                         call->call_reject_cb(call, local);
 234                         }
 235                 }
 236         }
 237 }
 238
 239 static void
 240 on_candidate_pair_established_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 241                                  SIPE_UNUSED_PARAMETER const gchar *sessionid,
 242                                  SIPE_UNUSED_PARAMETER const gchar *participant,
 243                                  SIPE_UNUSED_PARAMETER PurpleMediaCandidate *local_candidate,
 244                                  SIPE_UNUSED_PARAMETER PurpleMediaCandidate *remote_candidate,
 245                                  SIPE_UNUSED_PARAMETER struct sipe_media_call *call)
 246 {
 247 #if PURPLE_VERSION_CHECK(2,10,12) || PURPLE_VERSION_CHECK(3,0,0)
 248         if (purple_media_candidate_get_protocol(local_candidate) != PURPLE_MEDIA_NETWORK_PROTOCOL_UDP) {
 249                 purple_media_set_send_rtcp_mux(media, sessionid, participant, TRUE);
 250         }
 251 #endif
 252 }
 253
 254 struct sipe_backend_media *
 255 sipe_backend_media_new(struct sipe_core_public *sipe_public,
 256                        struct sipe_media_call *call,
 257                        const gchar *participant,
 258                        gboolean initiator)
 259 {
 260         struct sipe_backend_media *media = g_new0(struct sipe_backend_media, 1);
 261         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 262         PurpleMediaManager *manager = purple_media_manager_get();
 263         GstElement *pipeline;
 264
 265         media->m = purple_media_manager_create_media(manager,
 266                                                      purple_private->account,
 267                                                      "fsrtpconference",
 268                                                      participant, initiator);
 269
 270         g_signal_connect(G_OBJECT(media->m), "candidates-prepared",
 271                          G_CALLBACK(on_candidates_prepared_cb), call);
 272         g_signal_connect(G_OBJECT(media->m), "codecs-changed",
 273                          G_CALLBACK(on_codecs_changed_cb), call);
 274         g_signal_connect(G_OBJECT(media->m), "stream-info",
 275                          G_CALLBACK(on_stream_info_cb), call);
 276         g_signal_connect(G_OBJECT(media->m), "error",
 277                          G_CALLBACK(on_error_cb), call);
 278         g_signal_connect(G_OBJECT(media->m), "state-changed",
 279                          G_CALLBACK(on_state_changed_cb), call);
 280         g_signal_connect(G_OBJECT(media->m), "candidate-pair-established",
 281                          G_CALLBACK(on_candidate_pair_established_cb), call);
 282
 283
 284         /* On error, the pipeline is no longer in PLAYING state and libpurple
 285          * will not switch it back to PLAYING, preventing any more calls until
 286          * application restart. We switch the state ourselves here to negate
 287          * effect of any error in previous call (if any). */
 288         pipeline = purple_media_manager_get_pipeline(manager);
 289         gst_element_set_state(pipeline, GST_STATE_PLAYING);
 290
 291         return media;
 292 }
 293
 294 void
 295 sipe_backend_media_free(struct sipe_backend_media *media)
 296 {
 297         if (media) {
 298                 GSList *stream = media->streams;
 299
 300                 for (; stream; stream = g_slist_delete_link(stream, stream))
 301                         backend_stream_free(stream->data);
 302
 303                 g_free(media);
 304         }
 305 }
 306
 307 void
 308 sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname)
 309 {
 310         if (media) {
 311                 guint num_params = 3;
 312                 GParameter *params = g_new0(GParameter, num_params);
 313                 params[0].name = "sdes-cname";
 314                 g_value_init(&params[0].value, G_TYPE_STRING);
 315                 g_value_set_string(&params[0].value, cname);
 316                 params[1].name = "sdes-name";
 317                 g_value_init(&params[1].value, G_TYPE_STRING);
 318                 params[2].name = "sdes-tool";
 319                 g_value_init(&params[2].value, G_TYPE_STRING);
 320
 321                 purple_media_set_params(media->m, num_params, params);
 322
 323                 g_value_unset(&params[0].value);
 324                 g_free(params);
 325         }
 326 }
 327
 328 #define FS_CODECS_CONF \
 329         "# Automatically created by SIPE plugin\n" \
 330         "[video/H263]\n" \
 331         "farsight-send-profile=videoscale ! ffmpegcolorspace ! fsvideoanyrate ! ffenc_h263 rtp-payload-size=30 ! rtph263pay\n" \
 332         "\n" \
 333         "[audio/PCMA]\n" \
 334         "farsight-send-profile=audioconvert ! audioresample ! audioconvert ! alawenc ! rtppcmapay min-ptime=20000000 max-ptime=20000000\n" \
 335         "\n" \
 336         "[audio/PCMU]\n" \
 337         "farsight-send-profile=audioconvert ! audioresample ! audioconvert ! mulawenc ! rtppcmupay min-ptime=20000000 max-ptime=20000000\n";
 338
 339 static void
 340 ensure_codecs_conf()
 341 {
 342         gchar *filename;
 343         filename = g_build_filename(purple_user_dir(), "fs-codec.conf", NULL);
 344
 345         if (!g_file_test(filename, G_FILE_TEST_EXISTS)) {
 346                 int fd = g_open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
 347                 gchar *fs_codecs_conf = FS_CODECS_CONF;
 348                 if ((fd < 0) || write(fd, fs_codecs_conf, strlen(fs_codecs_conf)) == -1)
 349                         SIPE_DEBUG_ERROR_NOFORMAT("Can not create fs-codec.conf!");
 350                 if (fd >= 0)
 351                         close(fd);
 352         }
 353
 354         g_free(filename);
 355 }
 356
 357 static void
 358 append_relay(struct sipe_backend_media_relays *relay_info, const gchar *ip,
 359              guint port, gchar *type, gchar *username, gchar *password)
 360 {
 361         GstStructure *gst_relay_info;
 362
 363         gst_relay_info = gst_structure_new("relay-info",
 364                         "ip", G_TYPE_STRING, ip,
 365                         "port", G_TYPE_UINT, port,
 366                         "relay-type", G_TYPE_STRING, type,
 367                         "username", G_TYPE_STRING, username,
 368                         "password", G_TYPE_STRING, password,
 369                         NULL);
 370
 371         if (gst_relay_info) {
 372 #if PURPLE_VERSION_CHECK(3,0,0)
 373                 g_ptr_array_add((GPtrArray *)relay_info, gst_relay_info);
 374 #else
 375                 GValue value;
 376                 memset(&value, 0, sizeof(GValue));
 377                 g_value_init(&value, GST_TYPE_STRUCTURE);
 378                 gst_value_set_structure(&value, gst_relay_info);
 379
 380                 g_value_array_append((GValueArray *)relay_info, &value);
 381                 gst_structure_free(gst_relay_info);
 382 #endif
 383         }
 384 }
 385
 386 struct sipe_backend_media_relays *
 387 sipe_backend_media_relays_convert(GSList *media_relays, gchar *username, gchar *password)
 388 {
 389         struct sipe_backend_media_relays *relay_info;
 390
 391         relay_info = (struct sipe_backend_media_relays *)
 392 #if PURPLE_VERSION_CHECK(3,0,0)
 393                         g_ptr_array_new_with_free_func((GDestroyNotify) gst_structure_free);
 394 #else
 395                         g_value_array_new(0);
 396 #endif
 397
 398         for (; media_relays; media_relays = media_relays->next) {\
 399                 struct sipe_media_relay *relay = media_relays->data;
 400
 401                 /* Skip relays where IP could not be resolved. */
 402                 if (!relay->hostname)
 403                         continue;
 404
 405                 if (relay->udp_port != 0)
 406                         append_relay(relay_info, relay->hostname, relay->udp_port,
 407                                      "udp", username, password);
 408
 409 #ifdef HAVE_ICE_TCP
 410                 if (relay->tcp_port != 0) {
 411                         gchar *type = "tcp";
 412                         if (relay->tcp_port == 443)
 413                                 type = "tls";
 414                         append_relay(relay_info, relay->hostname, relay->tcp_port,
 415                                      type, username, password);
 416                 }
 417 #endif
 418         }
 419
 420         return relay_info;
 421 }
 422
 423 void
 424 sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays)
 425 {
 426 #if !PURPLE_VERSION_CHECK(3,0,0)
 427         g_value_array_free((GValueArray *)media_relays);
 428 #else
 429         g_ptr_array_unref((GPtrArray *)media_relays);
 430 #endif
 431 }
 432
 433 struct sipe_backend_stream *
 434 sipe_backend_media_add_stream(struct sipe_backend_media *media,
 435                               const gchar *id,
 436                               const gchar *participant,
 437                               SipeMediaType type,
 438                               SipeIceVersion ice_version,
 439                               gboolean initiator,
 440                               struct sipe_backend_media_relays *media_relays)
 441 {
 442         struct sipe_backend_stream *stream = NULL;
 443         PurpleMediaSessionType prpl_type = sipe_media_to_purple(type);
 444         // Preallocate enough space for all potential parameters to fit.
 445         GParameter *params = g_new0(GParameter, 5);
 446         guint params_cnt = 0;
 447         gchar *transmitter;
 448         GValue *relay_info = NULL;
 449
 450         if (ice_version != SIPE_ICE_NO_ICE) {
 451                 transmitter = "nice";
 452
 453                 params[params_cnt].name = "compatibility-mode";
 454                 g_value_init(&params[params_cnt].value, G_TYPE_UINT);
 455                 g_value_set_uint(&params[params_cnt].value,
 456                                  ice_version == SIPE_ICE_DRAFT_6 ?
 457                                  NICE_COMPATIBILITY_OC2007 :
 458                                  NICE_COMPATIBILITY_OC2007R2);
 459                 ++params_cnt;
 460
 461                 if (media_relays) {
 462                         params[params_cnt].name = "relay-info";
 463                         g_value_init(&params[params_cnt].value, SIPE_RELAYS_G_TYPE);
 464                         g_value_set_boxed(&params[params_cnt].value, media_relays);
 465                         relay_info = &params[params_cnt].value;
 466                         ++params_cnt;
 467                 }
 468         } else {
 469                 // TODO: session naming here, Communicator needs audio/video
 470                 transmitter = "rawudp";
 471                 //sessionid = "sipe-voice-rawudp";
 472         }
 473
 474         ensure_codecs_conf();
 475
 476         if (purple_media_add_stream(media->m, id, participant, prpl_type,
 477                                     initiator, transmitter, params_cnt,
 478                                     params)) {
 479                 stream = g_new0(struct sipe_backend_stream, 1);
 480                 stream->sessionid = g_strdup(id);
 481                 stream->participant = g_strdup(participant);
 482                 stream->initialized_cb_was_fired = FALSE;
 483
 484                 media->streams = g_slist_append(media->streams, stream);
 485                 if (!initiator)
 486                         ++media->unconfirmed_streams;
 487         }
 488
 489         if (relay_info) {
 490                 g_value_unset(relay_info);
 491         }
 492
 493         g_free(params);
 494
 495         return stream;
 496 }
 497
 498 void
 499 sipe_backend_media_remove_stream(struct sipe_backend_media *media,
 500                                  struct sipe_backend_stream *stream)
 501 {
 502         g_return_if_fail(media && stream);
 503
 504         purple_media_end(media->m, stream->sessionid, NULL);
 505         media->streams = g_slist_remove(media->streams, stream);
 506         backend_stream_free(stream);
 507 }
 508
 509 GSList *sipe_backend_media_get_streams(struct sipe_backend_media *media)
 510 {
 511         return media->streams;
 512 }
 513
 514 struct sipe_backend_stream *
 515 sipe_backend_media_get_stream_by_id(struct sipe_backend_media *media,
 516                                     const gchar *id)
 517 {
 518         GSList *i;
 519         for (i = media->streams; i; i = i->next) {
 520                 struct sipe_backend_stream *stream = i->data;
 521                 if (sipe_strequal(stream->sessionid, id))
 522                         return stream;
 523         }
 524         return NULL;
 525 }
 526
 527 void
 528 sipe_backend_media_add_remote_candidates(struct sipe_backend_media *media,
 529                                          struct sipe_backend_stream *stream,
 530                                          GList *candidates)
 531 {
 532         GList *udp_candidates = NULL;
 533
 534 #ifndef HAVE_ICE_TCP
 535         while (candidates) {
 536                 PurpleMediaCandidate *candidate = candidates->data;
 537                 PurpleMediaNetworkProtocol proto;
 538
 539                 proto = purple_media_candidate_get_protocol(candidate);
 540                 if (proto == PURPLE_MEDIA_NETWORK_PROTOCOL_UDP)
 541                         udp_candidates = g_list_append(udp_candidates, candidate);
 542
 543                 candidates = candidates->next;
 544         }
 545
 546         candidates = udp_candidates;
 547 #endif
 548
 549
 550         purple_media_add_remote_candidates(media->m, stream->sessionid,
 551                                            stream->participant, candidates);
 552
 553         g_list_free(udp_candidates);
 554 }
 555
 556 gboolean sipe_backend_media_is_initiator(struct sipe_backend_media *media,
 557                                          struct sipe_backend_stream *stream)
 558 {
 559         return purple_media_is_initiator(media->m,
 560                                          stream ? stream->sessionid : NULL,
 561                                          stream ? stream->participant : NULL);
 562 }
 563
 564 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media)
 565 {
 566         return purple_media_accepted(media->m, NULL, NULL);
 567 }
 568
 569 gboolean
 570 sipe_backend_stream_initialized(struct sipe_backend_media *media,
 571                                 struct sipe_backend_stream *stream)
 572 {
 573         g_return_val_if_fail(media, FALSE);
 574         g_return_val_if_fail(stream, FALSE);
 575
 576         if (purple_media_candidates_prepared(media->m,
 577                                              stream->sessionid,
 578                                              stream->participant)) {
 579                 GList *codecs;
 580                 codecs = purple_media_get_codecs(media->m, stream->sessionid);
 581                 if (codecs) {
 582                         purple_media_codec_list_free(codecs);
 583                         return TRUE;
 584                 }
 585         }
 586         return FALSE;
 587 }
 588
 589 static GList *
 590 duplicate_tcp_candidates(GList *candidates)
 591 {
 592         GList *i;
 593         GList *result = NULL;
 594
 595         for (i = candidates; i; i = i->next) {
 596                 PurpleMediaCandidate *candidate = i->data;
 597                 PurpleMediaNetworkProtocol protocol =
 598                                 purple_media_candidate_get_protocol(candidate);
 599                 guint component_id =
 600                                 purple_media_candidate_get_component_id(candidate);
 601
 602                 if (protocol != PURPLE_MEDIA_NETWORK_PROTOCOL_UDP) {
 603                         PurpleMediaCandidate *c2;
 604
 605                         if (component_id != PURPLE_MEDIA_COMPONENT_RTP) {
 606                                 /* Ignore TCP candidates for other than
 607                                  * the first component. */
 608                                 g_object_unref(candidate);
 609                                 continue;
 610                         }
 611
 612                         c2 = purple_media_candidate_copy(candidate);
 613                         g_object_set(c2,
 614                                      "component-id", PURPLE_MEDIA_COMPONENT_RTCP,
 615                                      NULL);
 616                         result = g_list_append(result, c2);
 617                 }
 618
 619                 result = g_list_append(result, candidate);
 620         }
 621
 622         g_list_free(candidates);
 623
 624         return result;
 625 }
 626
 627 GList *
 628 sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 629                                                struct sipe_backend_stream *stream)
 630 {
 631         GList *candidates = purple_media_get_active_local_candidates(
 632                         media->m, stream->sessionid, stream->participant);
 633         return duplicate_tcp_candidates(candidates);
 634 }
 635
 636 GList *
 637 sipe_backend_media_get_active_remote_candidates(struct sipe_backend_media *media,
 638                                                 struct sipe_backend_stream *stream)
 639 {
 640         GList *candidates = purple_media_get_active_remote_candidates(
 641                         media->m, stream->sessionid, stream->participant);
 642         return duplicate_tcp_candidates(candidates);
 643 }
 644
 645 const gchar *
 646 sipe_backend_stream_get_id(struct sipe_backend_stream *stream)
 647 {
 648         return stream->sessionid;
 649 }
 650
 651 void sipe_backend_stream_hold(struct sipe_backend_media *media,
 652                               struct sipe_backend_stream *stream,
 653                               gboolean local)
 654 {
 655         purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_HOLD,
 656                                  stream->sessionid, stream->participant,
 657                                  local);
 658 }
 659
 660 void sipe_backend_stream_unhold(struct sipe_backend_media *media,
 661                                 struct sipe_backend_stream *stream,
 662                                 gboolean local)
 663 {
 664         purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_UNHOLD,
 665                                  stream->sessionid, stream->participant,
 666                                  local);
 667 }
 668
 669 gboolean sipe_backend_stream_is_held(struct sipe_backend_stream *stream)
 670 {
 671         g_return_val_if_fail(stream, FALSE);
 672
 673         return stream->local_on_hold || stream->remote_on_hold;
 674 }
 675
 676 struct sipe_backend_codec *
 677 sipe_backend_codec_new(int id, const char *name, SipeMediaType type, guint clock_rate)
 678 {
 679         return (struct sipe_backend_codec *)purple_media_codec_new(id, name,
 680                                                     sipe_media_to_purple(type),
 681                                                     clock_rate);
 682 }
 683
 684 void
 685 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 686 {
 687         if (codec)
 688                 g_object_unref(codec);
 689 }
 690
 691 int
 692 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 693 {
 694         return purple_media_codec_get_id((PurpleMediaCodec *)codec);
 695 }
 696
 697 gchar *
 698 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 699 {
 700         /* Not explicitly documented, but return value must be g_free()'d */
 701         return purple_media_codec_get_encoding_name((PurpleMediaCodec *)codec);
 702 }
 703
 704 guint
 705 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 706 {
 707         return purple_media_codec_get_clock_rate((PurpleMediaCodec *)codec);
 708 }
 709
 710 void
 711 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 712                                                                                   const gchar *name, const gchar *value)
 713 {
 714         purple_media_codec_add_optional_parameter((PurpleMediaCodec *)codec, name, value);
 715 }
 716
 717 GList *
 718 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 719 {
 720         return purple_media_codec_get_optional_parameters((PurpleMediaCodec *)codec);
 721 }
 722
 723 gboolean
 724 sipe_backend_set_remote_codecs(struct sipe_backend_media *media,
 725                                struct sipe_backend_stream *stream,
 726                                GList *codecs)
 727 {
 728         return purple_media_set_remote_codecs(media->m,
 729                                               stream->sessionid,
 730                                               stream->participant,
 731                                               codecs);
 732 }
 733
 734 GList*
 735 sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 736                               struct sipe_backend_stream *stream)
 737 {
 738         GList *codecs = purple_media_get_codecs(media->m,
 739                                                 stream->sessionid);
 740         GList *i = codecs;
 741         gboolean is_conference = (g_strstr_len(stream->participant,
 742                                                strlen(stream->participant),
 743                                                "app:conf:audio-video:") != NULL);
 744
 745         /*
 746          * Do not announce Theora. Its optional parameters are too long,
 747          * Communicator rejects such SDP message and does not support the codec
 748          * anyway.
 749          *
 750          * For some yet unknown reason, A/V conferencing server does not accept
 751          * voice stream sent by SIPE when SIREN codec is in use. Nevertheless,
 752          * we are able to decode incoming SIREN from server and with MSOC
 753          * client, bidirectional call using the codec works. Until resolved,
 754          * do not try to negotiate SIREN usage when conferencing. PCMA or PCMU
 755          * seems to work properly in this scenario.
 756          */
 757         while (i) {
 758                 PurpleMediaCodec *codec = i->data;
 759                 gchar *encoding_name = purple_media_codec_get_encoding_name(codec);
 760
 761                 if (sipe_strequal(encoding_name,"THEORA") ||
 762                     (is_conference && sipe_strequal(encoding_name,"SIREN"))) {
 763                         GList *tmp;
 764                         g_object_unref(codec);
 765                         tmp = i->next;
 766                         codecs = g_list_delete_link(codecs, i);
 767                         i = tmp;
 768                 } else
 769                         i = i->next;
 770
 771                 g_free(encoding_name);
 772         }
 773
 774         return codecs;
 775 }
 776
 777 struct sipe_backend_candidate *
 778 sipe_backend_candidate_new(const gchar *foundation,
 779                            SipeComponentType component,
 780                            SipeCandidateType type, SipeNetworkProtocol proto,
 781                            const gchar *ip, guint port,
 782                            const gchar *username,
 783                            const gchar *password)
 784 {
 785         PurpleMediaCandidate *c = purple_media_candidate_new(
 786                 /* Libnice and Farsight rely on non-NULL foundation to
 787                  * distinguish between candidates of a component. When NULL
 788                  * foundation is passed (ie. ICE draft 6 does not use foudation),
 789                  * use username instead. If no foundation is provided, Farsight
 790                  * may signal an active candidate different from the one actually
 791                  * in use. See Farsight's agent_new_selected_pair() in
 792                  * fs-nice-stream-transmitter.h where first candidate in the
 793                  * remote list is always selected when no foundation. */
 794                 foundation ? foundation : username,
 795                 component,
 796                 sipe_candidate_type_to_purple(type),
 797                 sipe_network_protocol_to_purple(proto),
 798                 ip,
 799                 port);
 800         g_object_set(c, "username", username, "password", password, NULL);
 801         return (struct sipe_backend_candidate *)c;
 802 }
 803
 804 void
 805 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 806 {
 807         if (candidate)
 808                 g_object_unref(candidate);
 809 }
 810
 811 gchar *
 812 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 813 {
 814         /* Not explicitly documented, but return value must be g_free()'d */
 815         return purple_media_candidate_get_username((PurpleMediaCandidate*)candidate);
 816 }
 817
 818 gchar *
 819 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 820 {
 821         /* Not explicitly documented, but return value must be g_free()'d */
 822         return purple_media_candidate_get_password((PurpleMediaCandidate*)candidate);
 823 }
 824
 825 gchar *
 826 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 827 {
 828         /* Not explicitly documented, but return value must be g_free()'d */
 829         return purple_media_candidate_get_foundation((PurpleMediaCandidate*)candidate);
 830 }
 831
 832 gchar *
 833 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 834 {
 835         /* Not explicitly documented, but return value must be g_free()'d */
 836         return purple_media_candidate_get_ip((PurpleMediaCandidate*)candidate);
 837 }
 838
 839 guint
 840 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 841 {
 842         return purple_media_candidate_get_port((PurpleMediaCandidate*)candidate);
 843 }
 844
 845 gchar *
 846 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 847 {
 848         /* Not explicitly documented, but return value must be g_free()'d */
 849         return purple_media_candidate_get_base_ip((PurpleMediaCandidate*)candidate);
 850 }
 851
 852 guint
 853 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 854 {
 855         return purple_media_candidate_get_base_port((PurpleMediaCandidate*)candidate);
 856 }
 857
 858 guint32
 859 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 860 {
 861         return purple_media_candidate_get_priority((PurpleMediaCandidate*)candidate);
 862 }
 863
 864 void
 865 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 866 {
 867         g_object_set(candidate, "priority", priority, NULL);
 868 }
 869
 870 SipeComponentType
 871 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 872 {
 873         return purple_media_candidate_get_component_id((PurpleMediaCandidate*)candidate);
 874 }
 875
 876 SipeCandidateType
 877 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 878 {
 879         PurpleMediaCandidateType type =
 880                 purple_media_candidate_get_candidate_type((PurpleMediaCandidate*)candidate);
 881         return purple_candidate_type_to_sipe(type);
 882 }
 883
 884 SipeNetworkProtocol
 885 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 886 {
 887         PurpleMediaNetworkProtocol proto =
 888                 purple_media_candidate_get_protocol((PurpleMediaCandidate*)candidate);
 889         return purple_network_protocol_to_sipe(proto);
 890 }
 891
 892 static void
 893 remove_lone_candidate_cb(SIPE_UNUSED_PARAMETER gpointer key,
 894                          gpointer value,
 895                          gpointer user_data)
 896 {
 897         GList  *entry = value;
 898         GList **candidates = user_data;
 899
 900         g_object_unref(entry->data);
 901         *candidates = g_list_delete_link(*candidates, entry);
 902 }
 903
 904 static GList *
 905 ensure_candidate_pairs(GList *candidates)
 906 {
 907         GHashTable *lone_cand_links;
 908         GList      *i;
 909
 910         lone_cand_links = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 911
 912         for (i = candidates; i; i = i->next) {
 913                 PurpleMediaCandidate *c = i->data;
 914                 gchar *foundation = purple_media_candidate_get_foundation(c);
 915
 916                 if (g_hash_table_lookup(lone_cand_links, foundation)) {
 917                         g_hash_table_remove(lone_cand_links, foundation);
 918                         g_free(foundation);
 919                 } else {
 920                         g_hash_table_insert(lone_cand_links, foundation, i);
 921                 }
 922         }
 923
 924         g_hash_table_foreach(lone_cand_links, remove_lone_candidate_cb, &candidates);
 925         g_hash_table_destroy(lone_cand_links);
 926
 927         return candidates;
 928 }
 929
 930 GList *
 931 sipe_backend_get_local_candidates(struct sipe_backend_media *media,
 932                                   struct sipe_backend_stream *stream)
 933 {
 934         GList *candidates = purple_media_get_local_candidates(media->m,
 935                                                               stream->sessionid,
 936                                                               stream->participant);
 937         candidates = duplicate_tcp_candidates(candidates);
 938
 939         /*
 940          * Sometimes purple will not return complete list of candidates, even
 941          * after "candidates-prepared" signal is emitted. This is a feature of
 942          * libnice, namely affecting candidates discovered via UPnP. Nice does
 943          * not wait until discovery is finished and can signal end of candidate
 944          * gathering before all responses from UPnP enabled gateways are received.
 945          *
 946          * Remove any incomplete RTP+RTCP candidate pairs from the list.
 947          */
 948         candidates = ensure_candidate_pairs(candidates);
 949         return candidates;
 950 }
 951
 952 void
 953 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 954 {
 955         if (media)
 956                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_ACCEPT,
 957                                          NULL, NULL, local);
 958 }
 959
 960 void
 961 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 962 {
 963         if (media)
 964                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_HANGUP,
 965                                          NULL, NULL, local);
 966 }
 967
 968 void
 969 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 970 {
 971         if (media)
 972                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_REJECT,
 973                                          NULL, NULL, local);
 974 }
 975
 976 static PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type)
 977 {
 978         switch (type) {
 979                 case SIPE_MEDIA_AUDIO: return PURPLE_MEDIA_AUDIO;
 980                 case SIPE_MEDIA_VIDEO: return PURPLE_MEDIA_VIDEO;
 981                 default:               return PURPLE_MEDIA_NONE;
 982         }
 983 }
 984
 985 /*SipeMediaType purple_media_to_sipe(PurpleMediaSessionType type)
 986 {
 987         switch (type) {
 988                 case PURPLE_MEDIA_AUDIO: return SIPE_MEDIA_AUDIO;
 989                 case PURPLE_MEDIA_VIDEO: return SIPE_MEDIA_VIDEO;
 990                 default:                                 return SIPE_MEDIA_AUDIO;
 991         }
 992 }*/
 993
 994 static PurpleMediaCandidateType
 995 sipe_candidate_type_to_purple(SipeCandidateType type)
 996 {
 997         switch (type) {
 998                 case SIPE_CANDIDATE_TYPE_HOST:  return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
 999                 case SIPE_CANDIDATE_TYPE_RELAY: return PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
1000                 case SIPE_CANDIDATE_TYPE_SRFLX: return PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX;
1001                 case SIPE_CANDIDATE_TYPE_PRFLX: return PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX;
1002                 default:                        return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
1003         }
1004 }
1005
1006 static SipeCandidateType
1007 purple_candidate_type_to_sipe(PurpleMediaCandidateType type)
1008 {
1009         switch (type) {
1010                 case PURPLE_MEDIA_CANDIDATE_TYPE_HOST:  return SIPE_CANDIDATE_TYPE_HOST;
1011                 case PURPLE_MEDIA_CANDIDATE_TYPE_RELAY: return SIPE_CANDIDATE_TYPE_RELAY;
1012                 case PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX: return SIPE_CANDIDATE_TYPE_SRFLX;
1013                 case PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX: return SIPE_CANDIDATE_TYPE_PRFLX;
1014                 default:                                return SIPE_CANDIDATE_TYPE_HOST;
1015         }
1016 }
1017
1018 static PurpleMediaNetworkProtocol
1019 sipe_network_protocol_to_purple(SipeNetworkProtocol proto)
1020 {
1021         switch (proto) {
1022 #ifdef HAVE_ICE_TCP
1023                 case SIPE_NETWORK_PROTOCOL_TCP_ACTIVE:
1024                         return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_ACTIVE;
1025                 case SIPE_NETWORK_PROTOCOL_TCP_PASSIVE:
1026                         return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_PASSIVE;
1027                 case SIPE_NETWORK_PROTOCOL_TCP_SO:
1028                         return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_SO;
1029 #else
1030                 case SIPE_NETWORK_PROTOCOL_TCP_ACTIVE:
1031                 case SIPE_NETWORK_PROTOCOL_TCP_PASSIVE:
1032                 case SIPE_NETWORK_PROTOCOL_TCP_SO:
1033                         return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP;
1034 #endif
1035                 default:
1036                 case SIPE_NETWORK_PROTOCOL_UDP:
1037                         return PURPLE_MEDIA_NETWORK_PROTOCOL_UDP;
1038         }
1039 }
1040
1041 static SipeNetworkProtocol
1042 purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto)
1043 {
1044         switch (proto) {
1045 #ifdef HAVE_ICE_TCP
1046                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_ACTIVE:
1047                         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
1048                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_PASSIVE:
1049                         return SIPE_NETWORK_PROTOCOL_TCP_PASSIVE;
1050                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_SO:
1051                         return SIPE_NETWORK_PROTOCOL_TCP_SO;
1052 #else
1053                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP:
1054                         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
1055 #endif
1056                 default:
1057                 case PURPLE_MEDIA_NETWORK_PROTOCOL_UDP:
1058                         return SIPE_NETWORK_PROTOCOL_UDP;
1059         }
1060 }
1061
1062 /*
1063   Local Variables:
1064   mode: c
1065   c-file-style: "bsd"
1066   indent-tabs-mode: t
1067   tab-width: 8
1068   End:
1069 */