src/core/sipe-ft-lync.c

   1 /**
   2  * @file sipe-ft-lync.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2014-2017 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_stream *stream;
 464
 465         ft_private = g_new0(struct sipe_file_transfer_lync, 1);
 466         sipe_mime_parts_foreach(sipmsg_find_header(msg, "Content-Type"),
 467                                 msg->body, mime_mixed_cb, ft_private);
 468
 469         if (!ft_private->file_name || !ft_private->file_size || !ft_private->sdp) {
 470                 sip_transport_response(sipe_private, msg, 488, "Not Acceptable Here", NULL);
 471                 sipe_file_transfer_lync_free(ft_private);
 472                 return;
 473         }
 474
 475         /* Use the selected SDP part of multipart SIP message to initialize
 476          * media session. */
 477         ft_private->call = process_incoming_invite_call(sipe_private,
 478                                                         msg,
 479                                                         ft_private->sdp);
 480         g_free(ft_private->sdp);
 481         ft_private->sdp = NULL;
 482
 483         if (!ft_private->call) {
 484                 sip_transport_response(sipe_private, msg, 500, "Server Internal Error", NULL);
 485                 sipe_file_transfer_lync_free(ft_private);
 486                 return;
 487         }
 488
 489         ft_private->public.ft_init = ft_lync_incoming_init;
 490         ft_private->public.ft_request_denied = ft_lync_request_denied;
 491         ft_private->public.ft_cancelled = ft_lync_incoming_cancelled;
 492         ft_private->public.ft_end = ft_lync_end;
 493
 494         ft_private->call_reject_parent_cb = ft_private->call->call_reject_cb;
 495         ft_private->call->call_reject_cb = call_reject_cb;
 496
 497         stream = sipe_core_media_get_stream_by_id(ft_private->call, "data");
 498         if (stream) {
 499                 stream->candidate_pairs_established_cb = candidate_pairs_established_cb;
 500                 stream->read_cb = read_cb;
 501                 sipe_media_stream_add_extra_attribute(stream, "recvonly", NULL);
 502                 sipe_media_stream_set_data(stream, ft_private,
 503                                            (GDestroyNotify)sipe_file_transfer_lync_free);
 504
 505                 sipe_backend_ft_incoming(SIPE_CORE_PUBLIC, SIPE_FILE_TRANSFER,
 506                                          ft_private->call->with,
 507                                          ft_private->file_name,
 508                                          ft_private->file_size);
 509         } else {
 510                 sip_transport_response(sipe_private, msg, 500, "Server Internal Error", NULL);
 511                 sipe_file_transfer_lync_free(ft_private);
 512                 return;
 513         }
 514 }
 515
 516 static void
 517 process_response_incoming(struct sipe_file_transfer_lync *ft_private,
 518                           sipe_xml *xml)
 519 {
 520         const gchar *attr;
 521         guint request_id = sipe_xml_int_attribute(xml, "requestId", 0);
 522
 523         if (request_id != ft_private->request_id) {
 524                 return;
 525         }
 526
 527         attr = sipe_xml_attribute(xml, "code");
 528         if (sipe_strequal(attr, "failure")) {
 529                 const gchar *reason = sipe_xml_attribute(xml, "reason");
 530                 if (sipe_strequal(reason, "requestCancelled")) {
 531                         sipe_backend_ft_cancel_remote(SIPE_FILE_TRANSFER);
 532                 }
 533         }
 534 }
 535
 536 static void
 537 write_chunk(struct sipe_media_stream *stream,
 538             guint8 type, guint16 len, const gchar *buffer)
 539 {
 540         guint16 len_be = GUINT16_TO_BE(len);
 541
 542         sipe_media_stream_write(stream, &type, sizeof (guint8));
 543         sipe_media_stream_write(stream, (guint8 *)&len_be, sizeof (guint16));
 544         sipe_media_stream_write(stream, (guint8 *)buffer, len);
 545 }
 546
 547 static gboolean
 548 send_file_chunk(SIPE_UNUSED_PARAMETER GIOChannel *source,
 549                 SIPE_UNUSED_PARAMETER GIOCondition condition,
 550                 gpointer data)
 551 {
 552         struct sipe_file_transfer_lync *ft_private = data;
 553         struct sipe_media_call *call = ft_private->call;
 554         struct sipe_media_stream *stream;
 555         gssize bytes_read;
 556
 557         stream = sipe_core_media_get_stream_by_id(call, "data");
 558         if (!stream) {
 559                 SIPE_DEBUG_ERROR_NOFORMAT("Couldn't find data stream");
 560                 sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 561                 ft_private->backend_pipe_write_source_id = 0;
 562                 return FALSE; /* G_SOURCE_REMOVE */
 563         }
 564
 565         if (!sipe_media_stream_is_writable(stream)) {
 566                 return TRUE; /* G_SOURCE_CONTINUE */
 567         }
 568
 569         bytes_read = read(ft_private->backend_pipe[0],
 570                           ft_private->buffer, sizeof (ft_private->buffer));
 571         if (bytes_read > 0) {
 572                 write_chunk(stream, SIPE_XDATA_DATA_CHUNK,
 573                             bytes_read, (const gchar *)ft_private->buffer);
 574         } else if (bytes_read == 0) {
 575                 /* EOF, write end of stream */
 576                 gchar *request_id_str;
 577
 578                 request_id_str = g_strdup_printf("%u", ft_private->request_id);
 579                 write_chunk(stream, SIPE_XDATA_END_OF_STREAM,
 580                             strlen(request_id_str), request_id_str);
 581                 g_free(request_id_str);
 582
 583                 return FALSE; /* G_SOURCE_REMOVE */
 584         }
 585
 586         return TRUE; /* G_SOURCE_CONTINUE */
 587 }
 588
 589 static void
 590 start_writing(struct sipe_file_transfer_lync *ft_private)
 591 {
 592         struct sipe_media_stream *stream;
 593         gchar *request_id_str;
 594         struct sipe_backend_fd *fd;
 595         GIOChannel *channel;
 596
 597         stream = sipe_core_media_get_stream_by_id(ft_private->call, "data");
 598         if (!stream) {
 599                 return;
 600         }
 601
 602         if (!create_pipe(ft_private->backend_pipe)) {
 603                 SIPE_DEBUG_ERROR_NOFORMAT("Couldn't create backend pipe");
 604                 sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER);
 605                 return;
 606         }
 607
 608         request_id_str = g_strdup_printf("%u", ft_private->request_id);
 609         write_chunk(stream, SIPE_XDATA_START_OF_STREAM,
 610                     strlen(request_id_str), request_id_str);
 611         g_free(request_id_str);
 612
 613         channel = g_io_channel_unix_new(ft_private->backend_pipe[0]);
 614         ft_private->backend_pipe_write_source_id = g_io_add_watch(channel,
 615                                                                   G_IO_IN | G_IO_HUP,
 616                                                                   send_file_chunk,
 617                                                                   ft_private);
 618         g_io_channel_unref(channel);
 619
 620         fd = sipe_backend_fd_from_int(ft_private->backend_pipe[1]);
 621         sipe_backend_ft_start(SIPE_FILE_TRANSFER, fd, NULL, 0);
 622         sipe_backend_fd_free(fd);
 623 }
 624
 625 static void
 626 process_request(struct sipe_file_transfer_lync *ft_private, sipe_xml *xml)
 627 {
 628         static const gchar *DOWNLOAD_PENDING_RESPONSE =
 629                         "<response xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 630                           "requestId=\"%u\" code=\"pending\"/>";
 631
 632         if (sipe_xml_child(xml, "downloadFile")) {
 633                 ft_private->request_id =
 634                                 atoi(sipe_xml_attribute(xml, "requestId"));
 635
 636                 send_ms_filetransfer_msg(g_strdup_printf(DOWNLOAD_PENDING_RESPONSE,
 637                                                          ft_private->request_id),
 638                                          ft_private, NULL);
 639
 640                 start_writing(ft_private);
 641         }
 642 }
 643
 644 static void
 645 process_notify(struct sipe_file_transfer_lync *ft_private, sipe_xml *xml)
 646 {
 647         static const gchar *DOWNLOAD_SUCCESS_RESPONSE =
 648                 "<response xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 649                   "requestId=\"%u\" code=\"success\"/>";
 650
 651         const sipe_xml *progress_node = sipe_xml_child(xml, "fileTransferProgress");
 652
 653         if (progress_node) {
 654                 gchar *to_str = sipe_xml_data(sipe_xml_child(progress_node, "bytesReceived/to"));
 655
 656                 if (atoi(to_str) == (int)(ft_private->file_size - 1)) {
 657                         send_ms_filetransfer_msg(g_strdup_printf(DOWNLOAD_SUCCESS_RESPONSE,
 658                                                                  ft_private->request_id),
 659                                                  ft_private, NULL);
 660                         sipe_backend_media_hangup(ft_private->call->backend_private, TRUE);
 661                 }
 662                 g_free(to_str);
 663         }
 664 }
 665
 666 void
 667 process_incoming_info_ft_lync(struct sipe_core_private *sipe_private,
 668                               struct sipmsg *msg)
 669 {
 670         struct sipe_media_call *call;
 671         struct sipe_file_transfer_lync *ft_private;
 672         sipe_xml *xml;
 673
 674         call = g_hash_table_lookup(sipe_private->media_calls,
 675                                    sipmsg_find_header(msg, "Call-ID"));
 676         if (!call) {
 677                 return;
 678         }
 679
 680         ft_private = ft_private_from_call(call);
 681         if (!ft_private) {
 682                 return;
 683         }
 684
 685         xml = sipe_xml_parse(msg->body, msg->bodylen);
 686         if (!xml) {
 687                 return;
 688         }
 689
 690         sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 691
 692         if (sipe_backend_ft_is_incoming(SIPE_FILE_TRANSFER)) {
 693                 if (sipe_strequal(sipe_xml_name(xml), "response")) {
 694                         process_response_incoming(ft_private, xml);
 695                 }
 696         } else {
 697                 if (sipe_strequal(sipe_xml_name(xml), "request")) {
 698                         process_request(ft_private, xml);
 699                 } else if (sipe_strequal(sipe_xml_name(xml), "notify")) {
 700                         process_notify(ft_private, xml);
 701                 }
 702         }
 703
 704         sipe_xml_free(xml);
 705 }
 706
 707 static void
 708 append_publish_file_invite(struct sipe_media_call *call,
 709                            struct sipe_file_transfer_lync *ft_private)
 710 {
 711         static const gchar *PUBLISH_FILE_REQUEST =
 712                         "Content-Type: application/ms-filetransfer+xml\r\n"
 713                         "Content-Transfer-Encoding: 7bit\r\n"
 714                         "Content-Disposition: render; handling=optional\r\n"
 715                         "\r\n"
 716                         "<request xmlns=\"http://schemas.microsoft.com/rtc/2009/05/filetransfer\" "
 717                           "requestId=\"%u\">"
 718                                 "<publishFile>"
 719                                         "<fileInfo>"
 720                                                 "<id>{6244F934-2EB1-443F-8E2C-48BA64AF463D}</id>"
 721                                                 "<name>%s</name>"
 722                                                 "<size>%u</size>"
 723                                         "</fileInfo>"
 724                                 "</publishFile>"
 725                         "</request>\r\n";
 726         gchar *body;
 727
 728         ft_private->request_id =
 729                         ++ft_private->sipe_private->ms_filetransfer_request_id;
 730
 731         body = g_strdup_printf(PUBLISH_FILE_REQUEST, ft_private->request_id,
 732                                ft_private->file_name, ft_private->file_size);
 733
 734         sipe_media_add_extra_invite_section(call, "multipart/mixed", body);
 735 }
 736
 737 static void
 738 ft_lync_outgoing_init(struct sipe_file_transfer *ft, const gchar *filename,
 739                       gsize size, SIPE_UNUSED_PARAMETER const gchar *who)
 740 {
 741         struct sipe_core_private *sipe_private =
 742                         SIPE_FILE_TRANSFER_PRIVATE->sipe_private;
 743         struct sipe_file_transfer_lync *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
 744         struct sipe_media_call *call;
 745         struct sipe_media_stream *stream;
 746
 747         ft_private->file_name = g_strdup(filename);
 748         ft_private->file_size = size;
 749
 750         call = sipe_media_call_new(sipe_private, who, NULL, SIPE_ICE_RFC_5245,
 751                                    SIPE_MEDIA_CALL_NO_UI);
 752
 753         ft_private->call = call;
 754
 755         ft_private->call_reject_parent_cb = call->call_reject_cb;
 756         call->call_reject_cb = call_reject_cb;
 757
 758         stream = sipe_media_stream_add(call, "data", SIPE_MEDIA_APPLICATION,
 759                                        SIPE_ICE_RFC_5245, TRUE, 0);
 760         if (!stream) {
 761                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 762                                           _("Error occurred"),
 763                                           _("Error creating data stream"));
 764
 765                 sipe_backend_media_hangup(call->backend_private, FALSE);
 766                 sipe_backend_ft_cancel_local(ft);
 767                 return;
 768         }
 769
 770         sipe_media_stream_add_extra_attribute(stream, "sendonly", NULL);
 771         sipe_media_stream_add_extra_attribute(stream, "mid", "1");
 772         sipe_media_stream_set_data(stream, ft,
 773                                    (GDestroyNotify)sipe_file_transfer_lync_free);
 774         append_publish_file_invite(call, ft_private);
 775 }
 776
 777 struct sipe_file_transfer *
 778 sipe_file_transfer_lync_new_outgoing(struct sipe_core_private *sipe_private)
 779 {
 780         struct sipe_file_transfer_lync *ft_private;
 781
 782         ft_private = g_new0(struct sipe_file_transfer_lync, 1);
 783
 784         ft_private->sipe_private = sipe_private;
 785         ft_private->public.ft_init = ft_lync_outgoing_init;
 786
 787         return SIPE_FILE_TRANSFER;
 788 }
 789
 790 /*
 791   Local Variables:
 792   mode: c
 793   c-file-style: "bsd"
 794   indent-tabs-mode: t
 795   tab-width: 8
 796   End:
 797 */