Mercurial > pidgin3 / file revision

/*
 * purple - Bonjour Protocol Plugin
 *
 * Purple is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,  USA
 */

#include <config.h>

#include <sys/types.h>

#include <nice.h>

#include <purple.h>

#include "bonjour.h"
#include "bonjour_ft.h"

static void
bonjour_bytestreams_init(PurpleXfer *xfer);
static void
bonjour_bytestreams_connect(PurpleXfer *xfer);
static void
bonjour_xfer_init(PurpleXfer *xfer);
static void
bonjour_xfer_receive(PurpleConnection *pc, const char *id, const char *sid, const char *from,
		     goffset filesize, const char *filename, int option);

/* Look for specific xfer handle */
static unsigned int next_id = 0;

struct _XepXfer
{
	PurpleXfer parent;

	GCancellable *cancellable;
	void *data;
	char *filename;
	int filesize;
	char *iq_id;
	char *sid;
	char *recv_id;
	char *buddy_ip;
	int mode;
	GSocketClient *client;
	GSocketService *service;
	GSocketConnection *conn;
	char rx_buf[0x500];
	char tx_buf[0x500];
	char *jid;
	char *proxy_host;
	int proxy_port;
	PurpleXmlNode *streamhost;
	PurpleBuddy *pb;
};

G_DEFINE_DYNAMIC_TYPE(XepXfer, xep_xfer, PURPLE_TYPE_XFER);

static void
xep_ft_si_reject(BonjourData *bd, const char *id, const char *to, const char *error_code, const char *error_type)
{
	PurpleXmlNode *error_node;
	XepIq *iq;

	g_return_if_fail(error_code != NULL);
	g_return_if_fail(error_type != NULL);

	if(!to || !id) {
		purple_debug_info("bonjour", "xep file transfer stream initialization error.\n");
		return;
	}

	iq = xep_iq_new(bd, XEP_IQ_ERROR, to, bonjour_get_jid(bd->xmpp_data->account), id);
	if(iq == NULL)
		return;

	error_node = purple_xmlnode_new_child(iq->node, "error");
	purple_xmlnode_set_attrib(error_node, "code", error_code);
	purple_xmlnode_set_attrib(error_node, "type", error_type);

	/* TODO: Make this better */
	if (purple_strequal(error_code, "403")) {
		PurpleXmlNode *tmp_node = purple_xmlnode_new_child(error_node, "forbidden");
		purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");

		tmp_node = purple_xmlnode_new_child(error_node, "text");
		purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
		purple_xmlnode_insert_data(tmp_node, "Offer Declined", -1);
	} else if (purple_strequal(error_code, "404")) {
		PurpleXmlNode *tmp_node = purple_xmlnode_new_child(error_node, "item-not-found");
		purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
	}

	xep_iq_send_and_free(iq);
}

static void bonjour_xfer_cancel_send(PurpleXfer *xfer)
{
	XepXfer *xf = XEP_XFER(xfer);

	purple_debug_info("bonjour", "Bonjour-xfer-cancel-send.\n");
	g_cancellable_cancel(xf->cancellable);
}

static void bonjour_xfer_request_denied(PurpleXfer *xfer)
{
	XepXfer *xf = XEP_XFER(xfer);

	purple_debug_info("bonjour", "Bonjour-xfer-request-denied.\n");

	if(xf) {
		xep_ft_si_reject(xf->data, xf->sid, purple_xfer_get_remote_user(xfer), "403", "cancel");
	}
}

static void bonjour_xfer_cancel_recv(PurpleXfer *xfer)
{
	XepXfer *xf = XEP_XFER(xfer);

	purple_debug_info("bonjour", "Bonjour-xfer-cancel-recv.\n");
	g_cancellable_cancel(xf->cancellable);
}

static void bonjour_xfer_end(PurpleXfer *xfer)
{
	purple_debug_info("bonjour", "Bonjour-xfer-end for xfer %p", xfer);

	/* We can't allow the server side to close the connection until the client is complete,
	 * otherwise there is a RST resulting in an error on the client side */
	if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND && purple_xfer_is_completed(xfer)) {
		XepXfer *xf = XEP_XFER(xfer);
		g_io_stream_close_async(G_IO_STREAM(xf->conn), G_PRIORITY_DEFAULT, xf->cancellable, NULL, NULL);
		purple_xfer_set_fd(xfer, -1);
	}
}

static PurpleXfer*
bonjour_si_xfer_find(BonjourData *bd, const char *sid, const char *from)
{
	GSList *xfers;
	PurpleXfer *xfer;
	XepXfer *xf;

	if(!sid || !from || !bd)
		return NULL;

	purple_debug_info("bonjour", "Look for sid=%s from=%s xferlists.\n",
			  sid, from);

	for(xfers = bd->xfer_lists; xfers; xfers = xfers->next) {
		xfer = xfers->data;
		if(xfer == NULL)
			break;
		xf = XEP_XFER(xfer);
		if(xf == NULL)
			break;
		if(xf->sid && purple_xfer_get_remote_user(xfer) && purple_strequal(xf->sid, sid) &&
				purple_strequal(purple_xfer_get_remote_user(xfer), from))
			return xfer;
	}

	purple_debug_info("bonjour", "Look for xfer list fail\n");

	return NULL;
}

