void purple_xfer_cancel_local(PurpleXfer *xfer) { PurpleXferUiOps *ui_ops; char *msg = NULL; g_return_if_fail(xfer != NULL); purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL); xfer->end_time = time(NULL); if (purple_xfer_get_filename(xfer) != NULL) { msg = g_strdup_printf(_("You cancelled the transfer of %s"), purple_xfer_get_filename(xfer)); } else { msg = g_strdup(_("File transfer cancelled")); } purple_xfer_conversation_write(xfer, msg, FALSE); g_free(msg); if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) { if (xfer->ops.cancel_send != NULL) xfer->ops.cancel_send(xfer); } else { if (xfer->ops.cancel_recv != NULL) xfer->ops.cancel_recv(xfer); } if (xfer->watcher != 0) { purple_input_remove(xfer->watcher); xfer->watcher = 0; } if (xfer->fd != -1) close(xfer->fd); if (xfer->dest_fp != NULL) { fclose(xfer->dest_fp); xfer->dest_fp = NULL; } ui_ops = purple_xfer_get_ui_ops(xfer); if (ui_ops != NULL && ui_ops->cancel_local != NULL) ui_ops->cancel_local(xfer); xfer->bytes_remaining = 0; purple_xfer_unref(xfer); }
static void purple_xfer_ask_recv(PurpleXfer *xfer) { char *buf, *size_buf; size_t size; gconstpointer thumb; gsize thumb_size; /* If we have already accepted the request, ask the destination file name directly */ if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_ACCEPTED) { PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who); if (purple_xfer_get_filename(xfer) != NULL) { size = purple_xfer_get_size(xfer); size_buf = purple_str_size_to_units(size); buf = g_strdup_printf(_("%s wants to send you %s (%s)"), buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer), size_buf); g_free(size_buf); } else { buf = g_strdup_printf(_("%s wants to send you a file"), buddy ? purple_buddy_get_alias(buddy) : xfer->who); } if (xfer->message != NULL) serv_got_im(purple_account_get_connection(xfer->account), xfer->who, xfer->message, 0, time(NULL)); if ((thumb = purple_xfer_get_thumbnail(xfer, &thumb_size))) { purple_request_accept_cancel_with_icon(xfer, NULL, buf, NULL, PURPLE_DEFAULT_ACTION_NONE, xfer->account, xfer->who, NULL, thumb, thumb_size, xfer, G_CALLBACK(purple_xfer_choose_file), G_CALLBACK(cancel_recv_cb)); } else { purple_request_accept_cancel(xfer, NULL, buf, NULL, PURPLE_DEFAULT_ACTION_NONE, xfer->account, xfer->who, NULL, xfer, G_CALLBACK(purple_xfer_choose_file), G_CALLBACK(cancel_recv_cb)); } g_free(buf); } else purple_xfer_choose_file(xfer); }
void purple_pn_xfer_invite(PurpleXfer *xfer) { struct pn_peer_link *link; struct pn_peer_call *call; char *context; const char *fn; const char *fp; fn = purple_xfer_get_filename(xfer); fp = purple_xfer_get_local_filename(xfer); link = xfer->data; call = pn_peer_call_new(link); call->init_cb = send_file_cb; call->end_cb = xfer_end_cb; call->progress_cb = xfer_progress_cb; call->cb = xfer_completed_cb; call->xfer = xfer; purple_xfer_ref(call->xfer); call->pending = TRUE; purple_xfer_set_cancel_send_fnc(xfer, xfer_cancel); xfer->data = call; context = gen_context(fn, fp); pn_sip_send_invite(call, "5D3E02AB-6190-11D3-BBBB-00C04F795683", 2, context); g_free(context); }
static void tgprpl_xfer_send_init (PurpleXfer *X) { struct tgp_xfer_send_data *data = X->data; purple_xfer_start (X, -1, NULL, 0); const char *file = purple_xfer_get_filename (X); const char *localfile = purple_xfer_get_local_filename (X); const char *who = purple_xfer_get_remote_user (X); debug ("xfer_on_init (file=%s, local=%s, who=%s)", file, localfile, who); tgl_peer_t *P = find_peer_by_name (data->conn->TLS, who); if (P) { if (tgl_get_peer_type (P->id) != TGL_PEER_ENCR_CHAT) { tgl_do_send_document (data->conn->TLS, P->id, (char*) localfile, NULL, 0, TGL_SEND_MSG_FLAG_DOCUMENT_AUTO, tgprpl_xfer_on_finished, data); } else { purple_notify_message (_telegram_protocol, PURPLE_NOTIFY_MSG_ERROR, "Not supported", "Sorry, sending documents to encrypted chats not yet supported.", NULL, NULL, NULL); } } data->timer = purple_timeout_add (100, tgprpl_xfer_upload_progress, X); }
static void tgprpl_xfer_send_init (PurpleXfer *X) { debug ("tgprpl_xfer_send_init(): sending xfer accepted."); struct tgp_xfer_send_data *data; const char *file, *localfile, *who; tgl_peer_t *P; data = X->data; purple_xfer_start (X, -1, NULL, 0); file = purple_xfer_get_filename (X); localfile = purple_xfer_get_local_filename (X); who = purple_xfer_get_remote_user (X); debug ("xfer_on_init (file=%s, local=%s, who=%s)", file, localfile, who); P = tgp_blist_lookup_peer_get (data->conn->TLS, who); g_return_if_fail (P); if (tgl_get_peer_type (P->id) == TGL_PEER_ENCR_CHAT) { purple_xfer_error (PURPLE_XFER_SEND, data->conn->pa, who, _("Sorry, sending documents to encrypted chats not yet supported.")); purple_xfer_cancel_local (X); return; } tgl_do_send_document (data->conn->TLS, P->id, (char*) localfile, NULL, 0, TGL_SEND_MSG_FLAG_DOCUMENT_AUTO, tgprpl_xfer_send_on_finished, data); // see comment in tgprpl_xfer_recv_init() purple_xfer_ref (X); data->timer = purple_timeout_add (100, tgprpl_xfer_upload_progress, X); data->loading = TRUE; }
static void ft_outgoing_init(PurpleXfer *xfer) { sipe_core_ft_outgoing_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER, purple_xfer_get_filename(xfer), purple_xfer_get_size(xfer), xfer->who); }
void purple_xfer_set_completed(PurpleXfer *xfer, gboolean completed) { PurpleXferUiOps *ui_ops; g_return_if_fail(xfer != NULL); if (completed == TRUE) { char *msg = NULL; PurpleConversation *conv; purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_DONE); if (purple_xfer_get_filename(xfer) != NULL) { char *filename = g_markup_escape_text(purple_xfer_get_filename(xfer), -1); if (purple_xfer_get_local_filename(xfer) && purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { char *local = g_markup_escape_text(purple_xfer_get_local_filename(xfer), -1); msg = g_strdup_printf(_("Transfer of file <A HREF=\"file://%s\">%s</A> complete"), local, filename); g_free(local); } else msg = g_strdup_printf(_("Transfer of file %s complete"), filename); g_free(filename); } else msg = g_strdup(_("File transfer complete")); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who, purple_xfer_get_account(xfer)); if (conv != NULL) purple_conversation_write(conv, NULL, msg, PURPLE_MESSAGE_SYSTEM, time(NULL)); g_free(msg); } ui_ops = purple_xfer_get_ui_ops(xfer); if (ui_ops != NULL && ui_ops->update_progress != NULL) ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer)); }
std::string FiletransferRepeater::requestFT() { // purple_xfer_request_accepted(xfer, std::string(filename).c_str()); std::string filename(purple_xfer_get_filename(m_xfer)); m_sid = m_main->ft->requestFT(m_to, filename, purple_xfer_get_size(m_xfer), EmptyString, EmptyString, EmptyString, EmptyString, SIProfileFT::FTTypeAll, m_from); m_main->ftManager->m_info[m_sid].filename = filename; m_main->ftManager->m_info[m_sid].size = purple_xfer_get_size(m_xfer); m_main->ftManager->m_info[m_sid].straight = true; return m_sid; }
void purple_xfer_request(PurpleXfer *xfer) { g_return_if_fail(xfer != NULL); g_return_if_fail(xfer->ops.init != NULL); purple_xfer_ref(xfer); if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer); if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) { /* The file-transfer was cancelled by a plugin */ purple_xfer_cancel_local(xfer); } else if (purple_xfer_get_filename(xfer) || purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED) { gchar* message = NULL; PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who); message = g_strdup_printf(_("%s is offering to send file %s"), buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer)); purple_xfer_conversation_write_with_thumbnail(xfer, message); g_free(message); /* Ask for a filename to save to if it's not already given by a plugin */ if (xfer->local_filename == NULL) purple_xfer_ask_recv(xfer); } else { purple_xfer_ask_accept(xfer); } } else { purple_xfer_choose_file(xfer); } }
static int purple_xfer_choose_file(PurpleXfer *xfer) { purple_request_file(xfer, NULL, purple_xfer_get_filename(xfer), (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE), G_CALLBACK(purple_xfer_choose_file_ok_cb), G_CALLBACK(purple_xfer_choose_file_cancel_cb), purple_xfer_get_account(xfer), xfer->who, NULL, xfer); return 0; }
static void irc_dccsend_network_listen_cb(int sock, gpointer data) { PurpleXfer *xfer = data; struct irc_xfer_send_data *xd; PurpleConnection *gc; struct irc_conn *irc; const char *arg[2]; char *tmp; struct in_addr addr; unsigned short int port; xd = purple_xfer_get_protocol_data(xfer); xd->listen_data = NULL; if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL || purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE) { g_object_unref(xfer); return; } xd = purple_xfer_get_protocol_data(xfer); gc = purple_account_get_connection(purple_xfer_get_account(xfer)); irc = purple_connection_get_protocol_data(gc); g_object_unref(xfer); if (sock < 0) { 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); return; } xd->fd = sock; port = purple_network_get_port_from_fd(sock); purple_debug_misc("irc", "port is %hu\n", port); /* Monitor the listening socket */ purple_xfer_set_watcher(xfer, purple_input_add(sock, PURPLE_INPUT_READ, irc_dccsend_send_connected, xfer)); /* Send the intended recipient the DCC request */ arg[0] = purple_xfer_get_remote_user(xfer); inet_aton(purple_network_get_my_ip(irc->fd), &addr); arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %" G_GOFFSET_FORMAT "\001", purple_xfer_get_filename(xfer), ntohl(addr.s_addr), port, purple_xfer_get_size(xfer)); irc_cmd_privmsg(purple_connection_get_protocol_data(gc), "msg", NULL, arg); g_free(tmp); }
static void ggp_edisc_xfer_send_init(PurpleXfer *xfer) { ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer); purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_NOT_STARTED); edisc_xfer->filename = g_strdup(purple_xfer_get_filename(xfer)); g_strcanon(edisc_xfer->filename, GGP_EDISC_FNAME_ALLOWED, '_'); ggp_ggdrive_auth(edisc_xfer->gc, ggp_edisc_xfer_send_init_authenticated, xfer); }
void waprpl_xfer_init(PurpleXfer * xfer) { purple_debug_info(WHATSAPP_ID, "File xfer init...\n"); wa_file_upload *xinfo = (wa_file_upload *) xfer->data; whatsapp_connection *wconn = xinfo->wconn; size_t fs = purple_xfer_get_size(xfer); const char *fn = purple_xfer_get_filename(xfer); const char *fp = purple_xfer_get_local_filename(xfer); wa_file_upload *xfer_info = (wa_file_upload *) xfer->data; purple_xfer_set_size(xfer, fs); xfer_info->ref_id = waAPI_sendimage(wconn->waAPI, xinfo->to, 100, 100, fs, fp); purple_debug_info(WHATSAPP_ID, "Transfer file %s at %s with size %zu (given ref %d)\n", fn, fp, fs, xfer_info->ref_id); waprpl_check_output(xinfo->gc); }
static void tgprpl_xfer_send_init (PurpleXfer *X) { struct tgp_xfer_send_data *data = X->data; purple_xfer_start (X, -1, NULL, 0); const char *file = purple_xfer_get_filename (X); const char *localfile = purple_xfer_get_local_filename (X); const char *who = purple_xfer_get_remote_user (X); debug ("xfer_on_init (file=%s, local=%s, who=%s)", file, localfile, who); tgl_peer_t *P = find_peer_by_name (data->conn->TLS, who); if (P) { tgl_do_send_document (data->conn->TLS, P->id, (char*) localfile, NULL, 0, TGL_SEND_MSG_FLAG_DOCUMENT_AUTO, tgprpl_xfer_on_finished, data); } data->timer = purple_timeout_add (100, tgprpl_xfer_upload_progress, X); }
void finch_xfer_dialog_add_xfer(PurpleXfer *xfer) { PurpleGntXferUiData *data; PurpleXferType type; char *size_str, *remaining_str; char *lfilename, *utf8; g_return_if_fail(xfer_dialog != NULL); g_return_if_fail(xfer != NULL); purple_xfer_ref(xfer); data = FINCHXFER(xfer); data->in_list = TRUE; finch_xfer_dialog_show(); data->last_updated_time = 0; type = purple_xfer_get_type(xfer); size_str = purple_str_size_to_units(purple_xfer_get_size(xfer)); remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer)); lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer)); utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL); g_free(lfilename); lfilename = utf8; gnt_tree_add_row_last(GNT_TREE(xfer_dialog->tree), xfer, gnt_tree_create_row(GNT_TREE(xfer_dialog->tree), "0.0", (type == PURPLE_XFER_RECEIVE) ? purple_xfer_get_filename(xfer) : lfilename, size_str, "0.0", "",_("Waiting for transfer to begin")), NULL); g_free(lfilename); g_free(size_str); g_free(remaining_str); xfer_dialog->num_transfers++; update_title_progress(); }
void msn_request_ft(PurpleXfer *xfer) { MsnSlpCall *slpcall; MsnSlpLink *slplink; char *context; const char *fn; const char *fp; fn = purple_xfer_get_filename(xfer); fp = purple_xfer_get_local_filename(xfer); slplink = purple_xfer_get_protocol_data(xfer); g_return_if_fail(slplink != NULL); g_return_if_fail(fp != NULL); slpcall = msn_slpcall_new(slplink); msn_slpcall_init(slpcall, MSN_SLPCALL_DC); slpcall->session_init_cb = send_file_cb; slpcall->end_cb = msn_xfer_end_cb; slpcall->cb = msn_xfer_completed_cb; slpcall->xfer = xfer; g_object_ref(slpcall->xfer); slpcall->pending = TRUE; purple_xfer_set_cancel_send_fnc(xfer, msn_xfer_cancel); purple_xfer_set_read_fnc(xfer, msn_xfer_read); purple_xfer_set_write_fnc(xfer, msn_xfer_write); purple_xfer_set_protocol_data(xfer, slpcall); context = gen_context(xfer, fn, fp); msn_slpcall_invite(slpcall, MSN_FT_GUID, P2P_APPID_FILE, context); msn_slplink_unref(slplink); g_free(context); }
/*------------------------------------------------------------------------ * Send the file data. * * @param buffer The data to sent * @param size The length of the data to send * @param xfer The file transfer object * @return The amount of data actually sent */ static gssize mxit_xfer_write( const guchar* buffer, size_t size, PurpleXfer* xfer ) { struct mxitxfer* mx = (struct mxitxfer*) xfer->data; purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_write\n" ); if ( !mx ) { purple_debug_warning( MXIT_PLUGIN_ID, "mxit_xfer_write: invalid internal mxit xfer data\n" ); return -1; } else if ( purple_xfer_get_type( xfer ) != PURPLE_XFER_SEND ) { purple_debug_warning( MXIT_PLUGIN_ID, "mxit_xfer_write: wrong xfer type received\n" ); return -1; } /* create and send the packet to MXit */ mxit_send_file( mx->session, purple_xfer_get_remote_user( xfer ), purple_xfer_get_filename( xfer ), buffer, size ); /* the transfer is complete */ purple_xfer_set_completed( xfer, TRUE ); return size; }
void msn_slplink_request_ft(MsnSlpLink *slplink, PurpleXfer *xfer) { MsnSlpCall *slpcall; char *context; const char *fn; const char *fp; fn = purple_xfer_get_filename(xfer); fp = purple_xfer_get_local_filename(xfer); g_return_if_fail(slplink != NULL); g_return_if_fail(fp != NULL); slpcall = msn_slp_call_new(slplink); msn_slp_call_init(slpcall, MSN_SLPCALL_DC); slpcall->session_init_cb = send_file_cb; slpcall->end_cb = msn_xfer_end_cb; slpcall->progress_cb = msn_xfer_progress_cb; slpcall->cb = msn_xfer_completed_cb; slpcall->xfer = xfer; purple_xfer_ref(slpcall->xfer); slpcall->pending = TRUE; purple_xfer_set_cancel_send_fnc(xfer, msn_xfer_cancel); xfer->data = slpcall; context = gen_context(fn, fp); msn_slp_call_invite(slpcall, "5D3E02AB-6190-11D3-BBBB-00C04F795683", 2, context); g_free(context); }
static void ggp_edisc_xfer_recv_start(PurpleXfer *xfer) { ggp_edisc_session_data *sdata; ggp_edisc_xfer *edisc_xfer; gchar *upload_url; PurpleHttpRequest *req; g_return_if_fail(xfer != NULL); edisc_xfer = purple_xfer_get_protocol_data(xfer); g_return_if_fail(edisc_xfer != NULL); sdata = ggp_edisc_get_sdata(edisc_xfer->gc); g_return_if_fail(sdata != NULL); upload_url = g_strdup_printf("https://drive.mpa.gg.pl/me/file/inbox/" "%s,%s?api_version=%s&security_token=%s", edisc_xfer->ticket_id, purple_url_encode(purple_xfer_get_filename(xfer)), GGP_EDISC_API, sdata->security_token); req = purple_http_request_new(upload_url); g_free(upload_url); purple_http_request_set_timeout(req, -1); ggp_edisc_set_defaults(req); purple_http_request_set_max_len(req, purple_xfer_get_size(xfer) + 1); purple_http_request_set_cookie_jar(req, sdata->cookies); purple_http_request_set_response_writer(req, ggp_edisc_xfer_recv_writer, xfer); edisc_xfer->hc = purple_http_request(edisc_xfer->gc, req, ggp_edisc_xfer_recv_done, xfer); purple_http_request_unref(req); purple_http_conn_set_progress_watcher(edisc_xfer->hc, ggp_edisc_xfer_progress_watcher, xfer, 250000); }
void purple_xfer_cancel_remote(PurpleXfer *xfer) { PurpleXferUiOps *ui_ops; gchar *msg; PurpleAccount *account; PurpleBuddy *buddy; g_return_if_fail(xfer != NULL); purple_request_close_with_handle(xfer); purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE); xfer->end_time = time(NULL); account = purple_xfer_get_account(xfer); buddy = purple_find_buddy(account, xfer->who); if (purple_xfer_get_filename(xfer) != NULL) { msg = g_strdup_printf(_("%s cancelled the transfer of %s"), buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer)); } else { msg = g_strdup_printf(_("%s cancelled the file transfer"), buddy ? purple_buddy_get_alias(buddy) : xfer->who); } purple_xfer_conversation_write(xfer, msg, TRUE); purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg); g_free(msg); if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) { if (xfer->ops.cancel_send != NULL) xfer->ops.cancel_send(xfer); } else { if (xfer->ops.cancel_recv != NULL) xfer->ops.cancel_recv(xfer); } if (xfer->watcher != 0) { purple_input_remove(xfer->watcher); xfer->watcher = 0; } if (xfer->fd != -1) close(xfer->fd); if (xfer->dest_fp != NULL) { fclose(xfer->dest_fp); xfer->dest_fp = NULL; } ui_ops = purple_xfer_get_ui_ops(xfer); if (ui_ops != NULL && ui_ops->cancel_remote != NULL) ui_ops->cancel_remote(xfer); xfer->bytes_remaining = 0; purple_xfer_unref(xfer); }
void pidgin_xfer_dialog_add_xfer(PidginXferDialog *dialog, PurpleXfer *xfer) { PidginXferUiData *data; PurpleXferType type; GdkPixbuf *pixbuf; char *size_str, *remaining_str; char *lfilename, *utf8; g_return_if_fail(dialog != NULL); g_return_if_fail(xfer != NULL); purple_xfer_ref(xfer); data = PIDGINXFER(xfer); data->in_list = TRUE; pidgin_xfer_dialog_show(dialog); data->last_updated_time = 0; type = purple_xfer_get_type(xfer); size_str = purple_str_size_to_units(purple_xfer_get_size(xfer)); remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer)); pixbuf = gtk_widget_render_icon(dialog->window, (type == PURPLE_XFER_RECEIVE ? PIDGIN_STOCK_DOWNLOAD : PIDGIN_STOCK_UPLOAD), GTK_ICON_SIZE_MENU, NULL); gtk_list_store_append(dialog->model, &data->iter); lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer)); utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL); g_free(lfilename); lfilename = utf8; gtk_list_store_set(dialog->model, &data->iter, COLUMN_STATUS, pixbuf, COLUMN_PROGRESS, 0.0, COLUMN_FILENAME, (type == PURPLE_XFER_RECEIVE) ? purple_xfer_get_filename(xfer) : lfilename, COLUMN_SIZE, size_str, COLUMN_REMAINING, _("Waiting for transfer to begin"), COLUMN_DATA, xfer, -1); g_free(lfilename); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dialog->tree)); g_object_unref(pixbuf); g_free(size_str); g_free(remaining_str); dialog->num_transfers++; ensure_row_selected(dialog); update_title_progress(dialog); }
static void xep_ft_si_offer(PurpleXfer *xfer, const gchar *to) { PurpleXmlNode *si_node, *feature, *field, *file, *x; XepIq *iq; XepXfer *xf = purple_xfer_get_protocol_data(xfer); BonjourData *bd = NULL; char buf[32]; if(!xf) return; bd = xf->data; if(!bd) return; purple_debug_info("bonjour", "xep file transfer stream initialization offer-id=%d.\n", next_id); /* Assign stream id. */ g_free(xf->iq_id); xf->iq_id = g_strdup_printf("%u", next_id++); iq = xep_iq_new(xf->data, XEP_IQ_SET, to, bonjour_get_jid(bd->jabber_data->account), xf->iq_id); if(iq == NULL) return; /*Construct Stream initialization offer message.*/ si_node = purple_xmlnode_new_child(iq->node, "si"); purple_xmlnode_set_namespace(si_node, "http://jabber.org/protocol/si"); purple_xmlnode_set_attrib(si_node, "profile", "http://jabber.org/protocol/si/profile/file-transfer"); g_free(xf->sid); xf->sid = g_strdup(xf->iq_id); purple_xmlnode_set_attrib(si_node, "id", xf->sid); file = purple_xmlnode_new_child(si_node, "file"); purple_xmlnode_set_namespace(file, "http://jabber.org/protocol/si/profile/file-transfer"); purple_xmlnode_set_attrib(file, "name", purple_xfer_get_filename(xfer)); g_snprintf(buf, sizeof(buf), "%" G_GOFFSET_FORMAT, purple_xfer_get_size(xfer)); purple_xmlnode_set_attrib(file, "size", buf); feature = purple_xmlnode_new_child(si_node, "feature"); purple_xmlnode_set_namespace(feature, "http://jabber.org/protocol/feature-neg"); x = purple_xmlnode_new_child(feature, "x"); purple_xmlnode_set_namespace(x, "jabber:x:data"); purple_xmlnode_set_attrib(x, "type", "form"); field = purple_xmlnode_new_child(x, "field"); purple_xmlnode_set_attrib(field, "var", "stream-method"); purple_xmlnode_set_attrib(field, "type", "list-single"); if (xf->mode & XEP_BYTESTREAMS) { PurpleXmlNode *option = purple_xmlnode_new_child(field, "option"); PurpleXmlNode *value = purple_xmlnode_new_child(option, "value"); purple_xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1); } if (xf->mode & XEP_IBB) { PurpleXmlNode *option = purple_xmlnode_new_child(field, "option"); PurpleXmlNode *value = purple_xmlnode_new_child(option, "value"); purple_xmlnode_insert_data(value, "http://jabber.org/protocol/ibb", -1); } xep_iq_send_and_free(iq); }
static void got_file_send_progress(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message) { SkypeWebFileTransfer *swft = user_data; PurpleXfer *xfer = swft->xfer; SkypeWebAccount *sa = swft->sa; JsonParser *parser; JsonNode *node; JsonObject *obj; sa->url_datas = g_slist_remove(sa->url_datas, url_data); //{"content_length":0,"content_full_length":0,"view_length":0,"content_state":"no content","view_state":"none","view_location":"https://nus1-api.asm.skype.com/v1/objects/0-cus-d1-61121cfae8cf601944627a66afdb77ad/views/original","status_location":"https://nus1-api.asm.skype.com/v1/objects/0-cus-d1-61121cfae8cf601944627a66afdb77ad/views/original/status"} parser = json_parser_new(); if (!json_parser_load_from_data(parser, url_text, len, NULL)) { //probably bad poll_file_send_progress(swft); return; } node = json_parser_get_root(parser); if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT) { //probably bad poll_file_send_progress(swft); return; } obj = json_node_get_object(node); if (json_object_has_member(obj, "status_location")) { g_free(swft->url); swft->url = g_strdup(json_object_get_string_member(obj, "status_location")); } if (json_object_has_member(obj, "content_state") && g_str_equal(json_object_get_string_member(obj, "content_state"), "ready")) { xmlnode *uriobject = xmlnode_new("URIObject"); xmlnode *title = xmlnode_new_child(uriobject, "Title"); xmlnode *description = xmlnode_new_child(uriobject, "Description"); xmlnode *anchor = xmlnode_new_child(uriobject, "a"); xmlnode *originalname = xmlnode_new_child(uriobject, "OriginalName"); xmlnode *filesize = xmlnode_new_child(uriobject, "FileSize"); gchar *message, *temp; //We finally did it! // May the pesants rejoyce purple_xfer_set_completed(xfer, TRUE); // Don't forget to let the other end know about it xmlnode_set_attrib(uriobject, "type", "File.1"); temp = g_strconcat("https://" SKYPEWEB_XFER_HOST "/v1/objects/", purple_url_encode(swft->id), NULL); xmlnode_set_attrib(uriobject, "uri", temp); g_free(temp); temp = g_strconcat("https://" SKYPEWEB_XFER_HOST "/v1/objects/", purple_url_encode(swft->id), "/views/thumbnail", NULL); xmlnode_set_attrib(uriobject, "url_thumbnail", temp); g_free(temp); xmlnode_insert_data(title, purple_xfer_get_filename(xfer), -1); xmlnode_insert_data(description, "Description: ", -1); temp = g_strconcat("https://login.skype.com/login/sso?go=webclient.xmm&docid=", purple_url_encode(swft->id), NULL); xmlnode_set_attrib(anchor, "href", temp); xmlnode_insert_data(anchor, temp, -1); g_free(temp); xmlnode_set_attrib(originalname, "v", purple_xfer_get_filename(xfer)); temp = g_strdup_printf("%d", purple_xfer_get_size(xfer)); xmlnode_set_attrib(filesize, "v", temp); g_free(temp); message = xmlnode_to_str(uriobject, NULL); skypeweb_send_im(sa->pc, swft->from, message, PURPLE_MESSAGE_SEND); g_free(message); skypeweb_free_xfer(xfer); purple_xfer_unref(xfer); xmlnode_free(uriobject); g_object_unref(parser); return; } g_object_unref(parser); // probably good poll_file_send_progress(swft); }
std::string FiletransferRepeater::requestFT() { std::string filename(m_xfer ? purple_xfer_get_filename(m_xfer) : ""); m_sid = Transport::instance()->requestFT(m_to, filename, purple_xfer_get_size(m_xfer), EmptyString, EmptyString, EmptyString, EmptyString, SIProfileFT::FTTypeAll, m_from); return m_sid; }
static void update_detailed_info(PidginXferDialog *dialog, PurpleXfer *xfer) { PidginXferUiData *data; char *kbsec, *time_elapsed, *time_remaining; char *status, *utf8; if (dialog == NULL || xfer == NULL) return; data = PIDGINXFER(xfer); get_xfer_info_strings(xfer, &kbsec, &time_elapsed, &time_remaining); status = g_strdup_printf("%d%% (%" G_GSIZE_FORMAT " of %" G_GSIZE_FORMAT " bytes)", (int)(purple_xfer_get_progress(xfer)*100), purple_xfer_get_bytes_sent(xfer), purple_xfer_get_size(xfer)); if (purple_xfer_is_completed(xfer)) { GdkPixbuf *pixbuf = NULL; pixbuf = gtk_widget_render_icon(xfer_dialog->window, PIDGIN_STOCK_FILE_DONE, GTK_ICON_SIZE_MENU, NULL); gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter, COLUMN_STATUS, pixbuf, -1); g_object_unref(pixbuf); } if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label), _("<b>Receiving As:</b>")); gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label), _("<b>Receiving From:</b>")); } else { gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label), _("<b>Sending To:</b>")); gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label), _("<b>Sending As:</b>")); } gtk_label_set_text(GTK_LABEL(dialog->local_user_label), purple_account_get_username(xfer->account)); gtk_label_set_text(GTK_LABEL(dialog->remote_user_label), xfer->who); gtk_label_set_text(GTK_LABEL(dialog->protocol_label), purple_account_get_protocol_name(xfer->account)); if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { gtk_label_set_text(GTK_LABEL(dialog->filename_label), purple_xfer_get_filename(xfer)); } else { char *tmp; tmp = g_path_get_basename(purple_xfer_get_local_filename(xfer)); utf8 = g_filename_to_utf8(tmp, -1, NULL, NULL, NULL); g_free(tmp); gtk_label_set_text(GTK_LABEL(dialog->filename_label), utf8); g_free(utf8); } utf8 = g_filename_to_utf8((purple_xfer_get_local_filename(xfer)), -1, NULL, NULL, NULL); gtk_label_set_text(GTK_LABEL(dialog->localfile_label), utf8); g_free(utf8); gtk_label_set_text(GTK_LABEL(dialog->status_label), status); gtk_label_set_text(GTK_LABEL(dialog->speed_label), kbsec); gtk_label_set_text(GTK_LABEL(dialog->time_elapsed_label), time_elapsed); gtk_label_set_text(GTK_LABEL(dialog->time_remaining_label), time_remaining); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dialog->progress), purple_xfer_get_progress(xfer)); g_free(kbsec); g_free(time_elapsed); g_free(time_remaining); g_free(status); }
/* send a file to udp channel with QQ_FILE_DATA_PACKET_TAG */ static void _qq_send_file_data_packet(PurpleConnection *gc, guint16 packet_type, guint8 sub_type, guint32 fragment_index, guint16 seq, guint8 *data, gint len) { guint8 *raw_data, filename_md5[QQ_KEY_LENGTH], file_md5[QQ_KEY_LENGTH]; gint bytes; guint32 fragment_size = 1000; const char *filename; gint filename_len, filesize; qq_data *qd; ft_info *info; qd = (qq_data *) gc->proto_data; info = (ft_info *) qd->xfer->data; filename = purple_xfer_get_filename(qd->xfer); filesize = purple_xfer_get_size(qd->xfer); raw_data = g_newa(guint8, MAX_PACKET_SIZE); bytes = 0; bytes += qq_put8(raw_data + bytes, 0x00); bytes += qq_put16(raw_data + bytes, packet_type); switch (packet_type) { case QQ_FILE_BASIC_INFO: case QQ_FILE_DATA_INFO: case QQ_FILE_EOF: bytes += qq_put16(raw_data + bytes, 0x0000); bytes += qq_put8(raw_data + bytes, 0x00); break; case QQ_FILE_CMD_FILE_OP: switch(sub_type) { case QQ_FILE_BASIC_INFO: filename_len = strlen(filename); qq_get_md5(filename_md5, sizeof(filename_md5), (guint8 *)filename, filename_len); _fill_file_md5(purple_xfer_get_local_filename(qd->xfer), purple_xfer_get_size(qd->xfer), file_md5); info->fragment_num = (filesize - 1) / QQ_FILE_FRAGMENT_MAXLEN + 1; info->fragment_len = QQ_FILE_FRAGMENT_MAXLEN; purple_debug_info("QQ", "start transfering data, %d fragments with %d length each\n", info->fragment_num, info->fragment_len); /* Unknown */ bytes += qq_put16(raw_data + bytes, 0x0000); /* Sub-operation type */ bytes += qq_put8(raw_data + bytes, sub_type); /* Length of file */ bytes += qq_put32(raw_data + bytes, filesize); /* Number of fragments */ bytes += qq_put32(raw_data + bytes, info->fragment_num); /* Length of a single fragment */ bytes += qq_put32(raw_data + bytes, info->fragment_len); bytes += qq_putdata(raw_data + bytes, file_md5, 16); bytes += qq_putdata(raw_data + bytes, filename_md5, 16); /* Length of filename */ bytes += qq_put16(raw_data + bytes, filename_len); /* 8 unknown bytes */ bytes += qq_put32(raw_data + bytes, 0x00000000); bytes += qq_put32(raw_data + bytes, 0x00000000); /* filename */ bytes += qq_putdata(raw_data + bytes, (guint8 *) filename, filename_len); break; case QQ_FILE_DATA_INFO: purple_debug_info("QQ", "sending %dth fragment with length %d, offset %d\n", fragment_index, len, (fragment_index-1)*fragment_size); /* bytes += qq_put16(raw_data + bytes, ++(qd->send_seq)); */ bytes += qq_put16(raw_data + bytes, info->send_seq); bytes += qq_put8(raw_data + bytes, sub_type); /* bytes += qq_put32(raw_data + bytes, fragment_index); */ bytes += qq_put32(raw_data + bytes, fragment_index - 1); bytes += qq_put32(raw_data + bytes, (fragment_index - 1) * fragment_size); bytes += qq_put16(raw_data + bytes, len); bytes += qq_putdata(raw_data + bytes, data, len); break; case QQ_FILE_EOF: purple_debug_info("QQ", "end of sending data\n"); /* bytes += qq_put16(raw_data + bytes, info->fragment_num + 1); */ bytes += qq_put16(raw_data + bytes, info->fragment_num); bytes += qq_put8(raw_data + bytes, sub_type); /* purple_xfer_set_completed(qd->xfer, TRUE); */ } break; case QQ_FILE_CMD_FILE_OP_ACK: switch (sub_type) { case QQ_FILE_BASIC_INFO: bytes += qq_put16(raw_data + bytes, 0x0000); bytes += qq_put8(raw_data + bytes, sub_type); bytes += qq_put32(raw_data + bytes, 0x00000000); break; case QQ_FILE_DATA_INFO: bytes += qq_put16(raw_data + bytes, seq); bytes += qq_put8(raw_data + bytes, sub_type); bytes += qq_put32(raw_data + bytes, fragment_index); break; case QQ_FILE_EOF: bytes += qq_put16(raw_data + bytes, filesize / QQ_FILE_FRAGMENT_MAXLEN + 2); bytes += qq_put8(raw_data + bytes, sub_type); break; } } purple_debug_info("QQ", "<== send %s packet\n", qq_get_file_cmd_desc(packet_type)); _qq_send_file(gc, raw_data, bytes, QQ_FILE_DATA_PACKET_TAG, info->to_uid); }
void yahoo_process_filetrans_info_15(PurpleConnection *gc, struct yahoo_packet *pkt) { char *url = NULL; long val_249 = 0; long val_66 = 0; PurpleXfer *xfer; YahooData *yd; struct yahoo_xfer_data *xfer_data; char *xfer_peer_idstring = NULL; char *xfer_idstring_for_relay = NULL; GSList *l; struct yahoo_packet *pkt_to_send; 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: /* from */ 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_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; case 27: /* filename */ break; case 66: val_66 = strtol(pair->value, NULL, 10); break; case 249: val_249 = strtol(pair->value, NULL, 10); /* 249 has value 1 or 2 when doing p2p transfer and value 3 when relaying through yahoo server */ break; case 250: if (g_utf8_validate(pair->value, -1, NULL)) { url = pair->value; /* TODO: rename to host? what about non-relay? */ } else { purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; case 251: if (g_utf8_validate(pair->value, -1, NULL)) { xfer_idstring_for_relay = pair->value; } else { purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; } } if(!xfer_peer_idstring) return; xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map, xfer_peer_idstring); if(!xfer) return; if(val_66==-1) { purple_xfer_cancel_remote(xfer); return; } xfer_data = purple_xfer_get_protocol_data(xfer); xfer_data->info_val_249 = val_249; xfer_data->xfer_idstring_for_relay = g_strdup(xfer_idstring_for_relay); if(val_249 == 1 || val_249 == 3) { PurpleHttpRequest *req; PurpleAccount *account; xfer_data->is_relay = (val_249 == 3); if (!xfer_data->is_relay) { purple_debug_error("yahoo", "Non-relay FT aren't tested yet.\n"); purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unsupported method"), purple_request_cpar_from_connection(gc)); purple_xfer_cancel_remote(xfer); } account = purple_connection_get_account(xfer_data->gc); xfer_data->url = yahoo_ft_url_gen(xfer, url); pkt_to_send = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15, YAHOO_STATUS_AVAILABLE, yd->session_id); yahoo_packet_hash(pkt_to_send, "ssssis", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xfer_data->xfer_peer_idstring, 27, purple_xfer_get_filename(xfer), 249, xfer_data->info_val_249, 251, xfer_data->xfer_idstring_for_relay); yahoo_packet_send_and_free(pkt_to_send, yd); req = yahoo_ft_new_req(xfer_data); purple_http_request_set_method(req, "HEAD"); xfer_data->hc = purple_http_request(gc, req, yahoo_process_filetrans_info_15_got, xfer); purple_http_request_unref(req); } else if (val_249 == 2) purple_debug_error("yahoo", "p2p file transfers are not supported yet\n"); }
void* IMInvoker::purpeNotifyMessage(PurpleNotifyMsgType type, const char *title, const char *primary, const char *secondary, PurpleRequestCommonParameters *cpar) { #else void* IMInvoker::purpeNotifyMessage(PurpleNotifyMsgType type, const char *title, const char *primary, const char *secondary) { #endif return NULL; } void* IMInvoker::purpeNotifyEmail(PurpleConnection *gc, const char *subject, const char *from, const char *to, const char *url) { return NULL; } void* IMInvoker::purpeNotifyEmails(PurpleConnection *gc, size_t count, gboolean detailed, const char **subjects, const char **froms, const char **tos, const char **urls) { return NULL; } void* IMInvoker::purpeNotifyFormatted(const char *title, const char *primary, const char *secondary, const char *text) { return NULL; } void* IMInvoker::purpeNotifySearchResults(PurpleConnection *gc, const char *title, const char *primary, const char *secondary, PurpleNotifySearchResults *results, gpointer user_data) { return NULL; } void IMInvoker::purpeNotifySearchResultsNewRows(PurpleConnection *gc, PurpleNotifySearchResults *results, void *data) {} void* IMInvoker::purpeNotifyUserInfo(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) { return NULL; } void* IMInvoker::purpeNotifyURI(const char *uri) { return NULL; } void IMInvoker::purpeNotifyClose(PurpleNotifyType type, void *ui_handle) {} // privacy ui operations void IMInvoker::purplePermitAdded(PurpleAccount *account, const char *name) {} void IMInvoker::purplePermitRemoved(PurpleAccount *account, const char *name) {} void IMInvoker::purpleDebyAdded(PurpleAccount *account, const char *name) {} void IMInvoker::purpleDenyRemoved(PurpleAccount *account, const char *name) {} // request ui operations #if LIBPURPLE_VERSION_MAJOR >= 3 void* IMInvoker::purpleRequestInput(const char *title, const char *primary, const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint, const char *ok_text, GCallback ok_cb, const char *cancel_text, GCallback cancel_cb, PurpleRequestCommonParameters *cpar, void *user_data) { return NULL; } void* IMInvoker::purpleRequestChoice(const char *title, const char *primary, const char *secondary, gpointer default_value, const char *ok_text, GCallback ok_cb, const char *cancel_text, GCallback cancel_cb , PurpleRequestCommonParameters *cpar, void *user_data, va_list choices) { return NULL; } void* IMInvoker::purpleRequestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleRequestCommonParameters *cpar, void *user_data, size_t action_count, va_list actions) { return NULL; } void* IMInvoker::purpleRequestWait(const char *title, const char *primary, const char *secondary, gboolean with_progress, PurpleRequestCancelCb cancel_cb, PurpleRequestCommonParameters *cpar, void *user_data) { return NULL; } void IMInvoker::purpleRequestWaitUpdate(void *ui_handle, gboolean pulse, gfloat fraction) { } void* IMInvoker::purpleRequestFields(const char *title, const char *primary, const char *secondary, PurpleRequestFields *fields, const char *ok_text, GCallback ok_cb, const char *cancel_text, GCallback cancel_cb, PurpleRequestCommonParameters *cpar, void *user_data) { return NULL; } void* IMInvoker::purpleRequestFile(const char *title, const char *filename, gboolean savedialog, GCallback ok_cb, GCallback cancel_cb, PurpleRequestCommonParameters *cpar, void *user_data) { // click ok PurpleXfer *xfer = (PurpleXfer *)user_data; PurpleXferType xferType = purple_xfer_get_xfer_type(xfer); if (xferType == PURPLE_XFER_TYPE_RECEIVE) { ((PurpleRequestFileCb)ok_cb)(user_data, filename); } else if (xferType == PURPLE_XFER_TYPE_SEND) { if (purple_xfer_get_local_filename(xfer) != NULL && purple_xfer_get_filename(xfer) != NULL) { ((PurpleRequestFileCb)ok_cb)(user_data, purple_xfer_get_local_filename(xfer)); } else { ((PurpleRequestFileCb)cancel_cb)(user_data, purple_xfer_get_local_filename(xfer)); } } return NULL; }