/*------------------------------------------------------------------------ * 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 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); } }
//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)); } }
static void prplcb_xfer_new( PurpleXfer *xfer ) { if( purple_xfer_get_type( xfer ) == PURPLE_XFER_RECEIVE ) { /* This should suppress the stupid file dialog. */ purple_xfer_set_local_filename( xfer, "/tmp/wtf123" ); /* Sadly the xfer struct is still empty ATM so come back after the caller is done. */ b_timeout_add( 0, prplcb_xfer_new_send_cb, xfer ); } else { struct prpl_xfer_data *px = g_new0( struct prpl_xfer_data, 1 ); px->ft = next_ft; px->ft->data = px; px->xfer = xfer; px->xfer->ui_data = px; purple_xfer_set_filename( xfer, px->ft->file_name ); purple_xfer_set_size( xfer, px->ft->file_size ); next_ft = NULL; } }
void tgprpl_recv_file (PurpleConnection * gc, const char *who, struct tgl_message *M) { debug ("tgprpl_recv_file()"); PurpleXfer *X = tgprpl_new_xfer_recv (gc, who); const char *mime_type, *caption; long long access_hash; int flags, size; if (M->media.type == tgl_message_media_document_encr) { mime_type = M->media.encr_document->mime_type; caption = M->media.encr_document->caption; access_hash = M->media.encr_document->access_hash; flags = M->media.encr_document->flags; size = M->media.encr_document->size; } else { mime_type = M->media.document->mime_type; caption = M->media.document->caption; access_hash = M->media.document->access_hash; flags = M->media.document->flags; size = M->media.document->size; } char *filename = tgp_strdup_determine_filename (mime_type, caption, flags, access_hash); purple_xfer_set_filename (X, filename); g_free (filename); purple_xfer_set_size (X, size); tgprpl_xfer_init_data (X, purple_connection_get_protocol_data (gc), M); purple_xfer_request (X); }
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)); } } }
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 tgprpl_recv_encr_file (PurpleConnection * gc, const char *who, struct tgl_encr_document *D) { debug ("tgprpl_recv_encr_file()"); PurpleXfer *X = tgprpl_new_xfer_recv (gc, who); char *filename = tgp_strdup_determine_filename (D->mime_type, D->caption, D->flags, D->access_hash); purple_xfer_set_filename (X, filename); g_free (filename); purple_xfer_set_size (X, D->size); tgprpl_xfer_init_data (X, purple_connection_get_protocol_data (gc), NULL, D); purple_xfer_request (X); }
static void skypeweb_xfer_send_init(PurpleXfer *xfer) { PurpleConnection *pc = purple_account_get_connection(purple_xfer_get_account(xfer)); SkypeWebAccount *sa = purple_connection_get_protocol_data(pc); gchar *basename = g_path_get_basename(purple_xfer_get_local_filename(xfer)); gchar *id, *post, *headers; SkypeWebFileTransfer *swft = purple_xfer_get_protocol_data(xfer); JsonObject *obj = json_object_new(); JsonObject *permissions = json_object_new(); JsonArray *userpermissions = json_array_new(); purple_xfer_set_filename(xfer, basename); purple_xfer_ref(xfer); json_object_set_string_member(obj, "type", "sharing/file"); json_object_set_string_member(obj, "filename", basename); if (SKYPEWEB_BUDDY_IS_MSN(swft->from)) { id = g_strconcat("1:", swft->from, NULL); } else { id = g_strconcat("8:", swft->from, NULL); } json_array_add_string_element(userpermissions, "read"); json_object_set_array_member(permissions, id, userpermissions); json_object_set_object_member(obj, "permissions", permissions); post = skypeweb_jsonobj_to_string(obj); //POST to api.asm.skype.com /v1/objects //{"type":"sharing/file","permissions":{"8:eionrobb":["read"]},"filename":"GiantLobsterMoose.txt"} headers = g_strdup_printf("POST /v1/objects HTTP/1.0\r\n" "Connection: close\r\n" "Authorization: skype_token %s\r\n" //slightly different to normal! "Host: " SKYPEWEB_XFER_HOST "\r\n" "Content-Length: %d\r\n" "Content-Type: application/json\r\n" "\r\n\r\n%s", sa->skype_token, strlen(post), post); skypeweb_fetch_url_request(sa, "https://" SKYPEWEB_XFER_HOST, TRUE, NULL, FALSE, headers, FALSE, -1, skypeweb_got_object_for_file, swft); g_free(post); json_object_unref(obj); g_free(id); g_free(basename); }
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); } } }
/* * This function is called after the user has selected a file to send. */ static void irc_dccsend_send_init(PurpleXfer *xfer) { PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer)); struct irc_xfer_send_data *xd = purple_xfer_get_protocol_data(xfer); purple_xfer_set_filename(xfer, g_path_get_basename(purple_xfer_get_local_filename(xfer))); g_object_ref(xfer); /* Create a listening socket */ xd->listen_data = purple_network_listen_range(0, 0, AF_UNSPEC, SOCK_STREAM, TRUE, irc_dccsend_network_listen_cb, xfer); if (xd->listen_data == NULL) { g_object_unref(xfer); purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unable to open a listening port."), purple_request_cpar_from_connection(gc)); purple_xfer_cancel_local(xfer); } }
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); }
/** * Someone else wants to establish a peer connection with us. */ void peer_connection_got_proposition(OscarData *od, const gchar *bn, const gchar *message, IcbmArgsCh2 *args) { PurpleConnection *gc; PurpleAccount *account; PeerConnection *conn; gchar *buf; gc = od->gc; account = purple_connection_get_account(gc); /* * If we have a connection with this same cookie then they are * probably just telling us they weren't able to connect to us * and we should try connecting to them, instead. Or they want * to go through a proxy. */ conn = peer_connection_find_by_cookie(od, bn, args->cookie); if ((conn != NULL) && (conn->type == args->type)) { purple_debug_info("oscar", "Remote user wants to try a " "different connection method\n"); g_free(conn->proxyip); g_free(conn->clientip); g_free(conn->verifiedip); if (args->use_proxy) conn->proxyip = g_strdup(args->proxyip); else conn->proxyip = NULL; conn->verifiedip = g_strdup(args->verifiedip); conn->clientip = g_strdup(args->clientip); conn->port = args->port; conn->use_proxy |= args->use_proxy; conn->lastrequestnumber++; peer_connection_trynext(conn); return; } /* If this is a direct IM, then close any existing session */ if (args->type == OSCAR_CAPABILITY_DIRECTIM) { conn = peer_connection_find_by_type(od, bn, args->type); if (conn != NULL) { /* Close the old direct IM and start a new one */ purple_debug_info("oscar", "Received new direct IM request " "from %s. Destroying old connection.\n", bn); peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL); } } /* Check for proper arguments */ if (args->type == OSCAR_CAPABILITY_SENDFILE) { if ((args->info.sendfile.filename == NULL) || (args->info.sendfile.totsize == 0) || (args->info.sendfile.totfiles == 0)) { purple_debug_warning("oscar", "%s tried to send you a file with incomplete " "information.\n", bn); return; } } conn = peer_connection_new(od, args->type, bn); memcpy(conn->cookie, args->cookie, 8); if (args->use_proxy) conn->proxyip = g_strdup(args->proxyip); conn->clientip = g_strdup(args->clientip); conn->verifiedip = g_strdup(args->verifiedip); conn->port = args->port; conn->use_proxy |= args->use_proxy; conn->lastrequestnumber++; if (args->type == OSCAR_CAPABILITY_DIRECTIM) { buf = g_strdup_printf(_("%s has just asked to directly connect to %s"), bn, purple_account_get_username(account)); purple_request_action(conn, NULL, buf, _("This requires a direct connection between " "the two computers and is necessary for IM " "Images. Because your IP address will be " "revealed, this may be considered a privacy " "risk."), PURPLE_DEFAULT_ACTION_NONE, account, bn, NULL, conn, 2, _("C_onnect"), G_CALLBACK(peer_connection_got_proposition_yes_cb), _("Cancel"), G_CALLBACK(peer_connection_got_proposition_no_cb)); } else if (args->type == OSCAR_CAPABILITY_SENDFILE) { gchar *filename; conn->xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE, bn); if (conn->xfer) { conn->xfer->data = conn; purple_xfer_ref(conn->xfer); purple_xfer_set_size(conn->xfer, args->info.sendfile.totsize); /* Set the file name */ if (g_utf8_validate(args->info.sendfile.filename, -1, NULL)) filename = g_strdup(args->info.sendfile.filename); else filename = purple_utf8_salvage(args->info.sendfile.filename); if (args->info.sendfile.subtype == AIM_OFT_SUBTYPE_SEND_DIR) { /* * If they are sending us a directory then the last character * of the file name will be an asterisk. We don't want to * save stuff to a directory named "*" so we remove the * asterisk from the file name. */ char *tmp = strrchr(filename, '\\'); if ((tmp != NULL) && (tmp[1] == '*')) tmp[0] = '\0'; } purple_xfer_set_filename(conn->xfer, filename); g_free(filename); /* * Set the message, unless this is the dummy message from an * ICQ client or an empty message from an AIM client. * TODO: Maybe we should strip HTML and then see if strlen>0? */ if ((message != NULL) && (g_ascii_strncasecmp(message, "<ICQ_COOL_FT>", 13) != 0) && (g_ascii_strcasecmp(message, "<HTML>") != 0)) { purple_xfer_set_message(conn->xfer, message); } /* Setup our I/O op functions */ purple_xfer_set_init_fnc(conn->xfer, peer_oft_recvcb_init); purple_xfer_set_end_fnc(conn->xfer, peer_oft_recvcb_end); purple_xfer_set_request_denied_fnc(conn->xfer, peer_oft_cb_generic_cancel); purple_xfer_set_cancel_recv_fnc(conn->xfer, peer_oft_cb_generic_cancel); purple_xfer_set_ack_fnc(conn->xfer, peer_oft_recvcb_ack_recv); /* Now perform the request */ purple_xfer_request(conn->xfer); } } }
static void ggp_edisc_xfer_recv_ticket_update_got(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer user_data) { PurpleConnection *gc = purple_http_conn_get_purple_connection(hc); PurpleXfer *xfer; ggp_edisc_xfer *edisc_xfer; JsonParser *parser; JsonObject *result; int status = -1; ggp_edisc_session_data *sdata; const gchar *ticket_id, *file_name, *send_mode_str; uin_t sender, recipient; int file_size; if (!purple_http_response_is_successful(response)) { purple_debug_error("gg", "ggp_edisc_xfer_recv_ticket_update_got: " "cannot fetch update for ticket (code=%d)\n", purple_http_response_get_code(response)); return; } sdata = ggp_edisc_get_sdata(gc); g_return_if_fail(sdata != NULL); parser = ggp_json_parse(purple_http_response_get_data(response, NULL)); result = json_node_get_object(json_parser_get_root(parser)); result = json_object_get_object_member(result, "result"); if (json_object_has_member(result, "status")) status = json_object_get_int_member(result, "status"); result = json_object_get_object_member(result, "send_ticket"); if (status != 0) { purple_debug_warning("gg", "ggp_edisc_xfer_recv_ticket_update_got: failed to get " "update (status=%d)\n", status); g_object_unref(parser); return; } ticket_id = json_object_get_string_member(result, "id"); sender = ggp_str_to_uin(json_object_get_string_member(result, "sender")); recipient = ggp_str_to_uin(json_object_get_string_member(result, "recipient")); file_size = g_ascii_strtoll(json_object_get_string_member(result, "file_size"), NULL, 10); file_name = json_object_get_string_member(result, "file_name"); /* GG11: normal * AQQ 2.4.2.10: direct_inbox */ send_mode_str = json_object_get_string_member(result, "send_mode"); /* more fields: * send_progress (float), ack_status, send_status */ if (purple_debug_is_verbose() && purple_debug_is_unsafe()) purple_debug_info("gg", "Got ticket update: id=%s, sender=%u, " "recipient=%u, file name=\"%s\", file size=%d, " "send mode=%s)\n", ticket_id, sender, recipient, file_name, file_size, send_mode_str); xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id); if (xfer != NULL) { purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:" " ticket %s already updated\n", purple_debug_is_unsafe() ? ticket_id : ""); g_object_unref(parser); return; } if (recipient != ggp_get_my_uin(gc)) { purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:" " ticket %s is not for incoming transfer " "(its from %u to %u)\n", purple_debug_is_unsafe() ? ticket_id : "", sender, recipient); g_object_unref(parser); return; } xfer = ggp_edisc_xfer_recv_new(gc, ggp_uin_to_str(sender)); purple_xfer_set_filename(xfer, file_name); purple_xfer_set_size(xfer, file_size); purple_xfer_request(xfer); edisc_xfer = purple_xfer_get_protocol_data(xfer); edisc_xfer->ticket_id = g_strdup(ticket_id); g_hash_table_insert(sdata->xfers_initialized, edisc_xfer->ticket_id, xfer); g_hash_table_insert(sdata->xfers_history, g_strdup(ticket_id), GINT_TO_POINTER(1)); g_object_unref(parser); }
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); }
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); }
/* This function makes the necessary arrangements for receiving files */ void irc_dccsend_recv(struct irc_conn *irc, const char *from, const char *msg) { PurpleXfer *xfer; struct irc_xfer_rx_data *xd; gchar **token; struct in_addr addr; GString *filename; int i = 0; guint32 nip; token = g_strsplit(msg, " ", 0); if (!token[0] || !token[1] || !token[2]) { g_strfreev(token); return; } filename = g_string_new(""); if (token[0][0] == '"') { if (!strchr(&(token[0][1]), '"')) { g_string_append(filename, &(token[0][1])); for (i = 1; token[i]; i++) if (!strchr(token[i], '"')) { g_string_append_printf(filename, " %s", token[i]); } else { g_string_append_len(filename, token[i], strlen(token[i]) - 1); break; } } else { g_string_append_len(filename, &(token[0][1]), strlen(&(token[0][1])) - 1); } } else { g_string_append(filename, token[0]); } if (!token[i] || !token[i+1] || !token[i+2]) { g_strfreev(token); g_string_free(filename, TRUE); return; } i++; xfer = purple_xfer_new(irc->account, PURPLE_XFER_RECEIVE, from); if (xfer) { xd = g_new0(struct irc_xfer_rx_data, 1); xfer->data = xd; purple_xfer_set_filename(xfer, filename->str); xfer->remote_port = atoi(token[i+1]); nip = strtoul(token[i], NULL, 10); if (nip) { addr.s_addr = htonl(nip); xd->ip = g_strdup(inet_ntoa(addr)); } else { xd->ip = g_strdup(token[i]); } purple_debug(PURPLE_DEBUG_INFO, "irc", "Receiving file from %s\n", xd->ip); purple_xfer_set_size(xfer, token[i+2] ? atoi(token[i+2]) : 0); purple_xfer_set_init_fnc(xfer, irc_dccsend_recv_init); purple_xfer_set_ack_fnc(xfer, irc_dccsend_recv_ack); purple_xfer_set_end_fnc(xfer, irc_dccsend_recv_destroy); purple_xfer_set_request_denied_fnc(xfer, irc_dccsend_recv_destroy); purple_xfer_set_cancel_send_fnc(xfer, irc_dccsend_recv_destroy); purple_xfer_request(xfer); } g_strfreev(token); g_string_free(filename, TRUE); }
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); } } }
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 purple_xfer_request_accepted(PurpleXfer *xfer, const char *filename) { PurpleXferType type; struct stat st; char *msg, *utf8, *base; PurpleAccount *account; PurpleBuddy *buddy; if (xfer == NULL) return; type = purple_xfer_get_type(xfer); account = purple_xfer_get_account(xfer); purple_debug_misc("xfer", "request accepted for %p\n", xfer); if (!filename && type == PURPLE_XFER_RECEIVE) { xfer->status = PURPLE_XFER_STATUS_ACCEPTED; xfer->ops.init(xfer); return; } buddy = purple_find_buddy(account, xfer->who); if (type == PURPLE_XFER_SEND) { /* Sending a file */ /* Check the filename. */ PurpleXferUiOps *ui_ops; ui_ops = purple_xfer_get_ui_ops(xfer); #ifdef _WIN32 if (g_strrstr(filename, "../") || g_strrstr(filename, "..\\")) #else if (g_strrstr(filename, "../")) #endif { utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8); purple_xfer_error(type, account, xfer->who, msg); g_free(utf8); g_free(msg); purple_xfer_unref(xfer); return; } if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) { if (g_stat(filename, &st) == -1) { purple_xfer_show_file_error(xfer, filename); purple_xfer_unref(xfer); return; } purple_xfer_set_local_filename(xfer, filename); purple_xfer_set_size(xfer, st.st_size); } else { utf8 = g_strdup(filename); purple_xfer_set_local_filename(xfer, filename); } base = g_path_get_basename(filename); utf8 = g_filename_to_utf8(base, -1, NULL, NULL, NULL); g_free(base); purple_xfer_set_filename(xfer, utf8); msg = g_strdup_printf(_("Offering to send %s to %s"), utf8, buddy ? purple_buddy_get_alias(buddy) : xfer->who); g_free(utf8); purple_xfer_conversation_write(xfer, msg, FALSE); g_free(msg); } else { /* Receiving a file */ xfer->status = PURPLE_XFER_STATUS_ACCEPTED; purple_xfer_set_local_filename(xfer, filename); msg = g_strdup_printf(_("Starting transfer of %s from %s"), xfer->filename, buddy ? purple_buddy_get_alias(buddy) : xfer->who); purple_xfer_conversation_write(xfer, msg, FALSE); g_free(msg); } purple_xfer_add(xfer); xfer->ops.init(xfer); }
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); } }