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;
}
}
void tgprpl_recv_file (PurpleConnection * gc, const char *who, struct tgl_message *M) {
debug ("tgprpl_recv_file()");
PurpleXfer *X = tgprpl_new_xfer_recv (gc, who);
const char *mime_type, *caption;
long long access_hash;
int flags, size;
if (M->media.type == tgl_message_media_document_encr) {
mime_type = M->media.encr_document->mime_type;
caption = M->media.encr_document->caption;
access_hash = M->media.encr_document->access_hash;
flags = M->media.encr_document->flags;
size = M->media.encr_document->size;
} else {
mime_type = M->media.document->mime_type;
caption = M->media.document->caption;
access_hash = M->media.document->access_hash;
flags = M->media.document->flags;
size = M->media.document->size;
}
char *filename = tgp_strdup_determine_filename (mime_type, caption, flags, access_hash);
purple_xfer_set_filename (X, filename);
g_free (filename);
purple_xfer_set_size (X, size);
tgprpl_xfer_init_data (X, purple_connection_get_protocol_data (gc), M);
purple_xfer_request (X);
}
/*------------------------------------------------------------------------
* A file transfer offer has been received from the MXit server.
*
* @param session The MXit session object
* @param usermame The username of the sender
* @param filename The name of the file being offered
* @param filesize The size of the file being offered
* @param fileid A unique ID that identifies this file
*/
void mxit_xfer_rx_offer( struct MXitSession* session, const char* username, const char* filename, int filesize, const char* fileid )
{
PurpleXfer* xfer = NULL;
struct mxitxfer* mx = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "File Offer: file=%s, from=%s, size=%i\n", filename, username, filesize );
xfer = purple_xfer_new( session->acc, PURPLE_XFER_RECEIVE, username );
if ( xfer ) {
/* create a new mxit xfer struct for internal use */
mx = g_new0( struct mxitxfer, 1 );
mx->session = session;
memcpy( mx->fileid, fileid, MXIT_CHUNK_FILEID_LEN );
xfer->data = mx;
purple_xfer_set_filename( xfer, filename );
if( filesize > 0 )
purple_xfer_set_size( xfer, filesize );
/* register file transfer callback functions */
purple_xfer_set_init_fnc( xfer, mxit_xfer_init );
purple_xfer_set_request_denied_fnc( xfer, mxit_xfer_request_denied );
purple_xfer_set_cancel_recv_fnc( xfer, mxit_xfer_cancel_recv );
purple_xfer_set_end_fnc( xfer, mxit_xfer_end );
/* give the request to the user to accept/deny */
purple_xfer_request( xfer );
}
}
static gssize jabber_oob_xfer_read(guchar **buffer, PurpleXfer *xfer) {
JabberOOBXfer *jox = xfer->data;
char test[2048];
char *tmp, *lenstr;
int len;
if((len = read(xfer->fd, test, sizeof(test))) > 0) {
jox->headers = g_string_append_len(jox->headers, test, len);
if((tmp = strstr(jox->headers->str, "\r\n\r\n"))) {
*tmp = '\0';
lenstr = strstr(jox->headers->str, "Content-Length: ");
if(lenstr) {
int size;
sscanf(lenstr, "Content-Length: %d", &size);
purple_xfer_set_size(xfer, size);
}
purple_xfer_set_read_fnc(xfer, NULL);
tmp += 4;
*buffer = (unsigned char*) g_strdup(tmp);
return strlen(tmp);
}
return 0;
} else if (errno != EAGAIN) {
purple_debug(PURPLE_DEBUG_ERROR, "jabber", "Read error on oob xfer!\n");
purple_xfer_cancel_local(xfer);
}
return 0;
}
void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
struct sipe_file_transfer *ft,
const gchar *who,
const gchar *file_name,
gsize file_size)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleXfer *xfer;
xfer = purple_xfer_new(purple_private->account,
PURPLE_XFER_RECEIVE,
who);
if (xfer) {
ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
PURPLE_XFER_DATA = ft;
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_set_init_fnc(xfer, ft_incoming_init);
purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_start_fnc(xfer, tftp_incoming_start);
purple_xfer_set_end_fnc(xfer, tftp_incoming_stop);
purple_xfer_set_read_fnc(xfer, tftp_read);
purple_xfer_request(xfer);
}
}
void FiletransferRepeater::registerXfer(PurpleXfer *xfer) {
m_xfer = xfer;
// purple_xfer_set_local_filename(xfer, filename);
if (m_size != -1)
purple_xfer_set_size(xfer, m_size);
m_xfer->ui_data = this;
}
void FiletransferRepeater::registerXfer(PurpleXfer *xfer) {
m_xfer = xfer;
purple_xfer_ref(m_xfer);
if (m_size != -1)
purple_xfer_set_size(xfer, m_size);
m_xfer->ui_data = this;
}
void
purple_pn_xfer_got_invite(struct pn_peer_call *call,
const char *branch,
const char *context)
{
PurpleAccount *account;
PurpleXfer *xfer;
char *bin;
gsize bin_len;
guint32 file_size;
char *file_name;
gunichar2 *uni_name;
account = msn_session_get_user_data (pn_peer_link_get_session (call->link));
call->cb = xfer_completed_cb;
call->end_cb = xfer_end_cb;
call->progress_cb = xfer_progress_cb;
call->branch = g_strdup(branch);
call->pending = TRUE;
xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE,
pn_peer_link_get_passport (call->link));
if (xfer)
{
bin = (char *)purple_base64_decode(context, &bin_len);
file_size = GUINT32_FROM_LE(*(gsize *)(bin + 8));
uni_name = (gunichar2 *)(bin + 20);
while(*uni_name != 0 && ((char *)uni_name - (bin + 20)) < MAX_FILE_NAME_LEN) {
*uni_name = GUINT16_FROM_LE(*uni_name);
uni_name++;
}
file_name = g_utf16_to_utf8((const gunichar2 *)(bin + 20), -1,
NULL, NULL, NULL);
g_free(bin);
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_set_init_fnc(xfer, xfer_init);
purple_xfer_set_request_denied_fnc(xfer, xfer_cancel);
purple_xfer_set_cancel_recv_fnc(xfer, xfer_cancel);
call->xfer = xfer;
purple_xfer_ref(call->xfer);
xfer->data = call;
purple_xfer_request(xfer);
}
}
static int file_trans_on_progress(void* data,size_t now,size_t total)
{
PurpleXfer* xfer = data;
if(purple_xfer_is_canceled(xfer)||purple_xfer_is_completed(xfer)) {
return 1;
}
purple_xfer_set_size(xfer,total);
xfer->bytes_sent = now;
xfer->bytes_remaining = total-now;
qq_dispatch(vp_func_p,(CALLBACK_FUNC)purple_xfer_update_progress,xfer);
return 0;
}
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;
}
void tgprpl_recv_encr_file (PurpleConnection * gc, const char *who, struct tgl_encr_document *D) {
debug ("tgprpl_recv_encr_file()");
PurpleXfer *X = tgprpl_new_xfer_recv (gc, who);
char *filename = tgp_strdup_determine_filename (D->mime_type, D->caption, D->flags,
D->access_hash);
purple_xfer_set_filename (X, filename);
g_free (filename);
purple_xfer_set_size (X, D->size);
tgprpl_xfer_init_data (X, purple_connection_get_protocol_data (gc), NULL, D);
purple_xfer_request (X);
}
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);
}
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
skypeweb_got_vm_download_info(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
PurpleConversation *conv = user_data;
PurpleXfer *xfer;
JsonObject *obj, *file;
JsonArray *files;
gint64 fileSize;
const gchar *url, *assetId, *status;
gchar *filename;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT)
return;
obj = json_node_get_object(node);
files = json_object_get_array_member(obj, "files");
file = json_array_get_object_element(files, 0);
if (file != NULL) {
status = json_object_get_string_member(file, "status");
if (status && g_str_equal(status, "ok")) {
assetId = json_object_get_string_member(obj, "assetId");
fileSize = json_object_get_int_member(file, "fileSize");
url = json_object_get_string_member(file, "url");
(void) url;
filename = g_strconcat(assetId, ".mp4", NULL);
xfer = purple_xfer_new(sa->account, PURPLE_XFER_RECEIVE, conv->name);
purple_xfer_set_size(xfer, fileSize);
purple_xfer_set_filename(xfer, filename);
json_object_ref(file);
purple_xfer_set_protocol_data(xfer, file);
purple_xfer_set_init_fnc(xfer, skypeweb_init_vm_download);
purple_xfer_set_cancel_recv_fnc(xfer, skypeweb_cancel_vm_download);
purple_xfer_add(xfer);
g_free(filename);
} else if (status && g_str_equal(status, "running")) {
//skypeweb_download_video_message(sa, sid??????, conv);
}
}
}
static void
bonjour_xfer_receive(PurpleConnection *pc, const char *id, const char *sid, const char *from,
const goffset filesize, const char *filename, int option)
{
PurpleXfer *xfer;
XepXfer *xf;
BonjourData *bd;
if(pc == NULL || id == NULL || from == NULL)
return;
bd = purple_connection_get_protocol_data(pc);
if(bd == NULL)
return;
purple_debug_info("bonjour", "bonjour-xfer-receive.\n");
/* Build the file transfer handle */
xfer = purple_xfer_new(purple_connection_get_account(pc), PURPLE_XFER_TYPE_RECEIVE, from);
xf = g_new0(XepXfer, 1);
purple_xfer_set_protocol_data(xfer, xf);
xf->data = bd;
purple_xfer_set_filename(xfer, filename);
xf->iq_id = g_strdup(id);
xf->sid = g_strdup(sid);
if(filesize > 0)
purple_xfer_set_size(xfer, filesize);
purple_xfer_set_init_fnc(xfer, bonjour_xfer_init);
purple_xfer_set_request_denied_fnc(xfer, bonjour_xfer_request_denied);
purple_xfer_set_cancel_recv_fnc(xfer, bonjour_xfer_cancel_recv);
purple_xfer_set_end_fnc(xfer, bonjour_xfer_end);
bd->xfer_lists = g_slist_append(bd->xfer_lists, xfer);
purple_xfer_request(xfer);
}
static void
got_sessionreq(MsnSlpCall *slpcall, const char *branch,
const char *euf_guid, const char *context)
{
pecan_debug ("euf_guid=[%s]", euf_guid);
if (!strcmp(euf_guid, "A4268EEC-FEC5-49E5-95C3-F126696BDBF6"))
{
/* Emoticon or UserDisplay */
char *content;
gsize len;
MsnSlpSession *slpsession;
MsnSlpLink *slplink;
MsnSlpMessage *slpmsg;
MsnObject *obj;
char *msnobj_data;
PecanBuffer *image;
int type;
/* Send Ok */
content = pecan_strdup_printf("SessionID: %lu\r\n\r\n",
slpcall->session_id);
send_ok(slpcall, branch, "application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
slplink = slpcall->slplink;
msnobj_data = (char *)purple_base64_decode(context, &len);
obj = msn_object_new_from_string(msnobj_data);
type = msn_object_get_type(obj);
g_free(msnobj_data);
if (type == MSN_OBJECT_USERTILE)
{
/* image is owned by a local object, not obj */
image = msn_object_get_image(obj);
}
#if PURPLE_VERSION_CHECK(2,5,0)
else if (type == MSN_OBJECT_EMOTICON)
{
PurpleStoredImage *img;
char *path;
path = g_build_filename(purple_smileys_get_storing_dir(), msn_object_get_location(obj), NULL);
img = purple_imgstore_new_from_file(path);
image = pecan_buffer_new_memdup ((const gpointer) purple_imgstore_get_data (img),
purple_imgstore_get_size (img));
purple_imgstore_unref(img);
g_free(path);
}
#endif /* PURPLE_VERSION_CHECK(2,5,0) */
else
{
pecan_error ("Wrong object?");
msn_object_destroy(obj);
g_return_if_reached();
}
if (!image)
{
pecan_error ("Wrong object");
msn_object_destroy (obj);
g_return_if_reached ();
}
msn_object_destroy(obj);
{
gchar *tmp;
tmp = msn_object_to_string (obj);
pecan_info ("object requested: %s", tmp);
g_free (tmp);
}
slpsession = msn_slplink_find_slp_session(slplink,
slpcall->session_id);
/* DATA PREP */
slpmsg = msn_slpmsg_new(slplink);
slpmsg->slpcall = slpcall;
slpmsg->slpsession = slpsession;
slpmsg->session_id = slpsession->id;
msn_slpmsg_set_body(slpmsg, NULL, 4);
#ifdef PECAN_DEBUG_SLP
slpmsg->info = "SLP DATA PREP";
#endif
msn_slplink_queue_slpmsg(slplink, slpmsg);
/* DATA */
slpmsg = msn_slpmsg_new(slplink);
slpmsg->slpcall = slpcall;
slpmsg->slpsession = slpsession;
slpmsg->flags = 0x20;
#ifdef PECAN_DEBUG_SLP
slpmsg->info = "SLP DATA";
#endif
msn_slpmsg_set_image (slpmsg, image);
msn_slplink_queue_slpmsg(slplink, slpmsg);
}
else if (!strcmp(euf_guid, "5D3E02AB-6190-11D3-BBBB-00C04F795683"))
{
/* File Transfer */
PurpleAccount *account;
PurpleXfer *xfer;
char *bin;
gsize bin_len;
guint32 file_size;
char *file_name;
gunichar2 *uni_name;
account = slpcall->slplink->session->account;
slpcall->cb = msn_xfer_completed_cb;
slpcall->end_cb = msn_xfer_end_cb;
slpcall->progress_cb = msn_xfer_progress_cb;
slpcall->branch = g_strdup(branch);
slpcall->pending = TRUE;
xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE,
slpcall->slplink->remote_user);
if (xfer)
{
bin = (char *)purple_base64_decode(context, &bin_len);
file_size = GUINT32_FROM_LE(*(gsize *)(bin + 8));
uni_name = (gunichar2 *)(bin + 20);
while(*uni_name != 0 && ((char *)uni_name - (bin + 20)) < MAX_FILE_NAME_LEN) {
*uni_name = GUINT16_FROM_LE(*uni_name);
uni_name++;
}
file_name = g_utf16_to_utf8((const gunichar2 *)(bin + 20), -1,
NULL, NULL, NULL);
g_free(bin);
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_set_init_fnc(xfer, msn_xfer_init);
purple_xfer_set_request_denied_fnc(xfer, msn_xfer_cancel);
purple_xfer_set_cancel_recv_fnc(xfer, msn_xfer_cancel);
slpcall->xfer = xfer;
purple_xfer_ref(slpcall->xfer);
xfer->data = slpcall;
purple_xfer_request(xfer);
}
}
}
/**
* Someone else wants to establish a peer connection with us.
*/
void
peer_connection_got_proposition(OscarData *od, const gchar *bn, const gchar *message, IcbmArgsCh2 *args)
{
PurpleConnection *gc;
PurpleAccount *account;
PeerConnection *conn;
gchar *buf;
gc = od->gc;
account = purple_connection_get_account(gc);
/*
* If we have a connection with this same cookie then they are
* probably just telling us they weren't able to connect to us
* and we should try connecting to them, instead. Or they want
* to go through a proxy.
*/
conn = peer_connection_find_by_cookie(od, bn, args->cookie);
if ((conn != NULL) && (conn->type == args->type))
{
purple_debug_info("oscar", "Remote user wants to try a "
"different connection method\n");
g_free(conn->proxyip);
g_free(conn->clientip);
g_free(conn->verifiedip);
if (args->use_proxy)
conn->proxyip = g_strdup(args->proxyip);
else
conn->proxyip = NULL;
conn->verifiedip = g_strdup(args->verifiedip);
conn->clientip = g_strdup(args->clientip);
conn->port = args->port;
conn->use_proxy |= args->use_proxy;
conn->lastrequestnumber++;
peer_connection_trynext(conn);
return;
}
/* If this is a direct IM, then close any existing session */
if (args->type == OSCAR_CAPABILITY_DIRECTIM)
{
conn = peer_connection_find_by_type(od, bn, args->type);
if (conn != NULL)
{
/* Close the old direct IM and start a new one */
purple_debug_info("oscar", "Received new direct IM request "
"from %s. Destroying old connection.\n", bn);
peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
}
}
/* Check for proper arguments */
if (args->type == OSCAR_CAPABILITY_SENDFILE)
{
if ((args->info.sendfile.filename == NULL) ||
(args->info.sendfile.totsize == 0) ||
(args->info.sendfile.totfiles == 0))
{
purple_debug_warning("oscar",
"%s tried to send you a file with incomplete "
"information.\n", bn);
return;
}
}
conn = peer_connection_new(od, args->type, bn);
memcpy(conn->cookie, args->cookie, 8);
if (args->use_proxy)
conn->proxyip = g_strdup(args->proxyip);
conn->clientip = g_strdup(args->clientip);
conn->verifiedip = g_strdup(args->verifiedip);
conn->port = args->port;
conn->use_proxy |= args->use_proxy;
conn->lastrequestnumber++;
if (args->type == OSCAR_CAPABILITY_DIRECTIM)
{
buf = g_strdup_printf(_("%s has just asked to directly connect to %s"),
bn, purple_account_get_username(account));
purple_request_action(conn, NULL, buf,
_("This requires a direct connection between "
"the two computers and is necessary for IM "
"Images. Because your IP address will be "
"revealed, this may be considered a privacy "
"risk."),
PURPLE_DEFAULT_ACTION_NONE,
account, bn, NULL,
conn, 2,
_("C_onnect"), G_CALLBACK(peer_connection_got_proposition_yes_cb),
_("Cancel"), G_CALLBACK(peer_connection_got_proposition_no_cb));
}
else if (args->type == OSCAR_CAPABILITY_SENDFILE)
{
gchar *filename;
conn->xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE, bn);
if (conn->xfer)
{
conn->xfer->data = conn;
purple_xfer_ref(conn->xfer);
purple_xfer_set_size(conn->xfer, args->info.sendfile.totsize);
/* Set the file name */
if (g_utf8_validate(args->info.sendfile.filename, -1, NULL))
filename = g_strdup(args->info.sendfile.filename);
else
filename = purple_utf8_salvage(args->info.sendfile.filename);
if (args->info.sendfile.subtype == AIM_OFT_SUBTYPE_SEND_DIR)
{
/*
* If they are sending us a directory then the last character
* of the file name will be an asterisk. We don't want to
* save stuff to a directory named "*" so we remove the
* asterisk from the file name.
*/
char *tmp = strrchr(filename, '\\');
if ((tmp != NULL) && (tmp[1] == '*'))
tmp[0] = '\0';
}
purple_xfer_set_filename(conn->xfer, filename);
g_free(filename);
/*
* Set the message, unless this is the dummy message from an
* ICQ client or an empty message from an AIM client.
* TODO: Maybe we should strip HTML and then see if strlen>0?
*/
if ((message != NULL) &&
(g_ascii_strncasecmp(message, "<ICQ_COOL_FT>", 13) != 0) &&
(g_ascii_strcasecmp(message, "<HTML>") != 0))
{
purple_xfer_set_message(conn->xfer, message);
}
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(conn->xfer, peer_oft_recvcb_init);
purple_xfer_set_end_fnc(conn->xfer, peer_oft_recvcb_end);
purple_xfer_set_request_denied_fnc(conn->xfer, peer_oft_cb_generic_cancel);
purple_xfer_set_cancel_recv_fnc(conn->xfer, peer_oft_cb_generic_cancel);
purple_xfer_set_ack_fnc(conn->xfer, peer_oft_recvcb_ack_recv);
/* Now perform the request */
purple_xfer_request(conn->xfer);
}
}
}
static void ggp_edisc_xfer_recv_ticket_update_got(PurpleHttpConnection *hc,
PurpleHttpResponse *response, gpointer user_data)
{
PurpleConnection *gc = purple_http_conn_get_purple_connection(hc);
PurpleXfer *xfer;
ggp_edisc_xfer *edisc_xfer;
JsonParser *parser;
JsonObject *result;
int status = -1;
ggp_edisc_session_data *sdata;
const gchar *ticket_id, *file_name, *send_mode_str;
uin_t sender, recipient;
int file_size;
if (!purple_http_response_is_successful(response)) {
purple_debug_error("gg",
"ggp_edisc_xfer_recv_ticket_update_got: "
"cannot fetch update for ticket (code=%d)\n",
purple_http_response_get_code(response));
return;
}
sdata = ggp_edisc_get_sdata(gc);
g_return_if_fail(sdata != NULL);
parser = ggp_json_parse(purple_http_response_get_data(response, NULL));
result = json_node_get_object(json_parser_get_root(parser));
result = json_object_get_object_member(result, "result");
if (json_object_has_member(result, "status"))
status = json_object_get_int_member(result, "status");
result = json_object_get_object_member(result, "send_ticket");
if (status != 0) {
purple_debug_warning("gg",
"ggp_edisc_xfer_recv_ticket_update_got: failed to get "
"update (status=%d)\n", status);
g_object_unref(parser);
return;
}
ticket_id = json_object_get_string_member(result, "id");
sender = ggp_str_to_uin(json_object_get_string_member(result,
"sender"));
recipient = ggp_str_to_uin(json_object_get_string_member(result,
"recipient"));
file_size = g_ascii_strtoll(json_object_get_string_member(result,
"file_size"), NULL, 10);
file_name = json_object_get_string_member(result, "file_name");
/* GG11: normal
* AQQ 2.4.2.10: direct_inbox
*/
send_mode_str = json_object_get_string_member(result, "send_mode");
/* more fields:
* send_progress (float), ack_status, send_status
*/
if (purple_debug_is_verbose() && purple_debug_is_unsafe())
purple_debug_info("gg", "Got ticket update: id=%s, sender=%u, "
"recipient=%u, file name=\"%s\", file size=%d, "
"send mode=%s)\n",
ticket_id,
sender, recipient,
file_name, file_size,
send_mode_str);
xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id);
if (xfer != NULL) {
purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:"
" ticket %s already updated\n",
purple_debug_is_unsafe() ? ticket_id : "");
g_object_unref(parser);
return;
}
if (recipient != ggp_get_my_uin(gc)) {
purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:"
" ticket %s is not for incoming transfer "
"(its from %u to %u)\n",
purple_debug_is_unsafe() ? ticket_id : "",
sender, recipient);
g_object_unref(parser);
return;
}
xfer = ggp_edisc_xfer_recv_new(gc, ggp_uin_to_str(sender));
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_request(xfer);
edisc_xfer = purple_xfer_get_protocol_data(xfer);
edisc_xfer->ticket_id = g_strdup(ticket_id);
g_hash_table_insert(sdata->xfers_initialized,
edisc_xfer->ticket_id, xfer);
g_hash_table_insert(sdata->xfers_history,
g_strdup(ticket_id), GINT_TO_POINTER(1));
g_object_unref(parser);
}
static gssize yahoo_xfer_read(guchar **buffer, PurpleXfer *xfer)
{
gchar buf[4096];
gssize len;
gchar *start = NULL;
gchar *length;
gchar *end;
int filelen;
struct yahoo_xfer_data *xd = xfer->data;
if (purple_xfer_get_type(xfer) != PURPLE_XFER_RECEIVE) {
return 0;
}
len = read(xfer->fd, buf, sizeof(buf));
if (len <= 0) {
if ((purple_xfer_get_size(xfer) > 0) &&
(purple_xfer_get_bytes_sent(xfer) >= purple_xfer_get_size(xfer))) {
purple_xfer_set_completed(xfer, TRUE);
return 0;
} else
return -1;
}
if (!xd->started) {
xd->rxqueue = g_realloc(xd->rxqueue, len + xd->rxlen);
memcpy(xd->rxqueue + xd->rxlen, buf, len);
xd->rxlen += len;
length = g_strstr_len(xd->rxqueue, len, "Content-length:");
/* some proxies re-write this header, changing the capitalization :(
* technically that's allowed since headers are case-insensitive
* [RFC 2616, section 4.2] */
if (length == NULL)
length = g_strstr_len(xd->rxqueue, len, "Content-Length:");
if (length) {
end = g_strstr_len(length, length - xd->rxqueue, "\r\n");
if (!end)
return 0;
if ((filelen = calculate_length(length, len - (length - xd->rxqueue))))
purple_xfer_set_size(xfer, filelen);
}
start = g_strstr_len(xd->rxqueue, len, "\r\n\r\n");
if (start)
start += 4;
if (!start || start > (xd->rxqueue + len))
return 0;
xd->started = TRUE;
len -= (start - xd->rxqueue);
*buffer = g_malloc(len);
memcpy(*buffer, start, len);
g_free(xd->rxqueue);
xd->rxqueue = NULL;
xd->rxlen = 0;
} else {
*buffer = g_malloc(len);
memcpy(*buffer, buf, len);
}
return len;
}
/* This function makes the necessary arrangements for receiving files */
void irc_dccsend_recv(struct irc_conn *irc, const char *from, const char *msg) {
PurpleXfer *xfer;
struct irc_xfer_rx_data *xd;
gchar **token;
struct in_addr addr;
GString *filename;
int i = 0;
guint32 nip;
token = g_strsplit(msg, " ", 0);
if (!token[0] || !token[1] || !token[2]) {
g_strfreev(token);
return;
}
filename = g_string_new("");
if (token[0][0] == '"') {
if (!strchr(&(token[0][1]), '"')) {
g_string_append(filename, &(token[0][1]));
for (i = 1; token[i]; i++)
if (!strchr(token[i], '"')) {
g_string_append_printf(filename, " %s", token[i]);
} else {
g_string_append_len(filename, token[i], strlen(token[i]) - 1);
break;
}
} else {
g_string_append_len(filename, &(token[0][1]), strlen(&(token[0][1])) - 1);
}
} else {
g_string_append(filename, token[0]);
}
if (!token[i] || !token[i+1] || !token[i+2]) {
g_strfreev(token);
g_string_free(filename, TRUE);
return;
}
i++;
xfer = purple_xfer_new(irc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xd = g_new0(struct irc_xfer_rx_data, 1);
xfer->data = xd;
purple_xfer_set_filename(xfer, filename->str);
xfer->remote_port = atoi(token[i+1]);
nip = strtoul(token[i], NULL, 10);
if (nip) {
addr.s_addr = htonl(nip);
xd->ip = g_strdup(inet_ntoa(addr));
} else {
xd->ip = g_strdup(token[i]);
}
purple_debug(PURPLE_DEBUG_INFO, "irc", "Receiving file from %s\n",
xd->ip);
purple_xfer_set_size(xfer, token[i+2] ? atoi(token[i+2]) : 0);
purple_xfer_set_init_fnc(xfer, irc_dccsend_recv_init);
purple_xfer_set_ack_fnc(xfer, irc_dccsend_recv_ack);
purple_xfer_set_end_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_set_request_denied_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_set_cancel_send_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_request(xfer);
}
g_strfreev(token);
g_string_free(filename, TRUE);
}
void yahoo_process_filetransfer(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *from = NULL;
char *to = NULL;
char *msg = NULL;
char *url = NULL;
char *imv = NULL;
long expires = 0;
PurpleXfer *xfer;
struct yahoo_data *yd;
struct yahoo_xfer_data *xfer_data;
char *service = NULL;
char *filename = NULL;
unsigned long filesize = 0L;
GSList *l;
yd = gc->proto_data;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 4)
from = pair->value;
if (pair->key == 5)
to = pair->value;
if (pair->key == 14)
msg = pair->value;
if (pair->key == 20)
url = pair->value;
if (pair->key == 38)
expires = strtol(pair->value, NULL, 10);
if (pair->key == 27)
filename = pair->value;
if (pair->key == 28)
filesize = atol(pair->value);
if (pair->key == 49)
service = pair->value;
if (pair->key == 63)
imv = pair->value;
}
/*
* The remote user has changed their IMVironment. We
* record it for later use.
*/
if (from && imv && service && (strcmp("IMVIRONMENT", service) == 0)) {
g_hash_table_replace(yd->imvironments, g_strdup(from), g_strdup(imv));
return;
}
if (pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
if (service && (strcmp("FILEXFER", service) != 0)) {
purple_debug_misc("yahoo", "unhandled service 0x%02x\n", pkt->service);
return;
}
}
if (msg) {
char *tmp;
tmp = strchr(msg, '\006');
if (tmp)
*tmp = '\0';
}
if (!url || !from)
return;
/* Setup the Yahoo-specific file transfer data */
xfer_data = g_new0(struct yahoo_xfer_data, 1);
xfer_data->gc = gc;
if (!purple_url_parse(url, &(xfer_data->host), &(xfer_data->port), &(xfer_data->path), NULL, NULL)) {
g_free(xfer_data);
return;
}
purple_debug_misc("yahoo_filexfer", "Host is %s, port is %d, path is %s, and the full url was %s.\n",
xfer_data->host, xfer_data->port, xfer_data->path, url);
/* Build the file transfer handle. */
xfer = purple_xfer_new(gc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xfer->data = xfer_data;
/* Set the info about the incoming file. */
if (filename) {
char *utf8_filename = yahoo_string_decode(gc, filename, TRUE);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
} else {
gchar *start, *end;
start = g_strrstr(xfer_data->path, "/");
if (start)
start++;
end = g_strrstr(xfer_data->path, "?");
if (start && *start && end) {
char *utf8_filename;
filename = g_strndup(start, end - start);
utf8_filename = yahoo_string_decode(gc, filename, TRUE);
g_free(filename);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
filename = NULL;
}
}
purple_xfer_set_size(xfer, filesize);
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(xfer, yahoo_xfer_init);
purple_xfer_set_start_fnc(xfer, yahoo_xfer_start);
purple_xfer_set_end_fnc(xfer, yahoo_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, yahoo_xfer_cancel_send);
purple_xfer_set_cancel_recv_fnc(xfer, yahoo_xfer_cancel_recv);
purple_xfer_set_read_fnc(xfer, yahoo_xfer_read);
purple_xfer_set_write_fnc(xfer, yahoo_xfer_write);
/* Now perform the request */
purple_xfer_request(xfer);
}
}
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);
}
}
}
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
skypeweb_got_file_info(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
JsonObject *obj;
PurpleXfer *xfer;
SkypeWebFileTransfer *swft = user_data;
SkypeWebAccount *sa = swft->sa;
JsonParser *parser;
JsonNode *node;
sa->url_datas = g_slist_remove(sa->url_datas, url_data);
parser = json_parser_new();
if (!json_parser_load_from_data(parser, url_text, len, NULL)) {
g_free(swft->url);
g_free(swft->from);
g_free(swft);
g_object_unref(parser);
return;
}
node = json_parser_get_root(parser);
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT) {
g_free(swft->url);
g_free(swft->from);
g_free(swft);
g_object_unref(parser);
return;
}
obj = json_node_get_object(node);
/*
{
"content_length": 40708,
"content_full_length": 40708,
"view_length": 40708,
"content_state": "ready",
"view_state": "ready",
"view_location": "uri/views/original",
"status_location": "uri/views/original/status",
"scan": {
"status": "passed"
},
"original_filename": "filename"
} */
purple_debug_info("skypeweb", "File info: %s\n", url_text);
if (!json_object_has_member(obj, "content_state") || !g_str_equal(json_object_get_string_member(obj, "content_state"), "ready")) {
skypeweb_present_uri_as_filetransfer(sa, json_object_get_string_member(obj, "status_location"), swft->from);
g_free(swft->url);
g_free(swft->from);
g_free(swft);
g_object_unref(parser);
return;
}
json_object_ref(obj);
swft->info = obj;
xfer = purple_xfer_new(sa->account, PURPLE_XFER_RECEIVE, swft->from);
purple_xfer_set_size(xfer, json_object_get_int_member(obj, "content_full_length"));
purple_xfer_set_filename(xfer, json_object_get_string_member(obj, "original_filename"));
purple_xfer_set_init_fnc(xfer, skypeweb_init_file_download);
purple_xfer_set_cancel_recv_fnc(xfer, skypeweb_free_xfer);
swft->xfer = xfer;
purple_xfer_set_protocol_data(xfer, swft);
purple_xfer_request(xfer);
g_object_unref(parser);
}