static void
xep_ft_si_offer(PurpleXfer *xfer, const gchar *to)
{
	PurpleXmlNode *si_node, *feature, *field, *file, *x;
	XepIq *iq;
	XepXfer *xf = XEP_XFER(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->xmpp_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
xep_ft_si_result(PurpleXfer *xfer, const char *to)
{
	PurpleXmlNode *si_node, *feature, *field, *value, *x;
	XepIq *iq;
	XepXfer *xf;
	BonjourData *bd;

	if(!to || !xfer)
		return;
	xf = XEP_XFER(xfer);

	bd = xf->data;

	purple_debug_info("bonjour", "xep file transfer stream initialization result.\n");
	iq = xep_iq_new(bd, XEP_IQ_RESULT, to, bonjour_get_jid(bd->xmpp_data->account), xf->iq_id);
	if(iq == NULL)
		return;

	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");*/

	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", "submit");

	field = purple_xmlnode_new_child(x, "field");
	purple_xmlnode_set_attrib(field, "var", "stream-method");

	value = purple_xmlnode_new_child(field, "value");
	purple_xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1);

	xep_iq_send_and_free(iq);
}

/**
 * Frees the whole tree of an xml node
 *
 * First determines the root of the xml tree and then frees the whole tree
 * from there.
 *
 * @param node	The node to free the tree from
 */
static void
purple_xmlnode_free_tree(PurpleXmlNode *node)
{
	g_return_if_fail(node != NULL);

	while(purple_xmlnode_get_parent(node))
		node = purple_xmlnode_get_parent(node);

	purple_xmlnode_free(node);
}

PurpleXfer *
bonjour_new_xfer(PurpleProtocolXfer *prplxfer, PurpleConnection *gc, const char *who)
{
	PurpleXfer *xfer;
	XepXfer *xep_xfer;
	BonjourData *bd;

	if(who == NULL || gc == NULL)
		return NULL;

	purple_debug_info("bonjour", "Bonjour-new-xfer to %s.\n", who);
	bd = purple_connection_get_protocol_data(gc);
	if(bd == NULL)
		return NULL;

	/* Build the file transfer handle */
	xep_xfer = g_object_new(
		XEP_TYPE_XFER,
		"account", purple_connection_get_account(gc),
		"type", PURPLE_XFER_TYPE_SEND,
		"remote-user", who,
		NULL
	);
	xfer = PURPLE_XFER(xep_xfer);
	xep_xfer->data = bd;

	purple_debug_info("bonjour", "Bonjour-new-xfer bd=%p data=%p.\n", bd, xep_xfer->data);

	/* We don't support IBB yet */
	/*xep_xfer->mode = XEP_BYTESTREAMS | XEP_IBB;*/
	xep_xfer->mode = XEP_BYTESTREAMS;
	xep_xfer->sid = NULL;

	bd->xfer_lists = g_slist_append(bd->xfer_lists, xfer);

	return xfer;
}

void
bonjour_send_file(PurpleProtocolXfer *prplxfer, PurpleConnection *gc, const char *who, const char *file)
{
	PurpleXfer *xfer;

	g_return_if_fail(gc != NULL);
	g_return_if_fail(who != NULL);

	purple_debug_info("bonjour", "Bonjour-send-file to=%s.\n", who);

	xfer = bonjour_new_xfer(prplxfer, gc, who);

	if (file)
		purple_xfer_request_accepted(xfer, file);
	else
		purple_xfer_request(xfer);

}

static void
bonjour_xfer_init(PurpleXfer *xfer)
{
	PurpleBuddy *buddy;
	BonjourBuddy *bb;
	XepXfer *xf;

	xf = XEP_XFER(xfer);

	purple_debug_info("bonjour", "Bonjour-xfer-init.\n");

	buddy = purple_blist_find_buddy(purple_xfer_get_account(xfer), purple_xfer_get_remote_user(xfer));
	/* this buddy is offline. */
	if (buddy == NULL || (bb = purple_buddy_get_protocol_data(buddy)) == NULL)
		return;

	/* Assume it is the first IP. We could do something like keep track of which one is in use or something. */
	if (bb->ips)
		xf->buddy_ip = g_strdup(bb->ips->data);
	if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) {
		/* initiate file transfer, send SI offer. */
		purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_SEND.\n");
		xep_ft_si_offer(xfer, purple_xfer_get_remote_user(xfer));
	} else {
		/* accept file transfer request, send SI result. */
		xep_ft_si_result(xfer, purple_xfer_get_remote_user(xfer));
		purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_RECEIVE.\n");
	}
}

