Exemple #1
0
static void
silcpurple_ftp_cancel(PurpleXfer *x)
{
    SilcPurpleXfer xfer = x->data;
    xfer->xfer->status = PURPLE_XFER_STATUS_CANCEL_LOCAL;
    purple_xfer_update_progress(xfer->xfer);
    silc_client_file_close(xfer->sg->client, xfer->sg->conn, xfer->session_id);
}
Exemple #2
0
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);
}
Exemple #3
0
void
msn_xfer_progress_cb(MsnSlpCall *slpcall, gsize total_length, gsize len, gsize offset)
{
	PurpleXfer *xfer;

	xfer = slpcall->xfer;

	xfer->bytes_sent = (offset + len);
	xfer->bytes_remaining = total_length - (offset + len);

	purple_xfer_update_progress(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;
}
static void
yahoo_process_filetrans_15_watcher(PurpleHttpConnection *hc,
	gboolean reading_state, int processed, int total, gpointer _xfer)
{
	PurpleXfer *xfer = _xfer;

	if (reading_state !=
		(purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE))
	{
		return;
	}

	purple_xfer_set_size(xfer, total);
	purple_xfer_update_progress(xfer);
}
Exemple #6
0
static void
xfer_progress_cb(struct pn_peer_call *call,
                 gsize total_length,
                 gsize len,
                 gsize offset)
{
    PurpleXfer *xfer;

    xfer = call->xfer;

    xfer->bytes_sent = (offset + len);
    xfer->bytes_remaining = total_length - (offset + len);

    purple_xfer_update_progress(xfer);
}
Exemple #7
0
/* Checks if the WA protocol has data to output and schedules a write handler */
void waprpl_check_ssl_output(PurpleConnection * gc)
{
	whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
	if (wconn->sslfd >= 0) {

		int r = waAPI_sslhasoutdata(wconn->waAPI);
		if (r > 0) {
			/* Need to watch for output data (if we are not doing it already) */
			if (wconn->sslwh == 0)
				wconn->sslwh = purple_input_add(wconn->sslfd, PURPLE_INPUT_WRITE, waprpl_ssl_output_cb, gc);
		} else if (r < 0) {
			waprpl_ssl_cerr_cb(0, 0, gc);	/* Finished the connection! */
		} else {
			if (wconn->sslwh != 0)
				purple_input_remove(wconn->sslwh);

			wconn->sslwh = 0;
		}

		purple_debug_info(WHATSAPP_ID, "Watch for output is %d %d\n", r, errno);

		/* Update transfer status */
		int rid, bytes_sent;
		if (waAPI_fileuploadprogress(wconn->waAPI, &rid, &bytes_sent)) {
			GList *xfers = purple_xfers_get_all();
			while (xfers) {
				PurpleXfer *xfer = xfers->data;
				wa_file_upload *xinfo = (wa_file_upload *) xfer->data;
				if (xinfo->ref_id == rid) {
					purple_debug_info(WHATSAPP_ID, "Upload progress %d bytes done\n", bytes_sent);
					purple_xfer_set_bytes_sent(xfer, bytes_sent);
					purple_xfer_update_progress(xfer);
					break;
				}
				xfers = g_list_next(xfers);
			}
		}

	}
	
	// Check uploads to mark them as done :)
	waprpl_check_complete_uploads(gc);
}
Exemple #8
0
static void _qq_recv_file_progess(PurpleConnection *gc, guint8 *buffer, guint16 len, guint32 index, guint32 offset)
{
	qq_data *qd = (qq_data *) gc->proto_data;
	PurpleXfer *xfer = qd->xfer;
	ft_info *info = (ft_info *) xfer->data;
	guint32 mask;

	purple_debug_info("QQ",
			"receiving %dth fragment with length %d, slide window status %o, max_fragment_index %d\n",
			index, len, info->window, info->max_fragment_index);
	if (info->window == 0 && info->max_fragment_index == 0) {
		if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "wb", xfer) == -1) {
			purple_xfer_cancel_local(xfer);
			return;
		}
		purple_debug_info("QQ", "object file opened for writing\n");
	}
	mask = 0x1 << (index % sizeof(info->window));
	if (index < info->max_fragment_index || (info->window & mask)) {
		purple_debug_info("QQ", "duplicate %dth fragment, drop it!\n", index+1);
		return;
	}

	info->window |= mask;

	_qq_xfer_write_file(buffer, index, len, xfer);

	xfer->bytes_sent += len;
	xfer->bytes_remaining -= len;
	purple_xfer_update_progress(xfer);

	mask = 0x1 << (info->max_fragment_index % sizeof(info->window));
	while (info->window & mask)
	{
		info->window &= ~mask;
		info->max_fragment_index ++;
		if (mask & 0x8000) mask = 0x0001;
		else mask = mask << 1;
	}
	purple_debug_info("QQ", "procceed %dth fragment, slide window status %o, max_fragment_index %d\n",
			index, info->window, info->max_fragment_index);
}
Exemple #9
0
static void ggp_edisc_xfer_progress_watcher(PurpleHttpConnection *hc,
	gboolean reading_state, int processed, int total, gpointer _xfer)
{
	PurpleXfer *xfer = _xfer;
	gboolean eof;
	int total_real;

	if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
		if (!reading_state)
			return;
	} else {
		if (reading_state)
			return;
	}

	eof = (processed >= total);
	total_real = purple_xfer_get_size(xfer);
	if (eof || processed > total_real)
		processed = total_real; /* just to be sure */

	purple_xfer_set_bytes_sent(xfer, processed);
	purple_xfer_update_progress(xfer);
}
Exemple #10
0
static void
silcpurple_ftp_monitor(SilcClient client,
                       SilcClientConnection conn,
                       SilcClientMonitorStatus status,
                       SilcClientFileError error,
                       SilcUInt64 offset,
                       SilcUInt64 filesize,
                       SilcClientEntry client_entry,
                       SilcUInt32 session_id,
                       const char *filepath,
                       void *context)
{
    SilcPurpleXfer xfer = context;
    PurpleConnection *gc = xfer->sg->gc;
    char tmp[256];

    if (status == SILC_CLIENT_FILE_MONITOR_CLOSED) {
        purple_xfer_unref(xfer->xfer);
        silc_free(xfer);
        return;
    }

    if (status == SILC_CLIENT_FILE_MONITOR_KEY_AGREEMENT)
        return;

    if (status == SILC_CLIENT_FILE_MONITOR_ERROR) {
        if (error == SILC_CLIENT_FILE_NO_SUCH_FILE) {
            g_snprintf(tmp, sizeof(tmp), "No such file %s",
                       filepath ? filepath : "[N/A]");
            purple_notify_error(gc, _("Secure File Transfer"),
                                _("Error during file transfer"), tmp);
        } else if (error == SILC_CLIENT_FILE_PERMISSION_DENIED) {
            purple_notify_error(gc, _("Secure File Transfer"),
                                _("Error during file transfer"),
                                _("Permission denied"));
        } else if (error == SILC_CLIENT_FILE_KEY_AGREEMENT_FAILED) {
            purple_notify_error(gc, _("Secure File Transfer"),
                                _("Error during file transfer"),
                                _("Key agreement failed"));
        } else if (error == SILC_CLIENT_FILE_UNKNOWN_SESSION) {
            purple_notify_error(gc, _("Secure File Transfer"),
                                _("Error during file transfer"),
                                _("File transfer session does not exist"));
        } else {
            purple_notify_error(gc, _("Secure File Transfer"),
                                _("Error during file transfer"), NULL);
        }
        silc_client_file_close(client, conn, session_id);
        purple_xfer_unref(xfer->xfer);
        silc_free(xfer);
        return;
    }

    /* Update file transfer UI */
    if (!offset && filesize)
        purple_xfer_set_size(xfer->xfer, filesize);
    if (offset && filesize) {
        xfer->xfer->bytes_sent = offset;
        xfer->xfer->bytes_remaining = filesize - offset;
    }
    purple_xfer_update_progress(xfer->xfer);

    if (status == SILC_CLIENT_FILE_MONITOR_SEND ||
            status == SILC_CLIENT_FILE_MONITOR_RECEIVE) {
        if (offset == filesize) {
            /* Download finished */
            purple_xfer_set_completed(xfer->xfer, TRUE);
            silc_client_file_close(client, conn, session_id);
        }
    }
}