src/core/sipe-appshare.c

   1 /**
   2  * @file sipe-appshare.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2014-2018 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 <string.h>
  29
  30 #include <gio/gio.h>
  31
  32 #ifdef HAVE_APPSHARE_SERVER
  33 #include <glib/gstdio.h>
  34
  35 #include <sys/socket.h>
  36 #include <sys/un.h>
  37
  38 #include <freerdp/server/shadow.h>
  39 #endif // HAVE_APPSHARE_SERVER
  40
  41 #include "sipmsg.h"
  42 #include "sipe-appshare-client.h"
  43 #include "sipe-backend.h"
  44 #include "sipe-buddy.h"
  45 #include "sipe-chat.h"
  46 #include "sipe-common.h"
  47 #include "sipe-conf.h"
  48 #include "sipe-core.h"
  49 #include "sipe-core-private.h"
  50 #include "sipe-appshare.h"
  51 #include "sipe-media.h"
  52 #include "sipe-nls.h"
  53 #include "sipe-schedule.h"
  54 #include "sipe-user.h"
  55 #include "sipe-utils.h"
  56 #include "sdpmsg.h"
  57
  58 struct sipe_appshare {
  59         struct sipe_media_stream *stream;
  60         GSocket *socket;
  61         GIOChannel *channel;
  62         guint rdp_channel_readable_watch_id;
  63         guint rdp_channel_writable_watch_id;
  64         guint monitor_id;
  65         struct sipe_user_ask_ctx *ask_ctx;
  66
  67         gchar rdp_channel_buffer[0x800];
  68         gchar *rdp_channel_buffer_pos;
  69         gsize rdp_channel_buffer_len;
  70
  71         struct sipe_rdp_client client;
  72
  73 #ifdef HAVE_APPSHARE_SERVER
  74         rdpShadowServer *server;
  75 #endif // HAVE_APPSHARE_SERVER
  76 };
  77
  78 static void
  79 sipe_appshare_free(struct sipe_appshare *appshare)
  80 {
  81         if (appshare->rdp_channel_readable_watch_id != 0) {
  82                 g_source_destroy(g_main_context_find_source_by_id(NULL,
  83                                 appshare->rdp_channel_readable_watch_id));
  84         }
  85
  86         if (appshare->rdp_channel_writable_watch_id != 0) {
  87                 g_source_destroy(g_main_context_find_source_by_id(NULL,
  88                                 appshare->rdp_channel_writable_watch_id));
  89         }
  90
  91         if (appshare->channel) {
  92                 GError *error = NULL;
  93
  94                 g_io_channel_shutdown(appshare->channel, TRUE, &error);
  95                 if (error) {
  96                         SIPE_DEBUG_ERROR("Error shutting down RDP channel: %s",
  97                                          error->message);
  98                         g_error_free(error);
  99                 }
 100                 g_io_channel_unref(appshare->channel);
 101         }
 102
 103         if (appshare->socket) {
 104                 g_object_unref(appshare->socket);
 105         }
 106
 107 #ifdef HAVE_APPSHARE_SERVER
 108         if (appshare->server) {
 109                 if (appshare->server->ipcSocket) {
 110                         g_unlink(appshare->server->ipcSocket);
 111                 }
 112
 113                 shadow_server_stop(appshare->server);
 114                 shadow_server_uninit(appshare->server);
 115                 shadow_server_free(appshare->server);
 116         }
 117 #endif // HAVE_APPSHARE_SERVER
 118
 119         if (appshare->ask_ctx) {
 120                 sipe_user_close_ask(appshare->ask_ctx);
 121         }
 122
 123         g_free(appshare->client.cmdline);
 124         if (appshare->client.free_cb) {
 125                 appshare->client.free_cb(&appshare->client);
 126         }
 127
 128         g_free(appshare);
 129 }
 130
 131 static gboolean
 132 rdp_channel_readable_cb(GIOChannel *channel,
 133                         GIOCondition condition,
 134                         gpointer data)
 135 {
 136         struct sipe_appshare *appshare = data;
 137         GError *error = NULL;
 138         gchar *buffer;
 139         gsize bytes_read;
 140
 141         if (condition & G_IO_HUP) {
 142                 struct sipe_media_call *call = appshare->stream->call;
 143
 144                 SIPE_DEBUG_INFO_NOFORMAT("Received HUP from RDP client.");
 145                 sipe_backend_media_hangup(call->backend_private, TRUE);
 146                 return FALSE;
 147         }
 148
 149         buffer = g_malloc(2048);
 150         while (sipe_media_stream_is_writable(appshare->stream)) {
 151                 GIOStatus status;
 152
 153                 status = g_io_channel_read_chars(channel,
 154                                                  buffer, 2048,
 155                                                  &bytes_read, &error);
 156                 if (error) {
 157                         struct sipe_media_call *call = appshare->stream->call;
 158
 159                         SIPE_DEBUG_ERROR("Error reading from RDP channel: %s",
 160                                          error->message);
 161                         g_error_free(error);
 162                         sipe_backend_media_hangup(call->backend_private, TRUE);
 163                         g_free(buffer);
 164                         return FALSE;
 165                 }
 166
 167                 if (status == G_IO_STATUS_EOF) {
 168                         struct sipe_media_call *call = appshare->stream->call;
 169
 170                         sipe_backend_media_hangup(call->backend_private, TRUE);
 171                         g_free(buffer);
 172                         return FALSE;
 173                 }
 174
 175                 if (bytes_read == 0) {
 176                         break;
 177                 }
 178
 179                 sipe_media_stream_write(appshare->stream, (guint8 *)buffer,
 180                                         bytes_read);
 181                 SIPE_DEBUG_INFO("Written: %" G_GSIZE_FORMAT "\n", bytes_read);
 182         }
 183         g_free(buffer);
 184
 185         return TRUE;
 186 }
 187
 188 static gboolean
 189 socket_connect_cb(SIPE_UNUSED_PARAMETER GIOChannel *channel,
 190                   SIPE_UNUSED_PARAMETER GIOCondition condition,
 191                   gpointer data)
 192 {
 193         struct sipe_appshare *appshare = data;
 194         GError *error = NULL;
 195         GSocket *data_socket;
 196         int fd;
 197
 198         SIPE_DEBUG_INFO_NOFORMAT("RDP client has connected.");
 199
 200         data_socket = g_socket_accept(appshare->socket, NULL, &error);
 201         if (error) {
 202                 struct sipe_media_call *call = appshare->stream->call;
 203
 204                 SIPE_DEBUG_ERROR("Error accepting RDP client connection: %s",
 205                                  error->message);
 206                 g_error_free(error);
 207                 sipe_backend_media_hangup(call->backend_private, TRUE);
 208                 return FALSE;
 209         }
 210
 211         g_io_channel_shutdown(appshare->channel, TRUE, &error);
 212         if (error) {
 213                 struct sipe_media_call *call = appshare->stream->call;
 214
 215                 SIPE_DEBUG_ERROR("Error shutting down RDP channel: %s",
 216                                  error->message);
 217                 g_error_free(error);
 218                 g_object_unref(data_socket);
 219                 sipe_backend_media_hangup(call->backend_private, TRUE);
 220                 return FALSE;
 221         }
 222         g_io_channel_unref(appshare->channel);
 223
 224         g_object_unref(appshare->socket);
 225         appshare->socket = data_socket;
 226
 227         fd = g_socket_get_fd(appshare->socket);
 228         if (fd < 0) {
 229                 struct sipe_media_call *call = appshare->stream->call;
 230
 231                 SIPE_DEBUG_ERROR_NOFORMAT("Invalid file descriptor for RDP client connection socket");
 232                 sipe_backend_media_hangup(call->backend_private, TRUE);
 233                 return FALSE;
 234         }
 235         appshare->channel = g_io_channel_unix_new(fd);
 236
 237         // No encoding for binary data
 238         g_io_channel_set_encoding(appshare->channel, NULL, &error);
 239         if (error) {
 240                 struct sipe_media_call *call = appshare->stream->call;
 241
 242                 SIPE_DEBUG_ERROR("Error setting RDP channel encoding: %s",
 243                                  error->message);
 244                 g_error_free(error);
 245                 sipe_backend_media_hangup(call->backend_private, TRUE);
 246                 return FALSE;
 247         }
 248
 249         appshare->rdp_channel_readable_watch_id =
 250                         g_io_add_watch(appshare->channel, G_IO_IN | G_IO_HUP,
 251                                        rdp_channel_readable_cb, appshare);
 252
 253         return FALSE;
 254 }
 255
 256 static void
 257 launch_rdp_client(struct sipe_appshare *appshare)
 258 {
 259         struct sipe_rdp_client *client = &appshare->client;
 260         struct sipe_media_call *call = appshare->stream->call;
 261         GSocketAddress *address;
 262         GError *error = NULL;
 263         int fd;
 264
 265         address = client->get_listen_address_cb(client);
 266         if (!address) {
 267                 sipe_backend_media_hangup(call->backend_private, TRUE);
 268                 return;
 269         }
 270
 271         appshare->socket = g_socket_new(g_socket_address_get_family(address),
 272                                         G_SOCKET_TYPE_STREAM,
 273                                         G_SOCKET_PROTOCOL_DEFAULT,
 274                                         &error);
 275         if (error) {
 276                 SIPE_DEBUG_ERROR("Can't create RDP client listen socket: %s",
 277                                  error->message);
 278                 g_error_free(error);
 279                 g_object_unref(address);
 280                 sipe_backend_media_hangup(call->backend_private, TRUE);
 281                 return;
 282         }
 283
 284         g_socket_set_blocking(appshare->socket, FALSE);
 285
 286         g_socket_bind(appshare->socket, address, TRUE, &error);
 287         g_object_unref(address);
 288         if (error) {
 289                 SIPE_DEBUG_ERROR("Can't bind to RDP client socket: %s",
 290                                  error->message);
 291                 g_error_free(error);
 292                 sipe_backend_media_hangup(call->backend_private, TRUE);
 293                 return;
 294         }
 295
 296         g_socket_listen(appshare->socket, &error);
 297         if (error) {
 298                 SIPE_DEBUG_ERROR("Can't listen on RDP client socket: %s",
 299                                  error->message);
 300                 g_error_free(error);
 301                 sipe_backend_media_hangup(call->backend_private, TRUE);
 302                 return;
 303         }
 304
 305         fd = g_socket_get_fd(appshare->socket);
 306         if (fd < 0) {
 307                 SIPE_DEBUG_ERROR_NOFORMAT("Invalid file descriptor for RDP client listen socket");
 308                 sipe_backend_media_hangup(call->backend_private, TRUE);
 309                 return;
 310         }
 311         appshare->channel = g_io_channel_unix_new(fd);
 312
 313         appshare->rdp_channel_readable_watch_id =
 314                         g_io_add_watch(appshare->channel, G_IO_IN,
 315                                        socket_connect_cb, appshare);
 316
 317         address = g_socket_get_local_address(appshare->socket, &error);
 318         if (error) {
 319                 SIPE_DEBUG_ERROR("Couldn't get appshare socket address: %s",
 320                                  error->message);
 321                 g_error_free(error);
 322                 sipe_backend_media_hangup(call->backend_private, TRUE);
 323                 return;
 324         }
 325
 326         if (!client->launch_cb(client, address, appshare->stream)) {
 327                 SIPE_DEBUG_ERROR_NOFORMAT("Failed to launch RDP client.");
 328                 sipe_backend_media_hangup(call->backend_private, TRUE);
 329         }
 330
 331         SIPE_DEBUG_INFO_NOFORMAT("RDP client launched.");
 332
 333         g_object_unref(address);
 334 }
 335
 336 static gssize
 337 rdp_client_channel_write(struct sipe_appshare *appshare)
 338 {
 339         gsize bytes_written;
 340         GError *error = NULL;
 341
 342         g_io_channel_write_chars(appshare->channel,
 343                                  appshare->rdp_channel_buffer_pos,
 344                                  appshare->rdp_channel_buffer_len,
 345                                  &bytes_written, &error);
 346         if (error) {
 347                 SIPE_DEBUG_ERROR("Couldn't write data to RDP client: %s",
 348                                  error->message);
 349                 g_error_free(error);
 350                 return -1;
 351         }
 352
 353         g_io_channel_flush(appshare->channel, &error);
 354         if (error) {
 355                 if (g_error_matches(error, G_IO_CHANNEL_ERROR,
 356                                     G_IO_CHANNEL_ERROR_PIPE)) {
 357                         /* Ignore broken pipe here and wait for the call to be
 358                          * hung up upon G_IO_HUP in client_channel_cb(). */
 359                         g_error_free(error);
 360                         return 0;
 361                 }
 362
 363                 SIPE_DEBUG_ERROR("Couldn't flush RDP channel: %s",
 364                                  error->message);
 365                 g_error_free(error);
 366                 return -1;
 367         }
 368
 369         appshare->rdp_channel_buffer_pos += bytes_written;
 370         appshare->rdp_channel_buffer_len -= bytes_written;
 371
 372         return bytes_written;
 373 }
 374
 375 static void
 376 delayed_hangup_cb(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
 377                   gpointer data)
 378 {
 379         struct sipe_media_call *call = data;
 380
 381         sipe_backend_media_hangup(call->backend_private, TRUE);
 382 }
 383
 384 static gboolean
 385 rdp_channel_writable_cb(SIPE_UNUSED_PARAMETER GIOChannel *channel,
 386                         SIPE_UNUSED_PARAMETER GIOCondition condition,
 387                         gpointer data)
 388 {
 389         struct sipe_appshare *appshare = data;
 390         struct sipe_media_call *call = appshare->stream->call;
 391
 392         if (rdp_client_channel_write(appshare) < 0) {
 393                 sipe_backend_media_hangup(call->backend_private, TRUE);
 394                 return FALSE;
 395         }
 396
 397         if (appshare->rdp_channel_buffer_len == 0) {
 398                 // Writing done, disconnect writable watch.
 399                 appshare->rdp_channel_writable_watch_id = 0;
 400                 return FALSE;
 401         }
 402
 403         return TRUE;
 404 }
 405
 406 static void
 407 read_cb(struct sipe_media_stream *stream)
 408 {
 409         struct sipe_appshare *appshare = sipe_media_stream_get_data(stream);
 410         gint bytes_read = 0;
 411         gssize bytes_written = 0;
 412
 413         if (appshare->rdp_channel_writable_watch_id != 0) {
 414                 // Data still in the buffer. Let the client read it first.
 415                 return;
 416         }
 417
 418         while (bytes_read == (gint)bytes_written) {
 419                 bytes_read = sipe_backend_media_stream_read(stream,
 420                                 (guint8 *)appshare->rdp_channel_buffer,
 421                                 sizeof (appshare->rdp_channel_buffer));
 422                 if (bytes_read == 0) {
 423                         return;
 424                 }
 425
 426                 appshare->rdp_channel_buffer_pos = appshare->rdp_channel_buffer;
 427                 appshare->rdp_channel_buffer_len = bytes_read;
 428
 429                 bytes_written = rdp_client_channel_write(appshare);
 430
 431                 if (bytes_written < 0) {
 432                         /* Don't deallocate stream while in its read callback.
 433                          * Schedule call hangup to be executed after we're back
 434                          * in the message loop. */
 435                         sipe_schedule_seconds(sipe_media_get_sipe_core_private(stream->call),
 436                                               "appshare delayed hangup",
 437                                               stream->call->backend_private,
 438                                               0,
 439                                               delayed_hangup_cb,
 440                                               NULL);
 441                         return;
 442                 }
 443         }
 444
 445         if (bytes_read != (gint)bytes_written) {
 446                 /* Schedule writing of the buffer's remainder to when
 447                  * RDP channel becomes writable again. */
 448                 appshare->rdp_channel_writable_watch_id =
 449                                 g_io_add_watch(appshare->channel, G_IO_OUT,
 450                                                rdp_channel_writable_cb,
 451                                                appshare);
 452         }
 453 }
 454
 455 static void
 456 writable_cb(struct sipe_media_stream *stream)
 457 {
 458         struct sipe_appshare *appshare = sipe_media_stream_get_data(stream);
 459
 460         if (!appshare->socket) {
 461                 launch_rdp_client(appshare);
 462         }
 463 }
 464
 465 static void
 466 accept_cb(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
 467           gpointer data)
 468 {
 469         struct sipe_appshare *appshare = data;
 470         appshare->ask_ctx = NULL;
 471
 472         sipe_backend_media_accept(appshare->stream->call->backend_private, TRUE);
 473 }
 474
 475 static void
 476 decline_cb(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
 477           gpointer data)
 478 {
 479         struct sipe_appshare *appshare = data;
 480         appshare->ask_ctx = NULL;
 481
 482         sipe_backend_media_hangup(appshare->stream->call->backend_private, TRUE);
 483 }
 484
 485 static struct sipe_user_ask_ctx *
 486 ask_accept_applicationsharing(struct sipe_core_private *sipe_private,
 487                               const gchar *from,
 488                               SipeUserAskCb accept_cb,
 489                               SipeUserAskCb decline_cb,
 490                               gpointer user_data)
 491 {
 492         struct sipe_user_ask_ctx *ctx;
 493         gchar *alias = sipe_buddy_get_alias(sipe_private, from);
 494         gchar *ask_msg = g_strdup_printf(_("%s wants to start presenting"),
 495                                          alias ? alias : from);
 496
 497         ctx = sipe_user_ask(sipe_private, ask_msg,
 498                              _("Accept"), accept_cb,
 499                              _("Decline"), decline_cb,
 500                              user_data);
 501
 502         g_free(ask_msg);
 503         g_free(alias);
 504
 505         return ctx;
 506 }
 507
 508 static struct sipe_appshare *
 509 initialize_appshare(struct sipe_media_stream *stream)
 510 {
 511         struct sipe_appshare *appshare;
 512         struct sipe_media_call *call;
 513         struct sipe_core_private *sipe_private;
 514         const gchar *cmdline;
 515
 516         call = stream->call;
 517         sipe_private = sipe_media_get_sipe_core_private(call);
 518
 519         appshare = g_new0(struct sipe_appshare, 1);
 520         appshare->stream = stream;
 521
 522         sipe_media_stream_set_data(stream, appshare,
 523                                    (GDestroyNotify)sipe_appshare_free);
 524
 525         cmdline = sipe_backend_setting(SIPE_CORE_PUBLIC,
 526                                        SIPE_SETTING_RDP_CLIENT);
 527         if (is_empty(cmdline))
 528                 cmdline = "remmina";
 529         appshare->client.cmdline = g_strdup(cmdline);
 530
 531         if (strstr(cmdline, "xfreerdp")) {
 532                 sipe_appshare_xfreerdp_init(&appshare->client);
 533         } else if (strstr(cmdline, "remmina")) {
 534                 sipe_appshare_remmina_init(&appshare->client);
 535         } else {
 536                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 537                                           _("Application sharing error"),
 538                                           _("Unknown remote desktop client configured."));
 539                 sipe_backend_media_hangup(call->backend_private, TRUE);
 540                 return NULL;
 541         }
 542
 543         sipe_media_stream_add_extra_attribute(stream,
 544                         "x-applicationsharing-session-id", "1");
 545         sipe_media_stream_add_extra_attribute(stream,
 546                         "x-applicationsharing-role", "viewer");
 547         sipe_media_stream_add_extra_attribute(stream,
 548                         "x-applicationsharing-media-type", "rdp");
 549
 550         stream->read_cb = read_cb;
 551         stream->writable_cb = writable_cb;
 552
 553         return appshare;
 554 }
 555
 556 void
 557 process_incoming_invite_appshare(struct sipe_core_private *sipe_private,
 558                                  struct sipmsg *msg)
 559 {
 560         struct sipe_media_call *call;
 561         struct sipe_media_stream *stream;
 562         struct sipe_appshare *appshare;
 563         struct sdpmsg *sdpmsg;
 564         GSList *i;
 565
 566         sdpmsg = sdpmsg_parse_msg(msg->body);
 567
 568         /* Skype for Business compatibility - ignore desktop video. */
 569         i = sdpmsg->media;
 570         while (i) {
 571                 struct sdpmedia *media = i->data;
 572                 const gchar *label;
 573
 574                 i = i->next;
 575
 576                 label = sipe_utils_nameval_find(media->attributes, "label");
 577
 578                 if (sipe_strequal(media->name, "video") &&
 579                     sipe_strequal(label, "applicationsharing-video")) {
 580                         sdpmsg->media = g_slist_remove(sdpmsg->media, media);
 581                         sdpmedia_free(media);
 582                 }
 583         }
 584
 585         call = process_incoming_invite_call_parsed_sdp(sipe_private,
 586                                                        msg,
 587                                                        sdpmsg);
 588         if (!call) {
 589                 return;
 590         }
 591
 592         stream = sipe_core_media_get_stream_by_id(call, "applicationsharing");
 593         if (!stream) {
 594                 sipe_backend_media_hangup(call->backend_private, TRUE);
 595                 return;
 596         }
 597
 598         appshare = initialize_appshare(stream);
 599
 600         if (appshare) {
 601                 gchar *from;
 602
 603                 from = parse_from(sipmsg_find_header(msg, "From"));
 604                 appshare->ask_ctx = ask_accept_applicationsharing(sipe_private, from,
 605                                                                   accept_cb,
 606                                                                   decline_cb,
 607                                                                   appshare);
 608                 g_free(from);
 609         }
 610 }
 611
 612 static void
 613 connect_conference(struct sipe_core_private *sipe_private,
 614                    struct sipe_chat_session *chat_session)
 615 {
 616         struct sipe_media_call *call;
 617         struct sipe_media_stream *stream;
 618         gchar * uri;
 619
 620         chat_session->appshare_ask_ctx = NULL;
 621
 622         uri = sipe_conf_build_uri(chat_session->id, "applicationsharing");
 623
 624         call = sipe_media_call_new(sipe_private, uri, NULL,
 625                                    SIPE_ICE_RFC_5245,
 626                                    SIPE_MEDIA_CALL_NO_UI);
 627
 628         g_free(uri);
 629
 630         stream = sipe_media_stream_add(call, "applicationsharing",
 631                                        SIPE_MEDIA_APPLICATION,
 632                                        SIPE_ICE_RFC_5245, TRUE, 0);
 633         if (!stream) {
 634                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 635                                           _("Application sharing error"),
 636                                           _("Couldn't connect application sharing"));
 637                 sipe_backend_media_hangup(call->backend_private, FALSE);
 638         }
 639
 640         sipe_media_stream_add_extra_attribute(stream, "connection", "new");
 641         sipe_media_stream_add_extra_attribute(stream, "setup", "active");
 642
 643         initialize_appshare(stream);
 644 }
 645
 646 void
 647 sipe_core_appshare_connect_conference(struct sipe_core_public *sipe_public,
 648                                       struct sipe_chat_session *chat_session,
 649                                       gboolean user_must_accept)
 650 {
 651         if (user_must_accept) {
 652                 const gchar *from;
 653
 654                 if (chat_session->appshare_ask_ctx) {
 655                         // Accept dialog already opened.
 656                         return;
 657                 }
 658
 659                 if (chat_session->title) {
 660                         from = chat_session->title;
 661                 } else if (chat_session->organizer) {
 662                         from = chat_session->organizer;
 663                 } else {
 664                         from = chat_session->id;
 665                 }
 666
 667                 chat_session->appshare_ask_ctx =
 668                                 ask_accept_applicationsharing(SIPE_CORE_PRIVATE,
 669                                                               from,
 670                                                               (SipeUserAskCb)connect_conference,
 671                                                               NULL,
 672                                                               chat_session);
 673         } else {
 674                 connect_conference(SIPE_CORE_PRIVATE, chat_session);
 675         }
 676 }
 677
 678 sipe_appshare_role
 679 sipe_appshare_get_role(struct sipe_media_call *call)
 680 {
 681         struct sipe_media_stream *stream;
 682
 683         g_return_val_if_fail(call, SIPE_APPSHARE_ROLE_NONE);
 684
 685         stream = sipe_core_media_get_stream_by_id(call, "applicationsharing");
 686
 687         if (stream) {
 688                 struct sipe_appshare *appshare;
 689
 690                 appshare = sipe_media_stream_get_data(stream);
 691                 if (appshare) {
 692 #ifdef HAVE_APPSHARE_SERVER
 693                         return appshare->server ? SIPE_APPSHARE_ROLE_PRESENTER :
 694                                                   SIPE_APPSHARE_ROLE_VIEWER;
 695 #else
 696                         return SIPE_APPSHARE_ROLE_VIEWER;
 697 #endif // HAVE_APPSHARE_SERVER
 698                 }
 699         }
 700
 701         return SIPE_APPSHARE_ROLE_NONE;
 702 }
 703
 704 #ifdef HAVE_APPSHARE_SERVER
 705 static void
 706 set_shared_display_area(rdpShadowServer *server, guint monitor_id)
 707 {
 708         if (monitor_id == 0) {
 709                 MONITOR_DEF monitors[16];
 710                 int monitor_count;
 711                 int i;
 712                 UINT16 maxWidth = 0;
 713                 UINT16 maxHeight = 0;
 714
 715                 monitor_count = shadow_enum_monitors(monitors, 16);
 716                 for (i = 0; i != monitor_count; ++i) {
 717                         MONITOR_DEF *m = &monitors[i];
 718                         if (m->right > maxWidth) {
 719                                 maxWidth = m->right;
 720                         }
 721                         if (m->bottom >  maxHeight) {
 722                                 maxHeight = m->bottom;
 723                         }
 724                 }
 725
 726                 server->subRect.top = 0;
 727                 server->subRect.left = 0;
 728                 server->subRect.right = maxWidth;
 729                 server->subRect.bottom = maxHeight;
 730                 server->shareSubRect = TRUE;
 731         } else {
 732                 // Index 0 is reserved for "whole desktop" choice.
 733                 server->selectedMonitor = monitor_id - 1;
 734         }
 735 }
 736
 737 static void
 738 candidate_pairs_established_cb(struct sipe_media_stream *stream)
 739 {
 740         struct sipe_appshare *appshare;
 741         GSocketAddress *address;
 742         GError *error = NULL;
 743         struct sockaddr_un native;
 744         rdpShadowServer* server;
 745         const gchar *server_error = NULL;
 746
 747         g_return_if_fail(sipe_strequal(stream->id, "applicationsharing"));
 748
 749         appshare = sipe_media_stream_get_data(stream);
 750
 751         server = shadow_server_new();
 752         if(!server) {
 753                 server_error = _("Could not create RDP server.");
 754         } else {
 755                 server->ipcSocket = g_strdup_printf("%s/sipe-appshare-%u-%p",
 756                                                     g_get_user_runtime_dir(),
 757                                                     getpid(), stream);
 758                 server->authentication = FALSE;
 759                 set_shared_display_area(server, appshare->monitor_id);
 760
 761                 /* Experimentally determined cap on multifrag max request size
 762                  * Lync client would accept. Higher values result in a black
 763                  * screen being displayed on the remote end.
 764                  *
 765                  * See related https://github.com/FreeRDP/FreeRDP/pull/3669. */
 766                 server->settings->MultifragMaxRequestSize = 0x3EFFFF;
 767
 768                 if(shadow_server_init(server) < 0) {
 769                         server_error = _("Could not initialize RDP server.");
 770                 } else if(shadow_server_start(server) < 0) {
 771                         server_error = _("Could not start RDP server.");
 772                 }
 773         }
 774         if (server_error) {
 775                 struct sipe_core_private *sipe_private;
 776
 777                 sipe_private = sipe_media_get_sipe_core_private(stream->call);
 778                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 779                                           _("Application sharing error"),
 780                                           server_error);
 781                 sipe_backend_media_hangup(stream->call->backend_private, TRUE);
 782                 if (server) {
 783                         shadow_server_uninit(server);
 784                         shadow_server_free(server);
 785                 }
 786                 return;
 787         }
 788
 789         appshare->server = server;
 790         appshare->socket = g_socket_new(G_SOCKET_FAMILY_UNIX,
 791                                         G_SOCKET_TYPE_STREAM,
 792                                         G_SOCKET_PROTOCOL_DEFAULT,
 793                                         &error);
 794         if (error) {
 795                 SIPE_DEBUG_ERROR("Can't create RDP server socket: %s",
 796                                  error->message);
 797                 g_error_free(error);
 798                 sipe_backend_media_hangup(stream->call->backend_private, TRUE);
 799                 return;
 800         }
 801
 802         g_socket_set_blocking(appshare->socket, FALSE);
 803
 804         native.sun_family = AF_LOCAL;
 805         strncpy(native.sun_path, server->ipcSocket, sizeof (native.sun_path) - 1);
 806         native.sun_path[sizeof (native.sun_path) - 1] = '\0';
 807         address = g_socket_address_new_from_native(&native, sizeof native);
 808
 809         g_socket_connect(appshare->socket, address, NULL, &error);
 810         if (error) {
 811                 SIPE_DEBUG_ERROR("Can't connect to RDP server: %s", error->message);
 812                 g_error_free(error);
 813                 sipe_backend_media_hangup(stream->call->backend_private, TRUE);
 814                 return;
 815         }
 816
 817         appshare->channel = g_io_channel_unix_new(g_socket_get_fd(appshare->socket));
 818
 819         // No encoding for binary data
 820         g_io_channel_set_encoding(appshare->channel, NULL, &error);
 821         if (error) {
 822                 SIPE_DEBUG_ERROR("Error setting RDP channel encoding: %s",
 823                                  error->message);
 824                 g_error_free(error);
 825                 sipe_backend_media_hangup(stream->call->backend_private, TRUE);
 826                 return;
 827         }
 828
 829         appshare->rdp_channel_readable_watch_id =
 830                         g_io_add_watch(appshare->channel, G_IO_IN | G_IO_HUP,
 831                                        rdp_channel_readable_cb, appshare);
 832
 833         // Appshare structure initialized; don't call this again.
 834         stream->candidate_pairs_established_cb = NULL;
 835 }
 836
 837 static void
 838 monitor_selected_cb(struct sipe_core_private *sipe_private, gchar *with,
 839                     guint monitor_id)
 840 {
 841         struct sipe_media_call *call;
 842         struct sipe_media_stream *stream;
 843         struct sipe_appshare *appshare;
 844
 845         if (monitor_id == SIPE_CHOICE_CANCELLED) {
 846                 g_free(with);
 847                 return;
 848         }
 849
 850         call = sipe_media_call_new(sipe_private, with, NULL, SIPE_ICE_RFC_5245,
 851                                    SIPE_MEDIA_CALL_INITIATOR |
 852                                    SIPE_MEDIA_CALL_NO_UI);
 853         g_free(with);
 854
 855         stream = sipe_media_stream_add(call, "applicationsharing",
 856                                        SIPE_MEDIA_APPLICATION,
 857                                        SIPE_ICE_RFC_5245, TRUE, 0);
 858         if (!stream) {
 859                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 860                                 _("Application sharing error"),
 861                                 _("Couldn't initialize application sharing"));
 862                 sipe_backend_media_hangup(call->backend_private, TRUE);
 863                 return;
 864         }
 865
 866         stream->candidate_pairs_established_cb = candidate_pairs_established_cb;
 867         stream->read_cb = read_cb;
 868
 869         sipe_media_stream_add_extra_attribute(stream,
 870                                               "mid",
 871                                               "1");
 872         sipe_media_stream_add_extra_attribute(stream,
 873                                               "x-applicationsharing-session-id",
 874                                               "1");
 875         sipe_media_stream_add_extra_attribute(stream,
 876                                               "x-applicationsharing-role",
 877                                               "sharer");
 878         sipe_media_stream_add_extra_attribute(stream,
 879                                               "x-applicationsharing-media-type",
 880                                               "rdp");
 881
 882         appshare = g_new0(struct sipe_appshare, 1);
 883         appshare->stream = stream;
 884         appshare->monitor_id = monitor_id;
 885
 886         sipe_media_stream_set_data(stream, appshare,
 887                                    (GDestroyNotify)sipe_appshare_free);
 888 }
 889
 890 static void
 891 present_monitor_choice(struct sipe_core_public *sipe_public, const gchar *who)
 892 {
 893         MONITOR_DEF monitors[16];
 894         int monitor_count;
 895
 896         shadow_subsystem_set_entry_builtin("X11");
 897         monitor_count = shadow_enum_monitors(monitors, 16);
 898
 899         if (monitor_count == 1) {
 900                 // Don't show choice dialog, share whole desktop right away.
 901                 monitor_selected_cb(SIPE_CORE_PRIVATE, g_strdup(who), 0);
 902         } else {
 903                 GSList *choices = NULL;
 904                 int i;
 905
 906                 choices = g_slist_append(choices, g_strdup(_("Whole desktop")));
 907
 908                 for (i = 0; i != monitor_count; ++i) {
 909                         MONITOR_DEF *mon = &monitors[i];
 910                         gchar *str = g_strdup_printf("%dx%d @ [%d, %d]",
 911                                                      mon->right - mon->left,
 912                                                      mon->bottom - mon->top,
 913                                                      mon->left,
 914                                                      mon->top);
 915
 916                         choices = g_slist_append(choices, str);
 917                 }
 918
 919                 sipe_user_ask_choice(SIPE_CORE_PRIVATE, _("Monitor to share"),
 920                                      choices,
 921                                      (SipeUserAskChoiceCb)monitor_selected_cb,
 922                                      g_strdup(who));
 923
 924                 g_slist_free_full(choices, g_free);
 925         }
 926 }
 927
 928 void
 929 sipe_core_appshare_share_desktop(struct sipe_core_public *sipe_public,
 930                                  const gchar *with)
 931 {
 932         present_monitor_choice(sipe_public, with);
 933 }
 934 #endif // HAVE_APPSHARE_SERVER
 935
 936 /*
 937   Local Variables:
 938   mode: c
 939   c-file-style: "bsd"
 940   indent-tabs-mode: t
 941   tab-width: 8
 942   End:
 943 */