static void _qq_send_file_progess(PurpleConnection *gc)
{
qq_data *qd = (qq_data *) gc->proto_data;
PurpleXfer *xfer = qd->xfer;
ft_info *info = (ft_info *) xfer->data;
guint32 mask;
guint8 *buffer;
guint i;
gint readbytes;
if (purple_xfer_get_bytes_remaining(xfer) <= 0) return;
if (info->window == 0 && info->max_fragment_index == 0)
{
if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "rb", xfer) == -1) {
purple_xfer_cancel_local(xfer);
return;
}
}
buffer = g_newa(guint8, info->fragment_len);
mask = 0x1 << (info->max_fragment_index % sizeof(info->window));
for (i = 0; i < sizeof(info->window); i++) {
if ((info->window & mask) == 0) {
readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + i, info->fragment_len, xfer);
if (readbytes > 0)
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO,
info->max_fragment_index + i + 1, 0, buffer, readbytes);
}
if (mask & 0x8000) mask = 0x0001;
else mask = mask << 1;
}
}
static void ggp_edisc_xfer_recv_done(PurpleHttpConnection *hc,
PurpleHttpResponse *response, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer);
if (purple_xfer_is_cancelled(xfer))
return;
g_return_if_fail(edisc_xfer != NULL);
edisc_xfer->hc = NULL;
if (!purple_http_response_is_successful(response)) {
ggp_edisc_xfer_error(xfer, _("Error while receiving a file"));
return;
}
if (purple_xfer_get_bytes_remaining(xfer) == 0) {
purple_xfer_set_completed(xfer, TRUE);
purple_xfer_end(xfer);
ggp_edisc_xfer_free(xfer);
} else {
purple_debug_warning("gg", "ggp_edisc_xfer_recv_done: didn't "
"received everything\n");
ggp_edisc_xfer_error(xfer, _("Error while receiving a file"));
}
}
/*------------------------------------------------------------------------
* 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;
}
}
static gssize
tftp_read(guchar **buffer, PurpleXfer *xfer)
{
return sipe_core_tftp_read(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
buffer,
purple_xfer_get_bytes_remaining(xfer),
xfer->current_buffer_size);
}
static void _qq_update_send_progess(PurpleConnection *gc, guint32 fragment_index)
{
guint32 mask;
guint8 *buffer;
gint readbytes;
qq_data *qd = (qq_data *) gc->proto_data;
PurpleXfer *xfer = qd->xfer;
ft_info *info = (ft_info *) xfer->data;
purple_debug_info("QQ",
"receiving %dth fragment ack, slide window status %o, max_fragment_index %d\n",
fragment_index, info->window, info->max_fragment_index);
if (fragment_index < info->max_fragment_index ||
fragment_index >= info->max_fragment_index + sizeof(info->window)) {
purple_debug_info("QQ", "duplicate %dth fragment, drop it!\n", fragment_index+1);
return;
}
mask = 0x1 << (fragment_index % sizeof(info->window));
if ((info->window & mask) == 0)
{
info->window |= mask;
if (fragment_index + 1 != info->fragment_num) {
xfer->bytes_sent += info->fragment_len;
} else {
xfer->bytes_sent += purple_xfer_get_size(xfer) % info->fragment_len;
}
xfer->bytes_remaining = purple_xfer_get_size(xfer) - purple_xfer_get_bytes_sent(xfer);
purple_xfer_update_progress(xfer);
if (purple_xfer_get_bytes_remaining(xfer) <= 0) {
/* We have finished sending the file */
purple_xfer_set_completed(xfer, TRUE);
return;
}
mask = 0x1 << (info->max_fragment_index % sizeof(info->window));
while (info->window & mask)
{
/* move the slide window */
info->window &= ~mask;
buffer = g_newa(guint8, info->fragment_len);
readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + sizeof(info->window),
info->fragment_len, xfer);
if (readbytes > 0)
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO,
info->max_fragment_index + sizeof(info->window) + 1, 0, buffer, readbytes);
info->max_fragment_index ++;
if (mask & 0x8000) mask = 0x0001;
else mask = mask << 1;
}
}
purple_debug_info("QQ",
"procceed %dth fragment ack, slide window status %o, max_fragment_index %d\n",
fragment_index, info->window, info->max_fragment_index);
}
static gboolean ggp_edisc_xfer_recv_writer(PurpleHttpConnection *http_conn,
PurpleHttpResponse *response, const gchar *buffer, size_t offset,
size_t length, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
ggp_edisc_xfer *edisc_xfer;
gssize stored;
g_return_val_if_fail(xfer != NULL, FALSE);
edisc_xfer = purple_xfer_get_protocol_data(xfer);
g_return_val_if_fail(edisc_xfer != NULL, FALSE);
stored = purple_xfer_write_file(xfer, (guchar *)buffer, length) ?
(gssize)length : -1;
if (stored < 0 || (gsize)stored != length) {
purple_debug_error("gg", "ggp_edisc_xfer_recv_writer: "
"saved too less\n");
return FALSE;
}
if (stored > purple_xfer_get_bytes_remaining(xfer)) {
purple_debug_error("gg", "ggp_edisc_xfer_recv_writer: "
"saved too much (%" G_GSSIZE_FORMAT " > %" G_GOFFSET_FORMAT ")\n",
stored, purple_xfer_get_bytes_remaining(xfer));
return FALSE;
}
/* May look redundant with ggp_edisc_xfer_progress_watcher,
* but it isn't!
*/
purple_xfer_set_bytes_sent(xfer,
purple_xfer_get_bytes_sent(xfer) + stored);
return TRUE;
}
static gssize irc_dccsend_send_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
{
gssize s;
int ret;
s = MIN(purple_xfer_get_bytes_remaining(xfer), size);
if (!s)
return 0;
ret = write(xfer->fd, buffer, s);
if (ret < 0 && errno == EAGAIN)
ret = 0;
return ret;
}
static void
yahoo_process_filetrans_15_reader(PurpleHttpConnection *hc,
gchar *buffer, size_t offset, size_t length, gpointer _xfer,
PurpleHttpContentReaderCb cb)
{
PurpleXfer *xfer = _xfer;
gssize stored;
if ((goffset)offset != purple_xfer_get_bytes_sent(xfer)) {
purple_debug_warning("yahoo",
"offset != purple_xfer_get_bytes_sent(xfer)\n");
}
stored = purple_xfer_read_file(xfer, (guchar*)buffer, length);
cb(hc, (stored >= 0), (purple_xfer_get_bytes_remaining(xfer) == 0),
stored);
}
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();
}
gssize
purple_xfer_read(PurpleXfer *xfer, guchar **buffer)
{
gssize s, r;
g_return_val_if_fail(xfer != NULL, 0);
g_return_val_if_fail(buffer != NULL, 0);
if (purple_xfer_get_size(xfer) == 0)
s = xfer->current_buffer_size;
else
s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
if (xfer->ops.read != NULL) {
r = (xfer->ops.read)(buffer, xfer);
}
else {
*buffer = g_malloc0(s);
r = read(xfer->fd, *buffer, s);
if (r < 0 && errno == EAGAIN)
r = 0;
else if (r < 0)
r = -1;
else if (r == 0)
r = -1;
}
if (r == xfer->current_buffer_size)
/*
* We managed to read the entire buffer. This means our this
* network is fast and our buffer is too small, so make it
* bigger.
*/
purple_xfer_increase_buffer_size(xfer);
return r;
}
gssize
purple_xfer_write(PurpleXfer *xfer, const guchar *buffer, gsize size)
{
gssize r, s;
g_return_val_if_fail(xfer != NULL, 0);
g_return_val_if_fail(buffer != NULL, 0);
g_return_val_if_fail(size != 0, 0);
s = MIN(purple_xfer_get_bytes_remaining(xfer), size);
if (xfer->ops.write != NULL) {
r = (xfer->ops.write)(buffer, s, xfer);
} else {
r = write(xfer->fd, buffer, s);
if (r < 0 && errno == EAGAIN)
r = 0;
if ((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer))
purple_xfer_set_completed(xfer, TRUE);
}
return r;
}
static void
yahoo_process_filetrans_15_downloaded(PurpleHttpConnection *hc,
PurpleHttpResponse *response, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
struct yahoo_xfer_data *xd;
xd = purple_xfer_get_protocol_data(xfer);
xd->hc = NULL;
if (purple_xfer_is_cancelled(xfer))
return;
if (!purple_http_response_is_successful(response) ||
purple_xfer_get_bytes_remaining(xfer) > 0)
{
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
purple_xfer_end(xfer);
} else {
purple_xfer_set_completed(xfer, TRUE);
purple_xfer_end(xfer);
}
}
void
pidgin_xfer_dialog_update_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
char *size_str, *remaining_str;
GtkTreeSelection *selection;
time_t current_time;
GtkTreeIter iter;
gboolean valid;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
if ((data = PIDGINXFER(xfer)) == NULL)
return;
if (data->in_list == FALSE)
return;
current_time = time(NULL);
if (((current_time - data->last_updated_time) == 0) &&
(!purple_xfer_is_completed(xfer)))
{
/* Don't update the window more than once per second */
return;
}
data->last_updated_time = current_time;
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));
gtk_list_store_set(xfer_dialog->model, &data->iter,
COLUMN_PROGRESS, purple_xfer_get_progress(xfer),
COLUMN_SIZE, size_str,
COLUMN_REMAINING, remaining_str,
-1);
g_free(size_str);
g_free(remaining_str);
if (purple_xfer_is_completed(xfer))
{
GdkPixbuf *pixbuf;
pixbuf = gtk_widget_render_icon(dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_REMAINING, _("Finished"),
-1);
g_object_unref(pixbuf);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(xfer_dialog->tree));
update_title_progress(dialog);
if (xfer == dialog->selected_xfer)
update_detailed_info(xfer_dialog, xfer);
if (purple_xfer_is_completed(xfer) && dialog->auto_clear)
pidgin_xfer_dialog_remove_xfer(dialog, xfer);
else
update_buttons(dialog, xfer);
/*
* If all transfers are finished, and the pref is set, then
* close the dialog. Otherwise just exit this function.
*/
if (dialog->keep_open)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
while (valid)
{
GValue val;
PurpleXfer *next;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
next = g_value_get_pointer(&val);
if (!purple_xfer_is_completed(next))
return;
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* If we got to this point then we know everything is finished */
pidgin_xfer_dialog_hide(dialog);
}
void
finch_xfer_dialog_update_xfer(PurpleXfer *xfer)
{
PurpleGntXferUiData *data;
char *size_str, *remaining_str;
time_t current_time;
char prog_str[5];
double kb_sent;
double kbps = 0.0;
time_t elapsed, now;
char *kbsec;
gboolean send;
if ((now = purple_xfer_get_end_time(xfer)) == 0)
now = time(NULL);
kb_sent = purple_xfer_get_bytes_sent(xfer) / 1024.0;
elapsed = (purple_xfer_get_start_time(xfer) > 0 ? now - purple_xfer_get_start_time(xfer) : 0);
kbps = (elapsed > 0 ? (kb_sent / elapsed) : 0);
g_return_if_fail(xfer_dialog != NULL);
g_return_if_fail(xfer != NULL);
if ((data = FINCHXFER(xfer)) == NULL)
return;
if (data->in_list == FALSE || data->notified)
return;
current_time = time(NULL);
if (((current_time - data->last_updated_time) == 0) &&
(!purple_xfer_is_completed(xfer))) {
/* Don't update the window more than once per second */
return;
}
data->last_updated_time = current_time;
send = (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND);
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));
kbsec = g_strdup_printf(_("%.2f KiB/s"), kbps);
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_PROGRESS,
g_ascii_dtostr(prog_str, sizeof(prog_str), purple_xfer_get_progress(xfer) * 100.));
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_SIZE, size_str);
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_REMAINING, remaining_str);
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_SPEED, kbsec);
g_free(size_str);
g_free(remaining_str);
g_free(kbsec);
if (purple_xfer_is_completed(xfer)) {
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_STATUS, send ? _("Sent") : _("Received"));
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_REMAINING, _("Finished"));
if (!send) {
char *msg = g_strdup_printf(_("The file was saved as %s."), purple_xfer_get_local_filename(xfer));
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
}
data->notified = TRUE;
} else {
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_STATUS,
send ? _("Sending") : _("Receiving"));
}
update_title_progress();
if (purple_xfer_is_completed(xfer) && xfer_dialog->auto_clear)
finch_xfer_dialog_remove_xfer(xfer);
}
void
pidgin_xfer_dialog_add_xfer(PidginXferDialog *dialog, PurpleXfer *xfer)
{
PidginXferUiData *data;
PurpleXferType type;
GdkPixbuf *pixbuf;
char *size_str, *remaining_str;
char *lfilename, *utf8;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
purple_xfer_ref(xfer);
data = PIDGINXFER(xfer);
data->in_list = TRUE;
pidgin_xfer_dialog_show(dialog);
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));
pixbuf = gtk_widget_render_icon(dialog->window,
(type == PURPLE_XFER_RECEIVE
? PIDGIN_STOCK_DOWNLOAD
: PIDGIN_STOCK_UPLOAD),
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_append(dialog->model, &data->iter);
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;
gtk_list_store_set(dialog->model, &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_PROGRESS, 0.0,
COLUMN_FILENAME, (type == PURPLE_XFER_RECEIVE)
? purple_xfer_get_filename(xfer)
: lfilename,
COLUMN_SIZE, size_str,
COLUMN_REMAINING, _("Waiting for transfer to begin"),
COLUMN_DATA, xfer,
-1);
g_free(lfilename);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dialog->tree));
g_object_unref(pixbuf);
g_free(size_str);
g_free(remaining_str);
dialog->num_transfers++;
ensure_row_selected(dialog);
update_title_progress(dialog);
}
/**************************************************************************
* Utility Functions
**************************************************************************/
static void
get_xfer_info_strings(PurpleXfer *xfer, char **kbsec, char **time_elapsed,
char **time_remaining)
{
PidginXferUiData *data;
double kb_sent, kb_rem;
double kbps = 0.0;
time_t elapsed, now;
data = PIDGINXFER(xfer);
if (xfer->end_time != 0)
now = xfer->end_time;
else
now = time(NULL);
kb_sent = purple_xfer_get_bytes_sent(xfer) / 1024.0;
kb_rem = purple_xfer_get_bytes_remaining(xfer) / 1024.0;
elapsed = (xfer->start_time > 0 ? now - xfer->start_time : 0);
kbps = (elapsed > 0 ? (kb_sent / elapsed) : 0);
if (kbsec != NULL) {
*kbsec = g_strdup_printf(_("%.2f KiB/s"), kbps);
}
if (time_elapsed != NULL)
{
int h, m, s;
int secs_elapsed;
if (xfer->start_time > 0)
{
secs_elapsed = now - xfer->start_time;
h = secs_elapsed / 3600;
m = (secs_elapsed % 3600) / 60;
s = secs_elapsed % 60;
*time_elapsed = g_strdup_printf("%d:%02d:%02d", h, m, s);
}
else
{
*time_elapsed = g_strdup(_("Not started"));
}
}
if (time_remaining != NULL) {
if (purple_xfer_is_completed(xfer)) {
*time_remaining = g_strdup(_("Finished"));
}
else if (purple_xfer_is_canceled(xfer)) {
*time_remaining = g_strdup(_("Canceled"));
}
else if (purple_xfer_get_size(xfer) == 0 || (kb_sent > 0 && kbps == 0)) {
*time_remaining = g_strdup(_("Unknown"));
}
else if (kb_sent <= 0) {
*time_remaining = g_strdup(_("Waiting for transfer to begin"));
}
else {
int h, m, s;
int secs_remaining;
secs_remaining = (int)(kb_rem / kbps);
h = secs_remaining / 3600;
m = (secs_remaining % 3600) / 60;
s = secs_remaining % 60;
*time_remaining = g_strdup_printf("%d:%02d:%02d", h, m, s);
}
}
}
static void
do_transfer(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
guchar *buffer = NULL;
gssize r = 0;
ui_ops = purple_xfer_get_ui_ops(xfer);
if (xfer->type == PURPLE_XFER_RECEIVE) {
r = purple_xfer_read(xfer, &buffer);
if (r > 0) {
size_t wc;
if (ui_ops && ui_ops->ui_write)
wc = ui_ops->ui_write(xfer, buffer, r);
else
wc = fwrite(buffer, 1, r, xfer->dest_fp);
if (wc != r) {
purple_debug_error("filetransfer", "Unable to write whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
if ((purple_xfer_get_size(xfer) > 0) &&
((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
purple_xfer_set_completed(xfer, TRUE);
} else if(r < 0) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
}
} else if (xfer->type == PURPLE_XFER_SEND) {
size_t result = 0;
size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
PurpleXferPrivData *priv = g_hash_table_lookup(xfers_data, xfer);
gboolean read = TRUE;
/* this is so the prpl can keep the connection open
if it needs to for some odd reason. */
if (s == 0) {
if (xfer->watcher) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
}
if (priv->buffer) {
if (priv->buffer->len < s) {
s -= priv->buffer->len;
read = TRUE;
} else {
read = FALSE;
}
}
if (read) {
if (ui_ops && ui_ops->ui_read) {
gssize tmp = ui_ops->ui_read(xfer, &buffer, s);
if (tmp == 0) {
/*
* The UI claimed it was ready, but didn't have any data for
* us... It will call purple_xfer_ui_ready when ready, which
* sets back up this watcher.
*/
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
/* Need to indicate the prpl is still ready... */
priv->ready |= PURPLE_XFER_READY_PRPL;
g_return_if_reached();
} else if (tmp < 0) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
return;
}
result = tmp;
} else {
buffer = g_malloc(s);
result = fread(buffer, 1, s, xfer->dest_fp);
if (result != s) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
}
}
if (priv->buffer) {
g_byte_array_append(priv->buffer, buffer, result);
g_free(buffer);
buffer = priv->buffer->data;
result = priv->buffer->len;
}
r = purple_xfer_write(xfer, buffer, result);
if (r == -1) {
purple_xfer_cancel_remote(xfer);
if (!priv->buffer)
/* We don't free buffer if priv->buffer is set, because in
that case buffer doesn't belong to us. */
g_free(buffer);
return;
} else if (r == result) {
/*
* We managed to write the entire buffer. This means our
* network is fast and our buffer is too small, so make it
* bigger.
*/
purple_xfer_increase_buffer_size(xfer);
} else {
if (ui_ops && ui_ops->data_not_sent)
ui_ops->data_not_sent(xfer, buffer + r, result - r);
}
if (priv->buffer) {
/*
* Remove what we wrote
* If we wrote the whole buffer the byte array will be empty
* Otherwise we'll keep what wasn't sent for next time.
*/
buffer = NULL;
g_byte_array_remove_range(priv->buffer, 0, r);
}
}
if (r > 0) {
if (purple_xfer_get_size(xfer) > 0)
xfer->bytes_remaining -= r;
xfer->bytes_sent += r;
if (xfer->ops.ack != NULL)
xfer->ops.ack(xfer, buffer, r);
g_free(buffer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer,
purple_xfer_get_progress(xfer));
}
if (purple_xfer_is_completed(xfer))
purple_xfer_end(xfer);
}
static void
do_transfer(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
guchar *buffer = NULL;
gssize r = 0;
ui_ops = purple_xfer_get_ui_ops(xfer);
if (xfer->type == PURPLE_XFER_RECEIVE) {
r = purple_xfer_read(xfer, &buffer);
if (r > 0) {
size_t wc;
if (ui_ops && ui_ops->ui_write)
wc = ui_ops->ui_write(xfer, buffer, r);
else
wc = fwrite(buffer, 1, r, xfer->dest_fp);
if (wc != r) {
purple_debug_error("filetransfer", "Unable to write whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
if ((purple_xfer_get_size(xfer) > 0) &&
((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
purple_xfer_set_completed(xfer, TRUE);
} else if(r < 0) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
}
} else if (xfer->type == PURPLE_XFER_SEND) {
size_t result;
size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
/* this is so the prpl can keep the connection open
if it needs to for some odd reason. */
if (s == 0) {
if (xfer->watcher) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
}
if (ui_ops && ui_ops->ui_read) {
gssize tmp = ui_ops->ui_read(xfer, &buffer, s);
if (tmp == 0) {
/*
* UI isn't ready to send data. It will call
* purple_xfer_ui_ready when ready, which sets back up this
* watcher.
*/
if (xfer->watcher != 0) {
purple_timeout_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
} else if (tmp < 0) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
return;
}
result = tmp;
} else {
buffer = g_malloc0(s);
result = fread(buffer, 1, s, xfer->dest_fp);
if (result != s) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
}
/* Write as much as we're allowed to. */
r = purple_xfer_write(xfer, buffer, result);
if (r == -1) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
} else if (r < result) {
if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) {
/* We have to seek back in the file now. */
fseek(xfer->dest_fp, r - s, SEEK_CUR);
}
else {
ui_ops->data_not_sent(xfer, buffer + r, result - r);
}
} else {
/*
* We managed to write the entire buffer. This means our
* network is fast and our buffer is too small, so make it
* bigger.
*/
purple_xfer_increase_buffer_size(xfer);
}
}
if (r > 0) {
if (purple_xfer_get_size(xfer) > 0)
xfer->bytes_remaining -= r;
xfer->bytes_sent += r;
if (xfer->ops.ack != NULL)
xfer->ops.ack(xfer, buffer, r);
g_free(buffer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer,
purple_xfer_get_progress(xfer));
}
if (purple_xfer_is_completed(xfer))
purple_xfer_end(xfer);
}