src/purple/purple-ft.c

   1 /**
   2  * @file purple-ft.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010 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 "ft.h"
  36
  37 #ifdef _WIN32
  38 #include "win32/libc_interface.h"
  39 #endif
  40
  41 #include "sipe-common.h"
  42 #include "sipe-backend.h"
  43 #include "sipe-core.h"
  44
  45 #include "purple-private.h"
  46
  47 #define PURPLE_XFER                       ((PurpleXfer *) ft->backend_private)
  48 #define PURPLE_XFER_TO_SIPE_FILE_TRANSFER ((struct sipe_file_transfer *) xfer->data)
  49 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC   ((struct sipe_core_public *) xfer->account->gc->proto_data)
  50
  51 void sipe_backend_ft_error(struct sipe_file_transfer *ft,
  52                            const char *errmsg)
  53 {
  54         PurpleXfer *xfer = PURPLE_XFER;
  55         purple_xfer_error(purple_xfer_get_type(xfer),
  56                           xfer->account, xfer->who,
  57                           errmsg);
  58 }
  59
  60 const gchar *sipe_backend_ft_get_error(SIPE_UNUSED_PARAMETER struct sipe_file_transfer *ft)
  61 {
  62         return strerror(errno);
  63 }
  64
  65 void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
  66 {
  67         PurpleXfer *xfer = PURPLE_XFER;
  68         PurpleXferStatusType status = purple_xfer_get_status(xfer);
  69
  70         // If file transfer is not finished, cancel it
  71         if (   status != PURPLE_XFER_STATUS_DONE
  72                 && status != PURPLE_XFER_STATUS_CANCEL_LOCAL
  73                 && status != PURPLE_XFER_STATUS_CANCEL_REMOTE) {
  74                 purple_xfer_set_cancel_recv_fnc(xfer, NULL);
  75                 purple_xfer_set_cancel_send_fnc(xfer, NULL);
  76                 purple_xfer_cancel_remote(xfer);
  77         }
  78 }
  79
  80 gssize sipe_backend_ft_read(struct sipe_file_transfer *ft,
  81                             guchar *data,
  82                             gsize size)
  83 {
  84         gssize bytes_read = read(PURPLE_XFER->fd, data, size);
  85         if (bytes_read == 0) {
  86                 /* Sender canceled transfer before it was finished */
  87                 return -2;
  88         } else if (bytes_read == -1) {
  89                 if (errno == EAGAIN)
  90                         return 0;
  91                 else
  92                         return -1;
  93         }
  94         return bytes_read;
  95 }
  96
  97 gssize sipe_backend_ft_write(struct sipe_file_transfer *ft,
  98                              const guchar *data,
  99                              gsize size)
 100 {
 101         gssize bytes_written = write(PURPLE_XFER->fd, data, size);
 102         if (bytes_written == -1) {
 103                 if (errno == EAGAIN)
 104                         return 0;
 105                 else
 106                         return -1;
 107         }
 108         return bytes_written;
 109 }
 110
 111 void sipe_backend_ft_cancel_local(struct sipe_file_transfer *ft)
 112 {
 113         purple_xfer_cancel_local(PURPLE_XFER);
 114 }
 115
 116 void sipe_backend_ft_cancel_remote(struct sipe_file_transfer *ft)
 117 {
 118         purple_xfer_cancel_remote(PURPLE_XFER);
 119 }
 120
 121 static void
 122 ft_free_xfer_struct(PurpleXfer *xfer)
 123 {
 124         struct sipe_file_transfer *ft = PURPLE_XFER_TO_SIPE_FILE_TRANSFER;
 125
 126         if (ft) {
 127                 if (xfer->watcher) {
 128                         purple_input_remove(xfer->watcher);
 129                         xfer->watcher = 0;
 130                 }
 131                 sipe_core_ft_deallocate(ft);
 132                 xfer->data = NULL;
 133         }
 134 }
 135
 136 static void
 137 ft_request_denied(PurpleXfer *xfer)
 138 {
 139         if (xfer->type == PURPLE_XFER_RECEIVE)
 140                 sipe_core_ft_cancel(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
 141         ft_free_xfer_struct(xfer);
 142 }
 143
 144 static void
 145 ft_incoming_init(PurpleXfer *xfer)
 146 {
 147         sipe_core_ft_incoming_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
 148 }
 149
 150 static void
 151 tftp_incoming_start(PurpleXfer *xfer)
 152 {
 153         sipe_core_tftp_incoming_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 154                                       xfer->size);
 155 }
 156
 157 static void
 158 tftp_incoming_stop(PurpleXfer *xfer)
 159 {
 160         if (sipe_core_tftp_incoming_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 161                 /* We're done with this transfer */
 162                 ft_free_xfer_struct(xfer);
 163         } else {
 164                 unlink(xfer->local_filename);
 165         }
 166 }
 167
 168 static gssize
 169 tftp_read(guchar **buffer, PurpleXfer *xfer)
 170 {
 171         return sipe_core_tftp_read(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 172                                    buffer,
 173                                    purple_xfer_get_bytes_remaining(xfer),
 174                                    xfer->current_buffer_size);
 175 }
 176
 177 static void
 178 ft_outgoing_init(PurpleXfer *xfer)
 179 {
 180         sipe_core_ft_outgoing_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 181                                    purple_xfer_get_filename(xfer),
 182                                    purple_xfer_get_size(xfer),
 183                                    xfer->who);
 184 }
 185
 186 static void
 187 tftp_outgoing_start(PurpleXfer *xfer)
 188 {
 189         /* Set socket to non-blocking mode */
 190         int flags = fcntl(xfer->fd, F_GETFL, 0);
 191         if (flags == -1)
 192                 flags = 0;
 193         fcntl(xfer->fd, F_SETFL, flags | O_NONBLOCK);
 194
 195         sipe_core_tftp_outgoing_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 196                                       xfer->size);
 197 }
 198
 199 static void
 200 tftp_outgoing_stop(PurpleXfer *xfer)
 201 {
 202         if (sipe_core_tftp_outgoing_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 203                 /* We're done with this transfer */
 204                 ft_free_xfer_struct(xfer);
 205         }
 206 }
 207
 208 static gssize
 209 tftp_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
 210 {
 211         gssize bytes_written = sipe_core_tftp_write(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 212                                                     buffer, size);
 213
 214         if ((xfer->bytes_remaining - bytes_written) == 0)
 215                 purple_xfer_set_completed(xfer, TRUE);
 216
 217         return bytes_written;
 218 }
 219
 220 //******************************************************************************
 221
 222 void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
 223                               struct sipe_file_transfer *ft,
 224                               const gchar *who,
 225                               const gchar *file_name,
 226                               gsize file_size)
 227 {
 228         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 229         PurpleXfer *xfer;
 230
 231         xfer = purple_xfer_new(purple_private->account,
 232                                PURPLE_XFER_RECEIVE,
 233                                who);
 234
 235         if (xfer) {
 236                 ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
 237                 xfer->data = ft;
 238
 239                 purple_xfer_set_filename(xfer, file_name);
 240                 purple_xfer_set_size(xfer, file_size);
 241
 242                 purple_xfer_set_init_fnc(xfer, ft_incoming_init);
 243                 purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
 244                 purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
 245                 purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
 246                 purple_xfer_set_start_fnc(xfer, tftp_incoming_start);
 247                 purple_xfer_set_end_fnc(xfer, tftp_incoming_stop);
 248                 purple_xfer_set_read_fnc(xfer, tftp_read);
 249
 250                 purple_xfer_request(xfer);
 251         }
 252 }
 253
 254 static void
 255 connect_cb(gpointer data, gint fd, SIPE_UNUSED_PARAMETER const gchar *error_message)
 256 {
 257         struct sipe_file_transfer *ft = data;
 258
 259         if (fd < 0) {
 260                 purple_xfer_cancel_local(PURPLE_XFER);
 261                 return;
 262         }
 263
 264         purple_xfer_start(PURPLE_XFER, fd, NULL, 0);
 265 }
 266
 267 void
 268 sipe_backend_ft_start(struct sipe_file_transfer *ft, struct sipe_backend_fd *fd,
 269                       const char* ip, unsigned port)
 270 {
 271         if (ip && port && !sipe_backend_ft_is_incoming(ft)) {
 272                 /* Purple accepts ip & port only for incoming file transfers.
 273                  * If we want to send file with Sender-Connect = TRUE negotiated,
 274                  * we have to open the connection ourselves and pass the file
 275                  * descriptor to purple_xfer_start. */
 276                 purple_proxy_connect(NULL, PURPLE_XFER->account, ip, port,
 277                                      connect_cb, ft);
 278                 return;
 279         }
 280
 281         purple_xfer_start(PURPLE_XFER, fd ? fd->fd : -1, ip, port);
 282 }
 283
 284 void sipe_purple_ft_send_file(PurpleConnection *gc,
 285                               const char *who,
 286                               const char *file)
 287 {
 288         PurpleXfer *xfer = sipe_purple_ft_new_xfer(gc, who);
 289
 290         if (xfer) {
 291                 if (file != NULL)
 292                         purple_xfer_request_accepted(xfer, file);
 293                 else
 294                         purple_xfer_request(xfer);
 295         }
 296 }
 297
 298 PurpleXfer *sipe_purple_ft_new_xfer(PurpleConnection *gc, const char *who)
 299 {
 300         PurpleXfer *xfer = NULL;
 301
 302         if (PURPLE_CONNECTION_IS_VALID(gc)) {
 303                 xfer = purple_xfer_new(purple_connection_get_account(gc),
 304                                        PURPLE_XFER_SEND, who);
 305
 306                 if (xfer) {
 307                         struct sipe_file_transfer *ft = sipe_core_ft_allocate(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 308
 309                         ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
 310                         xfer->data = ft;
 311
 312                         purple_xfer_set_init_fnc(xfer, ft_outgoing_init);
 313                         purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
 314                         purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
 315                         purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
 316                         purple_xfer_set_start_fnc(xfer, tftp_outgoing_start);
 317                         purple_xfer_set_end_fnc(xfer, tftp_outgoing_stop);
 318                         purple_xfer_set_write_fnc(xfer, tftp_write);
 319                 }
 320         }
 321
 322         return xfer;
 323 }
 324
 325 gboolean
 326 sipe_backend_ft_is_incoming(struct sipe_file_transfer *ft)
 327 {
 328         return purple_xfer_get_type(PURPLE_XFER) == PURPLE_XFER_RECEIVE;
 329 }
 330
 331 /*
 332   Local Variables:
 333   mode: c
 334   c-file-style: "bsd"
 335   indent-tabs-mode: t
 336   tab-width: 8
 337   End:
 338 */