void mrim_send_xfer_connect_cb(gpointer data, gint source, const gchar *error_message) {
purple_debug_info("mrim-prpl", "[%s]\n", __func__);
MrimFT *ft = data;
ft->proxy_conn = NULL;
if (source >= 0) {
purple_debug_info("mrim-prpl", "[%s] Connected!\n", __func__);
ft->conn = source;
ft->state = WAITING_FOR_HELLO_ACK;
MrimData *mrim = ft->mrim;
MrimData *fake_mrim = g_new0(MrimData, 1);
fake_mrim->fd = source;
ft->fake_mrim = fake_mrim;
MrimPackage *pack = mrim_package_new(0, MRIM_CS_PROXY_HELLO);
pack->header->proto = 0x00010009;
mrim_package_add_UL(pack, ft->proxy_id[0]);
mrim_package_add_UL(pack, ft->proxy_id[1]);
mrim_package_add_UL(pack, ft->proxy_id[2]);
mrim_package_add_UL(pack, ft->proxy_id[3]);
if (mrim_package_send(pack, fake_mrim)) {
ft->inpa = purple_input_add(ft->conn, PURPLE_INPUT_READ, mrim_ft_send_input_cb, ft);
purple_debug_info("mrim-prpl", "[%s] MRIM_CS_PROXY_HELLO sent!\n", __func__);
} else {
purple_debug_info("mrim-prpl", "[%s] Failed to send MRIM_CS_PROXY_HELLO!\n", __func__);
purple_xfer_unref(ft->xfer);
}
} else {
purple_debug_info("mrim-prpl", "[%s] Fail!\n", __func__);
purple_xfer_unref(ft->xfer);
}
}
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);
}
static MsnSlpMessage *
init_first_msg(MsnSlpLink *slplink, MsnP2PInfo *info)
{
MsnSlpMessage *slpmsg;
guint32 session_id;
slpmsg = msn_slpmsg_new(slplink, NULL);
slpmsg->id = msn_p2p_info_get_id(info);
session_id = msn_p2p_info_get_session_id(info);
slpmsg->size = msn_p2p_info_get_total_size(info);
msn_p2p_info_init_first(slpmsg->p2p_info, info);
if (session_id)
{
slpmsg->slpcall = msn_slplink_find_slp_call_with_session_id(slplink, session_id);
if (slpmsg->slpcall != NULL)
{
if (msn_p2p_msg_is_data(info))
{
PurpleXfer *xfer = slpmsg->slpcall->xfer;
if (xfer != NULL)
{
slpmsg->ft = TRUE;
slpmsg->slpcall->xfer_msg = slpmsg;
purple_xfer_ref(xfer);
purple_xfer_start(xfer, -1, NULL, 0);
if (xfer->data == NULL) {
purple_xfer_unref(xfer);
msn_slpmsg_destroy(slpmsg);
g_return_val_if_reached(NULL);
} else {
purple_xfer_unref(xfer);
}
}
}
}
}
if (!slpmsg->ft && slpmsg->size)
{
slpmsg->buffer = g_try_malloc(slpmsg->size);
if (slpmsg->buffer == NULL)
{
purple_debug_error("msn", "Failed to allocate buffer for slpmsg\n");
msn_slpmsg_destroy(slpmsg);
return NULL;
}
}
return slpmsg;
}
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 = xfer->data;
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) {
purple_xfer_unref(xfer);
return;
}
xd = xfer->data;
gc = purple_account_get_connection(purple_xfer_get_account(xfer));
irc = gc->proto_data;
purple_xfer_unref(xfer);
if (sock < 0) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Could not open a listening port."));
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 */
xfer->watcher = purple_input_add(sock, PURPLE_INPUT_READ,
irc_dccsend_send_connected, xfer);
/* Send the intended recipient the DCC request */
arg[0] = xfer->who;
inet_aton(purple_network_get_my_ip(irc->fd), &addr);
arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %" G_GSIZE_FORMAT "\001",
xfer->filename, ntohl(addr.s_addr),
port, xfer->size);
irc_cmd_privmsg(gc->proto_data, "msg", NULL, arg);
g_free(tmp);
}
void
finch_xfer_dialog_remove_xfer(PurpleXfer *xfer)
{
PurpleGntXferUiData *data;
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;
data->in_list = FALSE;
gnt_tree_remove(GNT_TREE(xfer_dialog->tree), xfer);
xfer_dialog->num_transfers--;
if (xfer_dialog->num_transfers == 0 && !xfer_dialog->keep_open)
finch_xfer_dialog_destroy();
else
update_title_progress();
purple_xfer_unref(xfer);
}
void
pidgin_xfer_dialog_remove_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
data = PIDGINXFER(xfer);
if (data == NULL)
return;
if (!data->in_list)
return;
data->in_list = FALSE;
gtk_list_store_remove(GTK_LIST_STORE(dialog->model), &data->iter);
dialog->num_transfers--;
ensure_row_selected(dialog);
update_title_progress(dialog);
purple_xfer_unref(xfer);
}
static void tgprpl_xfer_send_on_finished (struct tgl_state *TLS, void *_data, int success, struct tgl_message *M) {
debug ("tgprpl_xfer_on_finished()");
struct tgp_xfer_send_data *data = _data;
if (success) {
if (! purple_xfer_is_canceled (data->xfer)) {
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);
}
write_secret_chat_file (TLS);
} else {
tgp_notify_on_error_gw (TLS, NULL, success);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_cancel_remote (data->xfer);
}
failure ("send xfer failed");
}
data->loading = FALSE;
data->xfer->data = NULL;
purple_xfer_unref (data->xfer);
tgprpl_xfer_free_data (data);
}
void
pn_peer_call_free(struct pn_peer_call *call)
{
MsnSession *session;
if (!call)
return;
pn_log("call=%p", call);
if (call->timer)
g_source_remove(call->timer);
g_free(call->id);
g_free(call->branch);
g_free(call->data_info);
session = pn_peer_link_get_session(call->link);
if (call->end_cb)
call->end_cb(call, session);
pn_peer_link_remove_call(call->link, call);
if (call->xfer)
purple_xfer_unref(call->xfer);
if (call->swboard)
call->swboard->calls = g_list_remove(call->swboard->calls, call);
g_free(call);
}
/*------------------------------------------------------------------------
* A file has been received from the MXit server.
*
* @param session The MXit session object
* @param fileid A unique ID that identifies this file
* @param data The file data
* @param datalen The size of the data
*/
void mxit_xfer_rx_file( struct MXitSession* session, const char* fileid, const char* data, int datalen )
{
PurpleXfer* xfer = NULL;
struct mxitxfer* mx = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_rx_file: (size=%i)\n", datalen );
/* find the file-transfer object */
xfer = find_mxit_xfer( session, fileid );
if ( xfer ) {
mx = xfer->data;
/* this is the transfer we have been looking for */
purple_xfer_ref( xfer );
purple_xfer_start( xfer, -1, NULL, 0 );
fwrite( data, datalen, 1, xfer->dest_fp );
purple_xfer_unref( xfer );
purple_xfer_set_completed( xfer, TRUE );
purple_xfer_end( xfer );
/* inform MXit that file was successfully received */
mxit_send_file_received( session, fileid, RECV_STATUS_SUCCESS );
}
else {
/* file transfer not found */
mxit_send_file_received( session, fileid, RECV_STATUS_BAD_ID );
}
}
void tgprpl_xfer_free_all (connection_data *conn) {
GList *xfers = purple_xfers_get_all ();
while (xfers) {
PurpleXfer *xfer = xfers->data;
if (purple_xfer_get_account (xfer) == conn->pa) {
debug ("xfer: %s", xfer->filename);
// cancel all non-completed file tranfsers to avoid them from being called
// in future sessions, as they still contain references to already freed data.
if (! purple_xfer_is_canceled (xfer) && ! purple_xfer_is_completed (xfer)) {
purple_xfer_cancel_local (xfer);
}
// if a file transfer is still running while going offline, it will be canceled when
// cleaning up libtgl memory. Since canceled file transfers are being kept (see
// tgprpl_xfer_canceled() and tgprpl_xfer_recv_init()) those need to be freed now.
struct tgp_xfer_send_data *data = xfer->data;
if (data) {
if (data->loading) {
tgprpl_xfer_free_data (data);
xfer->data = NULL;
purple_xfer_unref (xfer);
} else {
g_warn_if_reached();
}
}
}
xfers = g_list_next(xfers);
}
}
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
purple_xfer_end(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
/* See if we are actually trying to cancel this. */
if (!purple_xfer_is_completed(xfer)) {
purple_xfer_cancel_local(xfer);
return;
}
xfer->end_time = time(NULL);
if (xfer->ops.end != NULL)
xfer->ops.end(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;
}
purple_xfer_unref(xfer);
}
/*------------------------------------------------------------------------
* A file has been received from the MXit server.
*
* @param session The MXit session object
* @param fileid A unique ID that identifies this file
* @param data The file data
* @param datalen The size of the data
*/
void mxit_xfer_rx_file( struct MXitSession* session, const char* fileid, const char* data, int datalen )
{
PurpleXfer* xfer = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_rx_file: (size=%i)\n", datalen );
/* find the file-transfer object */
xfer = find_mxit_xfer( session, fileid );
if ( xfer ) {
/* this is the transfer we have been looking for */
purple_xfer_ref( xfer );
purple_xfer_start( xfer, -1, NULL, 0 );
if ( fwrite( data, datalen, 1, xfer->dest_fp ) > 0 ) {
purple_xfer_unref( xfer );
purple_xfer_set_completed( xfer, TRUE );
purple_xfer_end( xfer );
/* inform MXit that file was successfully received */
mxit_send_file_received( session, fileid, RECV_STATUS_SUCCESS );
}
else {
/* file write error */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "Unable to save the file" ) );
purple_xfer_cancel_local( xfer );
}
}
else {
/* file transfer not found */
mxit_send_file_received( session, fileid, RECV_STATUS_BAD_ID );
}
}
FiletransferRepeater::~FiletransferRepeater() {
Log("xferdestroyed", "in ftrepeater");
if (m_resender) {
Log("xferdestroyed", m_resender);
if (m_resender->isRunning()) {
Log("xferdestroyed", "resender is running, trying to stop it");
m_resender->stop();
m_resender->lockMutex();
m_resender->wakeUp();
m_resender->unlockMutex();
m_resender->join();
Log("xferdestroyed", "resender stopped.");
}
Log("xferdestroyed", m_resender);
delete m_resender;
m_resender = NULL;
}
if (m_xfer) {
m_xfer->ui_data = NULL;
purple_xfer_unref(m_xfer);
m_xfer = NULL;
}
m_deleteMeTimer->deleteLater();
m_readyTimer->deleteLater();
}
static int
ask_accept_cancel(PurpleXfer *xfer)
{
purple_xfer_request_denied(xfer);
purple_xfer_unref(xfer);
return 0;
}
static void
silcpurple_ftp_send_cancel(PurpleXfer *x)
{
SilcPurpleXfer xfer = x->data;
silc_client_file_close(xfer->sg->client, xfer->sg->conn, xfer->session_id);
purple_xfer_unref(xfer->xfer);
g_free(xfer->hostname);
silc_free(xfer);
}
static int
cancel_recv_cb(PurpleXfer *xfer)
{
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
purple_xfer_request_denied(xfer);
purple_xfer_unref(xfer);
return 0;
}
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);
}
void
purple_xfer_request_denied(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
if (xfer->ops.request_denied != NULL)
xfer->ops.request_denied(xfer);
purple_xfer_unref(xfer);
}
void
msn_slp_call_destroy(MsnSlpCall *slpcall)
{
GList *e;
MsnSession *session;
#ifdef MSN_DEBUG_SLPCALL
purple_debug_info("msn", "slpcall_destroy: slpcall(%p)\n", slpcall);
#endif
g_return_if_fail(slpcall != NULL);
if (slpcall->timer)
purple_timeout_remove(slpcall->timer);
if (slpcall->id != NULL)
g_free(slpcall->id);
if (slpcall->branch != NULL)
g_free(slpcall->branch);
if (slpcall->data_info != NULL)
g_free(slpcall->data_info);
for (e = slpcall->slplink->slp_msgs; e != NULL; )
{
MsnSlpMessage *slpmsg = e->data;
e = e->next;
#ifdef MSN_DEBUG_SLPCALL_VERBOSE
purple_debug_info("msn", "slpcall_destroy: trying slpmsg(%p)\n",
slpmsg);
#endif
if (slpmsg->slpcall == slpcall)
{
msn_slpmsg_destroy(slpmsg);
}
}
session = slpcall->slplink->session;
msn_slplink_remove_slpcall(slpcall->slplink, slpcall);
if (slpcall->end_cb != NULL)
slpcall->end_cb(slpcall, session);
if (slpcall->xfer != NULL) {
slpcall->xfer->data = NULL;
purple_xfer_unref(slpcall->xfer);
}
g_free(slpcall);
}
void
purple_xfer_request_denied(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
purple_debug_misc("xfer", "xfer %p denied\n", xfer);
if (xfer->ops.request_denied != NULL)
xfer->ops.request_denied(xfer);
purple_xfer_unref(xfer);
}
static void
purple_xfer_choose_file_cancel_cb(void *user_data, const char *filename)
{
PurpleXfer *xfer = (PurpleXfer *)user_data;
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
purple_xfer_cancel_local(xfer);
else
purple_xfer_request_denied(xfer);
purple_xfer_unref(xfer);
}
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);
}
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;
}
void mrim_xfer_proxy_ack(MrimPackage *pack, MrimData *mrim) {
guint status = mrim_package_read_UL(pack);
gchar *user_name = mrim_package_read_LPSA(pack);
guint32 id = mrim_package_read_UL(pack);
guint32 data_type = mrim_package_read_UL(pack);
gchar *file_list = mrim_package_read_LPSA(pack);
gchar *remote_ip = mrim_package_read_LPSA(pack);
// В пакете есть ещё и другие поля, но они нам не нужны (*кроме proxy_id)
g_return_if_fail(data_type != MRIM_PROXY_TYPE_FILES);
PurpleXfer *xfer = g_hash_table_lookup(mrim->transfers, GUINT_TO_POINTER(id));
if (xfer) {
if (status == PROXY_STATUS_OK) {
MrimFT *ft = xfer->data;
purple_debug_info("mrim-prpl", "[%s] Proxy accepted! Address list = '%s'\n", __func__, remote_ip);
gchar **addrs = g_strsplit(remote_ip, ";", 0);
gchar **addr = addrs;
gchar *ip = NULL;
guint16 port;
while (*addr) {
gchar **parts = g_strsplit(*addr, ":", 2);
ip = g_strdup(parts[0]);
port = atoi(parts[1]);
g_strfreev(parts);
if (port != 443) { // Мы не умеем SSL ;D
break;
} else {
g_free(ip);
}
addr++;
}
g_strfreev(addrs);
purple_debug_info("mrim-prpl", "[%s] Proxy host = '%s', port = %u\n", __func__, ip, port);
ft->proxy_id[0] = mrim_package_read_UL(pack);
ft->proxy_id[1] = mrim_package_read_UL(pack);
ft->proxy_id[2] = mrim_package_read_UL(pack);
ft->proxy_id[3] = mrim_package_read_UL(pack);
ft->proxy_conn = purple_proxy_connect(NULL, mrim->account, ip, port, mrim_send_xfer_connect_cb, ft);
} else {
purple_debug_info("mrim-prpl", "[%s] Proxy request failed!\n", __func__);
purple_xfer_unref(xfer);
}
}
}
/*
* 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 = xfer->data;
xfer->filename = g_path_get_basename(xfer->local_filename);
purple_xfer_ref(xfer);
/* Create a listening socket */
xd->listen_data = purple_network_listen_range(0, 0, SOCK_STREAM,
irc_dccsend_network_listen_cb, xfer);
if (xd->listen_data == NULL) {
purple_xfer_unref(xfer);
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Could not open a listening port."));
purple_xfer_cancel_local(xfer);
}
}
void mrim_xfer_ack(MrimPackage *pack, MrimData *mrim) {
purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER_ACK\n", __func__);
guint32 status = mrim_package_read_UL(pack);
gchar *user_name = mrim_package_read_LPSA(pack);
guint32 id = mrim_package_read_UL(pack);
gchar *remote_addr = mrim_package_read_LPSA(pack);
purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER_ACK: status = %u, user_name = '%s', remote_addr = '%s'\n", __func__, status, user_name, remote_addr);
PurpleXfer *xfer = g_hash_table_lookup(mrim->transfers, GUINT_TO_POINTER(id));
if (xfer) {
if (status == FILE_TRANSFER_MIRROR) {
MrimFT *ft = xfer->data;
purple_debug_info("mrim-prpl", "[%s] User='******' accepted files! id='%xu'\n", __func__, user_name, id);
//Допустим белого IP у нас нет и запросим зеркальный прокси TODO
MrimPackage *ack = mrim_package_new(mrim->seq++, MRIM_CS_PROXY);
mrim_package_add_LPSA(ack, user_name);
mrim_package_add_UL(ack, id);
mrim_package_add_UL(ack, MRIM_PROXY_TYPE_FILES);
gchar *file_list = g_strdup_printf("%s;%u;", ft->files[0].name, ft->files[0].size);
mrim_package_add_LPSA(ack, file_list);
mrim_package_add_UL(ack, 0); // Много-
mrim_package_add_UL(ack, 0); // много
mrim_package_add_UL(ack, 0); // не
mrim_package_add_UL(ack, 0); // нужных
mrim_package_add_UL(ack, 0); // полей
mrim_package_add_UL(ack, 4 + 4 + strlen(file_list) * 2); //Длина последующихъ данных
// Судя по всему далее идёт повтор пакета, но в UTF16
mrim_package_add_UL(ack, MRIM_PROXY_TYPE_FILES);
mrim_package_add_LPSW(ack, file_list);
mrim_package_add_UL(ack, 4); // Неизвестное поле
mrim_package_add_UL(ack, 1); // Ещё одно неизвестно поле... Имеет смысл узнать, что это...
mrim_package_send(ack, mrim);
} else {
purple_debug_info("mrim-prpl", "[%s] Transfer cancelled!\n", __func__);
purple_xfer_unref(xfer);
}
}
g_free(user_name);
g_free(remote_addr);
}
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);
}
static void
purple_xfer_choose_file_ok_cb(void *user_data, const char *filename)
{
PurpleXfer *xfer;
PurpleXferType type;
struct stat st;
gchar *dir;
xfer = (PurpleXfer *)user_data;
type = purple_xfer_get_type(xfer);
if (g_stat(filename, &st) != 0) {
/* File not found. */
if (type == PURPLE_XFER_RECEIVE) {
#ifndef _WIN32
int mode = W_OK;
#else
int mode = F_OK;
#endif
dir = g_path_get_dirname(filename);
if (g_access(dir, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("Directory is not writable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
g_free(dir);
}
else {
purple_xfer_show_file_error(xfer, filename);
purple_xfer_cancel_local(xfer);
}
}
else if ((type == PURPLE_XFER_SEND) && (st.st_size == 0)) {
purple_notify_error(NULL, NULL,
_("Cannot send a file of 0 bytes."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_SEND) && S_ISDIR(st.st_mode)) {
/*
* XXX - Sending a directory should be valid for some protocols.
*/
purple_notify_error(NULL, NULL,
_("Cannot send a directory."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_RECEIVE) && S_ISDIR(st.st_mode)) {
char *msg, *utf8;
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
msg = g_strdup_printf(
_("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8);
g_free(utf8);
purple_notify_error(NULL, NULL, msg, NULL);
g_free(msg);
purple_xfer_request_denied(xfer);
}
else if (type == PURPLE_XFER_SEND) {
#ifndef _WIN32
int mode = R_OK;
#else
int mode = F_OK;
#endif
if (g_access(filename, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("File is not readable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
}
else {
purple_xfer_request_accepted(xfer, filename);
}
purple_xfer_unref(xfer);
}
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);
}
