src/purple/purple-media.c

   1 /**
   2  * @file purple-media.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010 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 #include "glib.h"
  24 #include "glib/gstdio.h"
  25 #include <fcntl.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28
  29 #include <gst/gststructure.h>
  30 #include <gst/gstvalue.h>
  31
  32 #include "sipe-common.h"
  33
  34 #include "mediamanager.h"
  35 #include "request.h"
  36 #include "agent.h"
  37
  38 #include "sipe-backend.h"
  39 #include "sipe-core.h"
  40
  41 #include "purple-private.h"
  42
  43 struct sipe_backend_media {
  44         PurpleMedia *m;
  45         GSList *streams;
  46 };
  47
  48 struct sipe_backend_stream {
  49         gchar *sessionid;
  50         gchar *participant;
  51         gboolean candidates_prepared;
  52         gboolean local_on_hold;
  53         gboolean remote_on_hold;
  54 };
  55
  56 static void
  57 backend_stream_free(struct sipe_backend_stream *stream)
  58 {
  59         if (stream) {
  60                 g_free(stream->sessionid);
  61                 g_free(stream->participant);
  62                 g_free(stream);
  63         }
  64 }
  65
  66 static PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type);
  67 static PurpleMediaCandidateType sipe_candidate_type_to_purple(SipeCandidateType type);
  68 static SipeCandidateType purple_candidate_type_to_sipe(PurpleMediaCandidateType type);
  69 static PurpleMediaNetworkProtocol sipe_network_protocol_to_purple(SipeNetworkProtocol proto);
  70 static SipeNetworkProtocol purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto);
  71
  72 struct stream_info_context {
  73         struct sipe_media_call *call;
  74         struct sipe_backend_media *backend_media;
  75 };
  76
  77 static void
  78 on_candidates_prepared_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
  79                           gchar *sessionid,
  80                           SIPE_UNUSED_PARAMETER gchar *participant,
  81                           struct stream_info_context *ctx)
  82 {
  83         struct sipe_backend_stream *stream;
  84         stream = sipe_backend_media_get_stream_by_id(ctx->backend_media, sessionid);
  85
  86         stream->candidates_prepared = TRUE;
  87
  88         if (ctx->call->candidates_prepared_cb) {
  89                 GSList *streams = ctx->backend_media->streams;
  90                 for (; streams; streams = streams->next) {
  91                         struct sipe_backend_stream *s = streams->data;
  92                         if (!s->candidates_prepared)
  93                                 return;
  94                 }
  95                 ctx->call->candidates_prepared_cb(ctx->call, stream);
  96         }
  97 }
  98
  99 static void
 100 on_state_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 101                     PurpleMediaState state,
 102                     gchar *sessionid,
 103                     gchar *participant,
 104                     struct sipe_media_call *call)
 105 {
 106         // TODO: this should be aware of legacy backend_media
 107         SIPE_DEBUG_INFO("sipe_media_state_changed_cb: %d %s %s\n", state, sessionid, participant);
 108         if (state == PURPLE_MEDIA_STATE_CONNECTED && call->media_connected_cb)
 109                 call->media_connected_cb(call);
 110 }
 111
 112 static void
 113 on_stream_info_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
 114                   PurpleMediaInfoType type,
 115                   gchar *sessionid,
 116                   gchar *participant,
 117                   gboolean local,
 118                   struct stream_info_context *ctx)
 119 {
 120         if (type == PURPLE_MEDIA_INFO_ACCEPT && ctx->call->call_accept_cb
 121             && !sessionid && !participant)
 122                 ctx->call->call_accept_cb(ctx->call, local);
 123         else if (type == PURPLE_MEDIA_INFO_HOLD || type == PURPLE_MEDIA_INFO_UNHOLD) {
 124
 125                 gboolean state = (type == PURPLE_MEDIA_INFO_HOLD);
 126
 127                 if (sessionid) {
 128                         // Hold specific stream
 129                         struct sipe_backend_stream *stream;
 130                         stream = sipe_backend_media_get_stream_by_id(ctx->backend_media,
 131                                                                      sessionid);
 132
 133                         if (local)
 134                                 stream->local_on_hold = state;
 135                         else
 136                                 stream->remote_on_hold = state;
 137                 } else {
 138                         // Hold all streams
 139                         GSList *i = sipe_backend_media_get_streams(ctx->backend_media);
 140                         for (; i; i = i->next) {
 141                                 struct sipe_backend_stream *stream = i->data;
 142
 143                                 if (local)
 144                                         stream->local_on_hold = state;
 145                                 else
 146                                         stream->remote_on_hold = state;
 147                         }
 148                 }
 149
 150                 if (ctx->call->call_hold_cb)
 151                         ctx->call->call_hold_cb(ctx->call, local, state);
 152         } else if (type == PURPLE_MEDIA_INFO_HANGUP || type == PURPLE_MEDIA_INFO_REJECT) {
 153                 if (!sessionid && !participant) {
 154                         if (type == PURPLE_MEDIA_INFO_HANGUP && ctx->call->call_hangup_cb)
 155                                 ctx->call->call_hangup_cb(ctx->call, ctx->backend_media, local);
 156                         else if (type == PURPLE_MEDIA_INFO_REJECT && ctx->call->call_reject_cb)
 157                                 ctx->call->call_reject_cb(ctx->call, local);
 158                 } else if (sessionid && participant) {
 159                         struct sipe_backend_stream *stream;
 160                         stream = sipe_backend_media_get_stream_by_id(ctx->backend_media,
 161                                                                      sessionid);
 162
 163                         if (stream) {
 164                                 ctx->backend_media->streams = g_slist_remove(ctx->backend_media->streams, stream);
 165                                 backend_stream_free(stream);
 166                         }
 167                 }
 168         }
 169 }
 170
 171 struct sipe_backend_media *
 172 sipe_backend_media_new(struct sipe_core_public *sipe_public,
 173                        struct sipe_media_call *call,
 174                        const gchar *participant,
 175                        gboolean initiator)
 176 {
 177         struct sipe_backend_media *media = g_new0(struct sipe_backend_media, 1);
 178         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 179         PurpleMediaManager *manager = purple_media_manager_get();
 180         struct stream_info_context *ctx = g_new0(struct stream_info_context, 1);
 181
 182         media->m = purple_media_manager_create_media(manager,
 183                                                      purple_private->account,
 184                                                      "fsrtpconference",
 185                                                      participant, initiator);
 186
 187         ctx->call = call;
 188         ctx->backend_media = media;
 189
 190         /* Passing the same ctx structure to all signal handlers, only the first
 191          * of them has destroy_data closure and is responsible for freeing the
 192          * context. */
 193         g_signal_connect_data(G_OBJECT(media->m), "candidates-prepared",
 194                               G_CALLBACK(on_candidates_prepared_cb), ctx,
 195                               (GClosureNotify) g_free, 0);
 196         g_signal_connect(G_OBJECT(media->m), "stream-info",
 197                          G_CALLBACK(on_stream_info_cb), ctx);
 198         g_signal_connect(G_OBJECT(media->m), "state-changed",
 199                          G_CALLBACK(on_state_changed_cb), call);
 200
 201         return media;
 202 }
 203
 204 void
 205 sipe_backend_media_free(struct sipe_backend_media *media)
 206 {
 207         if (media) {
 208                 GSList *stream = media->streams;
 209                 g_object_unref(media->m);
 210
 211                 for (; stream; stream = g_slist_delete_link(stream, stream))
 212                         backend_stream_free(stream->data);
 213
 214                 g_free(media);
 215         }
 216 }
 217
 218 #define FS_CODECS_CONF \
 219         "# Automatically created by SIPE plugin\n" \
 220         "[video/H263]\n" \
 221         "farsight-send-profile=videoscale ! ffmpegcolorspace ! fsvideoanyrate ! ffenc_h263 rtp-payload-size=512 ! rtph263pay mtu=512\n";
 222
 223 static void
 224 ensure_codecs_conf()
 225 {
 226         gchar *filename;
 227         filename = g_build_filename(purple_user_dir(), "fs-codec.conf", NULL);
 228
 229         if (!g_file_test(filename, G_FILE_TEST_EXISTS)) {
 230                 int fd = g_open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
 231                 gchar *fs_codecs_conf = FS_CODECS_CONF;
 232                 if (!fd || write(fd, fs_codecs_conf, strlen(fs_codecs_conf)) == -1)
 233                         SIPE_DEBUG_ERROR_NOFORMAT("Can not create fs-codec.conf!");
 234                 close(fd);
 235         }
 236
 237         g_free(filename);
 238 }
 239
 240 struct sipe_backend_media_relays *
 241 sipe_backend_media_relays_convert(GSList *media_relays, gchar *username, gchar *password)
 242 {
 243         GValueArray *relay_info = g_value_array_new(0);
 244
 245         for (; media_relays; media_relays = media_relays->next) {
 246                 struct sipe_media_relay *relay = media_relays->data;
 247                 GValue value;
 248                 GstStructure *gst_relay_info = gst_structure_new("relay-info",
 249                                 "ip", G_TYPE_STRING, relay->hostname,
 250                                 "port", G_TYPE_UINT, relay->udp_port,
 251                                 "username", G_TYPE_STRING, username,
 252                                 "password", G_TYPE_STRING, password,
 253                                 NULL);
 254
 255                 if (!gst_relay_info) {
 256                         g_value_array_free(relay_info);
 257                         return NULL;
 258                 }
 259
 260                 memset(&value, 0, sizeof(GValue));
 261                 g_value_init(&value, GST_TYPE_STRUCTURE);
 262                 gst_value_set_structure(&value, gst_relay_info);
 263
 264                 relay_info = g_value_array_append(relay_info, &value);
 265                 gst_structure_free(gst_relay_info);
 266         }
 267
 268         return (struct sipe_backend_media_relays *)relay_info;
 269 }
 270
 271 void
 272 sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays)
 273 {
 274         g_value_array_free((GValueArray *)media_relays);
 275 }
 276
 277 struct sipe_backend_stream *
 278 sipe_backend_media_add_stream(struct sipe_backend_media *media,
 279                               const gchar *id,
 280                               const gchar *participant,
 281                               SipeMediaType type,
 282                               SipeIceVersion ice_version,
 283                               gboolean initiator,
 284                               struct sipe_backend_media_relays *media_relays)
 285 {
 286         struct sipe_backend_stream *stream = NULL;
 287         PurpleMediaSessionType prpl_type = sipe_media_to_purple(type);
 288         GParameter *params = NULL;
 289         guint params_cnt = 0;
 290         gchar *transmitter;
 291
 292         if (ice_version != SIPE_ICE_NO_ICE) {
 293                 transmitter = "nice";
 294                 params_cnt = 2;
 295
 296                 params = g_new0(GParameter, params_cnt);
 297
 298                 params[0].name = "compatibility-mode";
 299                 g_value_init(&params[0].value, G_TYPE_UINT);
 300                 g_value_set_uint(&params[0].value,
 301                                  ice_version == SIPE_ICE_DRAFT_6 ?
 302                                  NICE_COMPATIBILITY_OC2007 :
 303                                  NICE_COMPATIBILITY_OC2007R2);
 304
 305                 if (media_relays) {
 306                         params[1].name = "relay-info";
 307                         g_value_init(&params[1].value, G_TYPE_VALUE_ARRAY);
 308                         g_value_set_boxed(&params[1].value, media_relays);
 309                 } else
 310                         --params_cnt;
 311         } else {
 312                 // TODO: session naming here, Communicator needs audio/video
 313                 transmitter = "rawudp";
 314                 //sessionid = "sipe-voice-rawudp";
 315         }
 316
 317         ensure_codecs_conf();
 318
 319         if (purple_media_add_stream(media->m, id, participant, prpl_type,
 320                                     initiator, transmitter, params_cnt, params)) {
 321                 stream = g_new0(struct sipe_backend_stream, 1);
 322                 stream->sessionid = g_strdup(id);
 323                 stream->participant = g_strdup(participant);
 324                 stream->candidates_prepared = FALSE;
 325
 326                 media->streams = g_slist_append(media->streams, stream);
 327         }
 328
 329         g_free(params);
 330
 331         return stream;
 332 }
 333
 334 void
 335 sipe_backend_media_remove_stream(struct sipe_backend_media *media,
 336                                  struct sipe_backend_stream *stream)
 337 {
 338         g_return_if_fail(media && stream);
 339
 340         purple_media_end(media->m, stream->sessionid, NULL);
 341         media->streams = g_slist_remove(media->streams, stream);
 342         backend_stream_free(stream);
 343 }
 344
 345 GSList *sipe_backend_media_get_streams(struct sipe_backend_media *media)
 346 {
 347         return media->streams;
 348 }
 349
 350 struct sipe_backend_stream *
 351 sipe_backend_media_get_stream_by_id(struct sipe_backend_media *media,
 352                                     const gchar *id)
 353 {
 354         GSList *i;
 355         for (i = media->streams; i; i = i->next) {
 356                 struct sipe_backend_stream *stream = i->data;
 357                 if (sipe_strequal(stream->sessionid, id))
 358                         return stream;
 359         }
 360         return NULL;
 361 }
 362
 363 void
 364 sipe_backend_media_add_remote_candidates(struct sipe_backend_media *media,
 365                                          struct sipe_backend_stream *stream,
 366                                          GList *candidates)
 367 {
 368         purple_media_add_remote_candidates(media->m, stream->sessionid,
 369                                            stream->participant, candidates);
 370 }
 371
 372 gboolean sipe_backend_media_is_initiator(struct sipe_backend_media *media,
 373                                          struct sipe_backend_stream *stream)
 374 {
 375         return purple_media_is_initiator(media->m,
 376                                          stream ? stream->sessionid : NULL,
 377                                          stream ? stream->participant : NULL);
 378 }
 379
 380 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media)
 381 {
 382         return purple_media_accepted(media->m, NULL, NULL);
 383 }
 384
 385 GList *
 386 sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 387                                                struct sipe_backend_stream *stream)
 388 {
 389         return purple_media_get_active_local_candidates(media->m,
 390                                                         stream->sessionid,
 391                                                         stream->participant);
 392 }
 393
 394 GList *
 395 sipe_backend_media_get_active_remote_candidates(struct sipe_backend_media *media,
 396                                                 struct sipe_backend_stream *stream)
 397 {
 398         return purple_media_get_active_remote_candidates(media->m,
 399                                                          stream->sessionid,
 400                                                          stream->participant);
 401 }
 402
 403 gchar *
 404 sipe_backend_stream_get_id(struct sipe_backend_stream *stream)
 405 {
 406         return stream->sessionid;
 407 }
 408
 409 void sipe_backend_stream_hold(struct sipe_backend_media *media,
 410                               struct sipe_backend_stream *stream,
 411                               gboolean local)
 412 {
 413         purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_HOLD,
 414                                  stream->sessionid, stream->participant,
 415                                  local);
 416 }
 417
 418 void sipe_backend_stream_unhold(struct sipe_backend_media *media,
 419                                 struct sipe_backend_stream *stream,
 420                                 gboolean local)
 421 {
 422         purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_UNHOLD,
 423                                  stream->sessionid, stream->participant,
 424                                  local);
 425 }
 426
 427 gboolean sipe_backend_stream_is_held(struct sipe_backend_stream *stream)
 428 {
 429         g_return_val_if_fail(stream, FALSE);
 430
 431         return stream->local_on_hold || stream->remote_on_hold;
 432 }
 433
 434 struct sipe_backend_codec *
 435 sipe_backend_codec_new(int id, const char *name, SipeMediaType type, guint clock_rate)
 436 {
 437         return (struct sipe_backend_codec *)purple_media_codec_new(id, name,
 438                                                     sipe_media_to_purple(type),
 439                                                     clock_rate);
 440 }
 441
 442 void
 443 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 444 {
 445         if (codec)
 446                 g_object_unref(codec);
 447 }
 448
 449 int
 450 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 451 {
 452         return purple_media_codec_get_id((PurpleMediaCodec *)codec);
 453 }
 454
 455 gchar *
 456 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 457 {
 458         /* Not explicitly documented, but return value must be g_free()'d */
 459         return purple_media_codec_get_encoding_name((PurpleMediaCodec *)codec);
 460 }
 461
 462 guint
 463 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 464 {
 465         return purple_media_codec_get_clock_rate((PurpleMediaCodec *)codec);
 466 }
 467
 468 void
 469 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 470                                                                                   const gchar *name, const gchar *value)
 471 {
 472         purple_media_codec_add_optional_parameter((PurpleMediaCodec *)codec, name, value);
 473 }
 474
 475 GList *
 476 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 477 {
 478         return purple_media_codec_get_optional_parameters((PurpleMediaCodec *)codec);
 479 }
 480
 481 gboolean
 482 sipe_backend_set_remote_codecs(struct sipe_backend_media *media,
 483                                struct sipe_backend_stream *stream,
 484                                GList *codecs)
 485 {
 486         return purple_media_set_remote_codecs(media->m,
 487                                               stream->sessionid,
 488                                               stream->participant,
 489                                               codecs);
 490 }
 491
 492 GList*
 493 sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 494                               struct sipe_backend_stream *stream)
 495 {
 496         GList *codecs = purple_media_get_codecs(media->m,
 497                                                 stream->sessionid);
 498         GList *i = codecs;
 499
 500         /*
 501          * Do not announce Theora. Its optional parameters are too long,
 502          * Communicator rejects such SDP message and does not support the codec
 503          * anyway.
 504          */
 505         while (i) {
 506                 PurpleMediaCodec *codec = i->data;
 507                 gchar *encoding_name = purple_media_codec_get_encoding_name(codec);
 508
 509                 if (sipe_strequal(encoding_name,"THEORA")) {
 510                         GList *tmp;
 511                         g_object_unref(codec);
 512                         tmp = i->next;
 513                         codecs = g_list_delete_link(codecs, i);
 514                         i = tmp;
 515                 } else
 516                         i = i->next;
 517
 518                 g_free(encoding_name);
 519         }
 520
 521         return codecs;
 522 }
 523
 524 struct sipe_backend_candidate *
 525 sipe_backend_candidate_new(const gchar *foundation,
 526                            SipeComponentType component,
 527                            SipeCandidateType type, SipeNetworkProtocol proto,
 528                            const gchar *ip, guint port,
 529                            const gchar *username,
 530                            const gchar *password)
 531 {
 532         PurpleMediaCandidate *c = purple_media_candidate_new(
 533                 /* Libnice and Farsight rely on non-NULL foundation to
 534                  * distinguish between candidates of a component. When NULL
 535                  * foundation is passed (ie. ICE draft 6 does not use foudation),
 536                  * use username instead. If no foundation is provided, Farsight
 537                  * may signal an active candidate different from the one actually
 538                  * in use. See Farsight's agent_new_selected_pair() in
 539                  * fs-nice-stream-transmitter.h where first candidate in the
 540                  * remote list is always selected when no foundation. */
 541                 foundation ? foundation : username,
 542                 component,
 543                 sipe_candidate_type_to_purple(type),
 544                 sipe_network_protocol_to_purple(proto),
 545                 ip,
 546                 port);
 547         g_object_set(c, "username", username, "password", password, NULL);
 548         return (struct sipe_backend_candidate *)c;
 549 }
 550
 551 void
 552 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 553 {
 554         if (candidate)
 555                 g_object_unref(candidate);
 556 }
 557
 558 gchar *
 559 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 560 {
 561         /* Not explicitly documented, but return value must be g_free()'d */
 562         return purple_media_candidate_get_username((PurpleMediaCandidate*)candidate);
 563 }
 564
 565 gchar *
 566 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 567 {
 568         /* Not explicitly documented, but return value must be g_free()'d */
 569         return purple_media_candidate_get_password((PurpleMediaCandidate*)candidate);
 570 }
 571
 572 gchar *
 573 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 574 {
 575         /* Not explicitly documented, but return value must be g_free()'d */
 576         return purple_media_candidate_get_foundation((PurpleMediaCandidate*)candidate);
 577 }
 578
 579 gchar *
 580 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 581 {
 582         /* Not explicitly documented, but return value must be g_free()'d */
 583         return purple_media_candidate_get_ip((PurpleMediaCandidate*)candidate);
 584 }
 585
 586 guint
 587 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 588 {
 589         return purple_media_candidate_get_port((PurpleMediaCandidate*)candidate);
 590 }
 591
 592 gchar *
 593 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 594 {
 595         /* Not explicitly documented, but return value must be g_free()'d */
 596         return purple_media_candidate_get_base_ip((PurpleMediaCandidate*)candidate);
 597 }
 598
 599 guint
 600 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 601 {
 602         return purple_media_candidate_get_base_port((PurpleMediaCandidate*)candidate);
 603 }
 604
 605 guint32
 606 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 607 {
 608         return purple_media_candidate_get_priority((PurpleMediaCandidate*)candidate);
 609 }
 610
 611 void
 612 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 613 {
 614         g_object_set(candidate, "priority", priority, NULL);
 615 }
 616
 617 SipeComponentType
 618 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 619 {
 620         return purple_media_candidate_get_component_id((PurpleMediaCandidate*)candidate);
 621 }
 622
 623 SipeCandidateType
 624 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 625 {
 626         PurpleMediaCandidateType type =
 627                 purple_media_candidate_get_candidate_type((PurpleMediaCandidate*)candidate);
 628         return purple_candidate_type_to_sipe(type);
 629 }
 630
 631 SipeNetworkProtocol
 632 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 633 {
 634         PurpleMediaNetworkProtocol proto =
 635                 purple_media_candidate_get_protocol((PurpleMediaCandidate*)candidate);
 636         return purple_network_protocol_to_sipe(proto);
 637 }
 638
 639 static void
 640 remove_lone_candidate_cb(SIPE_UNUSED_PARAMETER gpointer key,
 641                          gpointer value,
 642                          gpointer user_data)
 643 {
 644         GList  *entry = value;
 645         GList **candidates = user_data;
 646
 647         g_object_unref(entry->data);
 648         *candidates = g_list_delete_link(*candidates, entry);
 649 }
 650
 651 static GList *
 652 ensure_candidate_pairs(GList *candidates)
 653 {
 654         GHashTable *lone_cand_links;
 655         GList      *i;
 656
 657         lone_cand_links = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 658
 659         for (i = candidates; i; i = i->next) {
 660                 PurpleMediaCandidate *c = i->data;
 661                 gchar *foundation = purple_media_candidate_get_foundation(c);
 662
 663                 if (g_hash_table_lookup(lone_cand_links, foundation)) {
 664                         g_hash_table_remove(lone_cand_links, foundation);
 665                         g_free(foundation);
 666                 } else {
 667                         g_hash_table_insert(lone_cand_links, foundation, i);
 668                 }
 669         }
 670
 671         g_hash_table_foreach(lone_cand_links, remove_lone_candidate_cb, &candidates);
 672         g_hash_table_destroy(lone_cand_links);
 673
 674         return candidates;
 675 }
 676
 677 GList *
 678 sipe_backend_get_local_candidates(struct sipe_backend_media *media,
 679                                   struct sipe_backend_stream *stream)
 680 {
 681         GList *candidates = purple_media_get_local_candidates(media->m,
 682                                                               stream->sessionid,
 683                                                               stream->participant);
 684         /*
 685          * Sometimes purple will not return complete list of candidates, even
 686          * after "candidates-prepared" signal is emitted. This is a feature of
 687          * libnice, namely affecting candidates discovered via UPnP. Nice does
 688          * not wait until discovery is finished and can signal end of candidate
 689          * gathering before all responses from UPnP enabled gateways are received.
 690          *
 691          * Remove any incomplete RTP+RTCP candidate pairs from the list.
 692          */
 693         candidates = ensure_candidate_pairs(candidates);
 694         return candidates;
 695 }
 696
 697 void
 698 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 699 {
 700         if (media)
 701                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_ACCEPT,
 702                                          NULL, NULL, local);
 703 }
 704
 705 void
 706 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 707 {
 708         if (media)
 709                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_HANGUP,
 710                                          NULL, NULL, local);
 711 }
 712
 713 void
 714 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 715 {
 716         if (media)
 717                 purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_REJECT,
 718                                          NULL, NULL, local);
 719 }
 720
 721 static PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type)
 722 {
 723         switch (type) {
 724                 case SIPE_MEDIA_AUDIO: return PURPLE_MEDIA_AUDIO;
 725                 case SIPE_MEDIA_VIDEO: return PURPLE_MEDIA_VIDEO;
 726                 default:               return PURPLE_MEDIA_NONE;
 727         }
 728 }
 729
 730 /*SipeMediaType purple_media_to_sipe(PurpleMediaSessionType type)
 731 {
 732         switch (type) {
 733                 case PURPLE_MEDIA_AUDIO: return SIPE_MEDIA_AUDIO;
 734                 case PURPLE_MEDIA_VIDEO: return SIPE_MEDIA_VIDEO;
 735                 default:                                 return SIPE_MEDIA_AUDIO;
 736         }
 737 }*/
 738
 739 static PurpleMediaCandidateType
 740 sipe_candidate_type_to_purple(SipeCandidateType type)
 741 {
 742         switch (type) {
 743                 case SIPE_CANDIDATE_TYPE_HOST:  return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
 744                 case SIPE_CANDIDATE_TYPE_RELAY: return PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
 745                 case SIPE_CANDIDATE_TYPE_SRFLX: return PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX;
 746                 case SIPE_CANDIDATE_TYPE_PRFLX: return PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX;
 747                 default:                        return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
 748         }
 749 }
 750
 751 static SipeCandidateType
 752 purple_candidate_type_to_sipe(PurpleMediaCandidateType type)
 753 {
 754         switch (type) {
 755                 case PURPLE_MEDIA_CANDIDATE_TYPE_HOST:  return SIPE_CANDIDATE_TYPE_HOST;
 756                 case PURPLE_MEDIA_CANDIDATE_TYPE_RELAY: return SIPE_CANDIDATE_TYPE_RELAY;
 757                 case PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX: return SIPE_CANDIDATE_TYPE_SRFLX;
 758                 case PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX: return SIPE_CANDIDATE_TYPE_PRFLX;
 759                 default:                                return SIPE_CANDIDATE_TYPE_HOST;
 760         }
 761 }
 762
 763 static PurpleMediaNetworkProtocol
 764 sipe_network_protocol_to_purple(SipeNetworkProtocol proto)
 765 {
 766         switch (proto) {
 767                 case SIPE_NETWORK_PROTOCOL_TCP: return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP;
 768                 case SIPE_NETWORK_PROTOCOL_UDP: return PURPLE_MEDIA_NETWORK_PROTOCOL_UDP;
 769                 default:                                                return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP;
 770         }
 771 }
 772
 773 static SipeNetworkProtocol
 774 purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto)
 775 {
 776         switch (proto) {
 777                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP: return SIPE_NETWORK_PROTOCOL_TCP;
 778                 case PURPLE_MEDIA_NETWORK_PROTOCOL_UDP: return SIPE_NETWORK_PROTOCOL_UDP;
 779                 default:                                                                return SIPE_NETWORK_PROTOCOL_UDP;
 780         }
 781 }
 782
 783 /*
 784   Local Variables:
 785   mode: c
 786   c-file-style: "bsd"
 787   indent-tabs-mode: t
 788   tab-width: 8
 789   End:
 790 */