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_string (TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER);
 598   g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
 599
 600   /* org.freedesktop.Telepathy.Channel.TargetHandleType */
 601   value = tp_g_value_slice_new_uint (TP_HANDLE_TYPE_CONTACT);
 602   g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
 603
 604   /* org.freedesktop.Telepathy.Channel.TargetHandle */
 605   value = tp_g_value_slice_new_uint (contact_handle);
 606   g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
 607
 608   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentType */
 609   value = tp_g_value_slice_new_string (priv->content_type);
 610   g_hash_table_insert (request,
 611       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentType", value);
 612
 613   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Filename */
 614   value = tp_g_value_slice_new_string (priv->filename);
 615   g_hash_table_insert (request,
 616       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Filename", value);
 617
 618   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Size */
 619   value = tp_g_value_slice_new_uint64 (priv->total_bytes);
 620   g_hash_table_insert (request,
 621       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Size", value);
 622
 623   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.Date */
 624   value = tp_g_value_slice_new_uint64 ((guint64) priv->mtime);
 625   g_hash_table_insert (request,
 626       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".Date", value);
 627 }
 628
 629 static gboolean
 630 hash_job_done (gpointer user_data)
 631 {
 632   HashingData *hash_data = user_data;
 633   EmpathyFTHandler *handler = hash_data->handler;
 634   EmpathyFTHandlerPriv *priv;
 635   GError *error = NULL;
 636   GValue *value;
 637
 638   DEBUG ("Closing stream after hashing.");
 639
 640   priv = GET_PRIV (handler);
 641
 642   if (hash_data->error != NULL)
 643     {
 644       error = hash_data->error;
 645       goto cleanup;
 646     }
 647
 648   DEBUG ("Got file hash %s", g_checksum_get_string (hash_data->checksum));
 649
 650   if (empathy_ft_handler_is_incoming (handler))
 651     {
 652       if (g_strcmp0 (g_checksum_get_string (hash_data->checksum),
 653                      priv->content_hash))
 654         {
 655           DEBUG ("Hash mismatch when checking incoming handler: "
 656                  "received %s, calculated %s", priv->content_hash,
 657                  g_checksum_get_string (hash_data->checksum));
 658
 659           error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
 660               EMPATHY_FT_ERROR_HASH_MISMATCH,
 661               _("The hash of the received file and the "
 662                 "sent one do not match"));
 663           goto cleanup;
 664         }
 665       else
 666         {
 667           DEBUG ("Hash verification matched, received %s, calculated %s",
 668                  priv->content_hash,
 669                  g_checksum_get_string (hash_data->checksum));
 670         }
 671     }
 672   else
 673     {
 674       /* set the checksum in the request...
 675        * org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentHash
 676        */
 677       value = tp_g_value_slice_new_string
 678           (g_checksum_get_string (hash_data->checksum));
 679       g_hash_table_insert (priv->request,
 680           TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentHash", value);
 681     }
 682
 683 cleanup:
 684
 685   if (error != NULL)
 686     {
 687       emit_error_signal (handler, error);
 688       g_clear_error (&error);
 689     }
 690   else
 691     {
 692       g_signal_emit (handler, signals[HASHING_DONE], 0);
 693
 694       if (!empathy_ft_handler_is_incoming (handler))
 695         /* the request is complete now, push it to the dispatcher */
 696         ft_handler_push_to_dispatcher (handler);
 697     }
 698
 699   hash_data_free (hash_data);
 700
 701   return FALSE;
 702 }
 703
 704 static gboolean
 705 emit_hashing_progress (gpointer user_data)
 706 {
 707   HashingData *hash_data = user_data;
 708
 709   g_signal_emit (hash_data->handler, signals[HASHING_PROGRESS], 0,
 710       (guint64) hash_data->total_read, (guint64) hash_data->total_bytes);
 711
 712   return FALSE;
 713 }
 714
 715 static gboolean
 716 do_hash_job (GIOSchedulerJob *job,
 717     GCancellable *cancellable,
 718     gpointer user_data)
 719 {
 720   HashingData *hash_data = user_data;
 721   gssize bytes_read;
 722   EmpathyFTHandlerPriv *priv;
 723   GError *error = NULL;
 724
 725   priv = GET_PRIV (hash_data->handler);
 726
 727 again:
 728   if (hash_data->buffer == NULL)
 729     hash_data->buffer = g_malloc0 (BUFFER_SIZE);
 730
 731   bytes_read = g_input_stream_read (hash_data->stream, hash_data->buffer,
 732                                     BUFFER_SIZE, cancellable, &error);
 733   if (error != NULL)
 734     goto out;
 735
 736   hash_data->total_read += bytes_read;
 737
 738   /* we now have the chunk */
 739   if (bytes_read > 0)
 740     {
 741       g_checksum_update (hash_data->checksum, hash_data->buffer, bytes_read);
 742       g_io_scheduler_job_send_to_mainloop_async (job, emit_hashing_progress,
 743           hash_data, NULL);
 744
 745       g_free (hash_data->buffer);
 746       hash_data->buffer = NULL;
 747
 748       goto again;
 749     }
 750   else
 751   {
 752     g_input_stream_close (hash_data->stream, cancellable, &error);
 753   }
 754
 755 out:
 756   if (error)
 757     hash_data->error = error;
 758
 759   g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
 760       hash_data, NULL);
 761
 762   return FALSE;
 763 }
 764
 765 static gboolean
 766 do_hash_job_incoming (GIOSchedulerJob *job,
 767     GCancellable *cancellable,
 768     gpointer user_data)
 769 {
 770   HashingData *hash_data = user_data;
 771   EmpathyFTHandler *handler = hash_data->handler;
 772   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 773   GError *error = NULL;
 774
 775   DEBUG ("checking integrity for incoming handler");
 776
 777   /* need to get the stream first */
 778   hash_data->stream =
 779     G_INPUT_STREAM (g_file_read (priv->gfile, cancellable, &error));
 780
 781   if (error)
 782     {
 783       hash_data->error = error;
 784       g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
 785           hash_data, NULL);
 786       return FALSE;
 787     }
 788
 789   return do_hash_job (job, cancellable, user_data);
 790 }
 791
 792 static void
 793 ft_handler_read_async_cb (GObject *source,
 794     GAsyncResult *res,
 795     gpointer user_data)
 796 {
 797   GFileInputStream *stream;
 798   GError *error = NULL;
 799   HashingData *hash_data;
 800   GValue *value;
 801   EmpathyFTHandler *handler = user_data;
 802   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 803
 804   DEBUG ("GFile read async CB.");
 805
 806   stream = g_file_read_finish (priv->gfile, res, &error);
 807   if (error != NULL)
 808     {
 809       emit_error_signal (handler, error);
 810       g_clear_error (&error);
 811
 812       return;
 813     }
 814
 815   hash_data = g_slice_new0 (HashingData);
 816   hash_data->stream = G_INPUT_STREAM (stream);
 817   hash_data->total_bytes = priv->total_bytes;
 818   hash_data->handler = g_object_ref (handler);
 819   /* FIXME: should look at the CM capabilities before setting the
 820    * checksum type?
 821    */
 822   hash_data->checksum = g_checksum_new (G_CHECKSUM_MD5);
 823
 824   /* org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentHashType */
 825   value = tp_g_value_slice_new_uint (TP_FILE_HASH_TYPE_MD5);
 826   g_hash_table_insert (priv->request,
 827       TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER ".ContentHashType", value);
 828
 829   g_signal_emit (handler, signals[HASHING_STARTED], 0);
 830
 831   g_io_scheduler_push_job (do_hash_job, hash_data, NULL,
 832       G_PRIORITY_DEFAULT, priv->cancellable);
 833 }
 834
 835 static void
 836 ft_handler_complete_request (EmpathyFTHandler *handler)
 837 {
 838   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 839   GError *myerr = NULL;
 840
 841   /* check if FT is allowed before firing up the I/O machinery */
 842   if (!ft_handler_check_if_allowed (handler))
 843     {
 844       g_set_error_literal (&myerr, EMPATHY_FT_ERROR_QUARK,
 845           EMPATHY_FT_ERROR_NOT_SUPPORTED,
 846           _("File transfer not supported by remote contact"));
 847
 848       emit_error_signal (handler, myerr);
 849       g_clear_error (&myerr);
 850
 851       return;
 852     }
 853
 854   /* populate the request table with all the known properties */
 855   ft_handler_populate_outgoing_request (handler);
 856
 857   if (priv->use_hash)
 858     /* start hashing the file */
 859     g_file_read_async (priv->gfile, G_PRIORITY_DEFAULT,
 860         priv->cancellable, ft_handler_read_async_cb, handler);
 861   else
 862     /* push directly the handler to the dispatcher */
 863     ft_handler_push_to_dispatcher (handler);
 864 }
 865
 866 static void
 867 callbacks_data_free (gpointer user_data)
 868 {
 869   CallbacksData *data = user_data;
 870
 871   if (data->handler)
 872     g_object_unref (data->handler);
 873
 874   g_slice_free (CallbacksData, data);
 875 }
 876
 877 static void
 878 ft_handler_gfile_ready_cb (GObject *source,
 879     GAsyncResult *res,
 880     CallbacksData *cb_data)
 881 {
 882   GFileInfo *info;
 883   GError *error = NULL;
 884   GTimeVal mtime;
 885   EmpathyFTHandlerPriv *priv = GET_PRIV (cb_data->handler);
 886
 887   DEBUG ("Got GFileInfo.");
 888
 889   info = g_file_query_info_finish (priv->gfile, res, &error);
 890
 891   if (error != NULL)
 892     goto out;
 893
 894   priv->content_type = g_strdup (g_file_info_get_content_type (info));
 895   priv->filename = g_strdup (g_file_info_get_display_name (info));
 896   priv->total_bytes = g_file_info_get_size (info);
 897   g_file_info_get_modification_time (info, &mtime);
 898   priv->mtime = mtime.tv_sec;
 899   priv->transferred_bytes = 0;
 900   priv->description = NULL;
 901
 902   g_object_unref (info);
 903
 904 out:
 905   if (error == NULL)
 906     {
 907       cb_data->callback (cb_data->handler, NULL, cb_data->user_data);
 908     }
 909   else
 910     {
 911       if (!g_cancellable_is_cancelled (priv->cancellable))
 912         g_cancellable_cancel (priv->cancellable);
 913
 914       cb_data->callback (NULL, error, cb_data->user_data);
 915       g_error_free (error);
 916       g_object_unref (cb_data->handler);
 917     }
 918
 919   callbacks_data_free (cb_data);
 920 }
 921
 922 static void
 923 contact_factory_contact_cb (EmpathyTpContactFactory *factory,
 924     EmpathyContact *contact,
 925     const GError *error,
 926     gpointer user_data,
 927     GObject *weak_object)
 928 {
 929   CallbacksData *cb_data = user_data;
 930   EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object);
 931   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 932
 933   if (error != NULL)
 934     {
 935       if (!g_cancellable_is_cancelled (priv->cancellable))
 936         g_cancellable_cancel (priv->cancellable);
 937
 938       cb_data->callback (NULL, (GError *) error, cb_data->user_data);
 939       g_object_unref (handler);
 940       return;
 941     }
 942
 943   priv->contact = contact;
 944
 945   cb_data->callback (handler, NULL, cb_data->user_data);
 946 }
 947
 948 static void
 949 channel_get_all_properties_cb (TpProxy *proxy,
 950     GHashTable *properties,
 951     const GError *error,
 952     gpointer user_data,
 953     GObject *weak_object)
 954 {
 955   CallbacksData *cb_data = user_data;
 956   EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object);
 957   EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
 958   EmpathyTpContactFactory *c_factory;
 959   TpHandle c_handle;
 960
 961   if (error != NULL)
 962     {
 963       if (!g_cancellable_is_cancelled (priv->cancellable))
 964         g_cancellable_cancel (priv->cancellable);
 965
 966       cb_data->callback (NULL, (GError *) error, cb_data->user_data);
 967       g_object_unref (handler);
 968       return;
 969     }
 970
 971   priv->total_bytes = g_value_get_uint64 (
 972       g_hash_table_lookup (properties, "Size"));
 973
 974   priv->transferred_bytes = g_value_get_uint64 (
 975       g_hash_table_lookup (properties, "TransferredBytes"));
 976
 977   priv->filename = g_value_dup_string (
 978       g_hash_table_lookup (properties, "Filename"));
 979
 980   priv->content_hash = g_value_dup_string (
 981       g_hash_table_lookup (properties, "ContentHash"));
 982
 983   priv->content_hash_type = g_value_get_uint (
 984       g_hash_table_lookup (properties, "ContentHashType"));
 985
 986   priv->content_type = g_value_dup_string (
 987       g_hash_table_lookup (properties, "ContentType"));
 988
 989   priv->description = g_value_dup_string (
 990       g_hash_table_lookup (properties, "Description"));
 991
 992   c_factory = empathy_tp_contact_factory_dup_singleton
 993       (tp_channel_borrow_connection (TP_CHANNEL (proxy)));
 994   c_handle = tp_channel_get_handle (TP_CHANNEL (proxy), NULL);
 995   empathy_tp_contact_factory_get_from_handle (c_factory, c_handle,
 996       contact_factory_contact_cb, cb_data, callbacks_data_free,
 997       G_OBJECT (handler));
 998
 999   g_object_unref (c_factory);