void
xep_si_parse(PurpleConnection *pc, PurpleXmlNode *packet, PurpleBuddy *pb)
{
	const char *type, *id;
	BonjourData *bd;
	PurpleXfer *xfer;
	const gchar *name = NULL;

	g_return_if_fail(pc != NULL);
	g_return_if_fail(packet != NULL);
	g_return_if_fail(pb != NULL);

	bd = purple_connection_get_protocol_data(pc);
	if(bd == NULL)
		return;

	purple_debug_info("bonjour", "xep-si-parse.\n");

	name = purple_buddy_get_name(pb);

	type = purple_xmlnode_get_attrib(packet, "type");
	id = purple_xmlnode_get_attrib(packet, "id");
	if(!type)
		return;

	if(purple_strequal(type, "set")) {
		PurpleXmlNode *si;
		gboolean parsed_receive = FALSE;

		si = purple_xmlnode_get_child(packet, "si");

		purple_debug_info("bonjour", "si offer Message type - SET.\n");
		if (si) {
			const char *profile;

			profile = purple_xmlnode_get_attrib(si, "profile");

			if (purple_strequal(profile, "http://jabber.org/protocol/si/profile/file-transfer")) {
				const char *filename = NULL, *filesize_str = NULL;
				goffset filesize = 0;
				PurpleXmlNode *file;

				const char *sid = purple_xmlnode_get_attrib(si, "id");

				if ((file = purple_xmlnode_get_child(si, "file"))) {
					filename = purple_xmlnode_get_attrib(file, "name");
					if((filesize_str = purple_xmlnode_get_attrib(file, "size")))
						filesize = g_ascii_strtoll(filesize_str, NULL, 10);
				}

				/* TODO: Make sure that it is advertising a bytestreams transfer */

				if (filename) {
					bonjour_xfer_receive(pc, id, sid, name, filesize, filename, XEP_BYTESTREAMS);

					parsed_receive = TRUE;
				}
			}
		}

		if (!parsed_receive) {
			BonjourData *bd = purple_connection_get_protocol_data(pc);

			purple_debug_info("bonjour", "rejecting unrecognized si SET offer.\n");
			xep_ft_si_reject(bd, id, name, "403", "cancel");
			/*TODO: Send Cancel (501) */
		}
	} else if(purple_strequal(type, "result")) {
		purple_debug_info("bonjour", "si offer Message type - RESULT.\n");

		xfer = bonjour_si_xfer_find(bd, id, name);

		if(xfer == NULL) {
			BonjourData *bd = purple_connection_get_protocol_data(pc);
			purple_debug_info("bonjour", "xfer find fail.\n");
			xep_ft_si_reject(bd, id, name, "403", "cancel");
		} else
			bonjour_bytestreams_init(xfer);

	} else if(purple_strequal(type, "error")) {
		purple_debug_info("bonjour", "si offer Message type - ERROR.\n");

		xfer = bonjour_si_xfer_find(bd, id, name);

		if(xfer == NULL)
			purple_debug_info("bonjour", "xfer find fail.\n");
		else
			purple_xfer_cancel_remote(xfer);
	} else
		purple_debug_info("bonjour", "si offer Message type - Unknown-%s.\n", type);
}

/**
 * Will compare a host with a buddy_ip.
 *
 * Additionally to a common 'purple_strequal(host, buddy_ip)', it will also return TRUE
 * if 'host' is a link local IPv6 address without an appended interface
 * identifier and 'buddy_ip' string is "host" + "%iface".
 *
 * Note: This may theoretically result in the attempt to connect to the wrong
 * host, because we do not know for sure which interface the according link
 * local IPv6 address might relate to and RFC4862 for instance only ensures the
 * uniqueness of this address on a given link. So we could possibly have two
 * distinct buddies with the same ipv6 link local address on two distinct
 * interfaces. Unfortunately XEP-0065 does not seem to specify how to deal with
 * link local ip addresses properly...
 * However, in practice the possiblity for such a conflict is relatively low
 * (2011 - might be different in the future though?).
 *
 * @param host		ipv4 or ipv6 address string
 * @param buddy_ip	ipv4 or ipv6 address string
 * @return		TRUE if they match, FALSE otherwise
 */
static gboolean
xep_cmp_addr(const char *host, const char *buddy_ip)
{
	GInetAddress *addr = NULL;

	addr = g_inet_address_new_from_string(host);
	if (addr != NULL &&
	    g_inet_address_get_family(addr) == G_SOCKET_FAMILY_IPV6 &&
	    g_inet_address_get_is_link_local(addr)) {
		g_clear_object(&addr);

		if (strlen(buddy_ip) <= strlen(host) || buddy_ip[strlen(host)] != '%') {
			return FALSE;
		}

		return !strncmp(host, buddy_ip, strlen(host));
	} else {
		g_clear_object(&addr);
		return purple_strequal(host, buddy_ip);
	}
}

