src/purple/purple-ft.c

   1 /**
   2  * @file purple-ft.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2013 SIPE Project <http://sipe.sourceforge.net/>
   7  * Copyright (C) 2010 Jakub Adam <jakub.adam@ktknet.cz>
   8  * Copyright (C) 2010 Tomáš Hrabčík <tomas.hrabcik@tieto.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <string.h>
  30 #include <fcntl.h>
  31 #include <errno.h>
  32
  33 #include <glib.h>
  34
  35 #include "version.h"
  36 #if PURPLE_VERSION_CHECK(3,0,0)
  37 #include "xfer.h"
  38 #else
  39 #include "ft.h"
  40 #endif
  41
  42 #ifdef _WIN32
  43 /* wrappers for write() & friends for socket handling */
  44 #include "win32/win32dep.h"
  45 #endif
  46
  47 #include "sipe-common.h"
  48 #include "sipe-backend.h"
  49 #include "sipe-core.h"
  50
  51 #include "purple-private.h"
  52
  53 #define PURPLE_XFER                       ((PurpleXfer *) ft->backend_private)
  54 #if PURPLE_VERSION_CHECK(3,0,0)
  55 #define PURPLE_XFER_DATA                  xfer->proto_data
  56 #else
  57 #define PURPLE_XFER_DATA                  xfer->data
  58 #endif
  59 #define PURPLE_XFER_TO_SIPE_FILE_TRANSFER ((struct sipe_file_transfer *) PURPLE_XFER_DATA)
  60 #if PURPLE_VERSION_CHECK(2,6,0) || PURPLE_VERSION_CHECK(3,0,0)
  61 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC   ((struct sipe_core_public *) purple_connection_get_protocol_data(purple_account_get_connection(xfer->account)))
  62 #else
  63 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC   ((struct sipe_core_public *) purple_account_get_connection(xfer->account)->proto_data)
  64 #endif
  65
  66 void sipe_backend_ft_error(struct sipe_file_transfer *ft,
  67                            const char *errmsg)
  68 {
  69         PurpleXfer *xfer = PURPLE_XFER;
  70         purple_xfer_error(purple_xfer_get_type(xfer),
  71                           xfer->account, xfer->who,
  72                           errmsg);
  73 }
  74
  75 const gchar *sipe_backend_ft_get_error(SIPE_UNUSED_PARAMETER struct sipe_file_transfer *ft)
  76 {
  77         return strerror(errno);
  78 }
  79
  80 void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
  81 {
  82         PurpleXfer *xfer = PURPLE_XFER;
  83         PurpleXferStatusType status = purple_xfer_get_status(xfer);
  84
  85         // If file transfer is not finished, cancel it
  86         if (   status != PURPLE_XFER_STATUS_DONE
  87                 && status != PURPLE_XFER_STATUS_CANCEL_LOCAL
  88                 && status != PURPLE_XFER_STATUS_CANCEL_REMOTE) {
  89                 purple_xfer_set_cancel_recv_fnc(xfer, NULL);
  90                 purple_xfer_set_cancel_send_fnc(xfer, NULL);
  91                 purple_xfer_cancel_remote(xfer);
  92         }
  93 }
  94
  95 gssize sipe_backend_ft_read(struct sipe_file_transfer *ft,
  96                             guchar *data,
  97                             gsize size)
  98 {
  99         gssize bytes_read = read(PURPLE_XFER->fd, data, size);
 100         if (bytes_read == 0) {
 101                 /* Sender canceled transfer before it was finished */
 102                 return -2;
 103         } else if (bytes_read == -1) {
 104                 if (errno == EAGAIN)
 105                         return 0;
 106                 else
 107                         return -1;
 108         }
 109         return bytes_read;
 110 }
 111
 112 gssize sipe_backend_ft_write(struct sipe_file_transfer *ft,
 113                              const guchar *data,
 114                              gsize size)
 115 {
 116         gssize bytes_written = write(PURPLE_XFER->fd, data, size);
 117         if (bytes_written == -1) {
 118                 if (errno == EAGAIN)
 119                         return 0;
 120                 else
 121                         return -1;
 122         }
 123         return bytes_written;
 124 }
 125
 126 void sipe_backend_ft_cancel_local(struct sipe_file_transfer *ft)
 127 {
 128         purple_xfer_cancel_local(PURPLE_XFER);
 129 }
 130
 131 void sipe_backend_ft_cancel_remote(struct sipe_file_transfer *ft)
 132 {
 133         purple_xfer_cancel_remote(PURPLE_XFER);
 134 }
 135
 136 static void
 137 ft_free_xfer_struct(PurpleXfer *xfer)
 138 {
 139         struct sipe_file_transfer *ft = PURPLE_XFER_TO_SIPE_FILE_TRANSFER;
 140
 141         if (ft) {
 142                 if (xfer->watcher) {
 143                         purple_input_remove(xfer->watcher);
 144                         xfer->watcher = 0;
 145                 }
 146                 sipe_core_ft_deallocate(ft);
 147                 PURPLE_XFER_DATA = NULL;
 148         }
 149 }
 150
 151 static void
 152 ft_request_denied(PurpleXfer *xfer)
 153 {
 154         if (xfer->type == PURPLE_XFER_RECEIVE)
 155                 sipe_core_ft_cancel(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
 156         ft_free_xfer_struct(xfer);
 157 }
 158
 159 static void
 160 ft_incoming_init(PurpleXfer *xfer)
 161 {
 162         sipe_core_ft_incoming_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
 163 }
 164
 165 static void
 166 tftp_incoming_start(PurpleXfer *xfer)
 167 {
 168         sipe_core_tftp_incoming_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 169                                       xfer->size);
 170 }
 171
 172 static void
 173 tftp_incoming_stop(PurpleXfer *xfer)
 174 {
 175         if (sipe_core_tftp_incoming_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 176                 /* We're done with this transfer */
 177                 ft_free_xfer_struct(xfer);
 178         } else {
 179                 unlink(xfer->local_filename);
 180         }
 181 }
 182
 183 static gssize
 184 tftp_read(guchar **buffer, PurpleXfer *xfer)
 185 {
 186         return sipe_core_tftp_read(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 187                                    buffer,
 188                                    purple_xfer_get_bytes_remaining(xfer),
 189                                    xfer->current_buffer_size);
 190 }
 191
 192 static void
 193 ft_outgoing_init(PurpleXfer *xfer)
 194 {
 195         sipe_core_ft_outgoing_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 196                                    purple_xfer_get_filename(xfer),
 197                                    purple_xfer_get_size(xfer),
 198                                    xfer->who);
 199 }
 200
 201 static void
 202 tftp_outgoing_start(PurpleXfer *xfer)
 203 {
 204         /* Set socket to non-blocking mode */
 205         int flags = fcntl(xfer->fd, F_GETFL, 0);
 206         if (flags == -1)
 207                 flags = 0;
 208         /* @TODO: ignoring potential error return - how to handle? */
 209         (void) fcntl(xfer->fd, F_SETFL, flags | O_NONBLOCK);
 210
 211         sipe_core_tftp_outgoing_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 212                                       xfer->size);
 213 }
 214
 215 static void
 216 tftp_outgoing_stop(PurpleXfer *xfer)
 217 {
 218         if (sipe_core_tftp_outgoing_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 219                 /* We're done with this transfer */
 220                 ft_free_xfer_struct(xfer);
 221         }
 222 }
 223
 224 static gssize
 225 tftp_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
 226 {
 227         gssize bytes_written = sipe_core_tftp_write(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 228                                                     buffer, size);
 229
 230         if ((xfer->bytes_remaining - bytes_written) == 0)
 231                 purple_xfer_set_completed(xfer, TRUE);
 232
 233         return bytes_written;
 234 }
 235
 236 //******************************************************************************
 237
 238 void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
 239                               struct sipe_file_transfer *ft,
 240                               const gchar *who,
 241                               const gchar *file_name,
 242                               gsize file_size)
 243 {
 244         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 245         PurpleXfer *xfer;
 246
 247         xfer = purple_xfer_new(purple_private->account,
 248                                PURPLE_XFER_RECEIVE,
 249                                who);
 250
 251         if (xfer) {
 252                 ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
 253                 PURPLE_XFER_DATA = ft;
 254
 255                 purple_xfer_set_filename(xfer, file_name);
 256                 purple_xfer_set_size(xfer, file_size);
 257
 258                 purple_xfer_set_init_fnc(xfer, ft_incoming_init);
 259                 purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
 260                 purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
 261                 purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
 262                 purple_xfer_set_start_fnc(xfer, tftp_incoming_start);
 263                 purple_xfer_set_end_fnc(xfer, tftp_incoming_stop);
 264                 purple_xfer_set_read_fnc(xfer, tftp_read);
 265
 266                 purple_xfer_request(xfer);
 267         }
 268 }
 269
 270 static void
 271 connect_cb(gpointer data, gint fd, SIPE_UNUSED_PARAMETER const gchar *error_message)
 272 {
 273         struct sipe_file_transfer *ft = data;
 274
 275         if (fd < 0) {
 276                 purple_xfer_cancel_local(PURPLE_XFER);
 277                 return;
 278         }
 279
 280         purple_xfer_start(PURPLE_XFER, fd, NULL, 0);
 281 }
 282
 283 void
 284 sipe_backend_ft_start(struct sipe_file_transfer *ft, struct sipe_backend_fd *fd,
 285                       const char* ip, unsigned port)
 286 {
 287         if (ip && port && !sipe_backend_ft_is_incoming(ft)) {
 288                 /* Purple accepts ip & port only for incoming file transfers.
 289                  * If we want to send file with Sender-Connect = TRUE negotiated,
 290                  * we have to open the connection ourselves and pass the file
 291                  * descriptor to purple_xfer_start. */
 292                 purple_proxy_connect(NULL, PURPLE_XFER->account, ip, port,
 293                                      connect_cb, ft);
 294                 return;
 295         }
 296
 297         purple_xfer_start(PURPLE_XFER, fd ? fd->fd : -1, ip, port);
 298 }
 299
 300 void sipe_purple_ft_send_file(PurpleConnection *gc,
 301                               const char *who,
 302                               const char *file)
 303 {
 304         PurpleXfer *xfer = sipe_purple_ft_new_xfer(gc, who);
 305
 306         if (xfer) {
 307                 if (file != NULL)
 308                         purple_xfer_request_accepted(xfer, file);
 309                 else
 310                         purple_xfer_request(xfer);
 311         }
 312 }
 313
 314 PurpleXfer *sipe_purple_ft_new_xfer(PurpleConnection *gc, const char *who)
 315 {
 316         PurpleXfer *xfer = NULL;
 317
 318         if (PURPLE_CONNECTION_IS_VALID(gc)) {
 319                 xfer = purple_xfer_new(purple_connection_get_account(gc),
 320                                        PURPLE_XFER_SEND, who);
 321
 322                 if (xfer) {
 323                         struct sipe_file_transfer *ft = sipe_core_ft_allocate(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 324
 325                         ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
 326                         PURPLE_XFER_DATA = ft;
 327
 328                         purple_xfer_set_init_fnc(xfer, ft_outgoing_init);
 329                         purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
 330                         purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
 331                         purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
 332                         purple_xfer_set_start_fnc(xfer, tftp_outgoing_start);
 333                         purple_xfer_set_end_fnc(xfer, tftp_outgoing_stop);
 334                         purple_xfer_set_write_fnc(xfer, tftp_write);
 335                 }
 336         }
 337
 338         return xfer;
 339 }
 340
 341 gboolean
 342 sipe_backend_ft_is_incoming(struct sipe_file_transfer *ft)
 343 {
 344         return purple_xfer_get_type(PURPLE_XFER) == PURPLE_XFER_RECEIVE;
 345 }
 346
 347 /*
 348   Local Variables:
 349   mode: c
 350   c-file-style: "bsd"
 351   indent-tabs-mode: t
 352   tab-width: 8
 353   End:
 354 */