static void begin_transfer(PurpleXfer *xfer, PurpleInputCondition cond) { PurpleXferType type = purple_xfer_get_type(xfer); PurpleXferUiOps *ui_ops = purple_xfer_get_ui_ops(xfer); if (xfer->start_time != 0) { purple_debug_error("xfer", "Transfer is being started multiple times\n"); g_return_if_reached(); } if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) { xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer), type == PURPLE_XFER_RECEIVE ? "wb" : "rb"); if (xfer->dest_fp == NULL) { purple_xfer_show_file_error(xfer, purple_xfer_get_local_filename(xfer)); purple_xfer_cancel_local(xfer); return; } fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET); } if (xfer->fd != -1) xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer); xfer->start_time = time(NULL); if (xfer->ops.start != NULL) xfer->ops.start(xfer); }
static void tgprpl_xfer_recv_on_finished (struct tgl_state *TLS, void *_data, int success, const char *filename) { debug ("tgprpl_xfer_recv_on_finished()"); struct tgp_xfer_send_data *data = _data; char *selected = g_strdup (purple_xfer_get_local_filename (data->xfer)); if (success) { debug ("purple_xfer_set_completed"); // always completed the file transfer to avoid a warning dialogue when closing (Adium) purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer)); purple_xfer_set_completed (data->xfer, TRUE); if (! purple_xfer_is_canceled (data->xfer)) { purple_xfer_end (data->xfer); } } else { tgp_notify_on_error_gw (TLS, NULL, success); if (! purple_xfer_is_canceled (data->xfer)) { purple_xfer_cancel_remote (data->xfer); } failure ("recv xfer failed"); } data->loading = FALSE; data->xfer->data = NULL; purple_xfer_unref (data->xfer); tgprpl_xfer_free_data (data); debug ("moving transferred file from tgl directory %s to selected target %s", selected, filename); g_unlink (selected); g_rename (filename, selected); g_free (selected); }
void mrim_xfer_send_rq(PurpleXfer *xfer) { gchar *file_name = purple_xfer_get_local_filename(xfer); purple_debug_info("mrim-prpl", "[%s] Sending file '%s'\n", __func__, file_name); MrimFT *mrim_ft = xfer->data; mrim_ft->xfer = xfer; mrim_ft->count = 1; mrim_ft->files = g_new0(MrimFT, 1); mrim_ft->files[0].name = basename(file_name); // TODO: strdup??? { GRand *rnd = g_rand_new(); mrim_ft->id = g_rand_int(rnd); g_rand_free(rnd); } { struct stat st; stat(file_name, &st); mrim_ft->files[0].size = st.st_size; } MrimData *mrim = mrim_ft->mrim; MrimPackage *pack = mrim_package_new(mrim->seq++, MRIM_CS_FILE_TRANSFER); mrim_package_add_LPSA(pack, mrim_ft->user_name); mrim_package_add_UL(pack, mrim_ft->id); mrim_package_add_UL(pack, mrim_ft->files[0].size); gchar *file_list = g_strdup_printf("%s;%u;", mrim_ft->files[0].name, mrim_ft->files[0].size); gchar *my_ip = "1.2.3.4:1234;"; // Заведомо некорректное значение, чтобы клиент обломался и пошёл использовать зеркальный прокси TODO mrim_package_add_UL(pack, 4 + strlen(file_list) + 4 + 4 + strlen(my_ip)); mrim_package_add_LPSA(pack, file_list); mrim_package_add_UL(pack, 0); mrim_package_add_LPSA(pack, my_ip); //mrim_add_ack_cb(mrim, pack->header->seq, mrim_xfer_ack, xfer); g_hash_table_insert(mrim->transfers, GUINT_TO_POINTER(mrim_ft->id), xfer); mrim_package_send(pack, mrim); }
static void _qq_send_file_progess(PurpleConnection *gc) { qq_data *qd = (qq_data *) gc->proto_data; PurpleXfer *xfer = qd->xfer; ft_info *info = (ft_info *) xfer->data; guint32 mask; guint8 *buffer; guint i; gint readbytes; if (purple_xfer_get_bytes_remaining(xfer) <= 0) return; if (info->window == 0 && info->max_fragment_index == 0) { if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "rb", xfer) == -1) { purple_xfer_cancel_local(xfer); return; } } buffer = g_newa(guint8, info->fragment_len); mask = 0x1 << (info->max_fragment_index % sizeof(info->window)); for (i = 0; i < sizeof(info->window); i++) { if ((info->window & mask) == 0) { readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + i, info->fragment_len, xfer); if (readbytes > 0) _qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO, info->max_fragment_index + i + 1, 0, buffer, readbytes); } if (mask & 0x8000) mask = 0x0001; else mask = mask << 1; } }
static void send_file_cb(MsnSlpSession *slpsession) { MsnSlpCall *slpcall; MsnSlpMessage *slpmsg; struct stat st; PurpleXfer *xfer; slpcall = slpsession->slpcall; slpmsg = msn_slpmsg_new(slpcall->slplink); slpmsg->slpcall = slpcall; slpmsg->flags = 0x1000030; slpmsg->slpsession = slpsession; #ifdef MSN_DEBUG_SLP slpmsg->info = "SLP FILE"; #endif xfer = (PurpleXfer *)slpcall->xfer; purple_xfer_start(slpcall->xfer, 0, NULL, 0); slpmsg->fp = xfer->dest_fp; if (g_stat(purple_xfer_get_local_filename(xfer), &st) == 0) slpmsg->size = st.st_size; xfer->dest_fp = NULL; /* Disable double fclose() */ msn_slplink_send_slpmsg(slpcall->slplink, slpmsg); }
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; }
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)); }
static int _qq_xfer_open_file(const gchar *filename, const gchar *method, PurpleXfer *xfer) { ft_info *info = xfer->data; info->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer), method); if (info->dest_fp == NULL) { return -1; } return 0; }
static void yahoo_xfer_init_15(PurpleXfer *xfer) { struct yahoo_xfer_data *xfer_data; PurpleConnection *gc; PurpleAccount *account; YahooData *yd; struct yahoo_packet *pkt; xfer_data = purple_xfer_get_protocol_data(xfer); gc = xfer_data->gc; yd = purple_connection_get_protocol_data(gc); account = purple_connection_get_account(gc); if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) { gchar *filename; filename = g_path_get_basename(purple_xfer_get_local_filename(xfer)); pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15, YAHOO_STATUS_AVAILABLE, yd->session_id); yahoo_packet_hash(pkt, "sssiiiisiii", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xfer_data->xfer_peer_idstring, 222, 1, 266, 1, 302, 268, 300, 268, 27, filename, 28, (int)purple_xfer_get_size(xfer), 301, 268, 303, 268); g_free(filename); } else { if(xfer_data->firstoflist == TRUE) { pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15, YAHOO_STATUS_AVAILABLE, yd->session_id); yahoo_packet_hash(pkt, "sssi", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xfer_data->xfer_peer_idstring, 222, 3); } else { pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15, YAHOO_STATUS_AVAILABLE, yd->session_id); yahoo_packet_hash(pkt, "sssi", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xfer_data->xfer_peer_idstring, 271, 1); } } yahoo_packet_send_and_free(pkt, yd); }
static int _qq_xfer_open_file(const gchar *filename, const gchar *method, PurpleXfer *xfer) { ft_info *info = xfer->data; int fd; if (method[0] == 'r') { fd = open(purple_xfer_get_local_filename(xfer), O_RDONLY); info->buffer = mmap(0, purple_xfer_get_size(xfer), PROT_READ, MAP_PRIVATE, fd, 0); } else { fd = open(purple_xfer_get_local_filename(xfer), O_RDWR|O_CREAT, 0644); info->buffer = mmap(0, purple_xfer_get_size(xfer), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FILE, fd, 0); } if (info->buffer == NULL) { return - 1; } return 0; }
static void silcpurple_ftp_ask_name_ok(PurpleXfer *x) { SilcPurpleXfer xfer = x->data; const char *name; name = purple_xfer_get_local_filename(x); g_unlink(name); xfer->completion(name, xfer->completion_context); }
static void tgprpl_xfer_recv_on_finished (struct tgl_state *TLS, void *_data, int success, const char *filename) { debug ("tgprpl_xfer_recv_on_finished()"); struct tgp_xfer_send_data *data = _data; if (success) { if (!data->done) { debug ("purple_xfer_set_completed"); purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer)); purple_xfer_set_completed (data->xfer, TRUE); purple_xfer_end (data->xfer); } g_unlink (purple_xfer_get_local_filename (data->xfer)); g_rename (filename, purple_xfer_get_local_filename (data->xfer)); } else { failure ("ERROR xfer failed"); } data->xfer->data = NULL; tgprpl_xfer_free_data (data); }
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 upload_file_init(PurpleXfer* xfer) { void** data = xfer->data; qq_account* ac = data[0]; LwqqClient* lc = ac->qq; LwqqMsgOffFile* file = s_malloc0(sizeof(*file)); file->from = s_strdup(lc->myself->uin); file->to = s_strdup(purple_xfer_get_remote_user(xfer)); file->name = s_strdup(purple_xfer_get_local_filename(xfer)); xfer->start_time = time(NULL); data[1] = file; data[2] = xfer; //lwqq_async_add_event_listener( background_upload_file(lc,file,file_trans_on_progress,xfer); //send_file,data); }
static void recv_file_init(PurpleXfer* xfer) { qq_account* ac = purple_connection_get_protocol_data(purple_account_get_connection(xfer->account)); LwqqClient* lc = ac->qq; LwqqMsgFileMessage* file = xfer->data; const char* filename = purple_xfer_get_local_filename(xfer); xfer->start_time = time(NULL); LwqqAsyncEvent* ev = lwqq_msg_accept_file(lc,file,filename); if(ev == NULL){ lwqq_puts("file trans error "); purple_xfer_error(PURPLE_XFER_RECEIVE, ac->account, purple_xfer_get_remote_user(xfer), "接受文件失败"); purple_xfer_cancel_local(xfer); return; } lwqq_async_event_set_progress(ev,file_trans_on_progress,xfer); lwqq_async_add_event_listener(ev,_C_(p,recv_file_complete,xfer)); }
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 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 recv_file_init(PurpleXfer* xfer) { qq_account* ac = purple_connection_get_protocol_data(purple_account_get_connection(xfer->account)); LwqqClient* lc = ac->qq; LwqqMsgFileMessage* file = xfer->data; const char* filename = purple_xfer_get_local_filename(xfer); xfer->start_time = time(NULL); LwqqAsyncEvent* ev = lwqq_msg_accept_file(lc,file,filename); if(ev == NULL){ lwqq_puts("file trans error "); purple_xfer_error(PURPLE_XFER_RECEIVE, ac->account, purple_xfer_get_remote_user(xfer), _("Receive file failed")); purple_xfer_cancel_local(xfer); return; } LwqqHttpRequest* req = lwqq_async_event_get_conn(ev); lwqq_http_on_progress(req, file_trans_on_progress, xfer); lwqq_http_set_option(req, LWQQ_HTTP_CANCELABLE,1L); lwqq_async_add_event_listener(ev,_C_(2p,recv_file_complete,xfer,ev)); }
static void _qq_recv_file_progess(PurpleConnection *gc, guint8 *buffer, guint16 len, guint32 index, guint32 offset) { qq_data *qd = (qq_data *) gc->proto_data; PurpleXfer *xfer = qd->xfer; ft_info *info = (ft_info *) xfer->data; guint32 mask; purple_debug_info("QQ", "receiving %dth fragment with length %d, slide window status %o, max_fragment_index %d\n", index, len, info->window, info->max_fragment_index); if (info->window == 0 && info->max_fragment_index == 0) { if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "wb", xfer) == -1) { purple_xfer_cancel_local(xfer); return; } purple_debug_info("QQ", "object file opened for writing\n"); } mask = 0x1 << (index % sizeof(info->window)); if (index < info->max_fragment_index || (info->window & mask)) { purple_debug_info("QQ", "duplicate %dth fragment, drop it!\n", index+1); return; } info->window |= mask; _qq_xfer_write_file(buffer, index, len, xfer); xfer->bytes_sent += len; xfer->bytes_remaining -= len; purple_xfer_update_progress(xfer); mask = 0x1 << (info->max_fragment_index % sizeof(info->window)); while (info->window & mask) { info->window &= ~mask; info->max_fragment_index ++; if (mask & 0x8000) mask = 0x0001; else mask = mask << 1; } purple_debug_info("QQ", "procceed %dth fragment, slide window status %o, max_fragment_index %d\n", index, info->window, info->max_fragment_index); }
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(); }
/* * 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); } }
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); }
static void silcpurple_ftp_send(PurpleXfer *x) { SilcPurpleXfer xfer = x->data; const char *name; char *local_ip = NULL, *remote_ip = NULL; gboolean local = TRUE; name = purple_xfer_get_local_filename(x); /* Do the same magic what we do with key agreement (see silcpurple_buddy.c) to see if we are behind NAT. */ if (silc_net_check_local_by_sock(xfer->sg->conn->sock->sock, NULL, &local_ip)) { /* Check if the IP is private */ if (silcpurple_ip_is_private(local_ip)) { local = FALSE; /* Local IP is private, resolve the remote server IP to see whether we are talking to Internet or just on LAN. */ if (silc_net_check_host_by_sock(xfer->sg->conn->sock->sock, NULL, &remote_ip)) if (silcpurple_ip_is_private(remote_ip)) /* We assume we are in LAN. Let's provide the connection point. */ local = TRUE; } } if (local && !local_ip) local_ip = silc_net_localip(); /* Send the file */ silc_client_file_send(xfer->sg->client, xfer->sg->conn, silcpurple_ftp_monitor, xfer, local_ip, 0, !local, xfer->client_entry, name, &xfer->session_id); silc_free(local_ip); silc_free(remote_ip); }
static void send_file_cb(struct pn_peer_call *call) { struct pn_peer_msg *peer_msg; struct stat st; PurpleXfer *xfer; peer_msg = pn_peer_msg_new(); peer_msg->call = call; peer_msg->flags = 0x1000030; #ifdef PECAN_DEBUG_SLP peer_msg->info = "SLP FILE"; #endif xfer = (PurpleXfer *) call->xfer; purple_xfer_start(call->xfer, 0, NULL, 0); peer_msg->fp = xfer->dest_fp; if (g_stat(purple_xfer_get_local_filename(xfer), &st) == 0) peer_msg->size = st.st_size; xfer->dest_fp = NULL; /* Disable double fclose() */ pn_peer_link_send_msg(call->link, peer_msg); }
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); }
/* 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); }
static void yahoo_xfer_dns_connected_15(GSList *hosts, gpointer data, const char *error_message) { PurpleXfer *xfer; struct yahoo_xfer_data *xd; struct sockaddr_in *addr; struct yahoo_packet *pkt; unsigned long actaddr; unsigned char a,b,c,d; PurpleConnection *gc; PurpleAccount *account; YahooData *yd; gchar *filename; if (!(xfer = data)) return; if (!(xd = purple_xfer_get_protocol_data(xfer))) return; gc = xd->gc; account = purple_connection_get_account(gc); yd = purple_connection_get_protocol_data(gc); if(!hosts) { purple_debug_error("yahoo", "Unable to find an IP address for relay.msg.yahoo.com\n"); purple_xfer_cancel_remote(xfer); return; } /* Discard the length... */ hosts = g_slist_remove(hosts, hosts->data); if(!hosts) { purple_debug_error("yahoo", "Unable to find an IP address for relay.msg.yahoo.com\n"); purple_xfer_cancel_remote(xfer); return; } /* TODO:actually, u must try with addr no.1 , if its not working addr no.2 ..... */ addr = hosts->data; actaddr = addr->sin_addr.s_addr; d = actaddr & 0xff; actaddr >>= 8; c = actaddr & 0xff; actaddr >>= 8; b = actaddr & 0xff; actaddr >>= 8; a = actaddr & 0xff; xd->host = g_strdup_printf("%u.%u.%u.%u", d, c, b, a); /* Free the address... */ g_free(hosts->data); hosts = g_slist_remove(hosts, hosts->data); addr = NULL; while (hosts != NULL) { /* Discard the length... */ hosts = g_slist_remove(hosts, hosts->data); /* Free the address... */ g_free(hosts->data); hosts = g_slist_remove(hosts, hosts->data); } pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_INFO_15, YAHOO_STATUS_AVAILABLE, yd->session_id); filename = g_path_get_basename(purple_xfer_get_local_filename(xfer)); yahoo_packet_hash(pkt, "ssssis", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xd->xfer_peer_idstring, 27, filename, 249, 3, 250, xd->host); g_free(filename); yahoo_packet_send_and_free(pkt, yd); }
void finch_xfer_dialog_update_xfer(PurpleXfer *xfer) { PurpleGntXferUiData *data; char *size_str, *remaining_str; time_t current_time; char prog_str[5]; double kb_sent; double kbps = 0.0; time_t elapsed, now; char *kbsec; gboolean send; if ((now = purple_xfer_get_end_time(xfer)) == 0) now = time(NULL); kb_sent = purple_xfer_get_bytes_sent(xfer) / 1024.0; elapsed = (purple_xfer_get_start_time(xfer) > 0 ? now - purple_xfer_get_start_time(xfer) : 0); kbps = (elapsed > 0 ? (kb_sent / elapsed) : 0); g_return_if_fail(xfer_dialog != NULL); g_return_if_fail(xfer != NULL); if ((data = FINCHXFER(xfer)) == NULL) return; if (data->in_list == FALSE || data->notified) return; current_time = time(NULL); if (((current_time - data->last_updated_time) == 0) && (!purple_xfer_is_completed(xfer))) { /* Don't update the window more than once per second */ return; } data->last_updated_time = current_time; send = (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND); 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)); kbsec = g_strdup_printf(_("%.2f KiB/s"), kbps); gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_PROGRESS, g_ascii_dtostr(prog_str, sizeof(prog_str), purple_xfer_get_progress(xfer) * 100.)); gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_SIZE, size_str); gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_REMAINING, remaining_str); gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_SPEED, kbsec); g_free(size_str); g_free(remaining_str); g_free(kbsec); if (purple_xfer_is_completed(xfer)) { gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_STATUS, send ? _("Sent") : _("Received")); gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_REMAINING, _("Finished")); if (!send) { char *msg = g_strdup_printf(_("The file was saved as %s."), purple_xfer_get_local_filename(xfer)); purple_xfer_conversation_write(xfer, msg, FALSE); g_free(msg); } data->notified = TRUE; } else { gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_STATUS, send ? _("Sending") : _("Receiving")); } update_title_progress(); if (purple_xfer_is_completed(xfer) && xfer_dialog->auto_clear) finch_xfer_dialog_remove_xfer(xfer); }