static inline gint
xep_addr_differ(const char *buddy_ip, const char *host)
{
	return !xep_cmp_addr(host, buddy_ip);
}

/**
 * Create and insert an identical twin
 *
 * Creates a copy of the specified node and inserts it right after
 * this original node.
 *
 * @param node	The node to clone
 * @return	A pointer to the new, cloned twin if successful
 *		or NULL otherwise.
 */
static PurpleXmlNode *
purple_xmlnode_insert_twin_copy(PurpleXmlNode *node) {
	PurpleXmlNode *copy;

	g_return_val_if_fail(node != NULL, NULL);

	copy = purple_xmlnode_copy(node);
	g_return_val_if_fail(copy != NULL, NULL);

	copy->next = node->next;
	node->next = copy;

	return copy;
}

/**
 * Tries to append an interface scope to an IPv6 link local address.
 *
 * If the given address is a link local IPv6 address (with no
 * interface scope) then we try to determine all fitting interfaces
 * from our Bonjour IP address list.
 *
 * For any such found matches we insert a copy of our current xml
 * streamhost entry right after this streamhost entry and append
 * the determined interface to the host address of this copy.
 *
 * @param cur_streamhost	The XML streamhost node we examine
 * @param host	The host address to examine in text form
 * @param pb	Buddy to get the list of link local IPv6 addresses
 *		and their interface from
 * @return	Returns TRUE if the specified 'host' address is a
 *		link local IPv6 address with no interface scope.
 *		Otherwise returns FALSE.
 */
static gboolean
add_ipv6_link_local_ifaces(PurpleXmlNode *cur_streamhost, const char *host,
			   PurpleBuddy *pb)
{
	PurpleXmlNode *new_streamhost = NULL;
	GInetAddress *addr;
	BonjourBuddy *bb;
	GSList *ip_elem;

	addr = g_inet_address_new_from_string(host);
	if (addr == NULL ||
	    g_inet_address_get_family(addr) != G_SOCKET_FAMILY_IPV6 ||
	    !g_inet_address_get_is_link_local(addr) ||
	    strchr(host, '%'))
	{
		g_clear_object(&addr);
		return FALSE;
	}
	g_clear_object(&addr);

	bb = purple_buddy_get_protocol_data(pb);

	for (ip_elem = bb->ips;
	     (ip_elem = g_slist_find_custom(ip_elem, host, (GCompareFunc)&xep_addr_differ));
	     ip_elem = ip_elem->next) {
		purple_debug_info("bonjour", "Inserting an PurpleXmlNode twin copy for %s with new host address %s\n",
				  host, (char*)ip_elem->data);
		new_streamhost = purple_xmlnode_insert_twin_copy(cur_streamhost);
		purple_xmlnode_set_attrib(new_streamhost, "host", ip_elem->data);
	}

	if (!new_streamhost)
		purple_debug_info("bonjour", "No interface for this IPv6 link local address found: %s\n",
				  host);

	return TRUE;
}

static gboolean
__xep_bytestreams_parse(PurpleBuddy *pb, PurpleXfer *xfer, PurpleXmlNode *streamhost,
			const char *iq_id)
{
	char *tmp_iq_id;
	const char *jid, *host, *port;
	int portnum;
	XepXfer *xf = XEP_XFER(xfer);

	for(; streamhost; streamhost = purple_xmlnode_get_next_twin(streamhost)) {
		if(!(jid = purple_xmlnode_get_attrib(streamhost, "jid")) ||
		   !(host = purple_xmlnode_get_attrib(streamhost, "host")) ||
		   !(port = purple_xmlnode_get_attrib(streamhost, "port")) ||
		   !(portnum = atoi(port))) {
			purple_debug_info("bonjour", "bytestream offer Message parse error.\n");
			continue;
		}

		/* skip IPv6 link local addresses with no interface scope
		 * (but try to add a new one with an interface scope then) */
		if(add_ipv6_link_local_ifaces(streamhost, host, pb))
			continue;

		tmp_iq_id = g_strdup(iq_id);
		g_free(xf->iq_id);
		g_free(xf->jid);
		g_free(xf->proxy_host);

		xf->iq_id = tmp_iq_id;
		xf->jid = g_strdup(jid);
		xf->proxy_host = g_strdup(host);
		xf->proxy_port = portnum;
		xf->streamhost = streamhost;
		xf->pb = pb;
		purple_debug_info("bonjour", "bytestream offer parse"
				  "jid=%s host=%s port=%d.\n", jid, host, portnum);
		bonjour_bytestreams_connect(xfer);
		return TRUE;
	}

	return FALSE;
}

