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); } }
PurpleXfer *sipe_purple_ft_new_xfer(PurpleConnection *gc, const char *who) { PurpleXfer *xfer = NULL; if (PURPLE_CONNECTION_IS_VALID(gc)) { xfer = purple_xfer_new(purple_connection_get_account(gc), PURPLE_XFER_SEND, who); if (xfer) { struct sipe_file_transfer *ft = sipe_core_ft_allocate(PURPLE_GC_TO_SIPE_CORE_PUBLIC); ft->backend_private = (struct sipe_backend_file_transfer *)xfer; PURPLE_XFER_DATA = ft; purple_xfer_set_init_fnc(xfer, ft_outgoing_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_outgoing_start); purple_xfer_set_end_fnc(xfer, tftp_outgoing_stop); purple_xfer_set_write_fnc(xfer, tftp_write); } } return 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 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 ); } }
PurpleXfer *yahoo_new_xfer(PurpleConnection *gc, const char *who) { PurpleXfer *xfer; struct yahoo_xfer_data *xfer_data; g_return_val_if_fail(who != NULL, NULL); xfer_data = g_new0(struct yahoo_xfer_data, 1); xfer_data->gc = gc; /* Build the file transfer handle. */ xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who); if (xfer) { xfer->data = xfer_data; /* 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); } return xfer; }
static PurpleXfer *tgprpl_new_xfer_recv (PurpleConnection *gc, const char *who) { PurpleXfer *X = purple_xfer_new (purple_connection_get_account (gc), PURPLE_XFER_RECEIVE, who); purple_xfer_set_init_fnc (X, tgprpl_xfer_recv_init); purple_xfer_set_cancel_recv_fnc (X, tgprpl_xfer_canceled); return X; }
static PurpleXfer *tgprpl_new_xfer_recv (PurpleConnection * gc, const char *who) { connection_data *conn = purple_connection_get_protocol_data (gc); PurpleXfer *X = purple_xfer_new (conn->pa, PURPLE_XFER_RECEIVE, who); purple_xfer_set_init_fnc (X, tgprpl_xfer_recv_init); purple_xfer_set_cancel_recv_fnc (X, tgprpl_xfer_canceled); return X; }
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); } }
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 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 sipe_backend_ft_deallocate(struct sipe_file_transfer *ft) { PurpleXfer *xfer = PURPLE_XFER; PurpleXferStatusType status = purple_xfer_get_status(xfer); // If file transfer is not finished, cancel it if ( status != PURPLE_XFER_STATUS_DONE && status != PURPLE_XFER_STATUS_CANCEL_LOCAL && status != PURPLE_XFER_STATUS_CANCEL_REMOTE) { purple_xfer_set_cancel_recv_fnc(xfer, NULL); purple_xfer_set_cancel_send_fnc(xfer, NULL); purple_xfer_cancel_remote(xfer); } }
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 PurpleXfer * yahoo_ft_new_xfer_struct(PurpleConnection *gc, PurpleXferType type, const char *who) { PurpleXfer *xfer; g_return_val_if_fail(gc != NULL, NULL); g_return_val_if_fail(who != NULL, NULL); xfer = purple_xfer_new(purple_connection_get_account(gc), type, who); g_return_val_if_fail(xfer != NULL, NULL); purple_xfer_set_init_fnc(xfer, yahoo_xfer_init_15); 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_request_denied_fnc(xfer, yahoo_xfer_cancel_recv); return xfer; }
static PurpleXfer * ggp_edisc_xfer_recv_new(PurpleConnection *gc, const char *who) { PurpleXfer *xfer; ggp_edisc_xfer *edisc_xfer; g_return_val_if_fail(gc != NULL, NULL); g_return_val_if_fail(who != NULL, NULL); xfer = purple_xfer_new(purple_connection_get_account(gc), PURPLE_XFER_TYPE_RECEIVE, who); edisc_xfer = g_new0(ggp_edisc_xfer, 1); purple_xfer_set_protocol_data(xfer, edisc_xfer); edisc_xfer->gc = gc; purple_xfer_set_init_fnc(xfer, ggp_edisc_xfer_recv_accept); purple_xfer_set_request_denied_fnc(xfer, ggp_edisc_xfer_recv_reject); purple_xfer_set_start_fnc(xfer, ggp_edisc_xfer_recv_start); purple_xfer_set_cancel_recv_fnc(xfer, ggp_edisc_xfer_cancel); return 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); }
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); } } }
/* 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_TYPE_RECEIVE, from); if (xfer) { xd = g_new0(struct irc_xfer_rx_data, 1); purple_xfer_set_protocol_data(xfer, xd); purple_xfer_set_filename(xfer, filename->str); xd->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 (%s) from %s\n", filename->str, 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_recv_fnc(xfer, irc_dccsend_recv_destroy); purple_xfer_request(xfer); } g_strfreev(token); g_string_free(filename, TRUE); }
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); }
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); } }