/*------------------------------------------------------------------------
* 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( xfer->type, xfer->account, xfer->who, _( "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 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;
}
std::string FiletransferRepeater::requestFT() {
// purple_xfer_request_accepted(xfer, std::string(filename).c_str());
std::string filename(purple_xfer_get_filename(m_xfer));
m_sid = m_main->ft->requestFT(m_to, filename, purple_xfer_get_size(m_xfer), EmptyString, EmptyString, EmptyString, EmptyString, SIProfileFT::FTTypeAll, m_from);
m_main->ftManager->m_info[m_sid].filename = filename;
m_main->ftManager->m_info[m_sid].size = purple_xfer_get_size(m_xfer);
m_main->ftManager->m_info[m_sid].straight = true;
return m_sid;
}
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);
}
double
purple_xfer_get_progress(const PurpleXfer *xfer)
{
g_return_val_if_fail(xfer != NULL, 0.0);
if (purple_xfer_get_size(xfer) == 0)
return 0.0;
return ((double)purple_xfer_get_bytes_sent(xfer) /
(double)purple_xfer_get_size(xfer));
}
static void yahoo_xfer_start(PurpleXfer *xfer)
{
PurpleHttpRequest *req;
struct yahoo_xfer_data *xd;
xd = purple_xfer_get_protocol_data(xfer);
req = yahoo_ft_new_req(xd);
purple_http_request_set_timeout(req, -1);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
purple_http_request_set_max_len(req, -1);
purple_http_request_set_response_writer(req,
yahoo_process_filetrans_15_writer, xfer);
xd->hc = purple_http_request(xd->gc, req,
yahoo_process_filetrans_15_downloaded, xfer);
} else {
purple_http_request_set_method(req, "POST");
/* YHttpServer quirk: it sets content-length, but doesn't sends
* any data. */
purple_http_request_set_max_len(req, 0);
purple_http_request_set_contents_reader(req,
yahoo_process_filetrans_15_reader,
purple_xfer_get_size(xfer), xfer);
xd->hc = purple_http_request(xd->gc, req,
yahoo_process_filetrans_15_sent, xfer);
}
purple_http_conn_set_progress_watcher(xd->hc,
yahoo_process_filetrans_15_watcher, xfer, -1);
purple_http_request_unref(req);
}
static void
skypeweb_xfer_send_connect_cb(gpointer user_data, PurpleSslConnection *ssl_connection, PurpleInputCondition cond)
{
SkypeWebFileTransfer *swft = user_data;
SkypeWebAccount *sa = swft->sa;
PurpleXfer *xfer = swft->xfer;
gchar *headers;
headers = g_strdup_printf("PUT /v1/objects/%s/content/original HTTP/1.0\r\n"
"Connection: close\r\n"
"Authorization: skype_token %s\r\n" //slightly different to normal!
"Host: " SKYPEWEB_XFER_HOST "\r\n"
"Content-Length: %d\r\n"
"Content-Type: application/json\r\n"
"\r\n\r\n",
purple_url_encode(swft->id),
sa->skype_token,
purple_xfer_get_size(xfer));
purple_ssl_write(ssl_connection, headers, strlen(headers));
swft->conn = ssl_connection;
purple_xfer_ref(xfer);
purple_xfer_start(xfer, ssl_connection->fd, NULL, 0);
//TODO add input watcher that calls this repeatedly
purple_xfer_prpl_ready(xfer);
//purple_ssl_input_add(
g_free(headers);
}
static void ggp_edisc_xfer_send_reader(PurpleHttpConnection *hc,
gchar *buffer, size_t offset, size_t length, gpointer _xfer,
PurpleHttpContentReaderCb cb)
{
PurpleXfer *xfer = _xfer;
ggp_edisc_xfer *edisc_xfer;
int stored;
gboolean success, eof = FALSE;
g_return_if_fail(xfer != NULL);
edisc_xfer = purple_xfer_get_protocol_data(xfer);
g_return_if_fail(edisc_xfer != NULL);
if (edisc_xfer->already_read != offset) {
purple_debug_error("gg", "ggp_edisc_xfer_send_reader: "
"Invalid offset (%" G_GSIZE_FORMAT " != %" G_GSIZE_FORMAT ")\n",
edisc_xfer->already_read, offset);
ggp_edisc_xfer_error(xfer, _("Error while reading a file"));
return;
}
stored = purple_xfer_read_file(xfer, (guchar *)buffer, length);
if (stored < 0)
success = FALSE;
else {
success = TRUE;
edisc_xfer->already_read += stored;
eof = ((goffset)edisc_xfer->already_read >= purple_xfer_get_size(xfer));
}
cb(hc, success, eof, stored);
}
static void
send_file_cb(MsnSlpCall *slpcall)
{
MsnSlpMessage *slpmsg;
PurpleXfer *xfer;
xfer = (PurpleXfer *)slpcall->xfer;
if (purple_xfer_get_status(xfer) >= PURPLE_XFER_STATUS_STARTED)
return;
purple_xfer_ref(xfer);
purple_xfer_start(xfer, -1, NULL, 0);
if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_STARTED) {
purple_xfer_unref(xfer);
return;
}
purple_xfer_unref(xfer);
slpmsg = msn_slpmsg_new(slpcall->slplink);
slpmsg->slpcall = slpcall;
slpmsg->flags = 0x1000030;
slpmsg->info = "SLP FILE";
slpmsg->size = purple_xfer_get_size(xfer);
msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
}
static void tgprpl_xfer_send_on_finished (struct tgl_state *TLS, void *_data, int success, struct tgl_message *M) {
debug ("tgprpl_xfer_on_finished()");
struct tgp_xfer_send_data *data = _data;
if (success) {
if (! purple_xfer_is_canceled (data->xfer)) {
debug ("purple_xfer_set_completed");
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
purple_xfer_end (data->xfer);
}
write_secret_chat_file (TLS);
} else {
tgp_notify_on_error_gw (TLS, NULL, success);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_cancel_remote (data->xfer);
}
failure ("send xfer failed");
}
data->loading = FALSE;
data->xfer->data = NULL;
purple_xfer_unref (data->xfer);
tgprpl_xfer_free_data (data);
}
static void tgprpl_xfer_recv_on_finished (struct tgl_state *TLS, void *_data, int success, const char *filename) {
debug ("tgprpl_xfer_recv_on_finished()");
struct tgp_xfer_send_data *data = _data;
char *selected = g_strdup (purple_xfer_get_local_filename (data->xfer));
if (success) {
debug ("purple_xfer_set_completed");
// always completed the file transfer to avoid a warning dialogue when closing (Adium)
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_end (data->xfer);
}
} else {
tgp_notify_on_error_gw (TLS, NULL, success);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_cancel_remote (data->xfer);
}
failure ("recv xfer failed");
}
data->loading = FALSE;
data->xfer->data = NULL;
purple_xfer_unref (data->xfer);
tgprpl_xfer_free_data (data);
debug ("moving transferred file from tgl directory %s to selected target %s", selected, filename);
g_unlink (selected);
g_rename (filename, selected);
g_free (selected);
}
static void
ft_outgoing_init(PurpleXfer *xfer)
{
sipe_core_ft_outgoing_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
purple_xfer_get_filename(xfer),
purple_xfer_get_size(xfer),
xfer->who);
}
void
purple_xfer_set_bytes_sent(PurpleXfer *xfer, size_t bytes_sent)
{
g_return_if_fail(xfer != NULL);
xfer->bytes_sent = bytes_sent;
xfer->bytes_remaining = purple_xfer_get_size(xfer) - bytes_sent;
}
static void
yahoo_xfer_init_15(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
PurpleConnection *gc;
PurpleAccount *account;
YahooData *yd;
struct yahoo_packet *pkt;
xfer_data = purple_xfer_get_protocol_data(xfer);
gc = xfer_data->gc;
yd = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) {
gchar *filename;
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15,
YAHOO_STATUS_AVAILABLE,
yd->session_id);
yahoo_packet_hash(pkt, "sssiiiisiii",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
222, 1,
266, 1,
302, 268,
300, 268,
27, filename,
28, (int)purple_xfer_get_size(xfer),
301, 268,
303, 268);
g_free(filename);
} else {
if(xfer_data->firstoflist == TRUE) {
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssi",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
222, 3);
} else {
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssi",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
271, 1);
}
}
yahoo_packet_send_and_free(pkt, yd);
}
static int _qq_xfer_open_file(const gchar *filename, const gchar *method, PurpleXfer *xfer)
{
ft_info *info = xfer->data;
int fd;
if (method[0] == 'r') {
fd = open(purple_xfer_get_local_filename(xfer), O_RDONLY);
info->buffer = mmap(0, purple_xfer_get_size(xfer), PROT_READ, MAP_PRIVATE, fd, 0);
}
else
{
fd = open(purple_xfer_get_local_filename(xfer), O_RDWR|O_CREAT, 0644);
info->buffer = mmap(0, purple_xfer_get_size(xfer), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FILE, fd, 0);
}
if (info->buffer == NULL) {
return - 1;
}
return 0;
}
static gint _qq_xfer_read_file(guint8 *buffer, guint index, guint len, PurpleXfer *xfer)
{
ft_info *info = xfer->data;
gint readbytes;
buffer = info->buffer + len * index;
readbytes = purple_xfer_get_size(xfer) - (buffer - info->buffer);
if (readbytes > info->fragment_len) readbytes = info->fragment_len;
return readbytes;
}
static void
update_title_progress(PidginXferDialog *dialog)
{
gboolean valid;
GtkTreeIter iter;
int num_active_xfers = 0;
guint64 total_bytes_xferred = 0;
guint64 total_file_size = 0;
if (dialog->window == NULL)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
/* Find all active transfers */
while (valid) {
GValue val;
PurpleXfer *xfer = NULL;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
xfer = g_value_get_pointer(&val);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) {
num_active_xfers++;
total_bytes_xferred += purple_xfer_get_bytes_sent(xfer);
total_file_size += purple_xfer_get_size(xfer);
}
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* Update the title */
if (num_active_xfers > 0)
{
gchar *title;
int total_pct = 0;
if (total_file_size > 0) {
total_pct = 100 * total_bytes_xferred / total_file_size;
}
title = g_strdup_printf(ngettext("File Transfers - %d%% of %d file",
"File Transfers - %d%% of %d files",
num_active_xfers),
total_pct, num_active_xfers);
gtk_window_set_title(GTK_WINDOW(dialog->window), title);
g_free(title);
} else {
gtk_window_set_title(GTK_WINDOW(dialog->window), _("File Transfers"));
}
}
static void
irc_dccsend_network_listen_cb(int sock, gpointer data)
{
PurpleXfer *xfer = data;
struct irc_xfer_send_data *xd;
PurpleConnection *gc;
struct irc_conn *irc;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
xd = purple_xfer_get_protocol_data(xfer);
xd->listen_data = NULL;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL
|| purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE) {
g_object_unref(xfer);
return;
}
xd = purple_xfer_get_protocol_data(xfer);
gc = purple_account_get_connection(purple_xfer_get_account(xfer));
irc = purple_connection_get_protocol_data(gc);
g_object_unref(xfer);
if (sock < 0) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to open a listening port."),
purple_request_cpar_from_connection(gc));
purple_xfer_cancel_local(xfer);
return;
}
xd->fd = sock;
port = purple_network_get_port_from_fd(sock);
purple_debug_misc("irc", "port is %hu\n", port);
/* Monitor the listening socket */
purple_xfer_set_watcher(xfer, purple_input_add(sock, PURPLE_INPUT_READ,
irc_dccsend_send_connected, xfer));
/* Send the intended recipient the DCC request */
arg[0] = purple_xfer_get_remote_user(xfer);
inet_aton(purple_network_get_my_ip(irc->fd), &addr);
arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %" G_GOFFSET_FORMAT "\001",
purple_xfer_get_filename(xfer), ntohl(addr.s_addr),
port, purple_xfer_get_size(xfer));
irc_cmd_privmsg(purple_connection_get_protocol_data(gc), "msg", NULL, arg);
g_free(tmp);
}
/* just in case you were wondering, this is why DCC is gay */
static void irc_dccsend_send_read(gpointer data, int source, PurpleInputCondition cond)
{
PurpleXfer *xfer = data;
struct irc_xfer_send_data *xd = purple_xfer_get_protocol_data(xfer);
char buffer[64];
int len;
len = read(source, buffer, sizeof(buffer));
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0) {
/* XXX: Shouldn't this be canceling the transfer? */
purple_input_remove(xd->inpa);
xd->inpa = 0;
return;
}
xd->rxqueue = g_realloc(xd->rxqueue, len + xd->rxlen);
memcpy(xd->rxqueue + xd->rxlen, buffer, len);
xd->rxlen += len;
while (1) {
gint32 val;
size_t acked;
if (xd->rxlen < 4)
break;
memcpy(&val, xd->rxqueue, sizeof(val));
acked = ntohl(val);
xd->rxlen -= 4;
if (xd->rxlen) {
unsigned char *tmp = g_memdup(xd->rxqueue + 4, xd->rxlen);
g_free(xd->rxqueue);
xd->rxqueue = tmp;
} else {
g_free(xd->rxqueue);
xd->rxqueue = NULL;
}
if ((goffset)acked >= purple_xfer_get_size(xfer)) {
purple_input_remove(xd->inpa);
xd->inpa = 0;
purple_xfer_set_completed(xfer, TRUE);
purple_xfer_end(xfer);
return;
}
}
}
static void
purple_xfer_ask_recv(PurpleXfer *xfer)
{
char *buf, *size_buf;
size_t size;
gconstpointer thumb;
gsize thumb_size;
/* If we have already accepted the request, ask the destination file
name directly */
if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_ACCEPTED) {
PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
if (purple_xfer_get_filename(xfer) != NULL)
{
size = purple_xfer_get_size(xfer);
size_buf = purple_str_size_to_units(size);
buf = g_strdup_printf(_("%s wants to send you %s (%s)"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who,
purple_xfer_get_filename(xfer), size_buf);
g_free(size_buf);
}
else
{
buf = g_strdup_printf(_("%s wants to send you a file"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who);
}
if (xfer->message != NULL)
serv_got_im(purple_account_get_connection(xfer->account),
xfer->who, xfer->message, 0, time(NULL));
if ((thumb = purple_xfer_get_thumbnail(xfer, &thumb_size))) {
purple_request_accept_cancel_with_icon(xfer, NULL, buf, NULL,
PURPLE_DEFAULT_ACTION_NONE, xfer->account, xfer->who, NULL,
thumb, thumb_size, xfer,
G_CALLBACK(purple_xfer_choose_file),
G_CALLBACK(cancel_recv_cb));
} else {
purple_request_accept_cancel(xfer, NULL, buf, NULL,
PURPLE_DEFAULT_ACTION_NONE, xfer->account, xfer->who, NULL,
xfer, G_CALLBACK(purple_xfer_choose_file),
G_CALLBACK(cancel_recv_cb));
}
g_free(buf);
} else
purple_xfer_choose_file(xfer);
}
void waprpl_xfer_init(PurpleXfer * xfer)
{
purple_debug_info(WHATSAPP_ID, "File xfer init...\n");
wa_file_upload *xinfo = (wa_file_upload *) xfer->data;
whatsapp_connection *wconn = xinfo->wconn;
size_t fs = purple_xfer_get_size(xfer);
const char *fn = purple_xfer_get_filename(xfer);
const char *fp = purple_xfer_get_local_filename(xfer);
wa_file_upload *xfer_info = (wa_file_upload *) xfer->data;
purple_xfer_set_size(xfer, fs);
xfer_info->ref_id = waAPI_sendimage(wconn->waAPI, xinfo->to, 100, 100, fs, fp);
purple_debug_info(WHATSAPP_ID, "Transfer file %s at %s with size %zu (given ref %d)\n", fn, fp, fs, xfer_info->ref_id);
waprpl_check_output(xinfo->gc);
}
static void tgprpl_xfer_on_finished (struct tgl_state *TLS, void *_data, int success, struct tgl_message *M) {
debug ("tgprpl_xfer_on_finished()");
struct tgp_xfer_send_data *data = _data;
if (success) {
if (!data->done) {
debug ("purple_xfer_set_completed");
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
purple_xfer_end(data->xfer);
}
} else {
failure ("ERROR xfer failed");
}
data->xfer->data = NULL;
tgprpl_xfer_free_data (data);
}
static void ggp_edisc_xfer_send_init_authenticated(PurpleConnection *gc,
gboolean success, gpointer _xfer)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleHttpRequest *req;
PurpleXfer *xfer = _xfer;
ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer);
gchar *data;
if (purple_xfer_is_cancelled(xfer))
return;
if (!success) {
ggp_edisc_xfer_error(xfer, _("Authentication failed"));
return;
}
g_return_if_fail(sdata != NULL);
req = purple_http_request_new("https://drive.mpa.gg.pl/send_ticket");
purple_http_request_set_method(req, "PUT");
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
data = g_strdup_printf("{\"send_ticket\":{"
"\"recipient\":\"%s\","
"\"file_name\":\"%s\","
"\"file_size\":\"%u\""
"}}",
purple_xfer_get_remote_user(xfer),
edisc_xfer->filename,
(int)purple_xfer_get_size(xfer));
purple_http_request_set_contents(req, data, -1);
g_free(data);
edisc_xfer->hc = purple_http_request(gc, req,
ggp_edisc_xfer_send_init_ticket_created, xfer);
purple_http_request_unref(req);
}
static void ggp_edisc_xfer_send_start(PurpleXfer *xfer)
{
ggp_edisc_session_data *sdata;
ggp_edisc_xfer *edisc_xfer;
gchar *upload_url, *filename_e;
PurpleHttpRequest *req;
g_return_if_fail(xfer != NULL);
edisc_xfer = purple_xfer_get_protocol_data(xfer);
g_return_if_fail(edisc_xfer != NULL);
sdata = ggp_edisc_get_sdata(edisc_xfer->gc);
g_return_if_fail(sdata != NULL);
filename_e = purple_strreplace(edisc_xfer->filename, " ", "%20");
upload_url = g_strdup_printf("https://drive.mpa.gg.pl/me/file/outbox/"
"%s%%2C%s", edisc_xfer->ticket_id, filename_e);
g_free(filename_e);
req = purple_http_request_new(upload_url);
g_free(upload_url);
purple_http_request_set_method(req, "PUT");
purple_http_request_set_timeout(req, -1);
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-local-revision", "0");
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
purple_http_request_header_set(req, "X-gged-metadata",
"{\"node_type\": \"file\"}");
purple_http_request_set_contents_reader(req, ggp_edisc_xfer_send_reader,
purple_xfer_get_size(xfer), xfer);
edisc_xfer->hc = purple_http_request(edisc_xfer->gc, req,
ggp_edisc_xfer_send_done, xfer);
purple_http_request_unref(req);
purple_http_conn_set_progress_watcher(edisc_xfer->hc,
ggp_edisc_xfer_progress_watcher, xfer, 250000);
}
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();
}
static void
update_title_progress(void)
{
GList *list;
int num_active_xfers = 0;
guint64 total_bytes_xferred = 0;
guint64 total_file_size = 0;
if (xfer_dialog == NULL || xfer_dialog->window == NULL)
return;
/* Find all active transfers */
for (list = gnt_tree_get_rows(GNT_TREE(xfer_dialog->tree)); list; list = list->next) {
PurpleXfer *xfer = (PurpleXfer *)list->data;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) {
num_active_xfers++;
total_bytes_xferred += purple_xfer_get_bytes_sent(xfer);
total_file_size += purple_xfer_get_size(xfer);
}
}
/* Update the title */
if (num_active_xfers > 0) {
gchar *title;
int total_pct = 0;
if (total_file_size > 0) {
total_pct = 100 * total_bytes_xferred / total_file_size;
}
title = g_strdup_printf(ngettext("File Transfers - %d%% of %d file",
"File Transfers - %d%% of %d files",
num_active_xfers),
total_pct, num_active_xfers);
gnt_screen_rename_widget((xfer_dialog->window), title);
g_free(title);
} else {
gnt_screen_rename_widget((xfer_dialog->window), _("File Transfers"));
}
}
static void
send_file_cb(MsnSlpCall *slpcall)
{
MsnSlpMessage *slpmsg;
PurpleXfer *xfer;
xfer = (PurpleXfer *)slpcall->xfer;
if (purple_xfer_get_status(xfer) >= PURPLE_XFER_STATUS_STARTED)
return;
g_object_ref(xfer);
purple_xfer_start(xfer, -1, NULL, 0);
if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_STARTED) {
g_object_unref(xfer);
return;
}
g_object_unref(xfer);
slpmsg = msn_slpmsg_file_new(slpcall, purple_xfer_get_size(xfer));
msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
}
static void tgprpl_xfer_recv_on_finished (struct tgl_state *TLS, void *_data, int success, const char *filename) {
debug ("tgprpl_xfer_recv_on_finished()");
struct tgp_xfer_send_data *data = _data;
if (success) {
if (!data->done) {
debug ("purple_xfer_set_completed");
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
purple_xfer_end (data->xfer);
}
g_unlink (purple_xfer_get_local_filename (data->xfer));
g_rename (filename, purple_xfer_get_local_filename (data->xfer));
} else {
failure ("ERROR xfer failed");
}
data->xfer->data = NULL;
tgprpl_xfer_free_data (data);
}
/* 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)
return;
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;
}
/* 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("waprpl", "Upload progress %d bytes done\n", bytes_sent);
purple_xfer_set_bytes_sent(xfer, bytes_sent);
purple_xfer_update_progress(xfer);
if (bytes_sent >= (signed)purple_xfer_get_size(xfer))
purple_xfer_set_completed(xfer, TRUE);
break;
}
xfers = g_list_next(xfers);
}
}
}
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;
}