void
xep_bytestreams_parse(PurpleConnection *pc, PurpleXmlNode *packet, PurpleBuddy *pb)
{
	const char *type, *from, *iq_id, *sid;
	PurpleXmlNode *query, *streamhost;
	BonjourData *bd;
	PurpleXfer *xfer;

	g_return_if_fail(pc != NULL);
	g_return_if_fail(packet != NULL);
	g_return_if_fail(pb != NULL);

	bd = purple_connection_get_protocol_data(pc);
	if(bd == NULL)
		return;

	purple_debug_info("bonjour", "xep-bytestreams-parse.\n");

	type = purple_xmlnode_get_attrib(packet, "type");
	from = purple_buddy_get_name(pb);
	query = purple_xmlnode_get_child(packet,"query");
	if(!type)
		return;

	query = purple_xmlnode_copy(query);
	if (!query)
		return;

	if(!purple_strequal(type, "set")) {
		purple_debug_info("bonjour", "bytestream offer Message type - Unknown-%s.\n", type);
		return;
	}

	purple_debug_info("bonjour", "bytestream offer Message type - SET.\n");

	iq_id = purple_xmlnode_get_attrib(packet, "id");

	sid = purple_xmlnode_get_attrib(query, "sid");
	xfer = bonjour_si_xfer_find(bd, sid, from);
	streamhost = purple_xmlnode_get_child(query, "streamhost");

	if(xfer && streamhost && __xep_bytestreams_parse(pb, xfer, streamhost, iq_id))
		return; /* success */

	purple_debug_error("bonjour", "Didn't find an acceptable streamhost.\n");

	if (iq_id && xfer != NULL)
		xep_ft_si_reject(bd, iq_id, purple_xfer_get_remote_user(xfer), "404", "cancel");
}

static void
bonjour_xfer_receive(PurpleConnection *pc, const char *id, const char *sid, const char *from,
		     goffset filesize, const char *filename, int option)
{
	PurpleXfer *xfer;
	XepXfer *xf;
	BonjourData *bd;

	if(pc == NULL || id == NULL || from == NULL)
		return;

	bd = purple_connection_get_protocol_data(pc);
	if(bd == NULL)
		return;

	purple_debug_info("bonjour", "bonjour-xfer-receive.\n");

	/* Build the file transfer handle */
	xf = g_object_new(
		XEP_TYPE_XFER,
		"account", purple_connection_get_account(pc),
		"type", PURPLE_XFER_TYPE_RECEIVE,
		"remote-user", from,
		NULL
	);

	xfer = PURPLE_XFER(xf);

	xf->data = bd;
	purple_xfer_set_filename(xfer, filename);
	xf->iq_id = g_strdup(id);
	xf->sid = g_strdup(sid);

	if(filesize > 0)
		purple_xfer_set_size(xfer, filesize);

	bd->xfer_lists = g_slist_append(bd->xfer_lists, xfer);

	purple_xfer_request(xfer);
}

static void
bonjour_sock5_request_cb(GObject *source, GAsyncResult *result,
                         gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	gsize bytes_written = 0;
	GError *error = NULL;
	GSocket *sock = NULL;
	gint fd = -1;

	purple_debug_info("bonjour", "bonjour_sock5_request_cb");

	if (!g_output_stream_write_all_finish(G_OUTPUT_STREAM(source), result,
	                                      &bytes_written, &error)) {
		if (error->code != G_IO_ERROR_CANCELLED) {
			purple_xfer_cancel_remote(xfer);
		}
		g_clear_error(&error);
		return;
	}

	sock = g_socket_connection_get_socket(xf->conn);
	fd = g_socket_get_fd(sock);
	purple_debug_info("bonjour", "Accepted SOCKS5 ft connection - fd=%d", fd);

	_purple_network_set_common_socket_flags(fd);
	purple_xfer_start(xfer, fd, NULL, -1);
}

static void
bonjour_sock5_read_connect_cb(GObject *source, GAsyncResult *result,
                              gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	GOutputStream *output = NULL;
	gsize bytes_read = 0;
	GError *error = NULL;

	purple_debug_info("bonjour", "bonjour_sock5_request_state4_cb");

	if (!g_input_stream_read_all_finish(G_INPUT_STREAM(source), result,
	                                    &bytes_read, &error)) {
		if (error->code != G_IO_ERROR_CANCELLED) {
			purple_xfer_cancel_remote(xfer);
		}
		g_clear_error(&error);
		return;
	}

	xf->tx_buf[0] = 0x05;
	xf->tx_buf[1] = 0x00;
	xf->tx_buf[2] = 0x00;
	xf->tx_buf[3] = 0x03;
	xf->tx_buf[4] = strlen(xf->buddy_ip);
	memcpy(xf->tx_buf + 5, xf->buddy_ip, strlen(xf->buddy_ip));
	xf->tx_buf[5 + strlen(xf->buddy_ip)] = 0x00;
	xf->tx_buf[6 + strlen(xf->buddy_ip)] = 0x00;
	output = g_io_stream_get_output_stream(G_IO_STREAM(xf->conn));
	g_output_stream_write_all_async(
	        output, xf->tx_buf, 7 + strlen(xf->buddy_ip), G_PRIORITY_DEFAULT,
	        xf->cancellable, bonjour_sock5_request_cb, xfer);
}

