/*------------------------------------------------------------------------
* Start the file transfer.
*
* @param xfer The file transfer object
*/
static void mxit_xfer_start( PurpleXfer* xfer )
{
goffset filesize;
unsigned char* buffer;
int wrote;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_start\n" );
if ( purple_xfer_get_type( xfer ) == PURPLE_XFER_SEND ) {
/*
* the user wants to send a file to one of his contacts. we need to create
* a buffer and copy the file data into memory and then we can send it to
* the contact. we will send the whole file with one go.
*/
filesize = purple_xfer_get_bytes_remaining( xfer );
buffer = g_malloc( filesize );
if ( fread( buffer, filesize, 1, xfer->dest_fp ) > 0 ) {
/* send data */
wrote = purple_xfer_write( xfer, buffer, filesize );
if ( wrote > 0 )
purple_xfer_set_bytes_sent( xfer, wrote );
}
else {
/* file read error */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "Unable to access the local file" ) );
purple_xfer_cancel_local( xfer );
}
/* free the buffer */
g_free( buffer );
buffer = NULL;
}
}
/*------------------------------------------------------------------------
* Initialise a new file transfer.
*
* @param xfer The file transfer object
*/
static void mxit_xfer_init( PurpleXfer* xfer )
{
struct mxitxfer* mx = (struct mxitxfer*) xfer->data;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_init\n" );
if ( purple_xfer_get_type( xfer ) == PURPLE_XFER_SEND ) {
/* we are trying to send a file to MXit */
if ( purple_xfer_get_size( xfer ) > CP_MAX_FILESIZE ) {
/* the file is too big */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "The file you are trying to send is too large!" ) );
purple_xfer_cancel_local( xfer );
return;
}
/* start the file transfer */
purple_xfer_start( xfer, -1, NULL, 0 );
}
else {
/*
* we have just accepted a file transfer request from MXit. send a confirmation
* to the MXit server so that can send us the file
*/
mxit_send_file_accept( mx->session, mx->fileid, purple_xfer_get_size( xfer ), 0 );
}
}
static void
update_buttons(PidginXferDialog *dialog, PurpleXfer *xfer)
{
if (dialog->selected_xfer == NULL) {
gtk_widget_set_sensitive(dialog->expander, FALSE);
gtk_widget_set_sensitive(dialog->open_button, FALSE);
gtk_widget_set_sensitive(dialog->stop_button, FALSE);
gtk_widget_show(dialog->stop_button);
gtk_widget_hide(dialog->remove_button);
return;
}
if (dialog->selected_xfer != xfer)
return;
if (purple_xfer_is_completed(xfer)) {
gtk_widget_hide(dialog->stop_button);
gtk_widget_show(dialog->remove_button);
#ifdef _WIN32
/* If using Win32... */
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_widget_set_sensitive(dialog->open_button, TRUE);
} else {
gtk_widget_set_sensitive(dialog->open_button, FALSE);
}
#else
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_widget_set_sensitive(dialog->open_button, TRUE);
} else {
gtk_widget_set_sensitive (dialog->open_button, FALSE);
}
#endif
gtk_widget_set_sensitive(dialog->remove_button, TRUE);
} else if (purple_xfer_is_canceled(xfer)) {
gtk_widget_hide(dialog->stop_button);
gtk_widget_show(dialog->remove_button);
gtk_widget_set_sensitive(dialog->open_button, FALSE);
gtk_widget_set_sensitive(dialog->remove_button, TRUE);
} else {
gtk_widget_show(dialog->stop_button);
gtk_widget_hide(dialog->remove_button);
gtk_widget_set_sensitive(dialog->open_button, FALSE);
gtk_widget_set_sensitive(dialog->stop_button, TRUE);
}
}
static void prplcb_xfer_new( PurpleXfer *xfer )
{
if( purple_xfer_get_type( xfer ) == PURPLE_XFER_RECEIVE )
{
/* This should suppress the stupid file dialog. */
purple_xfer_set_local_filename( xfer, "/tmp/wtf123" );
/* Sadly the xfer struct is still empty ATM so come back after
the caller is done. */
b_timeout_add( 0, prplcb_xfer_new_send_cb, xfer );
}
else
{
struct prpl_xfer_data *px = g_new0( struct prpl_xfer_data, 1 );
px->ft = next_ft;
px->ft->data = px;
px->xfer = xfer;
px->xfer->ui_data = px;
purple_xfer_set_filename( xfer, px->ft->file_name );
purple_xfer_set_size( xfer, px->ft->file_size );
next_ft = NULL;
}
}
/*------------------------------------------------------------------------
* A file has been received from the MXit server.
*
* @param session The MXit session object
* @param fileid A unique ID that identifies this file
* @param data The file data
* @param datalen The size of the data
*/
void mxit_xfer_rx_file( struct MXitSession* session, const char* fileid, const char* data, int datalen )
{
PurpleXfer* xfer = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_rx_file: (size=%i)\n", datalen );
/* find the file-transfer object */
xfer = find_mxit_xfer( session, fileid );
if ( xfer ) {
/* this is the transfer we have been looking for */
purple_xfer_ref( xfer );
purple_xfer_start( xfer, -1, NULL, 0 );
if ( fwrite( data, datalen, 1, xfer->dest_fp ) > 0 ) {
purple_xfer_unref( xfer );
purple_xfer_set_completed( xfer, TRUE );
purple_xfer_end( xfer );
/* inform MXit that file was successfully received */
mxit_send_file_received( session, fileid, RECV_STATUS_SUCCESS );
}
else {
/* file write error */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "Unable to save the file" ) );
purple_xfer_cancel_local( xfer );
}
}
else {
/* file transfer not found */
mxit_send_file_received( session, fileid, RECV_STATUS_BAD_ID );
}
}
void
purple_xfer_ui_ready(PurpleXfer *xfer)
{
PurpleInputCondition cond;
PurpleXferType type;
PurpleXferPrivData *priv;
g_return_if_fail(xfer != NULL);
priv = g_hash_table_lookup(xfers_data, xfer);
priv->ready |= PURPLE_XFER_READY_UI;
if (0 == (priv->ready & PURPLE_XFER_READY_PRPL))
return;
type = purple_xfer_get_type(xfer);
if (type == PURPLE_XFER_SEND)
cond = PURPLE_INPUT_WRITE;
else /* if (type == PURPLE_XFER_RECEIVE) */
cond = PURPLE_INPUT_READ;
if (xfer->watcher == 0 && xfer->fd != -1)
xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer);
priv->ready = PURPLE_XFER_READY_NONE;
do_transfer(xfer);
}
static gssize yahoo_xfer_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
{
gssize len;
struct yahoo_xfer_data *xd = xfer->data;
if (!xd)
return -1;
if (purple_xfer_get_type(xfer) != PURPLE_XFER_SEND) {
return -1;
}
len = write(xfer->fd, buffer, size);
if (len == -1) {
if (purple_xfer_get_bytes_sent(xfer) >= purple_xfer_get_size(xfer))
purple_xfer_set_completed(xfer, TRUE);
if ((errno != EAGAIN) && (errno != EINTR))
return -1;
return 0;
}
if ((purple_xfer_get_bytes_sent(xfer) + len) >= purple_xfer_get_size(xfer))
purple_xfer_set_completed(xfer, TRUE);
return len;
}
static void
bonjour_xfer_init(PurpleXfer *xfer)
{
PurpleBuddy *buddy;
BonjourBuddy *bb;
XepXfer *xf;
xf = (XepXfer*)xfer->data;
if(xf == NULL)
return;
purple_debug_info("bonjour", "Bonjour-xfer-init.\n");
buddy = purple_find_buddy(xfer->account, xfer->who);
/* this buddy is offline. */
if (buddy == NULL || (bb = purple_buddy_get_protocol_data(buddy)) == NULL)
return;
/* Assume it is the first IP. We could do something like keep track of which one is in use or something. */
if (bb->ips)
xf->buddy_ip = g_strdup(bb->ips->data);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
/* initiate file transfer, send SI offer. */
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_SEND.\n");
xep_ft_si_offer(xfer, xfer->who);
} else {
/* accept file transfer request, send SI result. */
xep_ft_si_result(xfer, xfer->who);
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_RECEIVE.\n");
}
}
static void
begin_transfer(PurpleXfer *xfer, PurpleInputCondition cond)
{
PurpleXferType type = purple_xfer_get_type(xfer);
PurpleXferUiOps *ui_ops = purple_xfer_get_ui_ops(xfer);
if (xfer->start_time != 0) {
purple_debug_error("xfer", "Transfer is being started multiple times\n");
g_return_if_reached();
}
if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) {
xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer),
type == PURPLE_XFER_RECEIVE ? "wb" : "rb");
if (xfer->dest_fp == NULL) {
purple_xfer_show_file_error(xfer, purple_xfer_get_local_filename(xfer));
purple_xfer_cancel_local(xfer);
return;
}
fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET);
}
if (xfer->fd != -1)
xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer);
xfer->start_time = time(NULL);
if (xfer->ops.start != NULL)
xfer->ops.start(xfer);
}
void
purple_xfer_ui_ready(PurpleXfer *xfer)
{
PurpleInputCondition cond;
PurpleXferType type;
PurpleXferPrivData *priv;
g_return_if_fail(xfer != NULL);
priv = g_hash_table_lookup(xfers_data, xfer);
priv->ready |= PURPLE_XFER_READY_UI;
if (0 == (priv->ready & PURPLE_XFER_READY_PRPL)) {
purple_debug_misc("xfer", "UI is ready on ft %p, waiting for prpl\n", xfer);
return;
}
purple_debug_misc("xfer", "UI (and prpl) ready on ft %p, so proceeding\n", xfer);
type = purple_xfer_get_type(xfer);
if (type == PURPLE_XFER_SEND)
cond = PURPLE_INPUT_WRITE;
else /* if (type == PURPLE_XFER_RECEIVE) */
cond = PURPLE_INPUT_READ;
if (xfer->watcher == 0 && xfer->fd != -1)
xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer);
priv->ready = PURPLE_XFER_READY_NONE;
do_transfer(xfer);
}
static void purple_xfer_show_file_error(PurpleXfer *xfer, const char *filename)
{
int err = errno;
gchar *msg = NULL, *utf8;
PurpleXferType xfer_type = purple_xfer_get_type(xfer);
PurpleAccount *account = purple_xfer_get_account(xfer);
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
switch(xfer_type) {
case PURPLE_XFER_SEND:
msg = g_strdup_printf(_("Error reading %s: \n%s.\n"),
utf8, g_strerror(err));
break;
case PURPLE_XFER_RECEIVE:
msg = g_strdup_printf(_("Error writing %s: \n%s.\n"),
utf8, g_strerror(err));
break;
default:
msg = g_strdup_printf(_("Error accessing %s: \n%s.\n"),
utf8, g_strerror(err));
break;
}
g_free(utf8);
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(xfer_type, account, xfer->who, msg);
g_free(msg);
}
void
peer_connection_finalize_connection(PeerConnection *conn)
{
conn->watcher_incoming = purple_input_add(conn->fd,
PURPLE_INPUT_READ, peer_connection_recv_cb, conn);
if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
{
/*
* If we are connecting to them then send our cookie so they
* can verify who we are. Note: This doesn't seem to be
* necessary, but it also doesn't seem to hurt.
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
peer_odc_send_cookie(conn);
}
else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
{
if (purple_xfer_get_type(conn->xfer) == PURPLE_XFER_SEND)
{
peer_oft_send_prompt(conn);
}
}
/*
* Tell the remote user that we're connected (which may also imply
* that we've accepted their request).
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
aim_im_sendch2_connected(conn);
}
/*------------------------------------------------------------------------
* Start the file transfer.
*
* @param xfer The file transfer object
*/
static void mxit_xfer_start( PurpleXfer* xfer )
{
unsigned char* buffer;
int size;
int wrote;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_start\n" );
if ( purple_xfer_get_type( xfer ) == PURPLE_XFER_SEND ) {
/*
* the user wants to send a file to one of his contacts. we need to create
* a buffer and copy the file data into memory and then we can send it to
* the contact. we will send the whole file with one go.
*/
buffer = g_malloc( xfer->bytes_remaining );
size = fread( buffer, xfer->bytes_remaining, 1, xfer->dest_fp );
wrote = purple_xfer_write( xfer, buffer, xfer->bytes_remaining );
if ( wrote > 0 )
purple_xfer_set_bytes_sent( xfer, wrote );
/* free the buffer */
g_free( buffer );
buffer = NULL;
}
}
/* Glorious hack: We seem to have to remind at least some libpurple plugins
that we're ready because this info may get lost if we give it too early.
So just do it ten times a second. :-/ */
static gboolean prplcb_xfer_write_request_cb( gpointer data, gint fd, b_input_condition cond )
{
struct prpl_xfer_data *px = data;
purple_xfer_ui_ready( px->xfer );
return purple_xfer_get_type( px->xfer ) == PURPLE_XFER_RECEIVE;
}
void sipe_backend_ft_error(struct sipe_file_transfer *ft,
const char *errmsg)
{
PurpleXfer *xfer = PURPLE_XFER;
purple_xfer_error(purple_xfer_get_type(xfer),
xfer->account, xfer->who,
errmsg);
}
void
purple_xfer_start(PurpleXfer *xfer, int fd, const char *ip,
unsigned int port)
{
PurpleInputCondition cond;
PurpleXferType type;
g_return_if_fail(xfer != NULL);
g_return_if_fail(purple_xfer_get_type(xfer) != PURPLE_XFER_UNKNOWN);
type = purple_xfer_get_type(xfer);
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_STARTED);
/*
* FIXME 3.0.0 -- there's too much broken code depending on fd == 0
* meaning "don't use a real fd"
*/
if (fd == 0)
fd = -1;
if (type == PURPLE_XFER_RECEIVE) {
cond = PURPLE_INPUT_READ;
if (ip != NULL) {
xfer->remote_ip = g_strdup(ip);
xfer->remote_port = port;
/* Establish a file descriptor. */
purple_proxy_connect(NULL, xfer->account, xfer->remote_ip,
xfer->remote_port, connect_cb, xfer);
return;
}
else {
xfer->fd = fd;
}
}
else {
cond = PURPLE_INPUT_WRITE;
xfer->fd = fd;
}
begin_transfer(xfer, cond);
}
void
purple_xfer_cancel_local(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
char *msg = NULL;
g_return_if_fail(xfer != NULL);
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
xfer->end_time = time(NULL);
if (purple_xfer_get_filename(xfer) != NULL)
{
msg = g_strdup_printf(_("You cancelled the transfer of %s"),
purple_xfer_get_filename(xfer));
}
else
{
msg = g_strdup(_("File transfer cancelled"));
}
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
{
if (xfer->ops.cancel_send != NULL)
xfer->ops.cancel_send(xfer);
}
else
{
if (xfer->ops.cancel_recv != NULL)
xfer->ops.cancel_recv(xfer);
}
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
if (xfer->fd != -1)
close(xfer->fd);
if (xfer->dest_fp != NULL) {
fclose(xfer->dest_fp);
xfer->dest_fp = NULL;
}
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->cancel_local != NULL)
ui_ops->cancel_local(xfer);
xfer->bytes_remaining = 0;
purple_xfer_unref(xfer);
}
static int
purple_xfer_choose_file(PurpleXfer *xfer)
{
purple_request_file(xfer, NULL, purple_xfer_get_filename(xfer),
(purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE),
G_CALLBACK(purple_xfer_choose_file_ok_cb),
G_CALLBACK(purple_xfer_choose_file_cancel_cb),
purple_xfer_get_account(xfer), xfer->who, NULL,
xfer);
return 0;
}
static void
purple_xfer_choose_file_cancel_cb(void *user_data, const char *filename)
{
PurpleXfer *xfer = (PurpleXfer *)user_data;
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
purple_xfer_cancel_local(xfer);
else
purple_xfer_request_denied(xfer);
purple_xfer_unref(xfer);
}
static void bonjour_xfer_end(PurpleXfer *xfer)
{
purple_debug_info("bonjour", "Bonjour-xfer-end.\n");
/* We can't allow the server side to close the connection until the client is complete,
* otherwise there is a RST resulting in an error on the client side */
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND && purple_xfer_is_completed(xfer)) {
struct socket_cleanup *sc = g_new0(struct socket_cleanup, 1);
sc->fd = xfer->fd;
xfer->fd = -1;
sc->handle = purple_input_add(sc->fd, PURPLE_INPUT_READ,
_wait_for_socket_close, sc);
}
bonjour_free_xfer(xfer);
}
static void prplcb_xfer_new(PurpleXfer *xfer)
{
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
struct prpl_xfer_data *px = g_new0(struct prpl_xfer_data, 1);
xfer->ui_data = px;
px->xfer = xfer;
px->fn = mktemp(g_strdup("/tmp/bitlbee-purple-ft.XXXXXX"));
px->fd = -1;
px->ic = purple_ic_by_pa(xfer->account);
purple_xfer_set_local_filename(xfer, px->fn);
/* Sadly the xfer struct is still empty ATM so come back after
the caller is done. */
b_timeout_add(0, prplcb_xfer_new_send_cb, xfer);
} else {
static void yahoo_xfer_init(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
xfer_data = xfer->data;
gc = xfer_data->gc;
yd = gc->proto_data;
account = purple_connection_get_account(gc);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
if (yd->jp) {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xferjp_host", YAHOOJP_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
} else {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
} else {
/* TODO: Using xfer->fd like this is probably a bad thing... */
if (purple_proxy_connect(NULL, account, xfer_data->host, xfer_data->port,
yahoo_receivefile_connected, xfer) == NULL)
xfer->fd = -1;
else
xfer->fd = 0;
if (xfer->fd == -1) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
}
void
purple_xfer_set_completed(PurpleXfer *xfer, gboolean completed)
{
PurpleXferUiOps *ui_ops;
g_return_if_fail(xfer != NULL);
if (completed == TRUE) {
char *msg = NULL;
PurpleConversation *conv;
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_DONE);
if (purple_xfer_get_filename(xfer) != NULL)
{
char *filename = g_markup_escape_text(purple_xfer_get_filename(xfer), -1);
if (purple_xfer_get_local_filename(xfer)
&& purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
{
char *local = g_markup_escape_text(purple_xfer_get_local_filename(xfer), -1);
msg = g_strdup_printf(_("Transfer of file <A HREF=\"file://%s\">%s</A> complete"),
local, filename);
g_free(local);
}
else
msg = g_strdup_printf(_("Transfer of file %s complete"),
filename);
g_free(filename);
}
else
msg = g_strdup(_("File transfer complete"));
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
purple_xfer_get_account(xfer));
if (conv != NULL)
purple_conversation_write(conv, NULL, msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
}
void
finch_xfer_dialog_add_xfer(PurpleXfer *xfer)
{
PurpleGntXferUiData *data;
PurpleXferType type;
char *size_str, *remaining_str;
char *lfilename, *utf8;
g_return_if_fail(xfer_dialog != NULL);
g_return_if_fail(xfer != NULL);
purple_xfer_ref(xfer);
data = FINCHXFER(xfer);
data->in_list = TRUE;
finch_xfer_dialog_show();
data->last_updated_time = 0;
type = purple_xfer_get_type(xfer);
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL);
g_free(lfilename);
lfilename = utf8;
gnt_tree_add_row_last(GNT_TREE(xfer_dialog->tree), xfer,
gnt_tree_create_row(GNT_TREE(xfer_dialog->tree),
"0.0", (type == PURPLE_XFER_RECEIVE) ? purple_xfer_get_filename(xfer) : lfilename,
size_str, "0.0", "",_("Waiting for transfer to begin")), NULL);
g_free(lfilename);
g_free(size_str);
g_free(remaining_str);
xfer_dialog->num_transfers++;
update_title_progress();
}
void
purple_xfer_request(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
g_return_if_fail(xfer->ops.init != NULL);
purple_xfer_ref(xfer);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
{
purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
{
/* The file-transfer was cancelled by a plugin */
purple_xfer_cancel_local(xfer);
}
else if (purple_xfer_get_filename(xfer) ||
purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED)
{
gchar* message = NULL;
PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
message = g_strdup_printf(_("%s is offering to send file %s"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
purple_xfer_conversation_write_with_thumbnail(xfer, message);
g_free(message);
/* Ask for a filename to save to if it's not already given by a plugin */
if (xfer->local_filename == NULL)
purple_xfer_ask_recv(xfer);
}
else
{
purple_xfer_ask_accept(xfer);
}
}
else
{
purple_xfer_choose_file(xfer);
}
}
static void
skypeweb_got_file(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
SkypeWebFileTransfer *swft = user_data;
PurpleXfer *xfer = swft->xfer;
SkypeWebAccount *sa = swft->sa;
sa->url_datas = g_slist_remove(sa->url_datas, url_data);
if (error_message) {
purple_xfer_error(purple_xfer_get_type(xfer), sa->account, swft->from, error_message);
purple_xfer_cancel_local(xfer);
} else {
purple_xfer_write_file(xfer, (guchar *)url_text, len);
purple_xfer_set_bytes_sent(xfer, len);
purple_xfer_set_completed(xfer, TRUE);
}
//cleanup
skypeweb_free_xfer(xfer);
}
static gboolean tgprpl_xfer_upload_progress (gpointer _data) {
PurpleXfer *X = _data;
struct tgp_xfer_send_data *data = X->data;
connection_data *conn = data->conn;
PurpleXferType type = purple_xfer_get_type(X);
switch (type) {
case PURPLE_XFER_SEND:
purple_xfer_set_size (X, conn->TLS->cur_uploading_bytes);
purple_xfer_set_bytes_sent (X, conn->TLS->cur_uploaded_bytes);
purple_xfer_update_progress (X);
debug ("PURPLE_XFER_SEND progress %d / %d", conn->TLS->cur_uploaded_bytes, conn->TLS->cur_uploading_bytes);
if (conn->TLS->cur_uploaded_bytes == conn->TLS->cur_uploading_bytes) {
data->timer = 0;
return FALSE;
}
break;
case PURPLE_XFER_RECEIVE:
purple_xfer_set_size (X, conn->TLS->cur_downloading_bytes);
purple_xfer_set_bytes_sent (X, conn->TLS->cur_downloaded_bytes);
purple_xfer_update_progress (X);
debug ("PURPLE_XFER_RECEIVE progress %d / %d", conn->TLS->cur_downloaded_bytes, conn->TLS->cur_downloading_bytes);
if (conn->TLS->cur_downloading_bytes == conn->TLS->cur_downloaded_bytes) {
data->timer = 0;
return FALSE;
}
break;
default:
case PURPLE_XFER_UNKNOWN:
failure ("ERROR: tgprpl_xfer_upload_progress xfer type PURPLE_XFER_UNKNOWN.");
return FALSE;
break;
}
return TRUE;
}
/*------------------------------------------------------------------------
* Send the file data.
*
* @param buffer The data to sent
* @param size The length of the data to send
* @param xfer The file transfer object
* @return The amount of data actually sent
*/
static gssize mxit_xfer_write( const guchar* buffer, size_t size, PurpleXfer* xfer )
{
struct mxitxfer* mx = (struct mxitxfer*) xfer->data;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_write\n" );
if ( !mx ) {
purple_debug_warning( MXIT_PLUGIN_ID, "mxit_xfer_write: invalid internal mxit xfer data\n" );
return -1;
}
else if ( purple_xfer_get_type( xfer ) != PURPLE_XFER_SEND ) {
purple_debug_warning( MXIT_PLUGIN_ID, "mxit_xfer_write: wrong xfer type received\n" );
return -1;
}
/* create and send the packet to MXit */
mxit_send_file( mx->session, purple_xfer_get_remote_user( xfer ), purple_xfer_get_filename( xfer ), buffer, size );
/* the transfer is complete */
purple_xfer_set_completed( xfer, TRUE );
return size;
}
void
purple_xfer_request_accepted(PurpleXfer *xfer, const char *filename)
{
PurpleXferType type;
struct stat st;
char *msg, *utf8, *base;
PurpleAccount *account;
PurpleBuddy *buddy;
if (xfer == NULL)
return;
type = purple_xfer_get_type(xfer);
account = purple_xfer_get_account(xfer);
purple_debug_misc("xfer", "request accepted for %p\n", xfer);
if (!filename && type == PURPLE_XFER_RECEIVE) {
xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
xfer->ops.init(xfer);
return;
}
buddy = purple_find_buddy(account, xfer->who);
if (type == PURPLE_XFER_SEND) {
/* Sending a file */
/* Check the filename. */
PurpleXferUiOps *ui_ops;
ui_ops = purple_xfer_get_ui_ops(xfer);
#ifdef _WIN32
if (g_strrstr(filename, "../") || g_strrstr(filename, "..\\"))
#else
if (g_strrstr(filename, "../"))
#endif
{
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8);
purple_xfer_error(type, account, xfer->who, msg);
g_free(utf8);
g_free(msg);
purple_xfer_unref(xfer);
return;
}
if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) {
if (g_stat(filename, &st) == -1) {
purple_xfer_show_file_error(xfer, filename);
purple_xfer_unref(xfer);
return;
}
purple_xfer_set_local_filename(xfer, filename);
purple_xfer_set_size(xfer, st.st_size);
} else {
utf8 = g_strdup(filename);
purple_xfer_set_local_filename(xfer, filename);
}
base = g_path_get_basename(filename);
utf8 = g_filename_to_utf8(base, -1, NULL, NULL, NULL);
g_free(base);
purple_xfer_set_filename(xfer, utf8);
msg = g_strdup_printf(_("Offering to send %s to %s"),
utf8, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
g_free(utf8);
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
}
else {
/* Receiving a file */
xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
purple_xfer_set_local_filename(xfer, filename);
msg = g_strdup_printf(_("Starting transfer of %s from %s"),
xfer->filename, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
}
purple_xfer_add(xfer);
xfer->ops.init(xfer);
}
static void
purple_xfer_choose_file_ok_cb(void *user_data, const char *filename)
{
PurpleXfer *xfer;
PurpleXferType type;
struct stat st;
gchar *dir;
xfer = (PurpleXfer *)user_data;
type = purple_xfer_get_type(xfer);
if (g_stat(filename, &st) != 0) {
/* File not found. */
if (type == PURPLE_XFER_RECEIVE) {
#ifndef _WIN32
int mode = W_OK;
#else
int mode = F_OK;
#endif
dir = g_path_get_dirname(filename);
if (g_access(dir, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("Directory is not writable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
g_free(dir);
}
else {
purple_xfer_show_file_error(xfer, filename);
purple_xfer_cancel_local(xfer);
}
}
else if ((type == PURPLE_XFER_SEND) && (st.st_size == 0)) {
purple_notify_error(NULL, NULL,
_("Cannot send a file of 0 bytes."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_SEND) && S_ISDIR(st.st_mode)) {
/*
* XXX - Sending a directory should be valid for some protocols.
*/
purple_notify_error(NULL, NULL,
_("Cannot send a directory."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_RECEIVE) && S_ISDIR(st.st_mode)) {
char *msg, *utf8;
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
msg = g_strdup_printf(
_("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8);
g_free(utf8);
purple_notify_error(NULL, NULL, msg, NULL);
g_free(msg);
purple_xfer_request_denied(xfer);
}
else if (type == PURPLE_XFER_SEND) {
#ifndef _WIN32
int mode = R_OK;
#else
int mode = F_OK;
#endif
if (g_access(filename, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("File is not readable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
}
else {
purple_xfer_request_accepted(xfer, filename);
}
purple_xfer_unref(xfer);
}
