void qq_send_file(PurpleConnection* gc,const char* who,const char* filename)
{
qq_account* ac = purple_connection_get_protocol_data(gc);
if(!(ac->flag&DEBUG_FILE_SEND)){
//purple_notify_warning(gc,NULL,"难题尚未攻破,曙光遥遥无期","请先用离线文件传输");
PurpleXfer* xfer = purple_xfer_new(ac->account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
if(filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
return;
}
PurpleAccount* account = ac->account;
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_file_init);
//purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
//purple_xfer_set_request_denied_fnc(xfer,file_trans_request_denied);
//purple_xfer_set_cancel_send_fnc(xfer,file_trans_cancel);
void** data = s_malloc(sizeof(void*)*3);
data[0] = ac;
xfer->data = data;
purple_xfer_request(xfer);
}
//the entrience for recv file messages
void file_message(LwqqClient* lc,LwqqMsgFileMessage* file)
{
qq_account* ac = lwqq_client_userdata(lc);
if(file->mode == MODE_RECV) {
PurpleAccount* account = ac->account;
LwqqClient* lc = ac->qq;
LwqqBuddy* buddy = lc->find_buddy_by_uin(lc,file->super.from);
if(buddy == NULL ) return;
const char* key = try_get(buddy->qqnumber,buddy->uin);
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_RECEIVE,key);
purple_xfer_set_filename(xfer,file->recv.name);
purple_xfer_set_init_fnc(xfer,recv_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_recv_fnc(xfer,recv_file_cancel);
LwqqMsgFileMessage* fdup = s_malloc0(sizeof(*fdup));
lwqq_msg_move(fdup,file);
xfer->data = fdup;
purple_xfer_request(xfer);
} else if(file->mode == MODE_REFUSE) {
if(file->refuse.cancel_type == CANCEL_BY_USER)
qq_sys_msg_write(ac, LWQQ_MS_BUDDY_MSG, file->super.from,
_("Other canceled file transport"),
PURPLE_MESSAGE_SYSTEM,
time(NULL));
else if(file->refuse.cancel_type == CANCEL_BY_OVERTIME)
qq_sys_msg_write(ac, LWQQ_MS_BUDDY_MSG, file->super.from,
_("File transport timeout"),
PURPLE_MESSAGE_SYSTEM,
time(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);
}
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 file_message(LwqqClient* lc,LwqqMsgFileMessage* file)
{
qq_account* ac = lwqq_client_userdata(lc);
if(file->mode == MODE_RECV) {
PurpleAccount* account = ac->account;
LwqqClient* lc = ac->qq;
//for(i=0;i<file->file_count;i++){
LwqqBuddy* buddy = lc->find_buddy_by_uin(lc,file->from);
if(buddy == NULL ) return;
const char* key = try_get(buddy->qqnumber,buddy->uin);
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_RECEIVE,key);
purple_xfer_set_filename(xfer,file->recv.name);
purple_xfer_set_init_fnc(xfer,recv_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_recv_fnc(xfer,recv_file_cancel);
LwqqMsgFileMessage* fdup = s_malloc(sizeof(*fdup));
memcpy(fdup,file,sizeof(*fdup));
file->from = file->to = file->reply_ip = file->recv.name = NULL;
xfer->data = fdup;
purple_xfer_request(xfer);
} else if(file->mode == MODE_REFUSE) {
if(file->refuse.cancel_type == CANCEL_BY_USER) {
qq_sys_msg_write(ac, LWQQ_MT_BUDDY_MSG, file->from, "对方取消文件传输", PURPLE_MESSAGE_SYSTEM, time(NULL));
} else if(file->refuse.cancel_type == CANCEL_BY_OVERTIME) {
qq_sys_msg_write(ac, LWQQ_MT_BUDDY_MSG, file->from, "文件传输超时", PURPLE_MESSAGE_SYSTEM, time(NULL));
}
}
}
/*------------------------------------------------------------------------
* 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 );
}
}
void mrim_send_file(PurpleConnection *gc, const char *who, const char *file) {
PurpleXfer *xfer = mrim_new_xfer(gc, who);
if (file) {
purple_xfer_request_accepted(xfer, file);
} else {
purple_xfer_request(xfer);
}
}
/**
* Purple calls this function when the user selects Send File from the
* buddy menu
* It sets up the PurpleXfer struct and tells Purple to go ahead
*/
void irc_dccsend_send_file(PurpleConnection *gc, const char *who, const char *file) {
PurpleXfer *xfer = irc_dccsend_new_xfer(gc, who);
/* Perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
/*------------------------------------------------------------------------
* The user has initiated a file transfer to a contact.
*
* @param gc The connection object
* @param who The username of the contact
* @param filename The filename (is NULL if request has not been accepted yet)
*/
void mxit_xfer_tx( PurpleConnection* gc, const char* who, const char* filename )
{
PurpleXfer *xfer = mxit_xfer_new( gc, who );
if ( filename )
purple_xfer_request_accepted( xfer, filename );
else
purple_xfer_request( xfer );
}
void tgprpl_send_file (PurpleConnection * gc, const char *who, const char *file) {
debug ("tgprpl_send_file()");
PurpleXfer *X = tgprpl_new_xfer (gc, who);
if (file) {
purple_xfer_request_accepted (X, file);
debug ("starting xfer...");
} else {
purple_xfer_request (X);
}
}
void
skypeweb_send_file(PurpleConnection *pc, const gchar *who, const gchar *filename)
{
PurpleXfer *xfer = skypeweb_new_xfer(pc, who);
if (filename && *filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
}
void qq_send_offline_file(PurpleBlistNode* node)
{
PurpleBuddy* buddy = PURPLE_BUDDY(node);
PurpleAccount* account = purple_buddy_get_account(buddy);
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,buddy->name);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
purple_xfer_request(xfer);
}
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 void waprpl_send_file(PurpleConnection * gc, const char *who, const char *file)
{
purple_debug_info(WHATSAPP_ID, "Send file called\n");
PurpleXfer *xfer = waprpl_new_xfer(gc, who);
if (file) {
purple_xfer_request_accepted(xfer, file);
purple_debug_info(WHATSAPP_ID, "Accepted transfer of file %s\n", file);
} else
purple_xfer_request(xfer);
}
void silcpurple_ftp_send_file(PurpleConnection *gc, const char *name, const char *file)
{
PurpleXfer *xfer = silcpurple_ftp_new_xfer(gc, name);
g_return_if_fail(xfer != NULL);
/* Choose file to send */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void yahoo_send_file(PurpleConnection *gc, const char *who, const char *file)
{
PurpleXfer *xfer = yahoo_new_xfer(gc, who);
g_return_if_fail(xfer != NULL);
/* Now perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void jabber_oob_parse(JabberStream *js, const char *from, JabberIqType type,
const char *id, xmlnode *querynode) {
JabberOOBXfer *jox;
PurpleXfer *xfer;
char *filename;
char *url;
xmlnode *urlnode;
if(type != JABBER_IQ_SET)
return;
if(!from)
return;
if(!(urlnode = xmlnode_get_child(querynode, "url")))
return;
url = xmlnode_get_data(urlnode);
jox = g_new0(JabberOOBXfer, 1);
if (!purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL)) {
g_free(url);
return;
}
g_free(url);
jox->js = js;
jox->headers = g_string_new("");
jox->iq_id = g_strdup(id);
xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xfer->data = jox;
if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
filename = g_strdup(jox->page);
purple_xfer_set_filename(xfer, filename);
g_free(filename);
purple_xfer_set_init_fnc(xfer, jabber_oob_xfer_init);
purple_xfer_set_end_fnc(xfer, jabber_oob_xfer_end);
purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_cancelled);
purple_xfer_set_read_fnc(xfer, jabber_oob_xfer_read);
purple_xfer_set_start_fnc(xfer, jabber_oob_xfer_start);
js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);
purple_xfer_request(xfer);
}
}
void sipe_purple_ft_send_file(PurpleConnection *gc,
const char *who,
const char *file)
{
PurpleXfer *xfer = sipe_purple_ft_new_xfer(gc, who);
if (xfer) {
if (file != NULL)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
}
void jabber_oob_parse(JabberStream *js, xmlnode *packet) {
JabberOOBXfer *jox;
PurpleXfer *xfer;
char *filename;
char *url;
const char *type;
xmlnode *querynode, *urlnode;
if(!(type = xmlnode_get_attrib(packet, "type")) || strcmp(type, "set"))
return;
if(!(querynode = xmlnode_get_child(packet, "query")))
return;
if(!(urlnode = xmlnode_get_child(querynode, "url")))
return;
url = xmlnode_get_data(urlnode);
jox = g_new0(JabberOOBXfer, 1);
purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL);
g_free(url);
jox->js = js;
jox->headers = g_string_new("");
jox->iq_id = g_strdup(xmlnode_get_attrib(packet, "id"));
xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE,
xmlnode_get_attrib(packet, "from"));
if (xfer)
{
xfer->data = jox;
if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
filename = g_strdup(jox->page);
purple_xfer_set_filename(xfer, filename);
g_free(filename);
purple_xfer_set_init_fnc(xfer, jabber_oob_xfer_init);
purple_xfer_set_end_fnc(xfer, jabber_oob_xfer_end);
purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_canceled);
purple_xfer_set_read_fnc(xfer, jabber_oob_xfer_read);
purple_xfer_set_start_fnc(xfer, jabber_oob_xfer_start);
js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);
purple_xfer_request(xfer);
}
}
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);
}
void ggp_edisc_xfer_send_file(PurpleConnection *gc, const char *who,
const char *filename)
{
PurpleXfer *xfer;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
/* Nothing interesting here, this code is common among protocols.
* See ggp_edisc_xfer_send_new. */
xfer = ggp_edisc_xfer_send_new(gc, who);
if (filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
}
void
bonjour_send_file(PurpleConnection *gc, const char *who, const char *file)
{
PurpleXfer *xfer;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
purple_debug_info("bonjour", "Bonjour-send-file to=%s.\n", who);
xfer = bonjour_new_xfer(gc, who);
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void qq_send_offline_file(PurpleBlistNode* node)
{
PurpleBuddy* buddy = PURPLE_BUDDY(node);
PurpleAccount* account = purple_buddy_get_account(buddy);
qq_account* ac = purple_connection_get_protocol_data(
purple_account_get_connection(account));
const char* who;
if(ac->qq_use_qqnum){
const char* qqnum = purple_buddy_get_name(buddy);
LwqqBuddy* b = find_buddy_by_qqnumber(ac->qq, qqnum);
if(b == NULL) return;
who = b->uin;
}else{
who = purple_buddy_get_name(buddy);
}
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
purple_xfer_request(xfer);
}
static void
silcpurple_ftp_ask_name(SilcClient client,
SilcClientConnection conn,
SilcUInt32 session_id,
const char *remote_filename,
SilcClientFileName completion,
void *completion_context,
void *context)
{
SilcPurpleXfer xfer = context;
xfer->completion = completion;
xfer->completion_context = completion_context;
purple_xfer_set_init_fnc(xfer->xfer, silcpurple_ftp_ask_name_ok);
purple_xfer_set_request_denied_fnc(xfer->xfer, silcpurple_ftp_ask_name_cancel);
/* Request to save the file */
purple_xfer_set_filename(xfer->xfer, remote_filename);
purple_xfer_request(xfer->xfer);
}
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);
}
void silcpurple_ftp_request(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry, SilcUInt32 session_id,
const char *hostname, SilcUInt16 port)
{
PurpleConnection *gc = client->application;
SilcPurple sg = gc->proto_data;
SilcPurpleXfer xfer;
xfer = silc_calloc(1, sizeof(*xfer));
if (!xfer) {
silc_client_file_close(sg->client, sg->conn, session_id);
return;
}
xfer->sg = sg;
xfer->client_entry = client_entry;
xfer->session_id = session_id;
xfer->hostname = g_strdup(hostname);
xfer->port = port;
xfer->xfer = purple_xfer_new(xfer->sg->account, PURPLE_XFER_RECEIVE,
xfer->client_entry->nickname);
if (!xfer->xfer) {
silc_client_file_close(xfer->sg->client, xfer->sg->conn, xfer->session_id);
g_free(xfer->hostname);
silc_free(xfer);
return;
}
purple_xfer_set_init_fnc(xfer->xfer, silcpurple_ftp_request_result);
purple_xfer_set_request_denied_fnc(xfer->xfer, silcpurple_ftp_request_denied);
purple_xfer_set_cancel_recv_fnc(xfer->xfer, silcpurple_ftp_cancel);
xfer->xfer->remote_ip = g_strdup(hostname);
xfer->xfer->remote_port = port;
xfer->xfer->data = xfer;
/* File transfer request */
purple_xfer_request(xfer->xfer);
}
void yahoo_send_file(PurpleConnection *gc, const char *who, const char *file)
{
struct yahoo_xfer_data *xfer_data;
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleXfer *xfer = yahoo_new_xfer(gc, who);
g_return_if_fail(xfer != NULL);
#if 0
/* if we don't have a p2p connection, try establishing it now */
if( !g_hash_table_lookup(yd->peers, who) )
yahoo_send_p2p_pkt(gc, who, 0);
#endif
xfer_data = purple_xfer_get_protocol_data(xfer);
xfer_data->xfer_peer_idstring = yahoo_xfer_new_xfer_id();
g_hash_table_insert(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring, xfer);
/* Now perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
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 yahoo_xfer_end(PurpleXfer *xfer_old)
{
struct yahoo_xfer_data *xfer_data;
PurpleXfer *xfer = NULL;
PurpleConnection *gc;
YahooData *yd;
xfer_data = purple_xfer_get_protocol_data(xfer_old);
if(xfer_data
&& purple_xfer_get_xfer_type(xfer_old) == PURPLE_XFER_TYPE_RECEIVE
&& xfer_data->filename_list) {
/* removing top of filename & size list completely */
g_free( xfer_data->filename_list->data );
g_free( xfer_data->size_list->data );
xfer_data->filename_list->data = NULL;
xfer_data->size_list->data = NULL;
xfer_data->filename_list = g_slist_delete_link(xfer_data->filename_list, xfer_data->filename_list);
xfer_data->size_list = g_slist_delete_link(xfer_data->size_list, xfer_data->size_list);
/* if there are still more files */
if(xfer_data->filename_list)
{
gchar* filename;
char *utf8_filename;
filename = xfer_data->filename_list->data;
gc = xfer_data->gc;
yd = purple_connection_get_protocol_data(gc);
/* setting up xfer_data for next file's tranfer */
g_free(xfer_data->host);
g_free(xfer_data->path);
g_free(xfer_data->xfer_idstring_for_relay);
xfer_data->host = NULL;
xfer_data->host = NULL;
xfer_data->xfer_idstring_for_relay = NULL;
xfer_data->info_val_249 = 0;
xfer_data->firstoflist = FALSE;
/* Dereference xfer_data from old xfer */
purple_xfer_set_protocol_data(xfer_old, NULL);
/* Build the file transfer handle. */
xfer = yahoo_ft_new_xfer_struct(gc, PURPLE_XFER_TYPE_RECEIVE, purple_xfer_get_remote_user(xfer_old));
g_return_if_fail(xfer != NULL);
/* Set the info about the incoming file. */
utf8_filename = yahoo_string_decode(gc, filename, TRUE);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
purple_xfer_set_protocol_data(xfer, xfer_data);
/* update map to current xfer */
g_hash_table_remove(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring);
g_hash_table_insert(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring, xfer);
/* Now perform the request */
purple_xfer_request(xfer);
return;
}
}
if (xfer_data)
yahoo_xfer_data_free(xfer_data);
purple_xfer_set_protocol_data(xfer_old, NULL);
}
void yahoo_process_filetrans_15(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *from = NULL;
char *imv = NULL;
long val_222 = 0L;
PurpleXfer *xfer;
YahooData *yd;
struct yahoo_xfer_data *xfer_data;
char *service = NULL;
char *filename = NULL;
char *xfer_peer_idstring = NULL;
char *utf8_filename;
GSList *l;
GSList *filename_list = NULL;
GSList *size_list = NULL;
int nooffiles = 0;
yd = purple_connection_get_protocol_data(gc);
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 4:
if (g_utf8_validate(pair->value, -1, NULL)) {
from = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 5: /* to */
break;
case 265:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_peer_idstring = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 27:
filename_list = g_slist_prepend(filename_list, g_strdup(pair->value));
nooffiles++;
break;
case 28:
if (g_utf8_validate(pair->value, -1, NULL)) {
size_list = g_slist_prepend(size_list, g_strdup(pair->value));
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 222:
val_222 = atol(pair->value);
/* 1=send, 2=cancel, 3=accept, 4=reject */
break;
/* check for p2p and imviron .... not sure it comes by this service packet. Since it was bundled with filexfer in old ymsg version, still keeping it. */
case 49:
if (g_utf8_validate(pair->value, -1, NULL)) {
service = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 63:
if (g_utf8_validate(pair->value, -1, NULL)) {
imv = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
/* end check */
}
}
if(!xfer_peer_idstring)
return;
if(val_222 == 2 || val_222 == 4)
{
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map,
xfer_peer_idstring);
if(!xfer) return;
purple_xfer_cancel_remote(xfer);
return;
}
if(val_222 == 3)
{
PurpleAccount *account;
struct yahoo_xfer_data *xd;
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map,
xfer_peer_idstring);
if(!xfer)
return;
xd = purple_xfer_get_protocol_data(xfer);
/*
* In the file trans info packet that we must reply with, we are
* supposed to mention the ip address...
* purple connect does not give me a way of finding the ip address...
* so, purple dnsquery is used... but retries, trying with next ip
* address etc. is not implemented..TODO
*/
/* To send through p2p */
if( g_hash_table_lookup(yd->peers, from) ) {
/* send p2p file transfer information */
purple_debug_error("yahoo", "p2p file transfers are not supported yet\n");
/*xd->is_relay = FALSE;*/
}
xd->is_relay = TRUE;
account = purple_connection_get_account(gc);
if (yd->jp)
{
purple_dnsquery_a(account, YAHOOJP_XFER_RELAY_HOST,
YAHOOJP_XFER_RELAY_PORT,
yahoo_xfer_dns_connected_15, xfer);
}
else
{
purple_dnsquery_a(account, YAHOO_XFER_RELAY_HOST,
YAHOO_XFER_RELAY_PORT,
yahoo_xfer_dns_connected_15, xfer);
}
return;
}
/* processing for p2p and imviron .... not sure it comes by this service packet. Since it was bundled with filexfer in old ymsg version, still keeping it. */
/*
* 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;
}
}
/* end processing */
if(!filename_list)
return;
/* have to change list into order in which client at other end sends */
filename_list = g_slist_reverse(filename_list);
size_list = g_slist_reverse(size_list);
filename = filename_list->data;
if(!from) return;
xfer_data = g_new0(struct yahoo_xfer_data, 1);
xfer_data->firstoflist = TRUE;
xfer_data->gc = gc;
xfer_data->xfer_peer_idstring = g_strdup(xfer_peer_idstring);
xfer_data->filename_list = filename_list;
xfer_data->size_list = size_list;
/* Build the file transfer handle. */
xfer = yahoo_ft_new_xfer_struct(gc, PURPLE_XFER_TYPE_RECEIVE, from);
/* Set the info about the incoming file. */
utf8_filename = yahoo_string_decode(gc, filename, TRUE);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
purple_xfer_set_protocol_data(xfer, xfer_data);
g_hash_table_insert(yd->xfer_peer_idstring_map,
xfer_data->xfer_peer_idstring,
xfer);
if(nooffiles > 1) {
gchar* message;
message = g_strdup_printf(_("%s is trying to send you a group of %d files.\n"), purple_xfer_get_remote_user(xfer), nooffiles);
purple_xfer_conversation_write(xfer, message, FALSE);
g_free(message);
}
/* Now perform the request */
purple_xfer_request(xfer);
}
