libempathy/empathy-ft-handler.c

   1 /*
   2  * empathy-ft-handler.c - Source for EmpathyFTHandler
   3  * Copyright (C) 2009 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Author: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
  20  */
  21
  22 /* empathy-ft-handler.c */
  23
  24 #include <glib.h>
  25 #include <glib/gi18n.h>
  26 #include <telepathy-glib/util.h>
  27
  28 #include "empathy-ft-handler.h"
  29 #include "empathy-tp-contact-factory.h"
  30 #include "empathy-dispatcher.h"
  31 #include "empathy-marshal.h"
  32 #include "empathy-time.h"
  33 #include "empathy-utils.h"
  34
  35 #define DEBUG_FLAG EMPATHY_DEBUG_FT
  36 #include "empathy-debug.h"
  37
  38 G_DEFINE_TYPE (EmpathyFTHandler, empathy_ft_handler, G_TYPE_OBJECT)
  39
  40 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTHandler)
  41
  42 #define BUFFER_SIZE 4096
  43
  44 enum {
  45   PROP_TP_FILE = 1,
  46   PROP_G_FILE,
  47   PROP_CONTACT,
  48   PROP_USE_HASH
  49 };
  50
  51 enum {
  52   HASHING_STARTED,
  53   HASHING_PROGRESS,
  54   HASHING_DONE,
  55   TRANSFER_STARTED,
  56   TRANSFER_PROGRESS,
  57   TRANSFER_DONE,
  58   TRANSFER_ERROR,
  59   LAST_SIGNAL
  60 };
  61
  62 typedef struct {
  63   GInputStream *stream;
  64   GError *error;
  65   guchar *buffer;
  66   GChecksum *checksum;
  67   gssize total_read;
  68   guint64 total_bytes;
  69   EmpathyFTHandler *handler;
  70 } HashingData;
  71
  72 typedef struct {
  73   EmpathyFTHandlerReadyCallback callback;
  74   gpointer user_data;
  75   EmpathyFTHandler *handler;
  76 } CallbacksData;
  77
  78 /* private data */
  79 typedef struct {
  80   gboolean dispose_run;
  81
  82   GFile *gfile;
  83   EmpathyTpFile *tpfile;
  84   GCancellable *cancellable;
  85   gboolean use_hash;
  86
  87   /* request for the new transfer */
  88   GHashTable *request;
  89
  90   /* transfer properties */
  91   EmpathyContact *contact;
  92   gchar *content_type;
  93   gchar *filename;
  94   gchar *description;
  95   guint64 total_bytes;
  96   guint64 transferred_bytes;
  97   guint64 mtime;
  98   gchar *content_hash;
  99   TpFileHashType content_hash_type;
 100   TpFileTransferState current_state;
 101
 102   /* time and speed */
 103   gdouble speed;
 104   guint remaining_time;
 105   time_t last_update_time;
 106
 107   gboolean is_completed;
 108 } EmpathyFTHandlerPriv;
 109
 110 static guint signals[LAST_SIGNAL] = { 0 };
 111
 112 static gboolean do_hash_job_incoming (GIOSchedulerJob *job,
 113     GCancellable *cancellable, gpointer user_data);
 114
 115 /* GObject implementations */
 116 static void
 117 do_get_property (GObject *object,
 118                  guint property_id,
 119                  GValue *value,
 120                  GParamSpec *pspec)
 121 {
 122   EmpathyFTHandlerPriv *priv = GET_PRIV (object);
 123
 124   switch (property_id)
 125     {
 126       case PROP_CONTACT:
 127         g_value_set_object (value, priv->contact);
 128         break;
 129       case PROP_G_FILE:
 130         g_value_set_object (value, priv->gfile);
 131         break;
 132       case PROP_TP_FILE:
 133         g_value_set_object (value, priv->tpfile);
 134         break;
 135       case PROP_USE_HASH:
 136         g_value_set_boolean (value, priv->use_hash);
 137         break;
 138       default:
 139         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 140     }
 141 }
 142
 143 static void
 144 do_set_property (GObject *object,
 145                  guint property_id,
 146                  const GValue *value,
 147                  GParamSpec *pspec)
 148 {
 149   EmpathyFTHandlerPriv *priv = GET_PRIV (object);
 150
 151   switch (property_id)
 152     {
 153       case PROP_CONTACT:
 154         priv->contact = g_value_dup_object (value);
 155         break;
 156       case PROP_G_FILE:
 157         priv->gfile = g_value_dup_object (value);
 158         break;
 159       case PROP_TP_FILE:
 160         priv->tpfile = g_value_dup_object (value);
 161         break;
 162       case PROP_USE_HASH:
 163         priv->use_hash = g_value_get_boolean (value);
 164         break;
 165       default:
 166         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 167     }
 168 }
 169
 170 static void
 171 do_dispose (GObject *object)
 172 {
 173   EmpathyFTHandlerPriv *priv = GET_PRIV (object);
 174
 175   if (priv->dispose_run)
 176     return;
 177
 178   priv->dispose_run = TRUE;
 179
 180   if (priv->contact) {
 181     g_object_unref (priv->contact);
 182     priv->contact = NULL;
 183   }
 184
 185   if (priv->gfile) {
 186     g_object_unref (priv->gfile);
 187     priv->gfile = NULL;
 188   }
 189
 190   if (priv->tpfile) {
 191     empathy_tp_file_close (priv->tpfile);
 192     g_object_unref (priv->tpfile);
 193     priv->tpfile = NULL;
 194   }
 195
 196   if (priv->cancellable) {
 197     g_object_unref (priv->cancellable);
 198     priv->cancellable = NULL;
 199   }
 200
 201   if (priv->request != NULL)
 202     {
 203       g_hash_table_unref (priv->request);
 204       priv->request = NULL;
 205     }
 206
 207   G_OBJECT_CLASS (empathy_ft_handler_parent_class)->dispose (object);
 208 }
 209
 210 static void
 211 do_finalize (GObject *object)
 212 {
 213   EmpathyFTHandlerPriv *priv = GET_PRIV (object);
 214
 215   DEBUG ("%p", object);
 216
 217   g_free (priv->content_type);
 218   priv->content_type = NULL;
 219
 220   g_free (priv->filename);
 221   priv->filename = NULL;
 222
 223   g_free (priv->description);
 224   priv->description = NULL;
 225
 226   g_free (priv->content_hash);
 227   priv->content_hash = NULL;
 228
 229   G_OBJECT_CLASS (empathy_ft_handler_parent_class)->finalize (object);
 230 }
 231
 232 static void
 233 empathy_ft_handler_class_init (EmpathyFTHandlerClass *klass)
 234 {
 235   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 236   GParamSpec *param_spec;
 237
 238   g_type_class_add_private (klass, sizeof (EmpathyFTHandlerPriv));
 239
 240   object_class->get_property = do_get_property;
 241   object_class->set_property = do_set_property;
 242   object_class->dispose = do_dispose;
 243   object_class->finalize = do_finalize;
 244
 245   /* properties */
 246   param_spec = g_param_spec_object ("contact",
 247     "contact", "The remote contact",
 248     EMPATHY_TYPE_CONTACT,
 249     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
 250   g_object_class_install_property (object_class, PROP_CONTACT, param_spec);
 251
 252   param_spec = g_param_spec_object ("gfile",
 253     "gfile", "The GFile we're handling",
 254     G_TYPE_FILE,
 255     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 256   g_object_class_install_property (object_class, PROP_G_FILE, param_spec);
 257
 258   param_spec = g_param_spec_object ("tp-file",
 259     "tp-file", "The file's channel wrapper",
 260     EMPATHY_TYPE_TP_FILE,
 261     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY);
 262   g_object_class_install_property (object_class, PROP_TP_FILE, param_spec);
 263
 264   param_spec = g_param_spec_boolean ("use-hash",
 265     "use-hash", "Whether we should use checksum when sending or receiving",
 266     FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 267   g_object_class_install_property (object_class, PROP_USE_HASH, param_spec);
 268
 269   /* signals */
 270   signals[TRANSFER_STARTED] =
 271     g_signal_new ("transfer-started", G_TYPE_FROM_CLASS (klass),
 272         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 273         g_cclosure_marshal_VOID__OBJECT,
 274         G_TYPE_NONE,
 275         1, EMPATHY_TYPE_TP_FILE);
 276
 277   signals[TRANSFER_DONE] =
 278     g_signal_new ("transfer-done", G_TYPE_FROM_CLASS (klass),
 279         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 280         g_cclosure_marshal_VOID__OBJECT,
 281         G_TYPE_NONE,
 282         1, EMPATHY_TYPE_TP_FILE);
 283
 284   signals[TRANSFER_ERROR] =
 285     g_signal_new ("transfer-error", G_TYPE_FROM_CLASS (klass),
 286         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 287         g_cclosure_marshal_VOID__POINTER,
 288         G_TYPE_NONE,
 289         1, G_TYPE_POINTER);
 290
 291   signals[TRANSFER_PROGRESS] =
 292     g_signal_new ("transfer-progress", G_TYPE_FROM_CLASS (klass),
 293         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 294         _empathy_marshal_VOID__UINT64_UINT64_UINT_DOUBLE,
 295         G_TYPE_NONE,
 296         4, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT, G_TYPE_DOUBLE);
 297
 298   signals[HASHING_STARTED] =
 299     g_signal_new ("hashing-started", G_TYPE_FROM_CLASS (klass),
 300         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 301         g_cclosure_marshal_VOID__VOID,
 302         G_TYPE_NONE, 0);
 303
 304   signals[HASHING_PROGRESS] =
 305     g_signal_new ("hashing-progress", G_TYPE_FROM_CLASS (klass),
 306         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 307         _empathy_marshal_VOID__UINT64_UINT64,
 308         G_TYPE_NONE,
 309         2, G_TYPE_UINT64, G_TYPE_UINT64);
 310
 311   signals[HASHING_DONE] =
 312     g_signal_new ("hashing-done", G_TYPE_FROM_CLASS (klass),
 313         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 314         g_cclosure_marshal_VOID__VOID,
 315         G_TYPE_NONE, 0);
 316 }
 317
 318 static void
 319 empathy_ft_handler_init (EmpathyFTHandler *self)
 320 {
 321   EmpathyFTHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 322     EMPATHY_TYPE_FT_HANDLER, EmpathyFTHandlerPriv);
 323
 324   self->priv = priv;
 325   priv->cancellable = g_cancellable_new ();
 326 }
 327
 328 /* private functions */
 329
 330 static void
 331 hash_data_free (HashingData *data)
 332 {
 333   if (data->buffer != NULL)
 334     {
 335       g_free (data->buffer);
 336       data->buffer = NULL;
 337     }
 338
 339   if (data->stream != NULL)
 340     {
 341       g_object_unref (data->stream);
 342       data->stream = NULL;
 343     }
 344
 345   if (data->checksum != NULL)
 346     {
 347       g_checksum_free (data->checksum);
 348       data->checksum = NULL;
 349     }
 350
 351   if (data->error != NULL)
 352     {
 353       g_error_free (data->error);
 354       data->error = NULL;
 355     }
 356   if (data->handler != NULL)
 357     {
 358       g_object_unref (data->handler);
 359       data->handler = NULL;
 360     }
 361
 362   g_slice_free (HashingData, data);
 363 }
 364
 365 static GChecksumType
 366 tp_file_hash_to_g_checksum (TpFileHashType type)
 367 {
 368   GChecksumType retval;
 369
 370   switch (type)
 371     {
 372       case TP_FILE_HASH_TYPE_MD5:
 373         retval = G_CHECKSUM_MD5;
 374         break;
 375       case TP_FILE_HASH_TYPE_SHA1:
 376         retval = G_CHECKSUM_SHA1;
 377         break;
 378       case TP_FILE_HASH_TYPE_SHA256:
 379         retval = G_CHECKSUM_SHA256;
 380         break;
 381       default:
 382         g_assert_not_reached ();
 383         break;
 384     }
 385
 386   return retval;
 387 }
 388
 389 static void
 390 check_hash_incoming (EmpathyFTHandler *handler)
 391 {
 392   HashingData *hash_data;
 393   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 394
 395   if (!EMP_STR_EMPTY (priv->content_hash))
 396     {
 397       hash_data = g_slice_new0 (HashingData);
 398       hash_data->total_bytes = priv->total_bytes;
 399       hash_data->handler = g_object_ref (handler);
 400       hash_data->checksum = g_checksum_new
 401         (tp_file_hash_to_g_checksum (priv->content_hash_type));
 402
 403       g_signal_emit (handler, signals[HASHING_STARTED], 0);
 404
 405       g_io_scheduler_push_job (do_hash_job_incoming, hash_data, NULL,
 406                                G_PRIORITY_DEFAULT, priv->cancellable);
 407     }
 408 }
 409
 410 static void
 411 emit_error_signal (EmpathyFTHandler *handler,
 412                    const GError *error)
 413 {
 414   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 415
 416   if (!g_cancellable_is_cancelled (priv->cancellable))
 417     g_cancellable_cancel (priv->cancellable);
 418
 419   g_signal_emit (handler, signals[TRANSFER_ERROR], 0, error);
 420 }
 421
 422 static void
 423 ft_transfer_operation_callback (EmpathyTpFile *tp_file,
 424                                 const GError *error,
 425                                 gpointer user_data)
 426 {
 427   EmpathyFTHandler *handler = user_data;
 428   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 429
 430   DEBUG ("Transfer operation callback, error %p", error);
 431
 432   if (error != NULL)
 433     {
 434       emit_error_signal (handler, error);
 435     }
 436   else
 437     {
 438       priv->is_completed = TRUE;
 439       g_signal_emit (handler, signals[TRANSFER_DONE], 0, tp_file);
 440
 441       empathy_tp_file_close (tp_file);
 442
 443       if (empathy_ft_handler_is_incoming (handler) && priv->use_hash)
 444         {
 445           check_hash_incoming (handler);
 446         }
 447     }
 448 }
 449
 450 static void
 451 update_remaining_time_and_speed (EmpathyFTHandler *handler,
 452                                  guint64 transferred_bytes)
 453 {
 454   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 455   time_t elapsed_time, current_time;
 456   guint64 transferred, last_transferred_bytes;
 457   gdouble speed;
 458   gint remaining_time;
 459
 460   last_transferred_bytes = priv->transferred_bytes;
 461   priv->transferred_bytes = transferred_bytes;
 462
 463   current_time = empathy_time_get_current ();
 464   elapsed_time = current_time - priv->last_update_time;
 465
 466   if (elapsed_time >= 1)
 467     {
 468       transferred = transferred_bytes - last_transferred_bytes;
 469       speed = (gdouble) transferred / (gdouble) elapsed_time;
 470       remaining_time = (priv->total_bytes - transferred) / speed;
 471       priv->speed = speed;
 472       priv->remaining_time = remaining_time;
 473       priv->last_update_time = current_time;
 474     }
 475 }
 476
 477 static void
 478 ft_transfer_progress_callback (EmpathyTpFile *tp_file,
 479                                guint64 transferred_bytes,
 480                                gpointer user_data)
 481 {
 482   EmpathyFTHandler *handler = user_data;
 483   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 484
 485   if (empathy_ft_handler_is_cancelled (handler))
 486     return;
 487
 488   if (transferred_bytes == 0)
 489     {
 490       priv->last_update_time = empathy_time_get_current ();
 491       g_signal_emit (handler, signals[TRANSFER_STARTED], 0, tp_file);
 492     }
 493
 494   if (priv->transferred_bytes != transferred_bytes)
 495     {
 496       update_remaining_time_and_speed (handler, transferred_bytes);
 497
 498       g_signal_emit (handler, signals[TRANSFER_PROGRESS], 0,
 499           transferred_bytes, priv->total_bytes, priv->remaining_time,
 500           priv->speed);
 501     }
 502 }
 503
 504 static void
 505 ft_handler_create_channel_cb (EmpathyDispatchOperation *operation,
 506                               const GError *error,
 507                               gpointer user_data)
 508 {
 509   EmpathyFTHandler *handler = user_data;
 510   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 511   GError *my_error = (GError *) error;
 512
 513   DEBUG ("Dispatcher create channel CB");
 514
 515   if (my_error == NULL)
 516     {
 517       g_cancellable_set_error_if_cancelled (priv->cancellable, &my_error);
 518     }
 519
 520   if (my_error != NULL)
 521     {
 522       emit_error_signal (handler, my_error);
 523
 524       if (my_error != error)
 525         g_clear_error (&my_error);
 526
 527       return;
 528     }
 529
 530   priv->tpfile = g_object_ref
 531       (empathy_dispatch_operation_get_channel_wrapper (operation));
 532
 533   empathy_tp_file_offer (priv->tpfile, priv->gfile, priv->cancellable,
 534       ft_transfer_progress_callback, handler,
 535       ft_transfer_operation_callback, handler);
 536
 537   empathy_dispatch_operation_claim (operation);
 538 }
 539
 540 static void
 541 ft_handler_push_to_dispatcher (EmpathyFTHandler *handler)
 542 {
 543   EmpathyDispatcher *dispatcher;
 544   TpConnection *connection;
 545   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 546
 547   DEBUG ("Pushing request to the dispatcher");
 548
 549   dispatcher = empathy_dispatcher_dup_singleton ();
 550   connection = empathy_contact_get_connection (priv->contact);
 551
 552   /* I want to own a reference to the request, and destroy it later */
 553   empathy_dispatcher_create_channel (dispatcher, connection,
 554       g_hash_table_ref (priv->request), ft_handler_create_channel_cb, handler);
 555
 556   g_object_unref (dispatcher);
 557 }
 558
 559 static gboolean
 560 ft_handler_check_if_allowed (EmpathyFTHandler *handler)
 561 {
 562   EmpathyDispatcher *dispatcher;
 563   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 564   TpConnection *connection;
 565   GStrv allowed;
 566   gboolean res = TRUE;
 567
 568   dispatcher = empathy_dispatcher_dup_singleton ();
 569   connection = empathy_contact_get_connection (priv->contact);
 570
 571   allowed = empathy_dispatcher_find_channel_class (dispatcher, connection,
 572       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER, TP_HANDLE_TYPE_CONTACT);
 573
 574   if (!tp_strv_contains ((const gchar * const *) allowed,
 575       TP_IFACE_CHANNEL ".TargetHandle"))
 576     res = FALSE;
 577
 578   g_object_unref (dispatcher);
 579
 580   return res;
 581 }
 582
 583 static void
 584 ft_handler_populate_outgoing_request (EmpathyFTHandler *handler)
 585 {
 586   guint contact_handle;
 587   GHashTable *request;
 588   GValue *value;
 589   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 590
 591   request = priv->request = g_hash_table_new_full (g_str_hash, g_str_equal,
 592             NULL, (GDestroyNotify) tp_g_value_slice_free);
 593
 594   contact_handle = empathy_contact_get_handle (priv->contact);
 595
 596   /* org.freedesktop.Telepathy.Channel.ChannelType */
 597   value = tp_g_value_slice_new (G_TYPE_STRING);
 598   g_value_set_string (value, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER);
 599   g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
 600
 601   /* org.freedesktop.Telepathy.Channel.TargetHandleType */
 602   value = tp_g_value_slice_new (G_TYPE_UINT);
 603   g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
 604   g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
 605
 606   /* org.freedesktop.Telepathy.Channel.TargetHandle */
 607   value = tp_g_value_slice_new (G_TYPE_UINT);
 608   g_value_set_uint (value, contact_handle);
 609   g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
 610
 611   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentType */
 612   value = tp_g_value_slice_new (G_TYPE_STRING);
 613   g_value_set_string (value, priv->content_type);
 614   g_hash_table_insert (request,
 615       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentType", value);
 616
 617   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Filename */
 618   value = tp_g_value_slice_new (G_TYPE_STRING);
 619   g_value_set_string (value, priv->filename);
 620   g_hash_table_insert (request,
 621       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Filename", value);
 622
 623   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Size */
 624   value = tp_g_value_slice_new (G_TYPE_UINT64);
 625   g_value_set_uint64 (value, (guint64) priv->total_bytes);
 626   g_hash_table_insert (request,
 627       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Size", value);
 628
 629   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Date */
 630   value = tp_g_value_slice_new (G_TYPE_UINT64);
 631   g_value_set_uint64 (value, (guint64) priv->mtime);
 632   g_hash_table_insert (request,
 633       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Date", value);
 634 }
 635
 636 static gboolean
 637 hash_job_done (gpointer user_data)
 638 {
 639   HashingData *hash_data = user_data;
 640   EmpathyFTHandler *handler = hash_data->handler;
 641   EmpathyFTHandlerPriv *priv;
 642   GError *error = NULL;
 643   GValue *value;
 644
 645   DEBUG ("Closing stream after hashing.");
 646
 647   priv = GET_PRIV (handler);
 648
 649   if (hash_data->error != NULL)
 650     {
 651       error = hash_data->error;
 652       goto cleanup;
 653     }
 654
 655   DEBUG ("Got file hash %s", g_checksum_get_string (hash_data->checksum));
 656
 657   if (empathy_ft_handler_is_incoming (handler))
 658     {
 659       if (g_strcmp0 (g_checksum_get_string (hash_data->checksum),
 660                      priv->content_hash))
 661         {
 662           hash_data->error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
 663               EMPATHY_FT_ERROR_HASH_MISMATCH,
 664               _("The hash of the received file and the sent one do not match"));
 665           goto cleanup;
 666         }
 667     }
 668   else
 669     {
 670       /* set the checksum in the request...
 671        * org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentHash
 672        */
 673       value = tp_g_value_slice_new (G_TYPE_STRING);
 674       g_value_set_string (value, g_checksum_get_string (hash_data->checksum));
 675       g_hash_table_insert (priv->request,
 676           TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentHash", value);
 677     }
 678
 679 cleanup:
 680
 681   if (error != NULL)
 682     {
 683       emit_error_signal (handler, error);
 684     }
 685   else
 686     {
 687       g_signal_emit (handler, signals[HASHING_DONE], 0);
 688
 689       if (!empathy_ft_handler_is_incoming (handler))
 690         /* the request is complete now, push it to the dispatcher */
 691         ft_handler_push_to_dispatcher (handler);
 692     }
 693
 694   hash_data_free (hash_data);
 695
 696   return FALSE;
 697 }
 698
 699 static gboolean
 700 emit_hashing_progress (gpointer user_data)
 701 {
 702   HashingData *hash_data = user_data;
 703
 704   g_signal_emit (hash_data->handler, signals[HASHING_PROGRESS], 0,
 705       (guint64) hash_data->total_read, (guint64) hash_data->total_bytes);
 706
 707   return FALSE;
 708 }
 709
 710 static gboolean
 711 do_hash_job (GIOSchedulerJob *job,
 712              GCancellable *cancellable,
 713              gpointer user_data)
 714 {
 715   HashingData *hash_data = user_data;
 716   gssize bytes_read;
 717   EmpathyFTHandlerPriv *priv;
 718   GError *error = NULL;
 719
 720   priv = GET_PRIV (hash_data->handler);
 721
 722 again:
 723   if (hash_data->buffer == NULL)
 724     hash_data->buffer = g_malloc0 (BUFFER_SIZE);
 725
 726   bytes_read = g_input_stream_read (hash_data->stream, hash_data->buffer,
 727                                     BUFFER_SIZE, cancellable, &error);
 728   if (error != NULL)
 729     goto out;
 730
 731   hash_data->total_read += bytes_read;
 732
 733   /* we now have the chunk */
 734   if (bytes_read > 0)
 735     {
 736       g_checksum_update (hash_data->checksum, hash_data->buffer, bytes_read);
 737       g_io_scheduler_job_send_to_mainloop_async (job, emit_hashing_progress,
 738           hash_data, NULL);
 739
 740       g_free (hash_data->buffer);
 741       hash_data->buffer = NULL;
 742
 743       goto again;
 744     }
 745   else
 746   {
 747     g_input_stream_close (hash_data->stream, cancellable, &error);
 748   }
 749
 750 out:
 751   if (error)
 752     hash_data->error = error;
 753
 754   g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
 755       hash_data, NULL);
 756
 757   return FALSE;
 758 }
 759
 760 static gboolean
 761 do_hash_job_incoming (GIOSchedulerJob *job,
 762                       GCancellable *cancellable,
 763                       gpointer user_data)
 764 {
 765   HashingData *hash_data = user_data;
 766   EmpathyFTHandler *handler = hash_data->handler;
 767   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 768   GError *error = NULL;
 769
 770   /* need to get the stream first */
 771   hash_data->stream =
 772     G_INPUT_STREAM (g_file_read (priv->gfile, cancellable, &error));
 773
 774   if (error)
 775     {
 776       hash_data->error = error;
 777       g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
 778           hash_data, NULL);
 779       return FALSE;
 780     }
 781
 782   return do_hash_job (job, cancellable, user_data);
 783 }
 784
 785 static void
 786 ft_handler_read_async_cb (GObject *source,
 787                           GAsyncResult *res,
 788                           gpointer user_data)
 789 {
 790   GFileInputStream *stream;
 791   GError *error = NULL;
 792   HashingData *hash_data;
 793   GValue *value;
 794   EmpathyFTHandler *handler = user_data;
 795   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 796
 797   DEBUG ("GFile read async CB.");
 798
 799   stream = g_file_read_finish (priv->gfile, res, &error);
 800   if (error != NULL)
 801     {
 802       emit_error_signal (handler, error);
 803       g_clear_error (&error);
 804
 805       return;
 806     }
 807
 808   hash_data = g_slice_new0 (HashingData);
 809   hash_data->stream = G_INPUT_STREAM (stream);
 810   hash_data->total_bytes = priv->total_bytes;
 811   hash_data->handler = g_object_ref (handler);
 812   /* FIXME: should look at the CM capabilities before setting the
 813    * checksum type?
 814    */
 815   hash_data->checksum = g_checksum_new (G_CHECKSUM_MD5);
 816
 817   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentHashType */
 818   value = tp_g_value_slice_new (G_TYPE_UINT);
 819   g_value_set_uint (value, TP_FILE_HASH_TYPE_MD5);
 820   g_hash_table_insert (priv->request,
 821       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentHashType", value);
 822
 823   g_signal_emit (handler, signals[HASHING_STARTED], 0);
 824
 825   g_io_scheduler_push_job (do_hash_job, hash_data, NULL,
 826       G_PRIORITY_DEFAULT, priv->cancellable);
 827 }
 828
 829 static void
 830 ft_handler_complete_request (EmpathyFTHandler *handler)
 831 {
 832   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 833   GError *myerr = NULL;
 834
 835   /* check if FT is allowed before firing up the I/O machinery */
 836   if (!ft_handler_check_if_allowed (handler))
 837     {
 838       g_set_error_literal (&myerr, EMPATHY_FT_ERROR_QUARK,
 839           EMPATHY_FT_ERROR_NOT_SUPPORTED,
 840           _("File transfer not supported by remote contact"));
 841
 842       emit_error_signal (handler, myerr);
 843
 844       return;
 845     }
 846
 847   /* populate the request table with all the known properties */
 848   ft_handler_populate_outgoing_request (handler);
 849
 850   if (priv->use_hash)
 851     /* start hashing the file */
 852     g_file_read_async (priv->gfile, G_PRIORITY_DEFAULT,
 853         priv->cancellable, ft_handler_read_async_cb, handler);
 854   else
 855     /* push directly the handler to the dispatcher */
 856     ft_handler_push_to_dispatcher (handler);
 857 }
 858
 859 static void
 860 callbacks_data_free (gpointer user_data)
 861 {
 862   CallbacksData *data = user_data;
 863
 864   if (data->handler)
 865     g_object_unref (data->handler);
 866
 867   g_slice_free (CallbacksData, data);
 868 }
 869
 870 static void
 871 ft_handler_gfile_ready_cb (GObject *source,
 872                            GAsyncResult *res,
 873                            CallbacksData *cb_data)
 874 {
 875   GFileInfo *info;
 876   GError *error = NULL;
 877   GTimeVal mtime;
 878   EmpathyFTHandlerPriv *priv = GET_PRIV (cb_data->handler);
 879
 880   DEBUG ("Got GFileInfo.");
 881
 882   info = g_file_query_info_finish (priv->gfile, res, &error);
 883
 884   if (error != NULL)
 885     goto out;
 886
 887   priv->content_type = g_strdup (g_file_info_get_content_type (info));
 888   priv->filename = g_strdup (g_file_info_get_display_name (info));
 889   priv->total_bytes = g_file_info_get_size (info);
 890   g_file_info_get_modification_time (info, &mtime);
 891   priv->mtime = mtime.tv_sec;
 892   priv->transferred_bytes = 0;
 893   priv->description = NULL;
 894
 895   g_object_unref (info);
 896
 897 out:
 898   if (error == NULL)
 899     {
 900       cb_data->callback (cb_data->handler, NULL, cb_data->user_data);
 901     }
 902   else
 903     {
 904       cb_data->callback (NULL, error, cb_data->user_data);
 905       g_error_free (error);
 906       g_object_unref (cb_data->handler);
 907     }
 908
 909   callbacks_data_free (cb_data);
 910 }
 911
 912 static void
 913 contact_factory_contact_cb (EmpathyTpContactFactory *factory,
 914                             EmpathyContact *contact,
 915                             const GError *error,
 916                             gpointer user_data,
 917                             GObject *weak_object)
 918 {
 919   CallbacksData *cb_data = user_data;
 920   EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object);
 921   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 922
 923   if (error != NULL)
 924     {
 925       cb_data->callback (NULL, (GError *) error, cb_data->user_data);
 926       g_object_unref (handler);
 927       return;
 928     }
 929
 930   priv->contact = contact;
 931
 932   cb_data->callback (handler, NULL, cb_data->user_data);
 933 }
 934
 935 static void
 936 channel_get_all_properties_cb (TpProxy *proxy,
 937                                GHashTable *properties,
 938                                const GError *error,
 939                                gpointer user_data,
 940                                GObject *weak_object)
 941 {
 942   CallbacksData *cb_data = user_data;
 943   EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object);
 944   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 945   EmpathyTpContactFactory *c_factory;
 946   TpHandle c_handle;
 947
 948   if (error != NULL)
 949     {
 950       cb_data->callback (NULL, (GError *) error, cb_data->user_data);
 951       g_object_unref (handler);
 952       return;
 953     }
 954
 955   priv->total_bytes = g_value_get_uint64 (
 956       g_hash_table_lookup (properties, "Size"));
 957
 958   priv->transferred_bytes = g_value_get_uint64 (
 959       g_hash_table_lookup (properties, "TransferredBytes"));
 960
 961   priv->filename = g_value_dup_string (
 962       g_hash_table_lookup (properties, "Filename"));
 963
 964   priv->content_hash = g_value_dup_string (
 965       g_hash_table_lookup (properties, "ContentHash"));
 966
 967   priv->content_hash_type = g_value_get_uint (
 968       g_hash_table_lookup (properties, "ContentHashType"));
 969
 970   priv->content_type = g_value_dup_string (
 971       g_hash_table_lookup (properties, "ContentType"));
 972
 973   priv->description = g_value_dup_string (
 974       g_hash_table_lookup (properties, "Description"));
 975
 976   g_hash_table_destroy (properties);
 977
 978   c_factory = empathy_tp_contact_factory_dup_singleton
 979       (tp_channel_borrow_connection (TP_CHANNEL (proxy)));
 980   c_handle = tp_channel_get_handle (TP_CHANNEL (proxy), NULL);
 981   empathy_tp_contact_factory_get_from_handle (c_factory, c_handle,
 982       contact_factory_contact_cb, cb_data, callbacks_data_free,
 983       G_OBJECT (handler));
 984 }
 985
 986 /* public methods */
 987
 988 void
 989 empathy_ft_handler_new_outgoing (EmpathyContact *contact,
 990                                  GFile *source,
 991                                  gboolean use_hash,
 992                                  EmpathyFTHandlerReadyCallback callback,
 993                                  gpointer user_data)
 994 {
 995   EmpathyFTHandler *handler;
 996   CallbacksData *data;
 997   EmpathyFTHandlerPriv *priv;
 998
 999   DEBUG ("New handler outgoing, use hash %s",
1000          use_hash ? "True" : "False");
1001
1002   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1003   g_return_if_fail (G_IS_FILE (source));
1004
1005   handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
1006       "contact", contact, "gfile", source, "use-hash", use_hash, NULL);
1007
1008   priv = GET_PRIV (handler);
1009
1010   data = g_slice_new0 (CallbacksData);
1011   data->callback = callback;
1012   data->user_data = user_data;
1013   data->handler = g_object_ref (handler);
1014
1015   /* start collecting info about the file */
1016   g_file_query_info_async (priv->gfile,
1017       G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
1018       G_FILE_ATTRIBUTE_STANDARD_SIZE ","
1019       G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
1020       G_FILE_ATTRIBUTE_TIME_MODIFIED,
1021       G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
1022       NULL, (GAsyncReadyCallback) ft_handler_gfile_ready_cb, data);
1023 }
1024
1025 void
1026 empathy_ft_handler_new_incoming (EmpathyTpFile *tp_file,
1027                                  EmpathyFTHandlerReadyCallback callback,
1028                                  gpointer user_data)
1029 {
1030   EmpathyFTHandler *handler;
1031   TpChannel *channel;
1032   CallbacksData *data;
1033
1034   g_return_if_fail (EMPATHY_IS_TP_FILE (tp_file));
1035
1036   handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
1037       "tp-file", tp_file, NULL);
1038
1039   g_object_get (tp_file, "channel", &channel, NULL);
1040
1041   data = g_slice_new0 (CallbacksData);
1042   data->callback = callback;
1043   data->user_data = user_data;
1044   data->handler = g_object_ref (handler);
1045
1046   tp_cli_dbus_properties_call_get_all (channel,
1047       -1, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER,
1048       channel_get_all_properties_cb, data, NULL, G_OBJECT (handler));
1049 }
1050
1051 void
1052 empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
1053 {
1054   EmpathyFTHandlerPriv *priv;
1055
1056   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1057
1058   priv = GET_PRIV (handler);
1059
1060   if (priv->tpfile == NULL)
1061     {
1062       ft_handler_complete_request (handler);
1063     }
1064   else
1065     {
1066       /* TODO: add support for resume. */
1067       empathy_tp_file_accept (priv->tpfile, 0, priv->gfile, priv->cancellable,
1068           ft_transfer_progress_callback, handler,
1069           ft_transfer_operation_callback, handler);
1070     }
1071 }
1072
1073 void
1074 empathy_ft_handler_cancel_transfer (EmpathyFTHandler *handler)
1075 {
1076   EmpathyFTHandlerPriv *priv;
1077
1078   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1079
1080   priv = GET_PRIV (handler);
1081
1082   /* if we don't have an EmpathyTpFile, we are hashing, so
1083    * we can just cancel the GCancellable to stop it.
1084    */
1085   if (priv->tpfile == NULL)
1086     g_cancellable_cancel (priv->cancellable);
1087   else
1088     empathy_tp_file_cancel (priv->tpfile);
1089 }
1090
1091 void
1092 empathy_ft_handler_incoming_set_destination (EmpathyFTHandler *handler,
1093                                              GFile *destination,
1094                                              gboolean use_hash)
1095 {
1096   DEBUG ("Set incoming destination, use hash %s",
1097          use_hash ? "True" : "False");
1098
1099   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1100   g_return_if_fail (G_IS_FILE (destination));
1101
1102   g_object_set (handler, "gfile", destination,
1103       "use-hash", use_hash, NULL);
1104 }
1105
1106 const char *
1107 empathy_ft_handler_get_filename (EmpathyFTHandler *handler)
1108 {
1109   EmpathyFTHandlerPriv *priv;
1110
1111   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1112
1113   priv = GET_PRIV (handler);
1114
1115   return priv->filename;
1116 }
1117
1118 const char *
1119 empathy_ft_handler_get_content_type (EmpathyFTHandler *handler)
1120 {
1121   EmpathyFTHandlerPriv *priv;
1122
1123   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1124
1125   priv = GET_PRIV (handler);
1126
1127   return priv->content_type;
1128 }
1129
1130 EmpathyContact *
1131 empathy_ft_handler_get_contact (EmpathyFTHandler *handler)
1132 {
1133   EmpathyFTHandlerPriv *priv;
1134
1135   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1136
1137   priv = GET_PRIV (handler);
1138
1139   return priv->contact;
1140 }
1141
1142 GFile *
1143 empathy_ft_handler_get_gfile (EmpathyFTHandler *handler)
1144 {
1145   EmpathyFTHandlerPriv *priv;
1146
1147   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1148
1149   priv = GET_PRIV (handler);
1150
1151   return priv->gfile;
1152 }
1153
1154 gboolean
1155 empathy_ft_handler_get_use_hash (EmpathyFTHandler *handler)
1156 {
1157   EmpathyFTHandlerPriv *priv;
1158
1159   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1160
1161   priv = GET_PRIV (handler);
1162
1163   return priv->use_hash;
1164 }
1165
1166 gboolean
1167 empathy_ft_handler_is_incoming (EmpathyFTHandler *handler)
1168 {
1169   EmpathyFTHandlerPriv *priv;
1170
1171   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1172
1173   priv = GET_PRIV (handler);
1174
1175   if (priv->tpfile == NULL)
1176     return FALSE;
1177
1178   return empathy_tp_file_is_incoming (priv->tpfile);
1179 }
1180
1181 guint64
1182 empathy_ft_handler_get_transferred_bytes (EmpathyFTHandler *handler)
1183 {
1184   EmpathyFTHandlerPriv *priv;
1185
1186   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
1187
1188   priv = GET_PRIV (handler);
1189
1190   return priv->transferred_bytes;
1191 }
1192
1193 guint64
1194 empathy_ft_handler_get_total_bytes (EmpathyFTHandler *handler)
1195 {
1196   EmpathyFTHandlerPriv *priv;
1197
1198   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
1199
1200   priv = GET_PRIV (handler);
1201
1202   return priv->total_bytes;
1203 }
1204
1205 gboolean
1206 empathy_ft_handler_is_completed (EmpathyFTHandler *handler)
1207 {
1208   EmpathyFTHandlerPriv *priv;
1209
1210   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1211
1212   priv = GET_PRIV (handler);
1213
1214   return priv->is_completed;
1215 }
1216
1217 gboolean
1218 empathy_ft_handler_is_cancelled (EmpathyFTHandler *handler)
1219 {
1220   EmpathyFTHandlerPriv *priv;
1221
1222   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1223
1224   priv = GET_PRIV (handler);
1225
1226   return g_cancellable_is_cancelled (priv->cancellable);
1227 }