static void
bonjour_sock5_write_server_method_cb(GObject *source, GAsyncResult *result,
                                     gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	GInputStream *input = NULL;
	gsize bytes_written = 0;
	GError *error = NULL;

	purple_debug_info("bonjour", "bonjour_sock5_request_state3_cb");

	if (!g_output_stream_write_all_finish(G_OUTPUT_STREAM(source), result,
	                                      &bytes_written, &error)) {
		if (error->code != G_IO_ERROR_CANCELLED) {
			purple_xfer_cancel_remote(xfer);
		}
		g_clear_error(&error);
		return;
	}

	input = g_io_stream_get_input_stream(G_IO_STREAM(xf->conn));
	g_input_stream_read_all_async(input, xf->rx_buf, 20, G_PRIORITY_DEFAULT,
	                              xf->cancellable,
	                              bonjour_sock5_read_connect_cb, xfer);
}

static void
bonjour_sock5_read_client_version_cb(GObject *source, GAsyncResult *result,
                                     gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	GOutputStream *output = NULL;
	gsize bytes_read = 0;
	GError *error = NULL;

	purple_debug_info("bonjour", "bonjour_sock5_read_client_version_cb");

	if (!g_input_stream_read_all_finish(G_INPUT_STREAM(source), result,
	                                    &bytes_read, &error)) {
		if (error->code != G_IO_ERROR_CANCELLED) {
			purple_xfer_cancel_remote(xfer);
		}
		g_clear_error(&error);
		return;
	}

	xf->tx_buf[0] = 0x05;
	xf->tx_buf[1] = 0x00;
	output = g_io_stream_get_output_stream(G_IO_STREAM(xf->conn));
	g_output_stream_write_all_async(output, xf->tx_buf, 2, G_PRIORITY_DEFAULT,
	                                xf->cancellable,
	                                bonjour_sock5_write_server_method_cb, xfer);
}

static void
bonjour_sock5_incoming_cb(GSocketService *service,
                          GSocketConnection *connection, GObject *source_object,
                          G_GNUC_UNUSED gpointer data)
{
	PurpleXfer *xfer = PURPLE_XFER(source_object);
	XepXfer *xf = XEP_XFER(xfer);
	GInputStream *input = NULL;

	if (xf == NULL) {
		return;
	}

	purple_debug_info("bonjour", "bonjour_sock5_incoming_cb");

	xf->conn = g_object_ref(connection);
	g_socket_service_stop(xf->service);
	g_clear_object(&xf->service);

	purple_debug_info("bonjour", "Accepted SOCKS5 ft connection");
	input = g_io_stream_get_input_stream(G_IO_STREAM(xf->conn));

	g_input_stream_read_all_async(input, xf->rx_buf, 3, G_PRIORITY_DEFAULT,
	                              xf->cancellable,
	                              bonjour_sock5_read_client_version_cb, xfer);
}

static void
bonjour_bytestreams_init(PurpleXfer *xfer)
{
	XepXfer *xf;
	XepIq *iq;
	PurpleXmlNode *query, *streamhost;
	guint16 port;
	gchar *port_str;
	GList *local_ips;
	BonjourData *bd;
	GError *error = NULL;

	if (xfer == NULL) {
		return;
	}

	purple_debug_info("bonjour", "Bonjour-bytestreams-init.\n");
	xf = XEP_XFER(xfer);

	xf->service = g_socket_service_new();
	port = purple_socket_listener_add_any_inet_port(
	        G_SOCKET_LISTENER(xf->service), G_OBJECT(xfer), &error);
	if (port == 0) {
		purple_debug_error("bonjour",
		                   "Unable to open port for file transfer: %s",
		                   error->message);
		purple_xfer_cancel_local(xfer);
		g_error_free(error);
		return;
	}

	g_signal_connect(xf->service, "incoming",
	                 G_CALLBACK(bonjour_sock5_incoming_cb), NULL);

	bd = xf->data;

	iq = xep_iq_new(bd, XEP_IQ_SET, purple_xfer_get_remote_user(xfer), bonjour_get_jid(bd->xmpp_data->account), xf->sid);

	query = purple_xmlnode_new_child(iq->node, "query");
	purple_xmlnode_set_namespace(query, "http://jabber.org/protocol/bytestreams");
	purple_xmlnode_set_attrib(query, "sid", xf->sid);
	purple_xmlnode_set_attrib(query, "mode", "tcp");

	purple_xfer_set_local_port(xfer, port);

	local_ips = nice_interfaces_get_local_ips(FALSE);

	port_str = g_strdup_printf("%hu", port);
	while(local_ips) {
		streamhost = purple_xmlnode_new_child(query, "streamhost");
		purple_xmlnode_set_attrib(streamhost, "jid", xf->sid);
		purple_xmlnode_set_attrib(streamhost, "host", local_ips->data);
		purple_xmlnode_set_attrib(streamhost, "port", port_str);
		g_free(local_ips->data);
		local_ips = g_list_delete_link(local_ips, local_ips);
	}
	g_free(port_str);

	xep_iq_send_and_free(iq);
}

