src/core/sdpmsg.c

   1 /**
   2  * @file sdpmsg.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2013-2015 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 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include <glib.h>
  29
  30 #include "sipe-backend.h"
  31 #include "sipe-core.h"
  32 #include "sdpmsg.h"
  33 #include "sipe-utils.h"
  34
  35 static gboolean
  36 append_attribute(struct sdpmedia *media, gchar *attr)
  37 {
  38         gchar **parts = g_strsplit(attr + 2, ":", 2);
  39
  40         if(!parts[0]) {
  41                 g_strfreev(parts);
  42                 return FALSE;
  43         }
  44
  45         media->attributes = sipe_utils_nameval_add(media->attributes,
  46                                                    parts[0],
  47                                                    parts[1] ? parts[1] : "");
  48         g_strfreev(parts);
  49         return TRUE;
  50 }
  51
  52 static gboolean
  53 parse_attributes(struct sdpmsg *smsg, gchar *msg) {
  54         gchar           **lines = g_strsplit(msg, "\r\n", 0);
  55         gchar           **ptr = lines;
  56
  57         while (*ptr != NULL) {
  58                 if (g_str_has_prefix(*ptr, "o=")) {
  59                         gchar **parts = g_strsplit(*ptr + 2, " ", 6);
  60                         smsg->ip = g_strdup(parts[5]);
  61                         g_strfreev(parts);
  62                 } else if (g_str_has_prefix(*ptr, "m=")) {
  63                         gchar **parts = g_strsplit(*ptr + 2, " ", 3);
  64                         struct sdpmedia *media = g_new0(struct sdpmedia, 1);
  65
  66                         smsg->media = g_slist_append(smsg->media, media);
  67
  68                         media->name = g_strdup(parts[0]);
  69                         media->port = atoi(parts[1]);
  70                         media->encryption_active =
  71                                         g_strstr_len(parts[2], -1, "/SAVP") != NULL;
  72
  73                         g_strfreev(parts);
  74
  75                         while (*(++ptr) && !g_str_has_prefix(*ptr, "m=")) {
  76
  77                                 if (g_str_has_prefix(*ptr, "a=")) {
  78                                         if (!append_attribute(media, *ptr)) {
  79                                                 g_strfreev(lines);
  80                                                 return FALSE;
  81                                         }
  82                                 }
  83                         }
  84                         continue;
  85                 }
  86
  87                 ++ptr;
  88         }
  89
  90         g_strfreev(lines);
  91
  92         return TRUE;
  93 }
  94
  95 static struct sdpcandidate * sdpcandidate_copy(struct sdpcandidate *candidate);
  96 static void sdpcandidate_free(struct sdpcandidate *candidate);
  97
  98 static SipeComponentType
  99 parse_component(const gchar *str)
 100 {
 101         switch (atoi(str)) {
 102                 case 1: return  SIPE_COMPONENT_RTP;
 103                 case 2: return  SIPE_COMPONENT_RTCP;
 104                 default: return SIPE_COMPONENT_NONE;
 105         }
 106 }
 107
 108 static gchar *
 109 base64_pad(const gchar* str)
 110 {
 111         size_t str_len = strlen(str);
 112         int mod = str_len % 4;
 113
 114         if (mod > 0) {
 115                 gchar *result = NULL;
 116                 int pad = 4 - mod;
 117                 gchar *ptr = result = g_malloc(str_len + pad + 1);
 118
 119                 memcpy(ptr, str, str_len);
 120                 ptr += str_len;
 121                 memset(ptr, '=', pad);
 122                 ptr += pad;
 123                 *ptr = '\0';
 124
 125                 return result;
 126         } else
 127                 return g_strdup(str);
 128 }
 129
 130 static GSList *
 131 parse_append_candidate_draft_6(gchar **tokens, GSList *candidates)
 132 {
 133         struct sdpcandidate *candidate = g_new0(struct sdpcandidate, 1);
 134
 135         candidate->username = base64_pad(tokens[0]);
 136         candidate->component = parse_component(tokens[1]);
 137         candidate->password = base64_pad(tokens[2]);
 138
 139         if (sipe_strequal(tokens[3], "UDP"))
 140                 candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
 141         else if (sipe_strequal(tokens[3], "TCP"))
 142                 candidate->protocol = SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 143         else {
 144                 sdpcandidate_free(candidate);
 145                 return candidates;
 146         }
 147
 148         candidate->priority = atoi(tokens[4] + 2);
 149         candidate->ip = g_strdup(tokens[5]);
 150         candidate->port = atoi(tokens[6]);
 151
 152         candidates = g_slist_append(candidates, candidate);
 153
 154         // draft 6 candidates are both active and passive
 155         if (candidate->protocol == SIPE_NETWORK_PROTOCOL_TCP_ACTIVE) {
 156                 candidate = sdpcandidate_copy(candidate);
 157                 candidate->protocol = SIPE_NETWORK_PROTOCOL_TCP_PASSIVE;
 158                 candidates = g_slist_append(candidates, candidate);
 159         }
 160
 161         return candidates;
 162 }
 163
 164 static GSList *
 165 parse_append_candidate_rfc_5245(gchar **tokens, GSList *candidates)
 166 {
 167         struct sdpcandidate *candidate = g_new0(struct sdpcandidate, 1);
 168
 169         candidate->foundation = g_strdup(tokens[0]);
 170         candidate->component = parse_component(tokens[1]);
 171
 172         if (sipe_strequal(tokens[2], "UDP"))
 173                 candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
 174         else if (sipe_strequal(tokens[2], "TCP-ACT"))
 175                 candidate->protocol = SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 176         else if (sipe_strequal(tokens[2], "TCP-PASS"))
 177                 candidate->protocol = SIPE_NETWORK_PROTOCOL_TCP_PASSIVE;
 178         else {
 179                 sdpcandidate_free(candidate);
 180                 return candidates;
 181         }
 182
 183         candidate->priority = atoi(tokens[3]);
 184         candidate->ip = g_strdup(tokens[4]);
 185         candidate->port = atoi(tokens[5]);
 186
 187         if (sipe_strequal(tokens[7], "host"))
 188                 candidate->type = SIPE_CANDIDATE_TYPE_HOST;
 189         else if (sipe_strequal(tokens[7], "relay"))
 190                 candidate->type = SIPE_CANDIDATE_TYPE_RELAY;
 191         else if (sipe_strequal(tokens[7], "srflx"))
 192                 candidate->type = SIPE_CANDIDATE_TYPE_SRFLX;
 193         else if (sipe_strequal(tokens[7], "prflx"))
 194                 candidate->type = SIPE_CANDIDATE_TYPE_PRFLX;
 195         else {
 196                 sdpcandidate_free(candidate);
 197                 return candidates;
 198         }
 199
 200         candidates = g_slist_append(candidates, candidate);
 201
 202         // TCP-ACT candidates are both active and passive
 203         if (candidate->protocol == SIPE_NETWORK_PROTOCOL_TCP_ACTIVE) {
 204                 candidate = sdpcandidate_copy(candidate);
 205                 candidate->protocol = SIPE_NETWORK_PROTOCOL_TCP_PASSIVE;
 206                 candidates = g_slist_append(candidates, candidate);
 207         }
 208         return candidates;
 209 }
 210
 211 static GSList *
 212 parse_candidates(GSList *attrs, SipeIceVersion *ice_version)
 213 {
 214         GSList *candidates = NULL;
 215         const gchar *attr;
 216         int i = 0;
 217
 218         while ((attr = sipe_utils_nameval_find_instance(attrs, "candidate", i++))) {
 219                 gchar **tokens = g_strsplit_set(attr, " ", 0);
 220
 221                 if (sipe_strequal(tokens[6], "typ")) {
 222                         candidates = parse_append_candidate_rfc_5245(tokens, candidates);
 223                         if (candidates)
 224                                 *ice_version = SIPE_ICE_RFC_5245;
 225                 } else {
 226                         candidates = parse_append_candidate_draft_6(tokens, candidates);
 227                         if (candidates)
 228                                 *ice_version = SIPE_ICE_DRAFT_6;
 229                 }
 230
 231                 g_strfreev(tokens);
 232         }
 233
 234         if (!candidates)
 235                 *ice_version = SIPE_ICE_NO_ICE;
 236
 237         if (*ice_version == SIPE_ICE_RFC_5245) {
 238                 const gchar *username = sipe_utils_nameval_find(attrs, "ice-ufrag");
 239                 const gchar *password = sipe_utils_nameval_find(attrs, "ice-pwd");
 240
 241                 if (username && password) {
 242                         GSList *i;
 243                         for (i = candidates; i; i = i->next) {
 244                                 struct sdpcandidate *c = i->data;
 245                                 c->username = g_strdup(username);
 246                                 c->password = g_strdup(password);
 247                         }
 248                 }
 249         }
 250
 251         return candidates;
 252 }
 253
 254 static GSList *
 255 create_legacy_candidates(gchar *ip, guint16 port)
 256 {
 257         struct sdpcandidate *candidate;
 258         GSList *candidates = NULL;
 259
 260         candidate = g_new0(struct sdpcandidate, 1);
 261         candidate->foundation = g_strdup("1");
 262         candidate->component = SIPE_COMPONENT_RTP;
 263         candidate->type = SIPE_CANDIDATE_TYPE_HOST;
 264         candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
 265         candidate->ip = g_strdup(ip);
 266         candidate->port = port;
 267
 268         candidates = g_slist_append(candidates, candidate);
 269
 270         candidate = g_new0(struct sdpcandidate, 1);
 271         candidate->foundation = g_strdup("1");
 272         candidate->component = SIPE_COMPONENT_RTCP;
 273         candidate->type = SIPE_CANDIDATE_TYPE_HOST;
 274         candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
 275         candidate->ip = g_strdup(ip);
 276         candidate->port = port + 1;
 277
 278         candidates = g_slist_append(candidates, candidate);
 279
 280         return candidates;
 281 }
 282
 283 static GSList *
 284 parse_codecs(GSList *attrs, SipeMediaType type)
 285 {
 286         int i = 0;
 287         const gchar *attr;
 288         GSList *codecs = NULL;
 289
 290         while ((attr = sipe_utils_nameval_find_instance(attrs, "rtpmap", i++))) {
 291                 struct sdpcodec *codec = g_new0(struct sdpcodec, 1);
 292                 gchar **tokens = g_strsplit_set(attr, " /", 3);
 293
 294                 int j = 0;
 295                 const gchar* params;
 296
 297                 codec->id = atoi(tokens[0]);
 298                 codec->name = g_strdup(tokens[1]);
 299                 codec->clock_rate = atoi(tokens[2]);
 300                 codec->type = type;
 301
 302                 // TODO: more secure and effective implementation
 303                 while((params = sipe_utils_nameval_find_instance(attrs, "fmtp", j++))) {
 304                         gchar **tokens = g_strsplit_set(params, " ", 0);
 305                         gchar **next = tokens + 1;
 306
 307                         if (atoi(tokens[0]) == codec->id) {
 308                                 while (*next) {
 309                                         gchar name[50];
 310                                         gchar value[50];
 311
 312                                         if (sscanf(*next, "%[a-zA-Z0-9]=%s", name, value) == 2)
 313                                                 codec->parameters = sipe_utils_nameval_add(codec->parameters, name, value);
 314
 315                                         ++next;
 316                                 }
 317                         }
 318
 319                         g_strfreev(tokens);
 320                 }
 321
 322                 codecs = g_slist_append(codecs, codec);
 323                 g_strfreev(tokens);
 324         }
 325
 326         return codecs;
 327 }
 328
 329 static guchar *
 330 parse_encryption_key(GSList *attrs)
 331 {
 332         int i = 0;
 333         const gchar *attr;
 334         guchar *result = NULL;
 335
 336         while ((attr = sipe_utils_nameval_find_instance(attrs, "crypto", i++))) {
 337                 gchar **tokens = g_strsplit_set(attr, " :|", 6);
 338
 339                 if (tokens[0] && tokens[1] && tokens[2] && tokens[3] && tokens[4] &&
 340                     sipe_strcase_equal(tokens[1], "AES_CM_128_HMAC_SHA1_80") &&
 341                     sipe_strequal(tokens[2], "inline") &&
 342                     !tokens[5]) {
 343                         gsize key_len;
 344                         result = g_base64_decode(tokens[3], &key_len);
 345                         if (key_len != SIPE_SRTP_KEY_LEN) {
 346                                 g_free(result);
 347                                 result = NULL;
 348                         }
 349                 }
 350
 351                 g_strfreev(tokens);
 352
 353                 if (result) {
 354                         break;
 355                 }
 356         }
 357
 358         return result;
 359 }
 360
 361 struct sdpmsg *
 362 sdpmsg_parse_msg(gchar *msg)
 363 {
 364         struct sdpmsg *smsg = g_new0(struct sdpmsg, 1);
 365         GSList *i;
 366
 367         if (!parse_attributes(smsg, msg)) {
 368                 sdpmsg_free(smsg);
 369                 return NULL;
 370         }
 371
 372         for (i = smsg->media; i; i = i->next) {
 373                 struct sdpmedia *media = i->data;
 374                 SipeMediaType type;
 375
 376                 media->candidates = parse_candidates(media->attributes,
 377                                                      &smsg->ice_version);
 378
 379                 if (!media->candidates && media->port != 0) {
 380                         // No a=candidate in SDP message, this seems to be MSOC 2005
 381                         media->candidates = create_legacy_candidates(smsg->ip, media->port);
 382                 }
 383
 384                 if (sipe_strequal(media->name, "audio"))
 385                         type = SIPE_MEDIA_AUDIO;
 386                 else if (sipe_strequal(media->name, "video"))
 387                         type = SIPE_MEDIA_VIDEO;
 388                 else {
 389                         // Unknown media type
 390                         sdpmsg_free(smsg);
 391                         return NULL;
 392                 }
 393
 394                 media->codecs = parse_codecs(media->attributes, type);
 395                 media->encryption_key = parse_encryption_key(media->attributes);
 396         }
 397
 398         return smsg;
 399 }
 400
 401 static gchar *
 402 codecs_to_string(GSList *codecs)
 403 {
 404         GString *result = g_string_new(NULL);
 405
 406         for (; codecs; codecs = codecs->next) {
 407                 struct sdpcodec *c = codecs->data;
 408                 GSList *params = c->parameters;
 409
 410                 g_string_append_printf(result,
 411                                        "a=rtpmap:%d %s/%d\r\n",
 412                                        c->id,
 413                                        c->name,
 414                                        c->clock_rate);
 415
 416                 if (params) {
 417                         GString *param_str = g_string_new(NULL);
 418                         int written_params = 0;
 419
 420                         g_string_append_printf(param_str, "a=fmtp:%d", c->id);
 421
 422                         for (; params; params = params->next) {
 423                                 struct sipnameval* par = params->data;
 424                                 if (sipe_strequal(par->name, "farsight-send-profile")) {
 425                                         // Lync AVMCU doesn't like this property.
 426                                         continue;
 427                                 }
 428
 429                                 g_string_append_printf(param_str, " %s=%s",
 430                                                        par->name, par->value);
 431                                 ++written_params;
 432                         }
 433
 434                         g_string_append(param_str, "\r\n");
 435
 436                         if (written_params > 0) {
 437                                 g_string_append(result, param_str->str);
 438                         }
 439
 440                         g_string_free(param_str, TRUE);
 441                 }
 442         }
 443
 444         return g_string_free(result, FALSE);
 445 }
 446
 447 static gchar *
 448 codec_ids_to_string(GSList *codecs)
 449 {
 450         GString *result = g_string_new(NULL);
 451
 452         for (; codecs; codecs = codecs->next) {
 453                 struct sdpcodec *c = codecs->data;
 454                 g_string_append_printf(result, " %d", c->id);
 455         }
 456
 457         return g_string_free(result, FALSE);
 458 }
 459
 460 static gchar *
 461 base64_unpad(const gchar *str)
 462 {
 463         gchar *result = g_strdup(str);
 464         gchar *ptr;
 465
 466         for (ptr = result + strlen(result); ptr != result; --ptr) {
 467                 if (*(ptr - 1) != '=') {
 468                         *ptr = '\0';
 469                         break;
 470                 }
 471         }
 472
 473         return result;
 474 }
 475
 476 static gchar *
 477 candidates_to_string(GSList *candidates, SipeIceVersion ice_version)
 478 {
 479         GString *result = g_string_new("");
 480         GSList *i;
 481         GSList *processed_tcp_candidates = NULL;
 482
 483         for (i = candidates; i; i = i->next) {
 484                 struct sdpcandidate *c = i->data;
 485                 const gchar *protocol;
 486                 const gchar *type;
 487                 gchar *related = NULL;
 488
 489                 if (ice_version == SIPE_ICE_RFC_5245) {
 490
 491                         switch (c->protocol) {
 492                                 case SIPE_NETWORK_PROTOCOL_TCP_ACTIVE:
 493                                         protocol = "TCP-ACT";
 494                                         break;
 495                                 case SIPE_NETWORK_PROTOCOL_TCP_PASSIVE:
 496                                         protocol = "TCP-PASS";
 497                                         break;
 498                                 case SIPE_NETWORK_PROTOCOL_UDP:
 499                                         protocol = "UDP";
 500                                         break;
 501                                 default:
 502                                         /* error unknown/unsupported type */
 503                                         protocol = "UNKNOWN";
 504                                         break;
 505                         }
 506
 507                         switch (c->type) {
 508                                 case SIPE_CANDIDATE_TYPE_HOST:
 509                                         type = "host";
 510                                         break;
 511                                 case SIPE_CANDIDATE_TYPE_RELAY:
 512                                         type = "relay";
 513                                         break;
 514                                 case SIPE_CANDIDATE_TYPE_SRFLX:
 515                                         type = "srflx";
 516                                         break;
 517                                 case SIPE_CANDIDATE_TYPE_PRFLX:
 518                                         type = "prflx";
 519                                         break;
 520                                 default:
 521                                         /* error unknown/unsupported type */
 522                                         type = "unknown";
 523                                         break;
 524                         }
 525
 526                         switch (c->type) {
 527                                 case SIPE_CANDIDATE_TYPE_RELAY:
 528                                 case SIPE_CANDIDATE_TYPE_SRFLX:
 529                                 case SIPE_CANDIDATE_TYPE_PRFLX:
 530                                         related = g_strdup_printf("raddr %s rport %d",
 531                                                                   c->base_ip,
 532                                                                   c->base_port);
 533                                         break;
 534                                 default:
 535                                         break;
 536                         }
 537
 538                         g_string_append_printf(result,
 539                                                "a=candidate:%s %u %s %u %s %d typ %s %s\r\n",
 540                                                c->foundation,
 541                                                c->component,
 542                                                protocol,
 543                                                c->priority,
 544                                                c->ip,
 545                                                c->port,
 546                                                type,
 547                                                related ? related : "");
 548                         g_free(related);
 549
 550                 } else if (ice_version == SIPE_ICE_DRAFT_6) {
 551                         gchar *username;
 552                         gchar *password;
 553
 554                         switch (c->protocol) {
 555                                 case SIPE_NETWORK_PROTOCOL_TCP_ACTIVE:
 556                                 case SIPE_NETWORK_PROTOCOL_TCP_PASSIVE: {
 557                                         GSList *prev_cand = processed_tcp_candidates;
 558                                         for (; prev_cand; prev_cand = prev_cand->next) {
 559                                                 struct sdpcandidate *c2 = (struct sdpcandidate *)prev_cand->data;
 560
 561                                                 if (sipe_strequal(c->ip, c2->ip) &&
 562                                                     c->component == c2->component) {
 563                                                         break;
 564                                                 }
 565                                         }
 566
 567                                         if (prev_cand) {
 568                                                 protocol = NULL;
 569                                         } else {
 570                                                 protocol = "TCP";
 571                                                 processed_tcp_candidates =
 572                                                         g_slist_append(processed_tcp_candidates, c);
 573                                         }
 574                                         break;
 575                                 }
 576                                 case SIPE_NETWORK_PROTOCOL_UDP:
 577                                         protocol = "UDP";
 578                                         break;
 579                                 default:
 580                                         /* unknown/unsupported type, ignore */
 581                                         protocol = NULL;
 582                                         break;
 583                         }
 584
 585                         if (!protocol) {
 586                                 continue;
 587                         }
 588
 589                         username = base64_unpad(c->username);
 590                         password = base64_unpad(c->password);
 591
 592                         g_string_append_printf(result,
 593                                                "a=candidate:%s %u %s %s 0.%u %s %d\r\n",
 594                                                username,
 595                                                c->component,
 596                                                password,
 597                                                protocol,
 598                                                c->priority,
 599                                                c->ip,
 600                                                c->port);
 601
 602                         g_free(username);
 603                         g_free(password);
 604                 }
 605         }
 606
 607         g_slist_free(processed_tcp_candidates);
 608
 609         return g_string_free(result, FALSE);
 610 }
 611
 612 static gchar *
 613 remote_candidates_to_string(GSList *candidates, SipeIceVersion ice_version)
 614 {
 615         GString *result = g_string_new("");
 616
 617         if (candidates) {
 618                 if (ice_version == SIPE_ICE_RFC_5245) {
 619                         GSList *i;
 620                         g_string_append(result, "a=remote-candidates:");
 621
 622                         for (i = candidates; i; i = i->next) {
 623                                 struct sdpcandidate *c = i->data;
 624                                 g_string_append_printf(result, "%u %s %u ",
 625                                                        c->component, c->ip, c->port);
 626                         }
 627
 628                         g_string_append(result, "\r\n");
 629                 } else if (ice_version == SIPE_ICE_DRAFT_6) {
 630                         struct sdpcandidate *c = candidates->data;
 631                         g_string_append_printf(result, "a=remote-candidate:%s\r\n",
 632                                                c->username);
 633                 }
 634         }
 635
 636         return g_string_free(result, FALSE);
 637 }
 638
 639 static gchar *
 640 attributes_to_string(GSList *attributes)
 641 {
 642         GString *result = g_string_new("");
 643
 644         for (; attributes; attributes = attributes->next) {
 645                 struct sipnameval *a = attributes->data;
 646                 g_string_append_printf(result, "a=%s", a->name);
 647                 if (!sipe_strequal(a->value, ""))
 648                         g_string_append_printf(result, ":%s", a->value);
 649                 g_string_append(result, "\r\n");
 650         }
 651
 652         return g_string_free(result, FALSE);
 653 }
 654
 655 static gchar *
 656 media_to_string(const struct sdpmsg *msg, const struct sdpmedia *media)
 657 {
 658         gchar *media_str;
 659
 660         gchar *transport_profile = NULL;
 661
 662         gchar *media_conninfo = NULL;
 663
 664         gchar *codecs_str = NULL;
 665         gchar *codec_ids_str = codec_ids_to_string(media->codecs);
 666
 667         gchar *candidates_str = NULL;
 668         gchar *remote_candidates_str = NULL;
 669
 670         gchar *attributes_str = NULL;
 671         gchar *credentials = NULL;
 672
 673         gchar *crypto = NULL;
 674
 675         gboolean uses_tcp_transport = FALSE;
 676
 677         if (media->port != 0) {
 678                 if (!sipe_strequal(msg->ip, media->ip)) {
 679                         media_conninfo = g_strdup_printf("c=IN IP4 %s\r\n", media->ip);
 680                 }
 681
 682                 codecs_str = codecs_to_string(media->codecs);
 683                 candidates_str = candidates_to_string(media->candidates, msg->ice_version);
 684                 remote_candidates_str = remote_candidates_to_string(media->remote_candidates,
 685                                                                     msg->ice_version);
 686
 687                 if (media->remote_candidates) {
 688                         struct sdpcandidate *c = media->remote_candidates->data;
 689                         uses_tcp_transport =
 690                                 c->protocol == SIPE_NETWORK_PROTOCOL_TCP_ACTIVE ||
 691                                 c->protocol == SIPE_NETWORK_PROTOCOL_TCP_PASSIVE ||
 692                                 c->protocol == SIPE_NETWORK_PROTOCOL_TCP_SO;
 693                 }
 694
 695                 attributes_str = attributes_to_string(media->attributes);
 696
 697                 if (msg->ice_version == SIPE_ICE_RFC_5245 && media->candidates) {
 698                         struct sdpcandidate *c = media->candidates->data;
 699
 700                         credentials = g_strdup_printf("a=ice-ufrag:%s\r\n"
 701                                                       "a=ice-pwd:%s\r\n",
 702                                                       c->username,
 703                                                       c->password);
 704                 }
 705
 706                 if (media->encryption_key) {
 707                         gchar *key_encoded = g_base64_encode(media->encryption_key, SIPE_SRTP_KEY_LEN);
 708                         crypto = g_strdup_printf("a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:%s|2^31\r\n",
 709                                         key_encoded);
 710                         g_free(key_encoded);
 711                 }
 712         }
 713
 714         transport_profile = g_strdup_printf("%sRTP/%sAVP",
 715                                             uses_tcp_transport ? "TCP/" : "",
 716                                             media->encryption_active ? "S" : "");
 717
 718         media_str = g_strdup_printf("m=%s %d %s%s\r\n"
 719                                     "%s"
 720                                     "%s"
 721                                     "%s"
 722                                     "%s"
 723                                     "%s"
 724                                     "%s"
 725                                     "%s",
 726                                     media->name, media->port, transport_profile, codec_ids_str,
 727                                     media_conninfo ? media_conninfo : "",
 728                                     candidates_str ? candidates_str : "",
 729                                     crypto ? crypto : "",
 730                                     remote_candidates_str ? remote_candidates_str : "",
 731                                     codecs_str ? codecs_str : "",
 732                                     attributes_str ? attributes_str : "",
 733                                     credentials ? credentials : "");
 734
 735         g_free(transport_profile);
 736         g_free(media_conninfo);
 737         g_free(codecs_str);
 738         g_free(codec_ids_str);
 739         g_free(candidates_str);
 740         g_free(remote_candidates_str);
 741         g_free(attributes_str);
 742         g_free(credentials);
 743         g_free(crypto);
 744
 745         return media_str;
 746 }
 747
 748 gchar *
 749 sdpmsg_to_string(const struct sdpmsg *msg)
 750 {
 751         GString *body = g_string_new(NULL);
 752         GSList *i;
 753
 754         g_string_append_printf(
 755                 body,
 756                 "v=0\r\n"
 757                 "o=- 0 0 IN IP4 %s\r\n"
 758                 "s=session\r\n"
 759                 "c=IN IP4 %s\r\n"
 760                 "b=CT:99980\r\n"
 761                 "t=0 0\r\n",
 762                 msg->ip, msg->ip);
 763
 764
 765         for (i = msg->media; i; i = i->next) {
 766                 gchar *media_str = media_to_string(msg, i->data);
 767                 g_string_append(body, media_str);
 768                 g_free(media_str);
 769         }
 770
 771         return g_string_free(body, FALSE);
 772 }
 773
 774 static struct sdpcandidate *
 775 sdpcandidate_copy(struct sdpcandidate *candidate)
 776 {
 777         if (candidate) {
 778                 struct sdpcandidate *copy = g_new0(struct sdpcandidate, 1);
 779
 780                 copy->foundation = g_strdup(candidate->foundation);
 781                 copy->component  = candidate->component;
 782                 copy->type       = candidate->type;
 783                 copy->protocol   = candidate->protocol;
 784                 copy->priority   = candidate->priority;
 785                 copy->ip         = g_strdup(candidate->ip);
 786                 copy->port       = candidate->port;
 787                 copy->base_ip    = g_strdup(candidate->base_ip);
 788                 copy->base_port  = candidate->base_port;
 789                 copy->username   = g_strdup(candidate->username);
 790                 copy->password   = g_strdup(candidate->password);
 791
 792                 return copy;
 793         } else
 794                 return NULL;
 795 }
 796
 797 static void
 798 sdpcandidate_free(struct sdpcandidate *candidate)
 799 {
 800         if (candidate) {
 801                 g_free(candidate->foundation);
 802                 g_free(candidate->ip);
 803                 g_free(candidate->base_ip);
 804                 g_free(candidate->username);
 805                 g_free(candidate->password);
 806                 g_free(candidate);
 807         }
 808 }
 809
 810 void
 811 sdpcodec_free(struct sdpcodec *codec)
 812 {
 813         if (codec) {
 814                 g_free(codec->name);
 815                 sipe_utils_nameval_free(codec->parameters);
 816                 g_free(codec);
 817         }
 818 }
 819
 820 void
 821 sdpmedia_free(struct sdpmedia *media)
 822 {
 823         if (media) {
 824                 g_free(media->name);
 825                 g_free(media->ip);
 826
 827                 sipe_utils_nameval_free(media->attributes);
 828
 829                 sipe_utils_slist_free_full(media->candidates,
 830                                   (GDestroyNotify) sdpcandidate_free);
 831                 sipe_utils_slist_free_full(media->codecs,
 832                                   (GDestroyNotify) sdpcodec_free);
 833                 sipe_utils_slist_free_full(media->remote_candidates,
 834                                   (GDestroyNotify) sdpcandidate_free);
 835
 836                 g_free(media->encryption_key);
 837
 838                 g_free(media);
 839         }
 840 }
 841
 842 void
 843 sdpmsg_free(struct sdpmsg *msg)
 844 {
 845         if (msg) {
 846                 g_free(msg->ip);
 847                 sipe_utils_slist_free_full(msg->media,
 848                                   (GDestroyNotify) sdpmedia_free);
 849                 g_free(msg);
 850         }
 851 }
 852
 853 /*
 854   Local Variables:
 855   mode: c
 856   c-file-style: "bsd"
 857   indent-tabs-mode: t
 858   tab-width: 8
 859   End:
 860 */