src/core/sipe-ft-lync.c

   1 /**
   2  * @file sipe-ft-lync.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2014-2016 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
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #include "sip-transport.h"
  38 #include "sipe-backend.h"
  39 #include "sipe-common.h"
  40 #include "sipe-core.h"
  41 #include "sipe-core-private.h"
  42 #include "sipe-ft-lync.h"
  43 #include "sipe-media.h"
  44 #include "sipe-mime.h"
  45 #include "sipe-nls.h"
  46 #include "sipe-utils.h"
  47 #include "sipe-xml.h"
  48 #include "sipmsg.h"
  49
  50 struct sipe_file_transfer_lync {
  51         struct sipe_file_transfer public;
  52
  53         gchar *sdp;
  54         gchar *file_name;
  55         gchar *id;
  56         gsize file_size;
  57         guint request_id;
  58
  59         guint bytes_left_in_chunk;
  60
  61         guint8 buffer[2048];
  62         guint buffer_len;
  63         guint buffer_read_pos;
  64
  65         int backend_pipe[2];
  66         int backend_pipe_write_source_id;
  67
  68         struct sipe_core_private *sipe_private;
  69         struct sipe_media_call *call;
  70
  71         void (*call_reject_parent_cb)(struct sipe_media_call *call,
  72                                       gboolean local);
  73 };
  74 #define SIPE_FILE_TRANSFER         ((struct sipe_file_transfer *) ft_private)
  75 #define SIPE_FILE_TRANSFER_PRIVATE ((struct sipe_file_transfer_lync *) ft)
  76
  77 typedef enum {
  78         SIPE_XDATA_DATA_CHUNK = 0x00,
  79         SIPE_XDATA_START_OF_STREAM = 0x01,
  80         SIPE_XDATA_END_OF_STREAM = 0x02
  81 } SipeXDataMessages;
  82
  83 #define XDATA_HEADER_SIZE sizeof (guint8) + sizeof (guint16)
  84
  85 static void
  86 sipe_file_transfer_lync_free(struct sipe_file_transfer_lync *ft_private)
  87 {
  88         int our_pipe_end;
  89
  90         our_pipe_end = sipe_backend_ft_is_incoming(SIPE_FILE_TRANSFER) ? 1 : 0;
  91
  92         if (ft_private->backend_pipe[our_pipe_end] != 0) {
  93                 // Backend is responsible for closing the pipe's other end.
  94                 close(ft_private->backend_pipe[our_pipe_end]);
  95         }
  96
  97         g_free(ft_private->file_name);
  98         g_free(ft_private->sdp);
  99         g_free(ft_private->id);
 100
 101         if (ft_private->backend_pipe_write_source_id) {
 102                 g_source_remove(ft_private->backend_pipe_write_source_id);
 103         }
 104
 105         g_free(ft_private);
 106 }
 107
 108 static void
 109 send_ms_filetransfer_msg(char *body, struct sipe_file_transfer_lync *ft_private,
 110                          TransCallback callback)
 111 {
 112         sip_transport_info(sipe_media_get_sipe_core_private(ft_private->call),
 113                            "Content-Type: application/ms-filetransfer+xml\r\n",
 114                            body,
 115                            sipe_media_get_sip_dialog(ft_private->call),
 116                            callback);
 117
 118         g_free(body);
 119 }
 120
 121 static void
 122 send_ms_filetransfer_response(struct sipe_file_transfer_lync *ft_private,
 123                               const gchar *code, const gchar *reason,
 124                               TransCallback callback)
 125 {
 126         static const gchar *RESPONSE_STR =
 127                         "<response xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" requestId=\"%d\" code=\"%s\" %s%s%s/>";
 128
 129         send_ms_filetransfer_msg(g_strdup_printf(RESPONSE_STR,
 130                                                  ft_private->request_id, code,
 131                                                  reason ? "reason=\"" : "",
 132                                                  reason ? reason : "",
 133                                                  reason ? "\"" : ""),
 134                                  ft_private, callback);
 135 }
 136
 137 static void
 138 mime_mixed_cb(gpointer user_data, const GSList *fields, const gchar *body,
 139               gsize length)
 140 {
 141         struct sipe_file_transfer_lync *ft_private = user_data;
 142         const gchar *ctype = sipe_utils_nameval_find(fields, "Content-Type");
 143
 144         /* Lync 2010 file transfer */
 145         if (g_str_has_prefix(ctype, "application/ms-filetransfer+xml")) {
 146                 sipe_xml *xml = sipe_xml_parse(body, length);
 147
 148                 if (xml) {
 149                         const sipe_xml *node;
 150
 151                         ft_private->request_id = sipe_xml_int_attribute(xml,
 152                                                                         "requestId",
 153                                                                         ft_private->request_id);
 154
 155                         node = sipe_xml_child(xml, "publishFile/fileInfo/name");
 156                         if (node) {
 157                                 g_free(ft_private->file_name);
 158                                 ft_private->file_name = sipe_xml_data(node);
 159                         }
 160
 161                         node = sipe_xml_child(xml, "publishFile/fileInfo/id");
 162                         if (node) {
 163                                 g_free(ft_private->id);
 164                                 ft_private->id = sipe_xml_data(node);
 165                         }
 166
 167                         node = sipe_xml_child(xml, "publishFile/fileInfo/size");
 168                         if (node) {
 169                                 gchar *size_str = sipe_xml_data(node);
 170                                 if (size_str) {
 171                                         ft_private->file_size = atoi(size_str);
 172                                         g_free(size_str);
 173                                 }
 174                         }
 175
 176                         sipe_xml_free(xml);
 177                 }
 178         } else if (g_str_has_prefix(ctype, "application/sdp")) {
 179                 g_free(ft_private->sdp);
 180                 ft_private->sdp = g_strndup(body, length);
 181         }
 182 }
 183
 184 static void
 185 candidate_pairs_established_cb(struct sipe_media_stream *stream)
 186 {
 187         struct sipe_file_transfer_lync *ft_private;
 188         static const gchar *DOWNLOAD_FILE_REQUEST =
 189                 "<request xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" requestId=\"%d\">"
 190                         "<downloadFile>"
 191                                 "<fileInfo>"
 192                                         "<id>%s</id>"
 193                                         "<name>%s</name>"
 194                                 "</fileInfo>"
 195                         "</downloadFile>"
 196                 "</request>";
 197
 198         g_return_if_fail(sipe_strequal(stream->id, "data"));
 199
 200         ft_private = sipe_media_stream_get_data(stream);
 201
 202         send_ms_filetransfer_response(ft_private, "success", NULL, NULL);
 203
 204         send_ms_filetransfer_msg(g_strdup_printf(DOWNLOAD_FILE_REQUEST,
 205                                                  ++ft_private->request_id,
 206                                                  ft_private->id,
 207                                                  ft_private->file_name),
 208                                  ft_private, NULL);
 209 }
 210
 211 static gboolean
 212 create_pipe(int pipefd[2])
 213 {
 214 #ifdef _WIN32
 215 #error "Pipes not implemented for Windows"
 216 /* Those interested in porting the code may use Pidgin's wpurple_input_pipe() in
 217  * win32dep.c as an inspiration. */
 218 #else
 219         if (pipe(pipefd) != 0) {
 220                 return FALSE;
 221         }
 222
 223         /* @TODO: ignoring potential error return - how to handle? */
 224         (void) fcntl(pipefd[0], F_SETFL, fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
 225         (void) fcntl(pipefd[1], F_SETFL, fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
 226
 227         return TRUE;
 228 #endif
 229 }
 230
 231 static void
 232 xdata_start_of_stream_cb(struct sipe_media_stream *stream,
 233                          guint8 *buffer, gsize len)
 234 {
 235         struct sipe_file_transfer_lync *ft_private =
 236                         sipe_media_stream_get_data(stream);
 237         struct sipe_backend_fd *fd;
 238
 239         buffer[len] = 0;
 240         SIPE_DEBUG_INFO("Received new stream for requestId : %s", buffer);
 241
 242         if (!create_pipe(ft_private->backend_pipe)) {
 243                 SIPE_DEBUG_ERROR_NOFORMAT("Couldn't create backend pipe");
 244                 sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 245                 return;
 246         }
 247
 248         fd = sipe_backend_fd_from_int(ft_private->backend_pipe[0]);
 249         sipe_backend_ft_start(SIPE_FILE_TRANSFER, fd, NULL, 0);
 250         sipe_backend_fd_free(fd);
 251 }
 252
 253 static void
 254 xdata_end_of_stream_cb(SIPE_UNUSED_PARAMETER struct sipe_media_stream *stream,
 255                        guint8 *buffer, gsize len)
 256 {
 257         buffer[len] = 0;
 258         SIPE_DEBUG_INFO("Received end of stream for requestId : %s", buffer);
 259 }
 260
 261 static void
 262 xdata_got_header_cb(struct sipe_media_stream *stream,
 263                     guint8 *buffer,
 264                     SIPE_UNUSED_PARAMETER gsize len)
 265 {
 266         struct sipe_file_transfer_lync *ft_private =
 267                         sipe_media_stream_get_data(stream);
 268
 269         guint8 type = buffer[0];
 270         guint16 size = (buffer[1] << 8) + buffer[2]; /* stored as big-endian */
 271
 272         switch (type) {
 273                 case SIPE_XDATA_START_OF_STREAM:
 274                         sipe_media_stream_read_async(stream,
 275                                                      ft_private->buffer, size,
 276                                                      xdata_start_of_stream_cb);
 277                         break;
 278                 case SIPE_XDATA_DATA_CHUNK:
 279                         SIPE_DEBUG_INFO("Received new data chunk of size %d",
 280                                         size);
 281                         ft_private->bytes_left_in_chunk = size;
 282                         break;
 283                         /* We'll read the data when read_cb is called again. */
 284                 case SIPE_XDATA_END_OF_STREAM:
 285                         sipe_media_stream_read_async(stream,
 286                                                      ft_private->buffer, size,
 287                                                      xdata_end_of_stream_cb);
 288                         break;
 289         }
 290 }
 291
 292 static void
 293 read_cb(struct sipe_media_stream *stream)
 294 {
 295         struct sipe_file_transfer_lync *ft_private =
 296                         sipe_media_stream_get_data(stream);
 297
 298         if (ft_private->buffer_read_pos < ft_private->buffer_len) {
 299                 /* Have data in buffer, write them to the backend. */
 300
 301                 gpointer buffer;
 302                 size_t len;
 303                 ssize_t written;
 304
 305                 buffer = ft_private->buffer + ft_private->buffer_read_pos;
 306                 len = ft_private->buffer_len - ft_private->buffer_read_pos;
 307                 written = write(ft_private->backend_pipe[1], buffer, len);
 308
 309                 if (written > 0) {
 310                         ft_private->buffer_read_pos += written;
 311                 } else if (written < 0 && errno != EAGAIN) {
 312                         SIPE_DEBUG_ERROR_NOFORMAT("Error while writing into "
 313                                                   "backend pipe");
 314                         sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 315                         return;
 316                 }
 317         } else if (ft_private->bytes_left_in_chunk != 0) {
 318                 /* Have data from the sender, replenish our buffer with it. */
 319
 320                 ft_private->buffer_len = MIN(ft_private->bytes_left_in_chunk,
 321                                              sizeof (ft_private->buffer));
 322
 323                 ft_private->buffer_len =
 324                                 sipe_backend_media_stream_read(stream,
 325                                                                ft_private->buffer,
 326                                                                ft_private->buffer_len);
 327
 328                 ft_private->bytes_left_in_chunk -= ft_private->buffer_len;
 329                 ft_private->buffer_read_pos = 0;
 330
 331                 SIPE_DEBUG_INFO("Read %d bytes. %d left in this chunk.",
 332                                 ft_private->buffer_len, ft_private->bytes_left_in_chunk);
 333         } else {
 334                 /* No data available. This is either stream start, beginning of
 335                  * chunk, or stream end. */
 336
 337                 sipe_media_stream_read_async(stream, ft_private->buffer,
 338                                              XDATA_HEADER_SIZE,
 339                                              xdata_got_header_cb);
 340         }
 341 }
 342
 343 static void
 344 ft_lync_incoming_init(struct sipe_file_transfer *ft,
 345                       SIPE_UNUSED_PARAMETER const gchar *filename,
 346                       SIPE_UNUSED_PARAMETER gsize size,
 347                       SIPE_UNUSED_PARAMETER const gchar *who)
 348 {
 349         struct sipe_media_call *call = SIPE_FILE_TRANSFER_PRIVATE->call;
 350
 351         if (call) {
 352                 sipe_backend_media_accept(call->backend_private, TRUE);
 353         }
 354 }
 355
 356 static void
 357 ft_lync_request_denied(struct sipe_file_transfer *ft)
 358 {
 359         struct sipe_file_transfer_lync *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
 360         struct sipe_media_call *call;
 361
 362         g_return_if_fail(ft_private);
 363
 364         call = ft_private->call;
 365
 366         if (call && call->backend_private) {
 367                 sipe_backend_media_reject(call->backend_private, TRUE);
 368         }
 369 }
 370
 371 static struct sipe_file_transfer_lync *
 372 ft_private_from_call(struct sipe_media_call *call)
 373 {
 374         struct sipe_media_stream *stream =
 375                         sipe_core_media_get_stream_by_id(call, "data");
 376         g_return_val_if_fail(stream, NULL);
 377
 378         return sipe_media_stream_get_data(stream);
 379 }
 380
 381 static void
 382 send_transfer_progress(struct sipe_file_transfer_lync *ft_private)
 383 {
 384         static const gchar *FILETRANSFER_PROGRESS =
 385                         "<notify xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" notifyId=\"%d\">"
 386                                 "<fileTransferProgress>"
 387                                         "<transferId>%d</transferId>"
 388                                         "<bytesReceived>"
 389                                                 "<from>0</from>"
 390                                                 "<to>%d</to>"
 391                                         "</bytesReceived>"
 392                                 "</fileTransferProgress>"
 393                         "</notify>";
 394
 395         send_ms_filetransfer_msg(g_strdup_printf(FILETRANSFER_PROGRESS,
 396                                                  rand(),
 397                                                  ft_private->request_id,
 398                                                  ft_private->file_size - 1),
 399                                  ft_private, NULL);
 400 }
 401
 402 static gboolean
 403 ft_lync_end(struct sipe_file_transfer *ft)
 404 {
 405         send_transfer_progress(SIPE_FILE_TRANSFER_PRIVATE);
 406
 407         return TRUE;
 408 }
 409
 410 static void
 411 call_reject_cb(struct sipe_media_call *call, gboolean local)
 412 {
 413         struct sipe_file_transfer_lync *ft_private = ft_private_from_call(call);
 414         g_return_if_fail(ft_private);
 415
 416         if (ft_private->call_reject_parent_cb) {
 417                 ft_private->call_reject_parent_cb(call, local);
 418         }
 419
 420         if (!local) {
 421                 sipe_backend_ft_cancel_remote(&ft_private->public);
 422         }
 423 }
 424
 425 static void
 426 ft_lync_incoming_cancelled(struct sipe_file_transfer *ft)
 427 {
 428         static const gchar *FILETRANSFER_CANCEL_REQUEST =
 429                         "<request xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" requestId=\"%d\"/>"
 430                                 "<cancelTransfer>"
 431                                         "<transferId>%d</transferId>"
 432                                         "<fileInfo>"
 433                                                 "<id>%s</id>"
 434                                                 "<name>%s</name>"
 435                                         "</fileInfo>"
 436                                 "</cancelTransfer>"
 437                         "</request>";
 438
 439         struct sipe_file_transfer_lync *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
 440         struct sipe_media_stream *stream;
 441
 442         send_ms_filetransfer_msg(g_strdup_printf(FILETRANSFER_CANCEL_REQUEST,
 443                                                  ft_private->request_id + 1,
 444                                                  ft_private->request_id,
 445                                                  ft_private->id,
 446                                                  ft_private->file_name),
 447                                  ft_private,
 448                                  NULL);
 449
 450         stream = sipe_core_media_get_stream_by_id(ft_private->call, "data");
 451         if (stream) {
 452                 stream->read_cb = NULL;
 453         }
 454
 455         sipe_backend_media_hangup(ft_private->call->backend_private, FALSE);
 456 }
 457
 458 void
 459 process_incoming_invite_ft_lync(struct sipe_core_private *sipe_private,
 460                                 struct sipmsg *msg)
 461 {
 462         struct sipe_file_transfer_lync *ft_private;
 463         struct sipe_media_call *call;
 464         struct sipe_media_stream *stream;
 465
 466         ft_private = g_new0(struct sipe_file_transfer_lync, 1);
 467         sipe_mime_parts_foreach(sipmsg_find_header(msg, "Content-Type"),
 468                                 msg->body, mime_mixed_cb, ft_private);
 469
 470         if (!ft_private->file_name || !ft_private->file_size || !ft_private->sdp) {
 471                 sip_transport_response(sipe_private, msg, 488, "Not Acceptable Here", NULL);
 472                 sipe_file_transfer_lync_free(ft_private);
 473                 return;
 474         }
 475
 476         /* Replace multipart message body with the selected SDP part and
 477          * initialize media session as if invited to a media call. */
 478         g_free(msg->body);
 479         msg->body = ft_private->sdp;
 480         msg->bodylen = strlen(msg->body);
 481         ft_private->sdp = NULL;
 482
 483         ft_private->call = process_incoming_invite_call(sipe_private, msg);
 484         if (!ft_private->call) {
 485                 sip_transport_response(sipe_private, msg, 500, "Server Internal Error", NULL);
 486                 sipe_file_transfer_lync_free(ft_private);
 487                 return;
 488         }
 489
 490         call = ft_private->call;
 491
 492         ft_private->public.ft_init = ft_lync_incoming_init;
 493         ft_private->public.ft_request_denied = ft_lync_request_denied;
 494         ft_private->public.ft_cancelled = ft_lync_incoming_cancelled;
 495         ft_private->public.ft_end = ft_lync_end;
 496
 497         ft_private->call_reject_parent_cb = call->call_reject_cb;
 498         call->call_reject_cb = call_reject_cb;
 499
 500         stream = sipe_core_media_get_stream_by_id(call, "data");
 501         stream->candidate_pairs_established_cb = candidate_pairs_established_cb;
 502         stream->read_cb = read_cb;
 503         sipe_media_stream_add_extra_attribute(stream, "recvonly", NULL);
 504         sipe_media_stream_set_data(stream, ft_private,
 505                                    (GDestroyNotify)sipe_file_transfer_lync_free);
 506
 507         sipe_backend_ft_incoming(SIPE_CORE_PUBLIC, SIPE_FILE_TRANSFER,
 508                                  call->with, ft_private->file_name,
 509                                  ft_private->file_size);
 510 }
 511
 512 static void
 513 process_response_incoming(struct sipe_file_transfer_lync *ft_private,
 514                           sipe_xml *xml)
 515 {
 516         const gchar *attr;
 517         guint request_id = sipe_xml_int_attribute(xml, "requestId", 0);
 518
 519         if (request_id != ft_private->request_id) {
 520                 return;
 521         }
 522
 523         attr = sipe_xml_attribute(xml, "code");
 524         if (sipe_strequal(attr, "failure")) {
 525                 const gchar *reason = sipe_xml_attribute(xml, "reason");
 526                 if (sipe_strequal(reason, "requestCancelled")) {
 527                         sipe_backend_ft_cancel_remote(SIPE_FILE_TRANSFER);
 528                 }
 529         }
 530 }
 531
 532 static void
 533 write_chunk(struct sipe_media_stream *stream,
 534             guint8 type, guint16 len, const gchar *buffer)
 535 {
 536         guint16 len_be = GUINT16_TO_BE(len);
 537
 538         sipe_media_stream_write(stream, &type, sizeof (guint8));
 539         sipe_media_stream_write(stream, (guint8 *)&len_be, sizeof (guint16));
 540         sipe_media_stream_write(stream, (guint8 *)buffer, len);
 541 }
 542
 543 static gboolean
 544 send_file_chunk(SIPE_UNUSED_PARAMETER GIOChannel *source,
 545                 SIPE_UNUSED_PARAMETER GIOCondition condition,
 546                 gpointer data)
 547 {
 548         struct sipe_file_transfer_lync *ft_private = data;
 549         struct sipe_media_call *call = ft_private->call;
 550         struct sipe_media_stream *stream;
 551         gssize bytes_read;
 552
 553         stream = sipe_core_media_get_stream_by_id(call, "data");
 554         if (!stream) {
 555                 SIPE_DEBUG_ERROR_NOFORMAT("Couldn't find data stream");
 556                 sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 557                 ft_private->backend_pipe_write_source_id = 0;
 558                 return FALSE; /* G_SOURCE_REMOVE */
 559         }
 560
 561         if (!sipe_media_stream_is_writable(stream)) {
 562                 return TRUE; /* G_SOURCE_CONTINUE */
 563         }
 564
 565         bytes_read = read(ft_private->backend_pipe[0],
 566                           ft_private->buffer, sizeof (ft_private->buffer));
 567         if (bytes_read > 0) {
 568                 write_chunk(stream, SIPE_XDATA_DATA_CHUNK,
 569                             bytes_read, (const gchar *)ft_private->buffer);
 570         } else if (bytes_read == 0) {
 571                 /* EOF, write end of stream */
 572                 gchar *request_id_str;
 573
 574                 request_id_str = g_strdup_printf("%u", ft_private->request_id);
 575                 write_chunk(stream, SIPE_XDATA_END_OF_STREAM,
 576                             strlen(request_id_str), request_id_str);
 577                 g_free(request_id_str);
 578
 579                 return FALSE; /* G_SOURCE_REMOVE */
 580         }
 581
 582         return TRUE; /* G_SOURCE_CONTINUE */
 583 }
 584
 585 static void
 586 start_writing(struct sipe_file_transfer_lync *ft_private)
 587 {
 588         struct sipe_media_stream *stream;
 589         gchar *request_id_str;
 590         struct sipe_backend_fd *fd;
 591         GIOChannel *channel;
 592
 593         stream = sipe_core_media_get_stream_by_id(ft_private->call, "data");
 594         if (!stream) {
 595                 return;
 596         }
 597
 598         if (!create_pipe(ft_private->backend_pipe)) {
 599                 SIPE_DEBUG_ERROR_NOFORMAT("Couldn't create backend pipe");
 600                 sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 601                 return;
 602         }
 603
 604         request_id_str = g_strdup_printf("%u", ft_private->request_id);
 605         write_chunk(stream, SIPE_XDATA_START_OF_STREAM,
 606                     strlen(request_id_str), request_id_str);
 607         g_free(request_id_str);
 608
 609         channel = g_io_channel_unix_new(ft_private->backend_pipe[0]);
 610         ft_private->backend_pipe_write_source_id = g_io_add_watch(channel,
 611                                                                   G_IO_IN | G_IO_HUP,
 612                                                                   send_file_chunk,
 613                                                                   ft_private);
 614         g_io_channel_unref(channel);
 615
 616         fd = sipe_backend_fd_from_int(ft_private->backend_pipe[1]);
 617         sipe_backend_ft_start(SIPE_FILE_TRANSFER, fd, NULL, 0);
 618         sipe_backend_fd_free(fd);
 619 }
 620
 621 static void
 622 process_request(struct sipe_file_transfer_lync *ft_private, sipe_xml *xml)
 623 {
 624         static const gchar *DOWNLOAD_PENDING_RESPONSE =
 625                         "<response xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 626                           "requestId=\"%u\" code=\"pending\"/>";
 627
 628         if (sipe_xml_child(xml, "downloadFile")) {
 629                 ft_private->request_id =
 630                                 atoi(sipe_xml_attribute(xml, "requestId"));
 631
 632                 send_ms_filetransfer_msg(g_strdup_printf(DOWNLOAD_PENDING_RESPONSE,
 633                                                          ft_private->request_id),
 634                                          ft_private, NULL);
 635
 636                 start_writing(ft_private);
 637         }
 638 }
 639
 640 static void
 641 process_notify(struct sipe_file_transfer_lync *ft_private, sipe_xml *xml)
 642 {
 643         static const gchar *DOWNLOAD_SUCCESS_RESPONSE =
 644                 "<response xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 645                   "requestId=\"%u\" code=\"success\"/>";
 646
 647         const sipe_xml *progress_node = sipe_xml_child(xml, "fileTransferProgress");
 648
 649         if (progress_node) {
 650                 gchar *to_str = sipe_xml_data(sipe_xml_child(progress_node, "bytesReceived/to"));
 651
 652                 if (atoi(to_str) == (int)(ft_private->file_size - 1)) {
 653                         send_ms_filetransfer_msg(g_strdup_printf(DOWNLOAD_SUCCESS_RESPONSE,
 654                                                                  ft_private->request_id),
 655                                                  ft_private, NULL);
 656                         sipe_backend_media_hangup(ft_private->call->backend_private, TRUE);
 657                 }
 658                 g_free(to_str);
 659         }
 660 }
 661
 662 void
 663 process_incoming_info_ft_lync(struct sipe_core_private *sipe_private,
 664                               struct sipmsg *msg)
 665 {
 666         struct sipe_media_call *call;
 667         struct sipe_file_transfer_lync *ft_private;
 668         sipe_xml *xml;
 669
 670         call = g_hash_table_lookup(sipe_private->media_calls,
 671                                    sipmsg_find_header(msg, "Call-ID"));
 672         if (!call) {
 673                 return;
 674         }
 675
 676         ft_private = ft_private_from_call(call);
 677         if (!ft_private) {
 678                 return;
 679         }
 680
 681         xml = sipe_xml_parse(msg->body, msg->bodylen);
 682         if (!xml) {
 683                 return;
 684         }
 685
 686         sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 687
 688         if (sipe_backend_ft_is_incoming(SIPE_FILE_TRANSFER)) {
 689                 if (sipe_strequal(sipe_xml_name(xml), "response")) {
 690                         process_response_incoming(ft_private, xml);
 691                 }
 692         } else {
 693                 if (sipe_strequal(sipe_xml_name(xml), "request")) {
 694                         process_request(ft_private, xml);
 695                 } else if (sipe_strequal(sipe_xml_name(xml), "notify")) {
 696                         process_notify(ft_private, xml);
 697                 }
 698         }
 699
 700         sipe_xml_free(xml);
 701 }
 702
 703 static void
 704 append_publish_file_invite(struct sipe_media_call *call,
 705                            struct sipe_file_transfer_lync *ft_private)
 706 {
 707         static const gchar *PUBLISH_FILE_REQUEST =
 708                         "Content-Type: application/ms-filetransfer+xml\r\n"
 709                         "Content-Transfer-Encoding: 7bit\r\n"
 710                         "Content-Disposition: render; handling=optional\r\n"
 711                         "\r\n"
 712                         "<request xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 713                           "requestId=\"%u\">"
 714                                 "<publishFile>"
 715                                         "<fileInfo>"
 716                                                 "<id>{6244F934-2EB1-443F-8E2C-48BA64AF463D}</id>"
 717                                                 "<name>%s</name>"
 718                                                 "<size>%u</size>"
 719                                         "</fileInfo>"
 720                                 "</publishFile>"
 721                         "</request>\r\n";
 722         gchar *body;
 723
 724         ft_private->request_id =
 725                         ++ft_private->sipe_private->ms_filetransfer_request_id;
 726
 727         body = g_strdup_printf(PUBLISH_FILE_REQUEST, ft_private->request_id,
 728                                ft_private->file_name, ft_private->file_size);
 729
 730         sipe_media_add_extra_invite_section(call, "multipart/mixed", body);
 731 }
 732
 733 static void
 734 ft_lync_outgoing_init(struct sipe_file_transfer *ft, const gchar *filename,
 735                       gsize size, SIPE_UNUSED_PARAMETER const gchar *who)
 736 {
 737         struct sipe_core_private *sipe_private =
 738                         SIPE_FILE_TRANSFER_PRIVATE->sipe_private;
 739         struct sipe_file_transfer_lync *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
 740         struct sipe_media_call *call;
 741         struct sipe_media_stream *stream;
 742
 743         ft_private->file_name = g_strdup(filename);
 744         ft_private->file_size = size;
 745
 746         call = sipe_media_call_new(sipe_private, who, NULL, SIPE_ICE_RFC_5245,
 747                                    SIPE_MEDIA_CALL_NO_UI);
 748
 749         ft_private->call = call;
 750
 751         ft_private->call_reject_parent_cb = call->call_reject_cb;
 752         call->call_reject_cb = call_reject_cb;
 753
 754         stream = sipe_media_stream_add(call, "data", SIPE_MEDIA_APPLICATION,
 755                                        SIPE_ICE_RFC_5245, TRUE, 0);
 756         if (!stream) {
 757                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 758                                           _("Error occurred"),
 759                                           _("Error creating data stream"));
 760
 761                 sipe_backend_media_hangup(call->backend_private, FALSE);
 762                 sipe_backend_ft_cancel_local(ft);
 763                 return;
 764         }
 765
 766         sipe_media_stream_add_extra_attribute(stream, "sendonly", NULL);
 767         sipe_media_stream_add_extra_attribute(stream, "mid", "1");
 768         sipe_media_stream_set_data(stream, ft,
 769                                    (GDestroyNotify)sipe_file_transfer_lync_free);
 770         append_publish_file_invite(call, ft_private);
 771 }
 772
 773 struct sipe_file_transfer *
 774 sipe_file_transfer_lync_new_outgoing(struct sipe_core_private *sipe_private)
 775 {
 776         struct sipe_file_transfer_lync *ft_private;
 777
 778         ft_private = g_new0(struct sipe_file_transfer_lync, 1);
 779
 780         ft_private->sipe_private = sipe_private;
 781         ft_private->public.ft_init = ft_lync_outgoing_init;
 782
 783         return SIPE_FILE_TRANSFER;
 784 }
 785
 786 /*
 787   Local Variables:
 788   mode: c
 789   c-file-style: "bsd"
 790   indent-tabs-mode: t
 791   tab-width: 8
 792   End:
 793 */