1000 }
1001
1002 /* public methods */
1003
1004 void
1005 empathy_ft_handler_new_outgoing (EmpathyContact *contact,
1006     GFile *source,
1007     gboolean use_hash,
1008     EmpathyFTHandlerReadyCallback callback,
1009     gpointer user_data)
1010 {
1011   EmpathyFTHandler *handler;
1012   CallbacksData *data;
1013   EmpathyFTHandlerPriv *priv;
1014
1015   DEBUG ("New handler outgoing, use hash %s",
1016          use_hash ? "True" : "False");
1017
1018   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1019   g_return_if_fail (G_IS_FILE (source));
1020
1021   handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
1022       "contact", contact, "gfile", source, "use-hash", use_hash, NULL);
1023
1024   priv = GET_PRIV (handler);
1025
1026   data = g_slice_new0 (CallbacksData);
1027   data->callback = callback;
1028   data->user_data = user_data;
1029   data->handler = g_object_ref (handler);
1030
1031   /* start collecting info about the file */
1032   g_file_query_info_async (priv->gfile,
1033       G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
1034       G_FILE_ATTRIBUTE_STANDARD_SIZE ","
1035       G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
1036       G_FILE_ATTRIBUTE_TIME_MODIFIED,
1037       G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
1038       NULL, (GAsyncReadyCallback) ft_handler_gfile_ready_cb, data);
1039 }
1040
1041 void
1042 empathy_ft_handler_new_incoming (EmpathyTpFile *tp_file,
1043     EmpathyFTHandlerReadyCallback callback,
1044     gpointer user_data)
1045 {
1046   EmpathyFTHandler *handler;
1047   TpChannel *channel;
1048   CallbacksData *data;
1049
1050   g_return_if_fail (EMPATHY_IS_TP_FILE (tp_file));
1051
1052   handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
1053       "tp-file", tp_file, NULL);
1054
1055   g_object_get (tp_file, "channel", &channel, NULL);
1056
1057   data = g_slice_new0 (CallbacksData);
1058   data->callback = callback;
1059   data->user_data = user_data;
1060   data->handler = g_object_ref (handler);
1061
1062   tp_cli_dbus_properties_call_get_all (channel,
1063       -1, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER,
1064       channel_get_all_properties_cb, data, NULL, G_OBJECT (handler));
1065 }
1066
1067 void
1068 empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
1069 {
1070   EmpathyFTHandlerPriv *priv;
1071
1072   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1073
1074   priv = GET_PRIV (handler);
1075
1076   if (priv->tpfile == NULL)
1077     {
1078       ft_handler_complete_request (handler);
1079     }
1080   else
1081     {
1082       /* TODO: add support for resume. */
1083       empathy_tp_file_accept (priv->tpfile, 0, priv->gfile, priv->cancellable,
1084           ft_transfer_progress_callback, handler,
1085           ft_transfer_operation_callback, handler);
1086     }
1087 }
1088
1089 void
1090 empathy_ft_handler_cancel_transfer (EmpathyFTHandler *handler)
1091 {
1092   EmpathyFTHandlerPriv *priv;
1093
1094   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1095
1096   priv = GET_PRIV (handler);
1097
1098   /* if we don't have an EmpathyTpFile, we are hashing, so
1099    * we can just cancel the GCancellable to stop it.
1100    */
1101   if (priv->tpfile == NULL)
1102     g_cancellable_cancel (priv->cancellable);
1103   else
1104     empathy_tp_file_cancel (priv->tpfile);
1105 }
1106
1107 void
1108 empathy_ft_handler_incoming_set_destination (EmpathyFTHandler *handler,
1109     GFile *destination,
1110     gboolean use_hash)
1111 {
1112   DEBUG ("Set incoming destination, use hash %s",
1113          use_hash ? "True" : "False");
1114
1115   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1116   g_return_if_fail (G_IS_FILE (destination));
1117
1118   g_object_set (handler, "gfile", destination,
1119       "use-hash", use_hash, NULL);
1120 }
1121
1122 const char *
1123 empathy_ft_handler_get_filename (EmpathyFTHandler *handler)
1124 {
1125   EmpathyFTHandlerPriv *priv;
1126
1127   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1128
1129   priv = GET_PRIV (handler);
1130
1131   return priv->filename;
1132 }
1133
1134 const char *
1135 empathy_ft_handler_get_content_type (EmpathyFTHandler *handler)
1136 {
1137   EmpathyFTHandlerPriv *priv;
1138
1139   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1140
1141   priv = GET_PRIV (handler);
1142
1143   return priv->content_type;
1144 }
1145
1146 EmpathyContact *
1147 empathy_ft_handler_get_contact (EmpathyFTHandler *handler)
1148 {
1149   EmpathyFTHandlerPriv *priv;
1150
1151   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1152
1153   priv = GET_PRIV (handler);
1154
1155   return priv->contact;
1156 }
1157
1158 GFile *
1159 empathy_ft_handler_get_gfile (EmpathyFTHandler *handler)
1160 {
1161   EmpathyFTHandlerPriv *priv;
1162
1163   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
1164
1165   priv = GET_PRIV (handler);
1166
1167   return priv->gfile;
1168 }
1169
1170 gboolean
1171 empathy_ft_handler_get_use_hash (EmpathyFTHandler *handler)
1172 {
1173   EmpathyFTHandlerPriv *priv;
1174
1175   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1176
1177   priv = GET_PRIV (handler);
1178
1179   return priv->use_hash;
1180 }
1181
1182 gboolean
1183 empathy_ft_handler_is_incoming (EmpathyFTHandler *handler)
1184 {
1185   EmpathyFTHandlerPriv *priv;
1186
1187   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1188
1189   priv = GET_PRIV (handler);
1190
1191   if (priv->tpfile == NULL)
1192     return FALSE;
1193
1194   return empathy_tp_file_is_incoming (priv->tpfile);
1195 }
1196
1197 guint64
1198 empathy_ft_handler_get_transferred_bytes (EmpathyFTHandler *handler)
1199 {
1200   EmpathyFTHandlerPriv *priv;
1201
1202   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
1203
1204   priv = GET_PRIV (handler);
1205
1206   return priv->transferred_bytes;
1207 }
1208
1209 guint64
1210 empathy_ft_handler_get_total_bytes (EmpathyFTHandler *handler)
1211 {
1212   EmpathyFTHandlerPriv *priv;
1213
1214   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
1215
1216   priv = GET_PRIV (handler);
1217
1218   return priv->total_bytes;
1219 }
1220
1221 gboolean
1222 empathy_ft_handler_is_completed (EmpathyFTHandler *handler)
1223 {
1224   EmpathyFTHandlerPriv *priv;
1225
1226   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1227
1228   priv = GET_PRIV (handler);
1229
1230   return priv->is_completed;
1231 }
1232
1233 gboolean
1234 empathy_ft_handler_is_cancelled (EmpathyFTHandler *handler)
1235 {
1236   EmpathyFTHandlerPriv *priv;
1237
1238   g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
1239
1240   priv = GET_PRIV (handler);
1241
1242   return g_cancellable_is_cancelled (priv->cancellable);
1243 }