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); }