Index: protocols/jabber/Makefile
===================================================================
--- protocols/jabber/Makefile	(revision 608f8cf652d0c443ef551ac979bd46096b361663)
+++ protocols/jabber/Makefile	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -10,5 +10,5 @@
 
 # [SH] Program variables
-objects = conference.o io.o iq.o jabber.o jabber_util.o message.o presence.o sasl.o xmltree.o
+objects = conference.o io.o iq.o jabber.o jabber_util.o message.o presence.o sasl.o xmltree.o si.o stream.o
 
 CFLAGS += -Wall
Index: protocols/jabber/iq.c
===================================================================
--- protocols/jabber/iq.c	(revision 608f8cf652d0c443ef551ac979bd46096b361663)
+++ protocols/jabber/iq.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -104,4 +104,7 @@
 			                           XMLNS_CHATSTATES,
 			                           XMLNS_MUC,
+						   XMLNS_SI,
+						   XMLNS_BYTESTREAMS,
+						   XMLNS_FILETRANSFER,
 			                           NULL };
 			const char **f;
@@ -123,5 +126,5 @@
 		{
 			xt_free_node( reply );
-			reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel" );
+			reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel", NULL );
 			pack = 0;
 		}
@@ -129,16 +132,18 @@
 	else if( strcmp( type, "set" ) == 0 )
 	{
-		if( !( c = xt_find_node( node->children, "query" ) ) ||
+		if(  ( c = xt_find_node( node->children, "si" ) ) &&
+		     ( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_SI ) == 0 ) )
+		{
+			return jabber_si_handle_request( ic, node, c );
+		} else if( !( c = xt_find_node( node->children, "query" ) ) ||
 		    !( s = xt_find_attr( c, "xmlns" ) ) )
 		{
 			imcb_log( ic, "WARNING: Received incomplete IQ-%s packet", type );
 			return XT_HANDLED;
-		}
-		
+		} else if( strcmp( s, XMLNS_ROSTER ) == 0 )
+		{
 		/* This is a roster push. XMPP servers send this when someone
 		   was added to (or removed from) the buddy list. AFAIK they're
 		   sent even if we added this buddy in our own session. */
-		if( strcmp( s, XMLNS_ROSTER ) == 0 )
-		{
 			int bare_len = strlen( ic->acc->user );
 			
@@ -157,12 +162,15 @@
 				
 				xt_free_node( reply );
-				reply = jabber_make_error_packet( node, "not-allowed", "cancel" );
+				reply = jabber_make_error_packet( node, "not-allowed", "cancel", NULL );
 				pack = 0;
 			}
-		}
-		else
+		} else if( strcmp( s, XMLNS_BYTESTREAMS ) == 0 )
+		{
+		     	/* Bytestream Request (stage 2 of file transfer) */
+			return jabber_bs_request( ic, node, c );
+		} else
 		{
 			xt_free_node( reply );
-			reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel" );
+			reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel", NULL );
 			pack = 0;
 		}
Index: protocols/jabber/jabber.h
===================================================================
--- protocols/jabber/jabber.h	(revision 608f8cf652d0c443ef551ac979bd46096b361663)
+++ protocols/jabber/jabber.h	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -81,4 +81,6 @@
 	GHashTable *node_cache;
 	GHashTable *buddies;
+
+	GSList *filetransfers;
 };
 
@@ -122,4 +124,28 @@
 	char *my_full_jid; /* Separate copy because of case sensitivity. */
 	struct jabber_buddy *me;
+};
+
+struct jabber_transfer
+{
+	/* bitlbee's handle for this transfer */
+	file_transfer_t *ft;
+
+	/* the stream's private handle */
+	gpointer streamhandle;
+
+	struct im_connection *ic;
+
+	int watch_in;
+	int watch_out;
+
+	char *ini_jid;
+	char *tgt_jid;
+	char *iq_id;
+	char *sid;
+	int accepted;
+
+	size_t bytesread, byteswritten;
+	int receiver_overflow;
+	int fd;
 };
 
@@ -149,13 +175,19 @@
 
 /* Some supported extensions/legacy stuff */
