6 * Copyright (C) 2010-2016 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>
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.
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.
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
40 #if PURPLE_VERSION_CHECK(3,0,0)
42 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) purple_connection_get_protocol_data(purple_account_get_connection(purple_xfer_get_account(xfer))))
45 #define PurpleXferStatus PurpleXferStatusType
46 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) purple_account_get_connection(xfer->account)->proto_data)
47 #define PURPLE_XFER_TYPE_RECEIVE PURPLE_XFER_RECEIVE
48 #define PURPLE_XFER_TYPE_SEND PURPLE_XFER_SEND
49 #define purple_xfer_get_fd(xfer) xfer->fd
50 #define purple_xfer_get_protocol_data(xfer) xfer->data
51 #define purple_xfer_get_status(xfer) purple_xfer_get_status(xfer)
52 #define purple_xfer_get_xfer_type(xfer) purple_xfer_get_type(xfer)
53 #define purple_xfer_get_watcher(xfer) xfer->watcher
54 #define purple_xfer_set_protocol_data(xfer, d) xfer->data = d
55 #define purple_xfer_set_watcher(xfer, w) xfer->watcher = w
59 /* wrappers for write() & friends for socket handling */
60 #include "win32/win32dep.h"
63 #include "sipe-common.h"
64 #include "sipe-backend.h"
65 #include "sipe-core.h"
67 #include "purple-private.h"
69 #define FT_TO_PURPLE_XFER ((PurpleXfer *) ft->backend_private)
70 #define PURPLE_XFER_TO_SIPE_FILE_TRANSFER ((struct sipe_file_transfer *) purple_xfer_get_protocol_data(xfer))
72 void sipe_backend_ft_error(struct sipe_file_transfer
*ft
,
75 PurpleXfer
*xfer
= FT_TO_PURPLE_XFER
;
76 purple_xfer_error(purple_xfer_get_xfer_type(xfer
),
77 purple_xfer_get_account(xfer
),
78 purple_xfer_get_remote_user(xfer
),
82 const gchar
*sipe_backend_ft_get_error(SIPE_UNUSED_PARAMETER
struct sipe_file_transfer
*ft
)
84 return strerror(errno
);
87 void sipe_backend_ft_deallocate(struct sipe_file_transfer
*ft
)
89 PurpleXfer
*xfer
= FT_TO_PURPLE_XFER
;
90 PurpleXferStatus status
= purple_xfer_get_status(xfer
);
92 // If file transfer is not finished, cancel it
93 if ( status
!= PURPLE_XFER_STATUS_DONE
94 && status
!= PURPLE_XFER_STATUS_CANCEL_LOCAL
95 && status
!= PURPLE_XFER_STATUS_CANCEL_REMOTE
) {
96 purple_xfer_set_cancel_recv_fnc(xfer
, NULL
);
97 purple_xfer_set_cancel_send_fnc(xfer
, NULL
);
98 purple_xfer_cancel_remote(xfer
);
102 gssize
sipe_backend_ft_read(struct sipe_file_transfer
*ft
,
106 gssize bytes_read
= read(purple_xfer_get_fd(FT_TO_PURPLE_XFER
),
109 if (bytes_read
== 0) {
110 /* Sender canceled transfer before it was finished */
112 } else if (bytes_read
== -1) {
121 gssize
sipe_backend_ft_write(struct sipe_file_transfer
*ft
,
125 gssize bytes_written
= write(purple_xfer_get_fd(FT_TO_PURPLE_XFER
),
128 if (bytes_written
== -1) {
134 return bytes_written
;
138 end_transfer_cb(gpointer data
)
140 purple_xfer_end((PurpleXfer
*)data
);
145 sipe_backend_ft_set_completed(struct sipe_file_transfer
*ft
)
147 purple_xfer_set_completed(FT_TO_PURPLE_XFER
, TRUE
);
148 purple_timeout_add(0, end_transfer_cb
, FT_TO_PURPLE_XFER
);
151 void sipe_backend_ft_cancel_local(struct sipe_file_transfer
*ft
)
153 purple_xfer_cancel_local(FT_TO_PURPLE_XFER
);
156 void sipe_backend_ft_cancel_remote(struct sipe_file_transfer
*ft
)
158 purple_xfer_cancel_remote(FT_TO_PURPLE_XFER
);
162 ft_free_xfer_struct(PurpleXfer
*xfer
)
164 if (purple_xfer_get_watcher(xfer
)) {
165 purple_input_remove(purple_xfer_get_watcher(xfer
));
166 purple_xfer_set_watcher(xfer
, 0);
169 purple_xfer_set_protocol_data(xfer
, NULL
);
173 ft_request_denied(PurpleXfer
*xfer
)
175 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
176 if (ft
->ft_request_denied
) {
177 ft
->ft_request_denied(ft
);
180 ft_free_xfer_struct(xfer
);
184 ft_cancelled(PurpleXfer
*xfer
)
186 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
188 if (ft
->ft_cancelled
&&
189 purple_xfer_get_status(xfer
) == PURPLE_XFER_STATUS_CANCEL_LOCAL
) {
190 ft
->ft_cancelled(ft
);
193 ft_free_xfer_struct(xfer
);
197 ft_init(PurpleXfer
*xfer
)
199 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
200 g_return_if_fail(ft
->ft_init
);
203 purple_xfer_get_filename(xfer
),
204 purple_xfer_get_size(xfer
),
205 purple_xfer_get_remote_user(xfer
));
209 ft_start(PurpleXfer
*xfer
)
211 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
213 if (purple_xfer_get_xfer_type(xfer
) == PURPLE_XFER_TYPE_RECEIVE
) {
214 /* Set socket to non-blocking mode */
215 int flags
= fcntl(purple_xfer_get_fd(xfer
), F_GETFL
, 0);
219 /* @TODO: ignoring potential error return - how to handle? */
220 fcntl(purple_xfer_get_fd(xfer
), F_SETFL
, flags
| O_NONBLOCK
);
224 ft
->ft_start(ft
, purple_xfer_get_size(xfer
));
229 ft_end(PurpleXfer
*xfer
)
231 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
233 if (!ft
->ft_end
|| ft
->ft_end(ft
)) {
234 /* We're done with this transfer */
235 ft_free_xfer_struct(xfer
);
236 } else if (purple_xfer_get_xfer_type(xfer
) == PURPLE_XFER_TYPE_RECEIVE
) {
237 /* Remove incomplete file from failed transfer. */
238 unlink(purple_xfer_get_local_filename(xfer
));
243 ft_read(guchar
**buffer
,
244 #if PURPLE_VERSION_CHECK(3,0,0)
249 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
250 g_return_val_if_fail(ft
->ft_read
, 0);
251 return ft
->ft_read(ft
, buffer
, purple_xfer_get_bytes_remaining(xfer
),
252 #if PURPLE_VERSION_CHECK(3,0,0)
255 xfer
->current_buffer_size
261 ft_write(const guchar
*buffer
, size_t size
, PurpleXfer
*xfer
)
263 struct sipe_file_transfer
*ft
= PURPLE_XFER_TO_SIPE_FILE_TRANSFER
;
264 gssize bytes_written
= 0;
266 g_return_val_if_fail(ft
->ft_write
, 0);
268 bytes_written
= ft
->ft_write(ft
, buffer
, size
);
270 if ((purple_xfer_get_bytes_remaining(xfer
) - bytes_written
) == 0)
271 purple_xfer_set_completed(xfer
, TRUE
);
273 return bytes_written
;
277 create_xfer(PurpleAccount
*account
, PurpleXferType type
, const char *who
,
278 struct sipe_file_transfer
*ft
)
280 PurpleXfer
*xfer
= purple_xfer_new(account
, type
, who
);
282 ft
->backend_private
= (struct sipe_backend_file_transfer
*)xfer
;
284 purple_xfer_set_protocol_data(xfer
, ft
);
285 purple_xfer_set_init_fnc(xfer
, ft_init
);
286 purple_xfer_set_request_denied_fnc(xfer
, ft_request_denied
);
287 purple_xfer_set_cancel_send_fnc(xfer
, ft_cancelled
);
288 purple_xfer_set_cancel_recv_fnc(xfer
, ft_cancelled
);
289 purple_xfer_set_start_fnc(xfer
, ft_start
);
290 purple_xfer_set_end_fnc(xfer
, ft_end
);
296 void sipe_backend_ft_incoming(struct sipe_core_public
*sipe_public
,
297 struct sipe_file_transfer
*ft
,
299 const gchar
*file_name
,
302 struct sipe_backend_private
*purple_private
= sipe_public
->backend_private
;
303 PurpleXfer
*xfer
= create_xfer(purple_private
->account
,
304 PURPLE_XFER_TYPE_RECEIVE
, who
, ft
);
306 purple_xfer_set_filename(xfer
, file_name
);
307 purple_xfer_set_size(xfer
, file_size
);
309 purple_xfer_request(xfer
);
314 sipe_backend_ft_outgoing(struct sipe_core_public
*sipe_public
,
315 struct sipe_file_transfer
*ft
,
317 const gchar
*file_name
)
319 struct sipe_backend_private
*purple_private
= sipe_public
->backend_private
;
320 PurpleXfer
*xfer
= create_xfer(purple_private
->account
,
321 PURPLE_XFER_TYPE_SEND
, who
, ft
);
323 if (file_name
!= NULL
)
324 purple_xfer_request_accepted(xfer
, file_name
);
326 purple_xfer_request(xfer
);
331 connect_cb(gpointer data
, gint fd
, SIPE_UNUSED_PARAMETER
const gchar
*error_message
)
333 struct sipe_file_transfer
*ft
= data
;
336 purple_xfer_cancel_local(FT_TO_PURPLE_XFER
);
340 purple_xfer_start(FT_TO_PURPLE_XFER
, fd
, NULL
, 0);
344 sipe_backend_ft_start(struct sipe_file_transfer
*ft
, struct sipe_backend_fd
*fd
,
345 const char* ip
, unsigned port
)
347 PurpleXferType type
= purple_xfer_get_xfer_type(FT_TO_PURPLE_XFER
);
348 if (type
== PURPLE_XFER_TYPE_SEND
&& ft
->ft_write
) {
349 purple_xfer_set_write_fnc(FT_TO_PURPLE_XFER
, ft_write
);
350 } else if (type
== PURPLE_XFER_TYPE_RECEIVE
&& ft
->ft_read
) {
351 purple_xfer_set_read_fnc(FT_TO_PURPLE_XFER
, ft_read
);
354 if (ip
&& port
&& !sipe_backend_ft_is_incoming(ft
)) {
355 /* Purple accepts ip & port only for incoming file transfers.
356 * If we want to send file with Sender-Connect = TRUE negotiated,
357 * we have to open the connection ourselves and pass the file
358 * descriptor to purple_xfer_start. */
359 purple_proxy_connect(NULL
,
360 purple_xfer_get_account(FT_TO_PURPLE_XFER
),
368 purple_xfer_start(FT_TO_PURPLE_XFER
, fd
? fd
->fd
: -1, ip
, port
);
371 void sipe_purple_ft_send_file(PurpleConnection
*gc
,
375 sipe_core_ft_create_outgoing(PURPLE_GC_TO_SIPE_CORE_PUBLIC
, who
, file
);
379 sipe_backend_ft_is_incoming(struct sipe_file_transfer
*ft
)
381 return(purple_xfer_get_xfer_type(FT_TO_PURPLE_XFER
) == PURPLE_XFER_TYPE_RECEIVE
);