static void
bonjour_bytestreams_handle_failure(PurpleXfer *xfer, const gchar *error_message)
{
	XepXfer *xf = XEP_XFER(xfer);
	PurpleXmlNode *tmp_node;
	gboolean ret;

	purple_debug_error("bonjour", "Error connecting via SOCKS5 to %s - %s",
	                   xf->proxy_host, error_message);

	tmp_node = purple_xmlnode_get_next_twin(xf->streamhost);
	ret = __xep_bytestreams_parse(xf->pb, xfer, tmp_node, xf->iq_id);

	if (!ret) {
		xep_ft_si_reject(xf->data, xf->iq_id, purple_xfer_get_remote_user(xfer),
		                 "404", "cancel");
		/* Cancel the connection */
		purple_xfer_cancel_local(xfer);
	}
}

static void
bonjour_bytestreams_connect_cb(GObject *source, GAsyncResult *result,
                               gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	GIOStream *stream;
	GError *error = NULL;
	GSocket *socket;
	XepIq *iq;
	PurpleXmlNode *q_node, *tmp_node;
	BonjourData *bd;

	stream = g_proxy_connect_finish(G_PROXY(source), result, &error);
	if (stream == NULL) {
		if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
			purple_debug_error("bonjour",
			                   "Unable to connect to destination host: %s",
			                   error->message);
			bonjour_bytestreams_handle_failure(
			        xfer, "Unable to connect to destination host.");
		}

		g_clear_error(&error);
		return;
	}

	if (!G_IS_SOCKET_CONNECTION(stream)) {
		purple_debug_error("bonjour",
		                   "GProxy didn't return a GSocketConnection.");
		bonjour_bytestreams_handle_failure(
		        xfer, "GProxy didn't return a GSocketConnection.");
		g_object_unref(stream);
		return;
	}

	purple_debug_info("bonjour", "Connected successfully via SOCKS5, starting transfer.\n");

	bd = xf->data;

	/* Here, start the file transfer.*/

	/* Notify Initiator of Connection */
	iq = xep_iq_new(bd, XEP_IQ_RESULT, purple_xfer_get_remote_user(xfer), bonjour_get_jid(bd->xmpp_data->account), xf->iq_id);
	q_node = purple_xmlnode_new_child(iq->node, "query");
	purple_xmlnode_set_namespace(q_node, "http://jabber.org/protocol/bytestreams");
	tmp_node = purple_xmlnode_new_child(q_node, "streamhost-used");
	purple_xmlnode_set_attrib(tmp_node, "jid", xf->jid);
	xep_iq_send_and_free(iq);

	xf->conn = G_SOCKET_CONNECTION(stream);
	socket = g_socket_connection_get_socket(xf->conn);
	purple_xfer_start(xfer, g_socket_get_fd(socket), NULL, -1);
}

/* This is called when we connect to the SOCKS5 proxy server (through any
 * relevant account proxy)
 */