-#define XMLNS_AUTH         "jabber:iq:auth"                     /* XEP-0078 */
-#define XMLNS_VERSION      "jabber:iq:version"                  /* XEP-0092 */
-#define XMLNS_TIME         "jabber:iq:time"                     /* XEP-0090 */
-#define XMLNS_VCARD        "vcard-temp"                         /* XEP-0054 */
-#define XMLNS_DELAY        "jabber:x:delay"                     /* XEP-0091 */
-#define XMLNS_CHATSTATES   "http://jabber.org/protocol/chatstates"  /* 0085 */
-#define XMLNS_DISCOVER     "http://jabber.org/protocol/disco#info"  /* 0030 */
-#define XMLNS_MUC          "http://jabber.org/protocol/muc"     /* XEP-0045 */
-#define XMLNS_MUC_USER     "http://jabber.org/protocol/muc#user"/* XEP-0045 */
+#define XMLNS_AUTH         "jabber:iq:auth"                                      /* XEP-0078 */
+#define XMLNS_VERSION      "jabber:iq:version"                                   /* XEP-0092 */
+#define XMLNS_TIME         "jabber:iq:time"                                      /* XEP-0090 */
+#define XMLNS_VCARD        "vcard-temp"                                          /* XEP-0054 */
+#define XMLNS_DELAY        "jabber:x:delay"                                      /* XEP-0091 */
+#define XMLNS_XDATA        "jabber:x:data"                                       /* XEP-0004 */
+#define XMLNS_CHATSTATES   "http://jabber.org/protocol/chatstates"               /* XEP-0085 */
+#define XMLNS_DISCOVER     "http://jabber.org/protocol/disco#info"               /* XEP-0030 */
+#define XMLNS_MUC          "http://jabber.org/protocol/muc"                      /* XEP-0045 */
+#define XMLNS_MUC_USER     "http://jabber.org/protocol/muc#user"                 /* XEP-0045 */
+#define XMLNS_FEATURE      "http://jabber.org/protocol/feature-neg"              /* XEP-0020 */
+#define XMLNS_SI           "http://jabber.org/protocol/si"                       /* XEP-0095 */
+#define XMLNS_FILETRANSFER "http://jabber.org/protocol/si/profile/file-transfer" /* XEP-0096 */
+#define XMLNS_BYTESTREAMS  "http://jabber.org/protocol/bytestreams"              /* XEP-0065 */
+#define XMLNS_IBB          "http://jabber.org/protocol/ibb"                      /* XEP-0047 */
 
 /* iq.c */
@@ -168,4 +200,10 @@
 int jabber_remove_from_roster( struct im_connection *ic, char *handle );
 
+/* si.c */
+int jabber_si_handle_request( struct im_connection *ic, struct xt_node *node, struct xt_node *sinode);
+
+/* stream.c */
+int jabber_bs_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode);
+
 /* message.c */
 xt_status jabber_pkt_message( struct xt_node *node, gpointer data );
@@ -180,5 +218,5 @@
 char *set_eval_tls( set_t *set, char *value );
 struct xt_node *jabber_make_packet( char *name, char *type, char *to, struct xt_node *children );
-struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type );
+struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type, char *err_code );
 void jabber_cache_add( struct im_connection *ic, struct xt_node *node, jabber_cache_event func );
 struct xt_node *jabber_cache_get( struct im_connection *ic, char *id );
Index: protocols/jabber/jabber_util.c
===================================================================
--- protocols/jabber/jabber_util.c	(revision 608f8cf652d0c443ef551ac979bd46096b361663)
+++ protocols/jabber/jabber_util.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -97,5 +97,5 @@
 }
 
-struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type )
+struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type, char *err_code )
 {
 	struct xt_node *node, *c;
@@ -109,4 +109,8 @@
 	c = xt_new_node( "error", NULL, c );
 	xt_add_attr( c, "type", err_type );
+	
+	/* Add the error code, if present */
+	if (err_code)
+		xt_add_attr( c, "code", err_code );
 	
 	/* To make the actual error packet, we copy the original packet and
Index: protocols/jabber/si.c
===================================================================
--- protocols/jabber/si.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
+++ protocols/jabber/si.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -0,0 +1,246 @@
+/***************************************************************************\
+*                                                                           *
+*  BitlBee - An IRC to IM gateway                                           *
+*  Jabber module - SI packets                                               *
+*                                                                           *
+*  Copyright 2007 Uli Meis <a.sporto+bee@gmail.com>                         *
+*                                                                           *
+*  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 "jabber.h"
+#include "sha1.h"
+
+void jabber_si_answer_request( file_transfer_t *ft );
+
+/* imcb callback */
+void jabber_si_free_transfer( file_transfer_t *ft)
+{
+	struct jabber_transfer *tf = ft->data;
+	struct jabber_data *jd = tf->ic->proto_data;
+
+	if ( tf->watch_in )
+		b_event_remove( tf->watch_in );
+
+	jd->filetransfers = g_slist_remove( jd->filetransfers, tf );
+
+	if( tf->fd )
+	{
+		close( tf->fd );
+		tf->fd = 0;
+	}
+
+	g_free( tf->ini_jid );
+	g_free( tf->tgt_jid );
+	g_free( tf->iq_id );
+	g_free( tf->sid );
+}
+
+/* imcb callback */
+void jabber_si_finished( file_transfer_t *ft )
+{
+	struct jabber_transfer *tf = ft->data;
+
+	imcb_log( tf->ic, "File %s transferred successfully!" , ft->file_name );
+}
+
+/* imcb callback */
+void jabber_si_canceled( file_transfer_t *ft, char *reason )
+{
+	struct jabber_transfer *tf = ft->data;
+	struct xt_node *reply, *iqnode;
+
+	if( tf->accepted )
+		return;
+	
+	iqnode = jabber_make_packet( "iq", "error", tf->ini_jid, NULL );
+	xt_add_attr( iqnode, "id", tf->iq_id );
+	reply = jabber_make_error_packet( iqnode, "forbidden", "cancel", "403" );
+	xt_free_node( iqnode );
+	
+	if( !jabber_write_packet( tf->ic, reply ) )
+		imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
+	xt_free_node( reply );
+
+}
+
+/*
+ * First function that gets called when a file transfer request comes in.
+ * A lot to parse.
+ *
+ * We choose a stream type from the options given by the initiator.
+ * Then we wait for imcb to call the accept or cancel callbacks.
+ */
+int jabber_si_handle_request( struct im_connection *ic, struct xt_node *node, struct xt_node *sinode)
+{
+	struct xt_node *c, *d, *reply;
+	char *sid, *ini_jid, *tgt_jid, *iq_id, *s, *ext_jid;
+	struct jabber_buddy *bud;
+	int requestok = FALSE;
+	char *name;
+	size_t size;
+	struct jabber_transfer *tf;
+	struct jabber_data *jd = ic->proto_data;
+	file_transfer_t *ft;
+	
+	/* All this means we expect something like this: ( I think )
+	 * <iq from=... to=... id=...>
+	 * 	<si id=id xmlns=si profile=ft>
+	 * 		<file xmlns=ft/>
+	 * 		<feature xmlns=feature>
+	 * 			<x xmlns=xdata type=submit>
+	 * 				<field var=stream-method>
+	 *
+	 */
+	if( !( ini_jid 		= xt_find_attr(   node, "from" ) 			) ||
+	    !( tgt_jid 		= xt_find_attr(   node, "to" ) 				) ||
+	    !( iq_id 		= xt_find_attr(   node, "id" ) 				) ||
+	    !( sid 		= xt_find_attr( sinode, "id" ) 				) ||
+	    !( strcmp( xt_find_attr( sinode, "profile" ), XMLNS_FILETRANSFER ) == 0	) ||
+	    !( d 		= xt_find_node( sinode->children, "file" ) 		) ||
+	    !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FILETRANSFER ) == 0 		) ||
+	    !( name 		= xt_find_attr( d, "name" ) 				) ||
+	    !( size 		= (size_t) atoll( xt_find_attr( d, "size" ) ) 		) ||
+	    !( d 		= xt_find_node( sinode->children, "feature" ) 		) ||
+	    !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FEATURE ) == 0 		) ||
+	    !( d 		= xt_find_node( d->children, "x" ) 			) ||
+	    !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_XDATA ) == 0 			) ||
+	    !( strcmp( xt_find_attr( d, "type" ), "form" ) == 0 			) ||
+	    !( d 		= xt_find_node( d->children, "field" ) 			) ||
+	    !( strcmp( xt_find_attr( d, "var" ), "stream-method" ) == 0 		) )
+	{
+		imcb_log( ic, "WARNING: Received incomplete Stream Initiation request" );
+	} else
+	{
+		/* Check if we support one of the options */
+
+		c = d->children;
+		while( ( c = xt_find_node( c, "option" ) ) )
+			if( 	( d = xt_find_node( c->children, "value" ) ) &&
+				( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) )
+			{
+				requestok = TRUE;
+				break;
+			}
+	}
+	
+	if ( requestok )
+	{
+		/* Figure out who the transfer should come frome... */
+
+		if( ( s = strchr( ini_jid, '/' ) ) )
+		{
+			if( ( bud = jabber_buddy_by_jid( ic, ini_jid, GET_BUDDY_EXACT ) ) )
+			{
+				bud->last_act = time( NULL );
+				ext_jid = bud->ext_jid ? : bud->bare_jid;
+			}
+			else
+				*s = 0; /* We need to generate a bare JID now. */
+		}
+
+		if( !( ft = imcb_file_send_start( ic, ext_jid, name, size ) ) )
+		{ 
+			imcb_log( ic, "WARNING: Error handling transfer request from %s", ini_jid);
+			requestok = FALSE;
+		}
+
+		*s = '/';
+	} else 
+		imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
+
+	if ( !requestok )
+	{ 
+		reply = jabber_make_error_packet( node, "item-not-found", "cancel", NULL );
+		if (!jabber_write_packet( ic, reply ))
+			imcb_log( ic, "WARNING: Error generating reply to file transfer request" );
+		xt_free_node( reply );
+		return XT_HANDLED;
+	}
+
+	/* Request is fine. */
+
+	imcb_log( ic, "File transfer request from %s for %s (%zd kb). ", xt_find_attr( node, "from" ), name, size/1024 );
+
+	imcb_log( ic, "Accept the DCC transfer if you'd like the file. If you don't, issue the 'transfers reject' command.");
+
+	tf = g_new0( struct jabber_transfer, 1 );
+
+	tf->ini_jid = g_strdup( ini_jid );
+	tf->tgt_jid = g_strdup( tgt_jid );
+	tf->iq_id = g_strdup( iq_id );
+	tf->sid = g_strdup( sid );
+	tf->ic = ic;
+	tf->ft = ft;
+	tf->ft->data = tf;
+	tf->ft->accept = jabber_si_answer_request;
+	tf->ft->free = jabber_si_free_transfer;
+	tf->ft->finished = jabber_si_finished;
+	tf->ft->canceled = jabber_si_canceled;
+
+	jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
+
+	return XT_HANDLED;
+}
+
+/*
+ * imcb called the accept callback which probably means that the user accepted this file transfer.
+ * We send our response to the initiator.
+ * In the next step, the initiator will send us a request for the given stream type.
+ * (currently that can only be a SOCKS5 bytestream)
+ */
+void jabber_si_answer_request( file_transfer_t *ft ) {
+	struct jabber_transfer *tf = ft->data;
+	struct xt_node *node, *sinode, *reply;
+
+	/* generate response, start with the SI tag */
+	sinode = xt_new_node( "si", NULL, NULL );
+	xt_add_attr( sinode, "xmlns", XMLNS_SI );
+	xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
+	xt_add_attr( sinode, "id", tf->sid );
+
+	/* now the file tag */
+	node = xt_new_node( "file", NULL, NULL );
+	xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
+
+	xt_add_child( sinode, node );
+
+	/* and finally the feature tag */
+	node = xt_new_node( "field", NULL, NULL );
+	xt_add_attr( node, "var", "stream-method" );
+	xt_add_attr( node, "type", "list-single" );
+
+	/* Currently all we can do. One could also implement in-band (IBB) */
+	xt_add_child( node, xt_new_node( "value", XMLNS_BYTESTREAMS, NULL ) );
+
+	node = xt_new_node( "x", NULL, node );
+	xt_add_attr( node, "xmlns", XMLNS_XDATA );
+	xt_add_attr( node, "type", "submit" );
+
+	node = xt_new_node( "feature", NULL, node );
+	xt_add_attr( node, "xmlns", XMLNS_FEATURE );
+
+	xt_add_child( sinode, node );
+
+	reply = jabber_make_packet( "iq", "result", tf->ini_jid, sinode );
+	xt_add_attr( reply, "id", tf->iq_id );
+	
+	if( !jabber_write_packet( tf->ic, reply ) )
+		imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
+	else
+		tf->accepted = TRUE;
+	xt_free_node( reply );
+}
Index: protocols/jabber/stream.c
===================================================================
--- protocols/jabber/stream.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
+++ protocols/jabber/stream.c	(revision 2c2df7dd91930345a9b22a8bb61327d1dcc7e3d5)
@@ -0,0 +1,593 @@
+/***************************************************************************\
+*                                                                           *
+*  BitlBee - An IRC to IM gateway                                           *
+*  Jabber module - stream handling                                          *
+*                                                                           *
+*  Copyright 2007 Uli Meis <a.sporto+bee@gmail.com>                         *
+*                                                                           *
+*  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 "jabber.h"
+#include "sha1.h"
+#include <poll.h>
+
+/* Some structs for the SOCKS5 handshake */
+
+struct bs_handshake_data {
+
+	struct jabber_transfer *tf;
+
+	/* <query> element and <streamhost> elements */
+	struct xt_node *qnode, *shnode;
+
+	enum 
+	{ 
+		BS_PHASE_CONNECT, 
+		BS_PHASE_CONNECTED, 
+		BS_PHASE_REQUEST, 
+		BS_PHASE_REPLY, 
+		BS_PHASE_REPLY_HAVE_LEN 
+	} phase;
+
+	/* SHA1( SID + Initiator JID + Target JID) */
+	char *pseudoadr;
+
+	void (*parentfree) ( file_transfer_t *ft );
+
+	gint connect_timeout;
+};
+
+struct socks5_hdr
+{
+	unsigned char ver;
+	union
+	{
+		unsigned char cmd;
+		unsigned char rep;
+	} cmdrep;
+	unsigned char rsv;
+	unsigned char atyp;
+};
+
+struct socks5_message
+{
+	struct socks5_hdr hdr;
+	unsigned char addrlen;
+	unsigned char address[64];
+}; 
+
+/* connect() timeout in seconds. */
+#define JABBER_BS_CONTIMEOUT 15
+
+/* shouldn't matter if it's mostly too much, kernel's smart about that
+ * and will only reserve some address space */
+#define JABBER_BS_BUFSIZE 65536
+
+gboolean jabber_bs_handshake( gpointer data, gint fd, b_input_condition cond );
+
+gboolean jabber_bs_handshake_abort( struct bs_handshake_data *bhd, char *format, ... );
+
+void jabber_bs_answer_request( struct bs_handshake_data *bhd );
+
+gboolean jabber_bs_read( gpointer data, gint fd, b_input_condition cond );
+
+void jabber_bs_out_of_data( file_transfer_t *ft );
+
+void jabber_bs_canceled( file_transfer_t *ft , char *reason );
+
+
+void jabber_bs_free_transfer( file_transfer_t *ft) {
+	struct jabber_transfer *tf = ft->data;
+	struct bs_handshake_data *bhd = tf->streamhandle;
+	void (*parentfree) ( file_transfer_t *ft );
+
+	parentfree = bhd->parentfree;
+
+	if ( tf->watch_in )
+		b_event_remove( tf->watch_in );
+	
+	if( tf->watch_out )
+		b_event_remove( tf->watch_out );
+	
+	g_free( bhd->pseudoadr );
+	xt_free_node( bhd->qnode );
+	g_free( bhd );
+
+	parentfree( ft );
+}
+
+/*
+ * Parses an incoming bytestream request and calls jabber_bs_handshake on success.
+ */
+int jabber_bs_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode)
+{
+	char *sid, *ini_jid, *tgt_jid, *mode, *iq_id;
+	struct jabber_data *jd = ic->proto_data;
+	struct jabber_transfer *tf = NULL;
+	GSList *tflist;
+	struct bs_handshake_data *bhd;
+
+	sha1_state_t sha;
+	char hash_hex[41];
+	unsigned char hash[20];
+	int i;
+	
+	if( !(iq_id   = xt_find_attr( node, "id" ) ) ||
+	    !(ini_jid = xt_find_attr( node, "from" ) ) ||
+	    !(tgt_jid = xt_find_attr( node, "to" ) ) ||
+	    !(sid     = xt_find_attr( qnode, "sid" ) ) )
+	{
+		imcb_log( ic, "WARNING: Received incomplete SI bytestream request");
+		return XT_HANDLED;
+	}
+
+	if( ( mode = xt_find_attr( qnode, "mode" ) ) &&
+	      ( strcmp( mode, "tcp" ) != 0 ) ) 
+	{
+		imcb_log( ic, "WARNING: Received SI Request for unsupported bytestream mode %s", xt_find_attr( qnode, "mode" ) );
+		return XT_HANDLED;
+	}
+
+	/* Let's see if we can find out what this bytestream should be for... */
+
+	for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
+	{
+		struct jabber_transfer *tft = tflist->data;
+		if( ( strcmp( tft->sid, sid ) == 0 ) &&
+		    ( strcmp( tft->ini_jid, ini_jid ) == 0 ) &&
+		    ( strcmp( tft->tgt_jid, tgt_jid ) == 0 ) )
+		{
+		    	tf = tft;
+			break;
+		}
+	}
+
+	if (!tf) 
+	{
+		imcb_log( ic, "WARNING: Received bytestream request from %s that doesn't match an SI request", ini_jid );
+		return XT_HANDLED;
+	}
+
+	/* iq_id and canceled can be reused since SI is done */
+	g_free( tf->iq_id );
+	tf->iq_id = g_strdup( iq_id );
+
+	tf->ft->canceled = jabber_bs_canceled;
+
+	/* SHA1( SID + Initiator JID + Target JID ) is given to the streamhost which it will match against the initiator's value */
+	sha1_init( &sha );
+	sha1_append( &sha, (unsigned char*) sid, strlen( sid ) );
+	sha1_append( &sha, (unsigned char*) ini_jid, strlen( ini_jid ) );
+	sha1_append( &sha, (unsigned char*) tgt_jid, strlen( tgt_jid ) );
+	sha1_finish( &sha, hash );
+	
+	for( i = 0; i < 20; i ++ )
+		sprintf( hash_hex + i * 2, "%02x", hash[i] );
+		
+	bhd = g_new0( struct bs_handshake_data, 1 );
+	bhd->tf = tf;
+	bhd->qnode = xt_dup( qnode );
+	bhd->shnode = bhd->qnode->children;
+	bhd->phase = BS_PHASE_CONNECT;
+	bhd->pseudoadr = g_strdup( hash_hex );
+	tf->streamhandle = bhd;
+	bhd->parentfree = tf->ft->free;
+	tf->ft->free = jabber_bs_free_transfer;
+
+	jabber_bs_handshake( bhd, 0, 0 ); 
+
+	return XT_HANDLED;
+}
+
+/* 
+ * This function is scheduled in bs_handshake via b_timeout_add after a (non-blocking) connect().
+ */
+gboolean jabber_bs_connect_timeout( gpointer data, gint fd, b_input_condition cond )
+{
+	struct bs_handshake_data *bhd = data;
+
+	bhd->connect_timeout = 0;
+
+	jabber_bs_handshake_abort( bhd, "no connection after %d seconds", JABBER_BS_CONTIMEOUT );
+
+	return FALSE;
+}
+
+/*
+ * This is what a protocol handshake can look like in cooperative multitasking :)
+ * Might be confusing at first because it's called from different places and is recursing.
+ * (places being the event thread, bs_request, bs_handshake_abort, and itself)
+ *
+ * All in all, it turned out quite nice :)
+ */
+gboolean jabber_bs_handshake( gpointer data, gint fd, b_input_condition cond )
+{
+
+/* very useful */
+#define ASSERTSOCKOP(op, msg) \
+	if( (op) == -1 ) \
+		return jabber_bs_handshake_abort( bhd , msg ": %s", strerror( errno ) );
+
+	struct bs_handshake_data *bhd = data;
+	struct pollfd pfd = { .fd = fd, .events = POLLHUP|POLLERR };
+	short revents;
+	
+	if ( bhd->connect_timeout )
+	{
+		b_event_remove( bhd->connect_timeout );
+		bhd->connect_timeout = 0;
+	}
+
+	
+	/* we need the real io condition */
+	if ( poll( &pfd, 1, 0 ) == -1 )
+	{
+		imcb_log( bhd->tf->ic, "poll() failed, weird!" );
+		revents = 0;
+	};
+
+	revents = pfd.revents;
+
+	if( revents & POLLERR )
+	{
+		int sockerror;
+		socklen_t errlen = sizeof( sockerror );
+
+		if ( getsockopt( fd, SOL_SOCKET, SO_ERROR, &sockerror, &errlen ) )
+			return jabber_bs_handshake_abort( bhd, "getsockopt() failed, unknown socket error during SOCKS5 handshake (weird!)" );
+
+		if ( bhd->phase == BS_PHASE_CONNECTED )
+			return jabber_bs_handshake_abort( bhd, "connect() failed: %s", strerror( sockerror ) );
+
+		return jabber_bs_handshake_abort( bhd, "Socket error during SOCKS5 handshake(weird!): %s", strerror( sockerror ) );
+	}
+
+	if( revents & POLLHUP )
+		return jabber_bs_handshake_abort( bhd, "Remote end closed connection" );
+	
+
+	switch( bhd->phase ) 
+	{
+	case BS_PHASE_CONNECT:
+		{
+			struct xt_node *c;
+			char *host, *port;
+			struct addrinfo hints, *rp;
+
+			if( ( c = bhd->shnode = xt_find_node( bhd->shnode, "streamhost" ) ) &&
+			    ( port = xt_find_attr( c, "port" ) ) &&
+			    ( host = xt_find_attr( c, "host" ) ) &&
+			    xt_find_attr( c, "jid" ) )
+			{
+				memset( &hints, 0, sizeof( struct addrinfo ) );
+				hints.ai_socktype = SOCK_STREAM;
+
+				if ( getaddrinfo( host, port, &hints, &rp ) != 0 )
+					return jabber_bs_handshake_abort( bhd, "getaddrinfo() failed: %s", strerror( errno ) );
+
+				ASSERTSOCKOP( bhd->tf->fd = fd = socket( rp->ai_family, rp->ai_socktype, 0 ), "Opening socket" );
+
+				sock_make_nonblocking( fd );
+
+				imcb_log( bhd->tf->ic, "Transferring file %s: Connecting to streamhost %s:%s", bhd->tf->ft->file_name, host, port );
+
+				if( ( connect( fd, rp->ai_addr, rp->ai_addrlen ) == -1 ) &&
+				    ( errno != EINPROGRESS ) )
+					return jabber_bs_handshake_abort( bhd , "connect() failed: %s", strerror( errno ) );
+
+				freeaddrinfo( rp );
+
+				bhd->phase = BS_PHASE_CONNECTED;
+				
+				bhd->tf->watch_out = b_input_add( fd, GAIM_INPUT_WRITE, jabber_bs_handshake, bhd );
+
+				/* since it takes forever(3mins?) till connect() fails on itself we schedule a timeout */
+				bhd->connect_timeout = b_timeout_add( JABBER_BS_CONTIMEOUT * 1000, jabber_bs_connect_timeout, bhd );
+
+				bhd->tf->watch_in = 0;
+				return FALSE;
+			} else
+				return jabber_bs_handshake_abort( bhd, c ? "incomplete streamhost entry: host=%s port=%s jid=%s" : NULL,
+								  host, port, xt_find_attr( c, "jid" ) );
+		}
+	case BS_PHASE_CONNECTED:
+		{
+			struct {
+				unsigned char ver;
+				unsigned char nmethods;
+				unsigned char method;
+			} socks5_hello = {
+				.ver = 5,
+				.nmethods = 1,
+				.method = 0x00 /* no auth */
+				/* one could also implement username/password. If you know
+				 * a jabber client or proxy that actually does it, tell me.
+				 */
+			};
+			
+			ASSERTSOCKOP( send( fd, &socks5_hello, sizeof( socks5_hello ) , 0 ), "Sending auth request" );
+
+			bhd->phase = BS_PHASE_REQUEST;
+
+			bhd->tf->watch_in = b_input_add( fd, GAIM_INPUT_READ, jabber_bs_handshake, bhd );
+
+			bhd->tf->watch_out = 0;
+			return FALSE;
+		}
+	case BS_PHASE_REQUEST:
+		{
+			struct socks5_message socks5_connect = 
+			{
+				.hdr =
+				{
+					.ver = 5,
+					.cmdrep.cmd = 0x01,
+					.rsv = 0,
+					.atyp = 0x03
+				},
+				.addrlen = strlen( bhd->pseudoadr )
+			};
+			int ret;
+			char buf[2];
+
+			/* If someone's trying to be funny and sends only one byte at a time we'll fail :) */
+			ASSERTSOCKOP( ret = recv( fd, buf, 2, 0 ) , "Receiving auth reply" );
+
+			if( !( ret == 2 ) ||
+			    !( buf[0] == 5 ) ||
+			    !( buf[1] == 0 ) )
+				return jabber_bs_handshake_abort( bhd, "Auth not accepted by streamhost (reply: len=%d, ver=%d, status=%d)",
+									ret, buf[0], buf[1] );
+
+			/* copy hash into connect message */
+			memcpy( socks5_connect.address, bhd->pseudoadr, socks5_connect.addrlen );
+
+			/* after the address comes the port, which is always 0 */
+			memset( socks5_connect.address + socks5_connect.addrlen, 0, sizeof( in_port_t ) );
+
+			ASSERTSOCKOP( send( fd, &socks5_connect, sizeof( struct socks5_hdr ) + 1 + socks5_connect.addrlen + sizeof( in_port_t ), 0 ) , "Sending SOCKS5 Connect" );
+
+			bhd->phase = BS_PHASE_REPLY;
+
+			return TRUE;
+		}
+	case BS_PHASE_REPLY:
+	case BS_PHASE_REPLY_HAVE_LEN:
+		{
+			/* we have to wait till we have the address length, then we know how much data is left
+			 * (not that we'd actually care about that data, but we need to eat it all up anyway)
+			 */
+			struct socks5_message socks5_reply;
+			int ret;
+			int expectedbytes = 
+				sizeof( struct socks5_hdr ) + 1 + 
+				( bhd->phase == BS_PHASE_REPLY_HAVE_LEN ? socks5_reply.addrlen + sizeof( in_port_t ) : 0 );
+
+			/* notice the peek, we're doing this till enough is there */
+			ASSERTSOCKOP( ret = recv( fd, &socks5_reply, expectedbytes, MSG_PEEK ) , "Peeking for SOCKS5 CONNECT reply" );
+
+			if ( ret == 0 )
+				return jabber_bs_handshake_abort( bhd , "peer has shutdown connection" );
+
+			/* come again */
+			if ( ret < expectedbytes )
+				return TRUE;
+
+			if ( bhd->phase == BS_PHASE_REPLY )
+			{
+				if( !( socks5_reply.hdr.ver == 5 ) ||
+				    !( socks5_reply.hdr.cmdrep.rep == 0 ) ||
+				    !( socks5_reply.hdr.atyp == 3 ) ||
+				    !( socks5_reply.addrlen <= 62 ) ) /* should also be 40, but who cares as long as all fits in the buffer... */
+					return jabber_bs_handshake_abort( bhd, "SOCKS5 CONNECT failed (reply: ver=%d, rep=%d, atyp=%d, addrlen=%d", 
+						socks5_reply.hdr.ver,
+						socks5_reply.hdr.cmdrep.rep,
+						socks5_reply.hdr.atyp,
+						socks5_reply.addrlen);
+
+				/* and again for the rest */
+				bhd->phase = BS_PHASE_REPLY_HAVE_LEN;
+				
+				/* since it's very likely that the rest is there as well, 
+				 * let's not wait for the event loop to call us again */
+				return jabber_bs_handshake( bhd , fd, 0 );
+			}
+
+			/* got it all, remove it from the queue */
+			ASSERTSOCKOP( ret = recv( fd, &socks5_reply, expectedbytes, 0 ) , "Dequeueing MSG_PEEK'ed data after SOCKS5 CONNECT" );
+
+			/* this shouldn't happen */
+			if ( ret < expectedbytes )
+				return jabber_bs_handshake_abort( bhd, "internal error, couldn't dequeue MSG_PEEK'ed data after SOCKS5 CONNECT" );
+
+			/* we're actually done now... */
+
+			jabber_bs_answer_request( bhd );
+
+			bhd->tf->watch_in = 0;
+			return FALSE;
+		}
+	default:
+		/* BUG */
+		imcb_log( bhd->tf->ic, "BUG in file transfer code: undefined handshake phase" );
+
+		bhd->tf->watch_in = 0;
+		return FALSE;
+	}
+#undef ASSERTSOCKOP
+#undef JABBER_BS_ERR_CONDS
+}
+
+/*
+ * If the handshake failed we can try the next streamhost, if there is one.
+ * An intelligent sender would probably specify himself as the first streamhost and
+ * a proxy as the second (Kopete is an example here). That way, a (potentially) 
+ * slow proxy is only used if neccessary.
+ */
+gboolean jabber_bs_handshake_abort( struct bs_handshake_data *bhd, char *format, ... )
+{
+	struct jabber_transfer *tf = bhd->tf;
+	struct xt_node *reply, *iqnode;
+
+	if( bhd->shnode ) 
+	{
+		if( format ) {
+			va_list params;
+			va_start( params, format );
+			char error[128];
+
+			if( vsnprintf( error, 128, format, params ) < 0 )
+				sprintf( error, "internal error parsing error string (BUG)" );
+			va_end( params );
+
+			imcb_log( tf->ic, "Transferring file %s: connection to streamhost %s:%s failed (%s)", 
+				  tf->ft->file_name, 
+				  xt_find_attr( bhd->shnode, "host" ),
+				  xt_find_attr( bhd->shnode, "port" ),
+				  error );
+		}
+
+		/* Alright, this streamhost failed, let's try the next... */
+		bhd->phase = BS_PHASE_CONNECT;
+		bhd->shnode = bhd->shnode->next;
+		
+		/* the if is not neccessary but saves us one recursion */
+		if( bhd->shnode )
+			return jabber_bs_handshake( bhd, 0, 0 );
+	}
+
+	/* out of stream hosts */
+
+	iqnode = jabber_make_packet( "iq", "result", tf->ini_jid, NULL );
+	reply = jabber_make_error_packet( iqnode, "item-not-found", "cancel" , "404" );
+	xt_free_node( iqnode );
+
+	xt_add_attr( reply, "id", tf->iq_id );
+		
+	if( !jabber_write_packet( tf->ic, reply ) )
+		imcb_log( tf->ic, "WARNING: Error transmitting bytestream response" );
+	xt_free_node( reply );
+
+	imcb_file_canceled( tf->ft, "couldn't connect to any streamhosts" );
+
+	bhd->tf->watch_in = 0;
+	return FALSE;
+}
+
+/* 
+ * After the SOCKS5 handshake succeeds we need to inform the initiator which streamhost we chose.
+ * If he is the streamhost himself, he might already know that. However, if it's a proxy,
+ * the initiator will have to make a connection himself.
+ */
+void jabber_bs_answer_request( struct bs_handshake_data *bhd )
+{
+	struct jabber_transfer *tf = bhd->tf;
+	struct xt_node *reply;
+
+	imcb_log( tf->ic, "Transferring file %s: established SOCKS5 connection to %s:%s", 
+		  tf->ft->file_name, 
+		  xt_find_attr( bhd->shnode, "host" ),
+		  xt_find_attr( bhd->shnode, "port" ) );
+
+	tf->ft->data = tf;
+	tf->ft->started = time( NULL );
+	tf->watch_in = b_input_add( tf->fd, GAIM_INPUT_READ, jabber_bs_read, tf );
+	tf->ft->out_of_data = jabber_bs_out_of_data;
+
+	reply = xt_new_node( "streamhost-used", NULL, NULL );
+	xt_add_attr( reply, "jid", xt_find_attr( bhd->shnode, "jid" ) );
+
+	reply = xt_new_node( "query", NULL, reply );
+	xt_add_attr( reply, "xmlns", XMLNS_BYTESTREAMS );
+
+	reply = jabber_make_packet( "iq", "result", tf->ini_jid, reply );
+
+	xt_add_attr( reply, "id", tf->iq_id );
+		
+	if( !jabber_write_packet( tf->ic, reply ) )
+		imcb_file_canceled( tf->ft, "Error transmitting bytestream response" );
+	xt_free_node( reply );
+}
+
+/* Reads till it is unscheduled or the receiver signifies an overflow. */
+gboolean jabber_bs_read( gpointer data, gint fd, b_input_condition cond )
+{
+	int ret;
+	struct jabber_transfer *tf = data;
+	char *buffer = g_malloc( JABBER_BS_BUFSIZE );
+
+	if (tf->receiver_overflow)
+	{
+		if( tf->watch_in )
+		{
+			/* should never happen, BUG */
+			imcb_file_canceled( tf->ft, "Bug in jabber file transfer code: read while overflow is true. Please report" );
+			return FALSE;
+		}
+	}
+
+	ret = recv( fd, buffer, JABBER_BS_BUFSIZE, 0 );
+
+	if( ret == -1 )
+	{
+		/* shouldn't actually happen */
+		if( errno == EAGAIN )
+			return TRUE;
+
+		imcb_file_canceled( tf->ft, "Error reading tcp socket" ); /* , strerror( errnum ) */
+
+		return FALSE;
+	}
+
+	/* that should be all */
+	if( ret == 0 )
+		return FALSE;
+	
+	tf->bytesread += ret;
+
+	buffer = g_realloc( buffer, ret );
+
+	if ( ( tf->receiver_overflow = imcb_file_write( tf->ft, buffer, ret ) ) )
+	{
+		/* wait for imcb to run out of data */
+		tf->watch_in = 0;
+		return FALSE;
+	}
+		
+
+	return TRUE;
+}
+
+/* imcb callback that is invoked when it runs out of data.
+ * We reschedule jabber_bs_read here if neccessary. */
+void jabber_bs_out_of_data( file_transfer_t *ft )
+{
+	struct jabber_transfer *tf = ft->data;
+
+	tf->receiver_overflow = FALSE;
+
+	if ( !tf->watch_in )
+		tf->watch_in = b_input_add( tf->fd, GAIM_INPUT_READ, jabber_bs_read, tf );
+}
+
+/* Bad luck */
+void jabber_bs_canceled( file_transfer_t *ft , char *reason )
+{
+	struct jabber_transfer *tf = ft->data;
+
+	imcb_log( tf->ic, "File transfer aborted: %s", reason );
+}
