static void
send_file_cb(MsnSlpCall *slpcall)
{
MsnSlpMessage *slpmsg;
PurpleXfer *xfer;
xfer = (PurpleXfer *)slpcall->xfer;
if (purple_xfer_get_status(xfer) >= PURPLE_XFER_STATUS_STARTED)
return;
purple_xfer_ref(xfer);
purple_xfer_start(xfer, -1, NULL, 0);
if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_STARTED) {
purple_xfer_unref(xfer);
return;
}
purple_xfer_unref(xfer);
slpmsg = msn_slpmsg_new(slpcall->slplink);
slpmsg->slpcall = slpcall;
slpmsg->flags = 0x1000030;
slpmsg->info = "SLP FILE";
slpmsg->size = purple_xfer_get_size(xfer);
msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
}
void
msn_xfer_end_cb(MsnSlpCall *slpcall, MsnSession *session)
{
if ((purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_DONE) &&
(purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_CANCEL_REMOTE) &&
(purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_CANCEL_LOCAL))
{
purple_xfer_cancel_remote(slpcall->xfer);
}
}
/* FIXME: Rename with cancelled for 3.0.0. */
gboolean
purple_xfer_is_canceled(const PurpleXfer *xfer)
{
g_return_val_if_fail(xfer != NULL, TRUE);
if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) ||
(purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE))
return TRUE;
else
return FALSE;
}
static void
xfer_end_cb(struct pn_peer_call *call,
MsnSession *session)
{
if ((purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_DONE) &&
(purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_CANCEL_REMOTE) &&
(purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_CANCEL_LOCAL))
{
purple_xfer_cancel_remote(call->xfer);
}
}
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);
}
void
finch_xfer_dialog_cancel_xfer(PurpleXfer *xfer)
{
PurpleGntXferUiData *data;
const gchar *status;
g_return_if_fail(xfer_dialog != NULL);
g_return_if_fail(xfer != NULL);
data = FINCHXFER(xfer);
if (data == NULL)
return;
if (!data->in_list)
return;
if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) && (xfer_dialog->auto_clear)) {
finch_xfer_dialog_remove_xfer(xfer);
return;
}
update_title_progress();
if (purple_xfer_is_canceled(xfer))
status = _("Cancelled");
else
status = _("Failed");
gnt_tree_change_text(GNT_TREE(xfer_dialog->tree), xfer, COLUMN_STATUS, status);
}
void
msn_xfer_cancel(PurpleXfer *xfer)
{
MsnSlpCall *slpcall;
char *content;
g_return_if_fail(xfer != NULL);
g_return_if_fail(xfer->data != NULL);
slpcall = xfer->data;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
{
if (slpcall->started)
{
msn_slp_call_close(slpcall);
}
else
{
content = pecan_strdup_printf("SessionID: %lu\r\n\r\n",
slpcall->session_id);
send_decline(slpcall, slpcall->branch, "application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
msn_slplink_unleash(slpcall->slplink);
msn_slp_call_destroy(slpcall);
}
}
}
static void
purple_xfer_destroy(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "destroyed %p [%d]\n", xfer, xfer->ref);
/* Close the file browser, if it's open */
purple_request_close_with_handle(xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED)
purple_xfer_cancel_local(xfer);
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->destroy != NULL)
ui_ops->destroy(xfer);
g_free(xfer->who);
g_free(xfer->filename);
g_free(xfer->remote_ip);
g_free(xfer->local_filename);
g_hash_table_remove(xfers_data, xfer);
PURPLE_DBUS_UNREGISTER_POINTER(xfer);
xfers = g_list_remove(xfers, xfer);
g_free(xfer);
}
static void
xfer_cancel(PurpleXfer *xfer)
{
struct pn_peer_call *call;
char *content;
call = xfer->data;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) {
if (call->started)
pn_peer_call_close(call);
else {
content = g_strdup_printf("SessionID: %lu\r\n\r\n",
call->session_id);
pn_sip_send_decline(call, call->branch,
"application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
pn_peer_link_unleash(call->link);
pn_peer_call_unref(call);
}
}
}
gboolean
purple_xfer_is_completed(const PurpleXfer *xfer)
{
g_return_val_if_fail(xfer != NULL, TRUE);
return (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_DONE);
}
void FiletransferRepeater::_tryToDeleteMe() {
// TODO: There should be timer which deletes this filetransfer after some time (3 minutes for example)
// if will still be NULL, because it means we were not able to connect XMPP user, so this class can die
if (m_resender == NULL) {
Log("xfer-tryToDeleteMe", "can't delete, m_resender has not been created yet");
}
else if (m_xfer == NULL && m_buffer_size == 0) {
Log("xfer-tryToDeleteMe", "there's not xfer, buffer_size = 0 => finishing it and removing repeater");
delete this;
}
else if (purple_xfer_get_status(m_xfer) == PURPLE_XFER_STATUS_DONE && m_buffer_size == 0) {
Log("xfer-tryToDeleteMe", "xfer is done, buffer_size = 0 => finishing it and removing repeater");
delete this;
}
else {
Log("xfer-tryToDeleteMe", "can't delete, because status is " << (int) purple_xfer_get_status(m_xfer));
}
}
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 void
update_title_progress(PidginXferDialog *dialog)
{
gboolean valid;
GtkTreeIter iter;
int num_active_xfers = 0;
guint64 total_bytes_xferred = 0;
guint64 total_file_size = 0;
if (dialog->window == NULL)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
/* Find all active transfers */
while (valid) {
GValue val;
PurpleXfer *xfer = NULL;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
xfer = g_value_get_pointer(&val);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) {
num_active_xfers++;
total_bytes_xferred += purple_xfer_get_bytes_sent(xfer);
total_file_size += purple_xfer_get_size(xfer);
}
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* Update the title */
if (num_active_xfers > 0)
{
gchar *title;
int total_pct = 0;
if (total_file_size > 0) {
total_pct = 100 * total_bytes_xferred / total_file_size;
}
title = g_strdup_printf(ngettext("File Transfers - %d%% of %d file",
"File Transfers - %d%% of %d files",
num_active_xfers),
total_pct, num_active_xfers);
gtk_window_set_title(GTK_WINDOW(dialog->window), title);
g_free(title);
} else {
gtk_window_set_title(GTK_WINDOW(dialog->window), _("File Transfers"));
}
}
static void
send_file_cb(MsnSlpCall *slpcall)
{
MsnSlpMessage *slpmsg;
PurpleXfer *xfer;
xfer = (PurpleXfer *)slpcall->xfer;
if (purple_xfer_get_status(xfer) >= PURPLE_XFER_STATUS_STARTED)
return;
g_object_ref(xfer);
purple_xfer_start(xfer, -1, NULL, 0);
if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_STARTED) {
g_object_unref(xfer);
return;
}
g_object_unref(xfer);
slpmsg = msn_slpmsg_file_new(slpcall, purple_xfer_get_size(xfer));
msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
}
void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
{
PurpleXfer *xfer = PURPLE_XFER;
PurpleXferStatusType status = purple_xfer_get_status(xfer);
// If file transfer is not finished, cancel it
if ( status != PURPLE_XFER_STATUS_DONE
&& status != PURPLE_XFER_STATUS_CANCEL_LOCAL
&& status != PURPLE_XFER_STATUS_CANCEL_REMOTE) {
purple_xfer_set_cancel_recv_fnc(xfer, NULL);
purple_xfer_set_cancel_send_fnc(xfer, NULL);
purple_xfer_cancel_remote(xfer);
}
}
static void
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);
}
static void
yahoo_xfer_cancel_recv(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
xfer_data = purple_xfer_get_protocol_data(xfer);
if(purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
{
PurpleConnection *gc;
PurpleAccount *account;
YahooData *yd;
struct yahoo_packet *pkt;
gc = xfer_data->gc;
yd = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
if(!xfer_data->xfer_idstring_for_relay) /* hack to see if file trans acc/info packet has been received */
{
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, 4);
}
else
{
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15,
YAHOO_STATUS_DISCONNECTED,
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,
66, -1);
}
yahoo_packet_send_and_free(pkt, yd);
}
if (xfer_data) {
purple_http_conn_cancel(xfer_data->hc);
yahoo_xfer_data_free(xfer_data);
}
purple_xfer_set_protocol_data(xfer, NULL);
}
static void
stop_button_cb(GntButton *button)
{
PurpleXfer *selected_xfer = gnt_tree_get_selection_data(GNT_TREE(xfer_dialog->tree));
PurpleXferStatusType status;
if (!selected_xfer)
return;
status = purple_xfer_get_status(selected_xfer);
if (status != PURPLE_XFER_STATUS_CANCEL_LOCAL &&
status != PURPLE_XFER_STATUS_CANCEL_REMOTE &&
status != PURPLE_XFER_STATUS_DONE)
purple_xfer_cancel_local(selected_xfer);
}
void
pidgin_xfer_dialog_cancel_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
GdkPixbuf *pixbuf;
const gchar *status;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
data = PIDGINXFER(xfer);
if (data == NULL)
return;
if (!data->in_list)
return;
if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) && (dialog->auto_clear)) {
pidgin_xfer_dialog_remove_xfer(dialog, xfer);
return;
}
data = PIDGINXFER(xfer);
update_detailed_info(dialog, xfer);
update_title_progress(dialog);
pixbuf = gtk_widget_render_icon(dialog->window,
PIDGIN_STOCK_FILE_CANCELED,
GTK_ICON_SIZE_MENU, NULL);
if (purple_xfer_is_canceled(xfer))
status = _("Canceled");
else
status = _("Failed");
gtk_list_store_set(dialog->model, &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_REMAINING, status,
-1);
g_object_unref(pixbuf);
update_buttons(dialog, xfer);
}
static gboolean
peer_connection_destroy_cb(gpointer data)
{
PeerConnection *conn;
conn = data;
purple_request_close_with_handle(conn);
peer_connection_close(conn);
if (conn->checksum_data != NULL)
peer_oft_checksum_destroy(conn->checksum_data);
if (conn->xfer != NULL)
{
PurpleXferStatusType status;
conn->xfer->data = NULL;
status = purple_xfer_get_status(conn->xfer);
if ((status != PURPLE_XFER_STATUS_DONE) &&
(status != PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
(status != PURPLE_XFER_STATUS_CANCEL_REMOTE))
{
if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) ||
(conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED))
purple_xfer_cancel_remote(conn->xfer);
else
purple_xfer_cancel_local(conn->xfer);
}
purple_xfer_unref(conn->xfer);
conn->xfer = NULL;
}
g_free(conn->bn);
g_free(conn->error_message);
g_free(conn->proxyip);
g_free(conn->clientip);
g_free(conn->verifiedip);
g_free(conn->xferdata.name);
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn);
g_free(conn);
return FALSE;
}
static void
silcpurple_ftp_request_result(PurpleXfer *x)
{
SilcPurpleXfer xfer = x->data;
SilcClientFileError status;
PurpleConnection *gc = xfer->sg->gc;
if (purple_xfer_get_status(x) != PURPLE_XFER_STATUS_ACCEPTED)
return;
/* Start the file transfer */
status = silc_client_file_receive(xfer->sg->client, xfer->sg->conn,
silcpurple_ftp_monitor, xfer,
NULL, xfer->session_id,
silcpurple_ftp_ask_name, xfer);
switch (status) {
case SILC_CLIENT_FILE_OK:
return;
break;
case SILC_CLIENT_FILE_UNKNOWN_SESSION:
purple_notify_error(gc, _("Secure File Transfer"),
_("No file transfer session active"), NULL);
break;
case SILC_CLIENT_FILE_ALREADY_STARTED:
purple_notify_error(gc, _("Secure File Transfer"),
_("File transfer already started"), NULL);
break;
case SILC_CLIENT_FILE_KEY_AGREEMENT_FAILED:
purple_notify_error(gc, _("Secure File Transfer"),
_("Could not perform key agreement for file transfer"),
NULL);
break;
default:
purple_notify_error(gc, _("Secure File Transfer"),
_("Could not start the file transfer"), NULL);
break;
}
/* Error */
purple_xfer_unref(xfer->xfer);
g_free(xfer->hostname);
silc_free(xfer);
}
/* We have received the message ack */
static void
msg_ack(MsnMessage *msg, void *data)
{
MsnSlpMessage *slpmsg;
long long real_size;
slpmsg = data;
real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size;
slpmsg->offset += msg->msnslp_header.length;
slpmsg->msgs = g_list_remove(slpmsg->msgs, msg);
if (slpmsg->offset < real_size)
{
if (slpmsg->slpcall->xfer && purple_xfer_get_status(slpmsg->slpcall->xfer) == PURPLE_XFER_STATUS_STARTED)
{
slpmsg->slpcall->xfer_msg = slpmsg;
msn_message_ref(msg);
purple_xfer_prpl_ready(slpmsg->slpcall->xfer);
}
else
msn_slplink_send_msgpart(slpmsg->slplink, slpmsg);
}
else
{
/* The whole message has been sent */
if (slpmsg->flags == 0x20 ||
slpmsg->flags == 0x1000020 || slpmsg->flags == 0x1000030)
{
if (slpmsg->slpcall != NULL)
{
if (slpmsg->slpcall->cb)
slpmsg->slpcall->cb(slpmsg->slpcall,
NULL, 0);
}
}
}
msn_message_unref(msg);
}
static void
update_title_progress(void)
{
GList *list;
int num_active_xfers = 0;
guint64 total_bytes_xferred = 0;
guint64 total_file_size = 0;
if (xfer_dialog == NULL || xfer_dialog->window == NULL)
return;
/* Find all active transfers */
for (list = gnt_tree_get_rows(GNT_TREE(xfer_dialog->tree)); list; list = list->next) {
PurpleXfer *xfer = (PurpleXfer *)list->data;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) {
num_active_xfers++;
total_bytes_xferred += purple_xfer_get_bytes_sent(xfer);
total_file_size += purple_xfer_get_size(xfer);
}
}
/* Update the title */
if (num_active_xfers > 0) {
gchar *title;
int total_pct = 0;
if (total_file_size > 0) {
total_pct = 100 * total_bytes_xferred / total_file_size;
}
title = g_strdup_printf(ngettext("File Transfers - %d%% of %d file",
"File Transfers - %d%% of %d files",
num_active_xfers),
total_pct, num_active_xfers);
gnt_screen_rename_widget((xfer_dialog->window), title);
g_free(title);
} else {
gnt_screen_rename_widget((xfer_dialog->window), _("File Transfers"));
}
}
void
msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg)
{
MsnMessage *msg;
long long real_size;
size_t len = 0;
/* Maybe we will want to create a new msg for this slpmsg instead of
* reusing the same one all the time. */
msg = slpmsg->msg;
real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size;
if (slpmsg->offset < real_size)
{
if (slpmsg->slpcall && slpmsg->slpcall->xfer && purple_xfer_get_type(slpmsg->slpcall->xfer) == PURPLE_XFER_SEND &&
purple_xfer_get_status(slpmsg->slpcall->xfer) == PURPLE_XFER_STATUS_STARTED)
{
len = MIN(1202, slpmsg->slpcall->u.outgoing.len);
msn_message_set_bin_data(msg, slpmsg->slpcall->u.outgoing.data, len);
}
else
{
len = slpmsg->size - slpmsg->offset;
if (len > 1202)
len = 1202;
msn_message_set_bin_data(msg, slpmsg->buffer + slpmsg->offset, len);
}
msg->msnslp_header.offset = slpmsg->offset;
msg->msnslp_header.length = len;
}
if (purple_debug_is_verbose())
msn_message_show_readable(msg, slpmsg->info, slpmsg->text_body);
#ifdef MSN_DEBUG_SLP_FILES
debug_msg_to_file(msg, TRUE);
#endif
slpmsg->msgs =
g_list_append(slpmsg->msgs, msn_message_ref(msg));
msn_slplink_send_msg(slplink, msg);
if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000020 ||
slpmsg->flags == 0x1000030) &&
(slpmsg->slpcall != NULL))
{
slpmsg->slpcall->progress = TRUE;
if (slpmsg->slpcall->progress_cb != NULL)
{
slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size,
len, slpmsg->offset);
}
}
/* slpmsg->offset += len; */
}
void
msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg)
{
MsnSlpMessagePart *part;
MsnP2PInfo *info;
long long real_size;
size_t len = 0;
guint64 offset;
/* Maybe we will want to create a new msg for this slpmsg instead of
* reusing the same one all the time. */
info = slpmsg->p2p_info;
part = msn_slpmsgpart_new(msn_p2p_info_dup(info));
part->ack_data = slpmsg;
real_size = msn_p2p_info_is_ack(info) ? 0 : slpmsg->size;
offset = msn_p2p_info_get_offset(info);
if (offset < real_size)
{
if (slpmsg->slpcall && slpmsg->slpcall->xfer && purple_xfer_get_type(slpmsg->slpcall->xfer) == PURPLE_XFER_SEND &&
purple_xfer_get_status(slpmsg->slpcall->xfer) == PURPLE_XFER_STATUS_STARTED)
{
len = MIN(MSN_SBCONN_MAX_SIZE, slpmsg->slpcall->u.outgoing.len);
msn_slpmsgpart_set_bin_data(part, slpmsg->slpcall->u.outgoing.data, len);
}
else
{
len = slpmsg->size - offset;
if (len > MSN_SBCONN_MAX_SIZE)
len = MSN_SBCONN_MAX_SIZE;
msn_slpmsgpart_set_bin_data(part, slpmsg->buffer + offset, len);
}
msn_p2p_info_set_length(slpmsg->p2p_info, len);
}
#if 0
/* TODO: port this function to SlpMessageParts */
if (purple_debug_is_verbose())
msn_message_show_readable(msg, slpmsg->info, slpmsg->text_body);
#endif
#ifdef MSN_DEBUG_SLP_FILES
debug_part_to_file(slpmsg, TRUE);
#endif
slpmsg->parts = g_list_append(slpmsg->parts, part);
msn_slplink_send_part(slplink, part);
if (msn_p2p_msg_is_data(info) && slpmsg->slpcall != NULL)
{
slpmsg->slpcall->progress = TRUE;
if (slpmsg->slpcall->progress_cb != NULL)
{
slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size,
len);
}
}
/* slpmsg->offset += len; */
}