static void
bonjour_bytestreams_socks5_connect_to_host_cb(GObject *source,
                                              GAsyncResult *result,
                                              gpointer user_data)
{
	PurpleXfer *xfer = PURPLE_XFER(user_data);
	XepXfer *xf = XEP_XFER(xfer);
	GSocketConnection *conn;
	GProxy *proxy;
	GSocketAddress *addr;
	GInetSocketAddress *inet_addr;
	GSocketAddress *proxy_addr;
	PurpleBuddy *pb;
	gchar *hash_input;
	gchar *dstaddr;
	GError *error = NULL;

	conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source),
	                                              result, &error);
	if (conn == NULL) {
		if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
			purple_debug_error("bonjour",
			                   "Unable to connect to SOCKS5 host: %s",
			                   error->message);
			bonjour_bytestreams_handle_failure(
			        xfer, "Unable to connect to SOCKS5 host.");
		}

		g_clear_error(&error);
		return;
	}

	proxy = g_proxy_get_default_for_protocol("socks5");
	if (proxy == NULL) {
		purple_debug_error("bonjour", "SOCKS5 proxy backend missing.");
		bonjour_bytestreams_handle_failure(xfer,
		                                   "SOCKS5 proxy backend missing.");
		g_object_unref(conn);
		return;
	}

	addr = g_socket_connection_get_remote_address(conn, &error);
	if (addr == NULL) {
		purple_debug_error(
		        "bonjour",
		        "Unable to retrieve SOCKS5 host address from connection: %s",
		        error->message);
		bonjour_bytestreams_handle_failure(
		        xfer, "Unable to retrieve SOCKS5 host address from connection");
		g_object_unref(conn);
		g_object_unref(proxy);
		g_clear_error(&error);
		return;
	}

	pb = xf->pb;
	hash_input = g_strdup_printf("%s%s%s", xf->sid, purple_buddy_get_name(pb),
	                             bonjour_get_jid(purple_buddy_get_account(pb)));
	dstaddr = g_compute_checksum_for_string(G_CHECKSUM_SHA1, hash_input, -1);
	g_free(hash_input);

	purple_debug_info("bonjour", "Connecting to %s using SOCKS5 proxy %s:%d",
	                  dstaddr, xf->proxy_host, xf->proxy_port);

	inet_addr = G_INET_SOCKET_ADDRESS(addr);
	proxy_addr =
	        g_proxy_address_new(g_inet_socket_address_get_address(inet_addr),
	                            g_inet_socket_address_get_port(inet_addr),
	                            "socks5", dstaddr, 0, NULL, NULL);
	g_object_unref(inet_addr);

	g_proxy_connect_async(proxy, G_IO_STREAM(conn), G_PROXY_ADDRESS(proxy_addr),
	                      xf->cancellable, bonjour_bytestreams_connect_cb,
	                      xfer);
	g_object_unref(proxy_addr);
	g_object_unref(conn);
	g_object_unref(proxy);
	g_free(dstaddr);
}

static void
bonjour_bytestreams_connect(PurpleXfer *xfer)
{
	PurpleAccount *account = NULL;
	XepXfer *xf;
	GError *error = NULL;

	if (xfer == NULL) {
		return;
	}

	purple_debug_info("bonjour", "bonjour-bytestreams-connect.");

	xf = XEP_XFER(xfer);
	account = purple_buddy_get_account(xf->pb);

	xf->client = purple_gio_socket_client_new(account, &error);
	if (xf->client == NULL) {
		/* Cancel the connection */
		purple_debug_error("bonjour",
		                   "Failed to connect to SOCKS5 streamhost proxy: %s",
		                   error->message);
		g_clear_error(&error);
		xep_ft_si_reject(xf->data, xf->iq_id, purple_xfer_get_remote_user(xfer),
		                 "404", "cancel");
		purple_xfer_cancel_local(xfer);
		return;
	}

	purple_debug_info("bonjour", "Connecting to SOCKS5 proxy %s:%d",
	                  xf->proxy_host, xf->proxy_port);

	g_socket_client_connect_to_host_async(
	        xf->client, xf->proxy_host, xf->proxy_port, xf->cancellable,
	        bonjour_bytestreams_socks5_connect_to_host_cb, xfer);
}

static void
xep_xfer_init(XepXfer *xf)
{
	xf->cancellable = g_cancellable_new();
}

static void
xep_xfer_finalize(GObject *obj) {
	XepXfer *xf = XEP_XFER(obj);
	BonjourData *bd = (BonjourData*)xf->data;

	if(bd != NULL) {
		bd->xfer_lists = g_slist_remove(bd->xfer_lists, PURPLE_XFER(xf));
		purple_debug_misc("bonjour", "B free xfer from lists(%p).\n", bd->xfer_lists);
	}
	g_cancellable_cancel(xf->cancellable);
	g_clear_object(&xf->cancellable);
	g_clear_object(&xf->client);
	if (xf->service) {
		g_socket_service_stop(xf->service);
	}
	g_clear_object(&xf->service);
	g_clear_object(&xf->conn);

	g_free(xf->iq_id);
	g_free(xf->jid);
	g_free(xf->proxy_host);
	g_free(xf->buddy_ip);
	g_free(xf->sid);

	g_clear_pointer(&xf->streamhost, purple_xmlnode_free_tree);

	G_OBJECT_CLASS(xep_xfer_parent_class)->finalize(obj);
}

static void
xep_xfer_class_finalize(XepXferClass *klass) {

}

static void
xep_xfer_class_init(XepXferClass *klass) {
	GObjectClass *obj_class = G_OBJECT_CLASS(klass);
	PurpleXferClass *xfer_class = PURPLE_XFER_CLASS(klass);

	obj_class->finalize = xep_xfer_finalize;

	xfer_class->init = bonjour_xfer_init;
	xfer_class->request_denied = bonjour_xfer_request_denied;
	xfer_class->cancel_recv = bonjour_xfer_cancel_recv;
	xfer_class->cancel_send = bonjour_xfer_cancel_send;
	xfer_class->end = bonjour_xfer_end;
}

void
xep_xfer_register(GTypeModule *module) {
	xep_xfer_register_type(module);
}