Changeset 2ff2076

Timestamp:

2007-12-03T14:28:45Z (17 years ago)

Author:

ulim <a.sporto+bee@…>

Branches:

master

Children:

dce3903

Parents:

2c2df7d

Message:

Intermediate commit. Sending seems to work. TODOs:

• move from out_of_data to is_writable, eliminate buffers
• implement "transfers reject [id]"
• documentation in commands.xml
• implement throughput and cummulative throughput boundaries
• feature discovery before sending
• implement sending over a proxy (proxy discovery, socks5 client handshake for sending, activate message)
• integrate toxik-mek-ft

Files:

• dcc.c (modified) (10 diffs)
• dcc.h (modified) (2 diffs)
• doc/user-guide/commands.xml (modified) (1 diff)
• irc.c (modified) (2 diffs)
• protocols/ft.h (modified) (4 diffs)
• protocols/jabber/Makefile (modified) (1 diff)
• protocols/jabber/iq.c (modified) (1 diff)
• protocols/jabber/jabber.c (modified) (1 diff)
• protocols/jabber/jabber.h (modified) (2 diffs)
• protocols/jabber/jabber_util.c (modified) (1 diff)
• protocols/jabber/s5bytestream.c (added)
• protocols/jabber/si.c (modified) (7 diffs)
• protocols/jabber/stream.c (deleted)
• protocols/nogaim.h (modified) (1 diff)

dcc.c

@@ -28 +28 @@
 #include <poll.h>
 #include <netinet/tcp.h>
+#include <regex.h>
 
 /* 
@@ -76 +77 @@
 gboolean dcc_listen( dcc_file_transfer_t *df, struct sockaddr_storage **saddr_ptr );
 int dccs_send_request( struct dcc_file_transfer *df, char *user_nick, struct sockaddr_storage *saddr );
+gboolean dccs_recv_start( file_transfer_t *ft );
+gboolean dccs_recv_proto( gpointer data, gint fd, b_input_condition cond);
+void dccs_recv_out_of_data( file_transfer_t *ft );
 
 /* As defined in ft.h */
@@ -104 +108 @@
 }
 
-/* This is where the sending magic starts... */
-file_transfer_t *dccs_send_start( struct im_connection *ic, char *user_nick, char *file_name, size_t file_size )
-{
-        file_transfer_t *file;
-        dcc_file_transfer_t *df;
-        struct sockaddr_storage **saddr;
-
-        if( file_size > global.conf->max_filetransfer_size )
-                return NULL;
-        
-        /* alloc stuff */
-        file = g_new0( file_transfer_t, 1 );
-        file->priv = df = g_new0( dcc_file_transfer_t, 1);
+/* As defined in ft.h */
+gboolean imcb_file_recv_start( file_transfer_t *ft )
+{
+        return dccs_recv_start( ft );
+}
+
+dcc_file_transfer_t *dcc_alloc_transfer( char *file_name, size_t file_size, struct im_connection *ic )
+{
+        file_transfer_t *file = g_new0( file_transfer_t, 1 );
+        dcc_file_transfer_t *df = file->priv = g_new0( dcc_file_transfer_t, 1);
         file->file_size = file_size;
         file->file_name = g_strdup( file_name );
@@ -123 +124 @@
         df->ft = file;
         
+        return df;
+}
+
+/* This is where the sending magic starts... */
+file_transfer_t *dccs_send_start( struct im_connection *ic, char *user_nick, char *file_name, size_t file_size )
+{
+        file_transfer_t *file;
+        dcc_file_transfer_t *df;
+        struct sockaddr_storage *saddr;
+
+        if( file_size > global.conf->max_filetransfer_size )
+                return NULL;
+        
+        df = dcc_alloc_transfer( file_name, file_size, ic );
+        file = df->ft;
+
         /* listen and request */
-        if( !dcc_listen( df, saddr ) ||
-            !dccs_send_request( df, user_nick, *saddr ) )
+        if( !dcc_listen( df, &saddr ) ||
+            !dccs_send_request( df, user_nick, saddr ) )
                 return NULL;
 
-        g_free( *saddr );
+        g_free( saddr );
 
         /* watch */
@@ -261 +278 @@
 
 /*
+ * Checks poll(), same for receiving and sending
+ */
+gboolean dcc_poll( dcc_file_transfer_t *df, int fd, short *revents )
+{
+        struct pollfd pfd = { .fd = fd, .events = POLLHUP|POLLERR|POLLIN|POLLOUT };
+
+        ASSERTSOCKOP( poll( &pfd, 1, 0 ), "poll()" )
+
+        if( pfd.revents & POLLERR )
+        {
+                int sockerror;
+                socklen_t errlen = sizeof( sockerror );
+
+                if ( getsockopt( fd, SOL_SOCKET, SO_ERROR, &sockerror, &errlen ) )
+                        return dcc_abort( df, "getsockopt() failed, unknown socket error (weird!)" );
+
+                return dcc_abort( df, "Socket error: %s", strerror( sockerror ) );
+        }
+        
+        if( pfd.revents & POLLHUP ) 
+                return dcc_abort( df, "Remote end closed connection" );
+        
+        *revents = pfd.revents;
+
+        return TRUE;
+}
+
+gboolean  dcc_check_maxseg( dcc_file_transfer_t *df, int fd )
+{
+#ifdef DCC_SEND_AHEAD
+        /* 
+         * use twice the maximum segment size as a maximum for calls to send().
+         */
+        if( max_packet_size == 0 )
+        {
+                unsigned int mpslen = sizeof( max_packet_size );
+                if( getsockopt( fd, IPPROTO_TCP, TCP_MAXSEG, &max_packet_size, &mpslen ) )
+                        return dcc_abort( df, "getsockopt() failed" );
+                max_packet_size *= 2;
+        }
+#endif
+        return TRUE;
+}
+
+/*
  * After setup, the transfer itself is handled entirely by this function.
  * There are basically four things to handle: connect, receive, send, and error.
@@ -268 +330 @@
         dcc_file_transfer_t *df = data;
         file_transfer_t *file = df->ft;
-        struct pollfd pfd = { .fd = fd, .events = POLLHUP|POLLERR|POLLIN|POLLOUT };
         short revents;
         
-        if ( poll( &pfd, 1, 0 ) == -1 )
-        {
-                imcb_log( df->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 dcc_abort( df, "getsockopt() failed, unknown socket error (weird!)" );
-
-                return dcc_abort( df, "Socket error: %s", strerror( sockerror ) );
-        }
-        
-        if( revents & POLLHUP ) 
-                return dcc_abort( df, "Remote end closed connection" );
-        
+        if( !dcc_poll( df, fd, &revents) )
+                return FALSE;
+
         if( ( revents & POLLIN ) &&
             ( file->status & FT_STATUS_LISTENING ) )
@@ -305 +347 @@
                 closesocket( fd );
                 fd = df->fd;
-                file->status = FT_STATUS_TRANSFERING;
+                file->status = FT_STATUS_TRANSFERRING;
                 sock_make_nonblocking( fd );
 
-#ifdef DCC_SEND_AHEAD
-                /* 
-                 * use twice the maximum segment size as a maximum for calls to send().
-                 */
-                if( max_packet_size == 0 )
-                {
-                        unsigned int mpslen = sizeof( max_packet_size );
-                        if( getsockopt( fd, IPPROTO_TCP, TCP_MAXSEG, &max_packet_size, &mpslen ) )
-                                return dcc_abort( df, "getsockopt() failed" );
-                        max_packet_size *= 2;
-                }
-#endif
+                if ( !dcc_check_maxseg( df, fd ) )
+                        return FALSE;
+
                 /* IM protocol callback */
 
@@ -453 +486 @@
 }
 
+gboolean dccs_recv_start( file_transfer_t *ft )
+{
+        dcc_file_transfer_t *df = ft->priv;
+        struct sockaddr_storage *saddr = &df->saddr;
+        int fd;
+        socklen_t sa_len = saddr->ss_family == AF_INET ? 
+                sizeof( struct sockaddr_in ) : sizeof( struct sockaddr_in6 );
+        
+        if( !ft->write )
+                return dcc_abort( df, "Protocol didn't register write()" );
+        
+        ASSERTSOCKOP( fd = df->fd = socket( saddr->ss_family, SOCK_STREAM, 0 ) , "Opening Socket" );
+
+        sock_make_nonblocking( fd );
+
+        if( ( connect( fd, (struct sockaddr *)saddr, sa_len ) == -1 ) &&
+            ( errno != EINPROGRESS ) )
+                return dcc_abort( df, "Connecting" );
+
+        ft->status = FT_STATUS_CONNECTING;
+
+        /* watch */
+        df->watch_out = b_input_add( df->fd, GAIM_INPUT_WRITE, dccs_recv_proto, df );
+        ft->out_of_data = dccs_recv_out_of_data;
+
+        return TRUE;
+}
+
+gboolean dccs_recv_proto( gpointer data, gint fd, b_input_condition cond)
+{
+        dcc_file_transfer_t *df = data;
+        file_transfer_t *ft = df->ft;
+        short revents;
+
+        if( !dcc_poll( df, fd, &revents ) )
+                return FALSE;
+        
+        if( ( revents & POLLOUT ) &&
+            ( ft->status & FT_STATUS_CONNECTING ) )
+        {
+                ft->status = FT_STATUS_TRANSFERRING;
+                if ( !dcc_check_maxseg( df, fd ) )
+                        return FALSE;
+
+                //df->watch_in = b_input_add( df->fd, GAIM_INPUT_READ, dccs_recv_proto, df );
+
+                df->watch_out = 0;
+                return FALSE;
+        }
+
+        if( revents & POLLIN )
+        {
+                char *buffer = g_malloc( 65536 );
+                int ret, done;
+
+                ASSERTSOCKOP( ret = recv( fd, buffer, 65536, 0 ), "Receiving" );
+
+                if( ret == 0 )
+                        return dcc_abort( df, "Remote end closed connection" );
+
+                buffer = g_realloc( buffer, ret );
+
+                df->bytes_sent += ret;
+
+                done = df->bytes_sent >= ft->file_size;
+
+                if( ( ( df->bytes_sent - ft->bytes_transferred ) > DCC_PACKET_SIZE ) ||
+                    done )
+                {
+                        int ack, ackret;
+                        ack = htonl( ft->bytes_transferred = df->bytes_sent );
+
+                        ASSERTSOCKOP( ackret = send( fd, &ack, 4, 0 ), "Sending DCC ACK" );
+                        
+                        if ( ackret != 4 )
+                                return dcc_abort( df, "Error sending DCC ACK, sent %d instead of 4 bytes", ret );
+                }
+                
+                if( !ft->write( df->ft, buffer, ret ) && !done )
+                {
+                        df->watch_in = 0;
+                        return FALSE;
+                }
+
+                if( done )
+                {
+                        closesocket( fd );
+                        dcc_finish( ft );
+
+                        df->watch_in = 0;
+                        return FALSE;
+                }
+
+                return TRUE;
+        }
+
+        return TRUE;
+}
+
+void dccs_recv_out_of_data( file_transfer_t *ft )
+{
+        dcc_file_transfer_t *df = ft->priv;
+
+        if( !df->watch_in )
+                df->watch_in = b_input_add( df->fd, GAIM_INPUT_READ, dccs_recv_proto, df );
+}
+
 /* 
  * Incoming data. Note that the buffer MUST NOT be freed by the caller!
@@ -472 +612 @@
         df->queued_bytes += data_size;
 
-        if( ( file->status & FT_STATUS_TRANSFERING ) && 
+        if( ( file->status & FT_STATUS_TRANSFERRING ) && 
 #ifndef DCC_SEND_AHEAD
             ( file->bytes_transferred >= df->bytes_sent ) && 
@@ -533 +673 @@
         dcc_close( file );
 }
+
+/* 
+ * DCC SEND <filename> <IP> <port> <filesize>
+ *
+ * filename can be in "" or not. If it is, " can probably be escaped...
+ * IP can be an unsigned int (IPV4) or something else (IPV6)
+ * 
+ */
+file_transfer_t *dcc_request( struct im_connection *ic, char *line )
+{
+        char *pattern = "SEND"
+                " (([^\"][^ ]*)|\"([^\"]|\\\")*\")"
+                " (([0-9]*)|([^ ]*))"
+                " ([0-9]*)"
+                " ([0-9]*)\001";
+        regmatch_t pmatch[9];
+        regex_t re;
+        file_transfer_t *ft;
+        dcc_file_transfer_t *df;
+
+        if( regcomp( &re, pattern, REG_EXTENDED ) )
+                return NULL;
+        if( regexec( &re, line, 9, pmatch, 0 ) )
+                return NULL;
+
+        if( ( pmatch[1].rm_so > 0 ) &&
+            ( pmatch[4].rm_so > 0 ) &&
+            ( pmatch[7].rm_so > 0 ) &&
+            ( pmatch[8].rm_so > 0 ) )
+        {
+                char *input = g_strdup( line );
+                char *filename, *host, *port;
+                size_t filesize;
+                struct addrinfo hints, *rp;
+
+                /* "filename" or filename */
+                if ( pmatch[2].rm_so > 0 )
+                {
+                        input[pmatch[2].rm_eo] = '\0';
+                        filename = input + pmatch[2].rm_so;
+                } else
+                {
+                        input[pmatch[3].rm_eo] = '\0';
+                        filename = input + pmatch[3].rm_so;
+                }
+                        
+                input[pmatch[4].rm_eo] = '\0';
+
+                /* number means ipv4, something else means ipv6 */
+                if ( pmatch[5].rm_so > 0 )
+                {
+                        struct in_addr ipaddr = { htonl( atoi( input + pmatch[5].rm_so ) ) };
+                        host = inet_ntoa( ipaddr );
+                } else
+                {
+                        /* Contains non-numbers, hopefully an IPV6 address */
+                        host = input + pmatch[6].rm_so;
+                }
+
+                input[pmatch[7].rm_eo] = '\0';
+                input[pmatch[8].rm_eo] = '\0';
+
+                port = input + pmatch[7].rm_so;
+                filesize = atoll( input + pmatch[8].rm_so );
+
+                memset( &hints, 0, sizeof ( struct addrinfo ) );
+                if ( getaddrinfo( host, port, &hints, &rp ) )
+                {
+                        g_free( input );
+                        return NULL;
+                }
+
+                df = dcc_alloc_transfer( filename, filesize, ic );
+                ft = df->ft;
+                ft->sending = TRUE;
+                memcpy( &df->saddr, rp->ai_addr, rp->ai_addrlen );
+
+                freeaddrinfo( rp );
+                g_free( input );
+
+                df->ic->irc->file_transfers = g_slist_prepend( df->ic->irc->file_transfers, ft );
+
+                return ft;
+        }
+
+        return NULL;
+}
+

dcc.h

@@ -112 +112 @@
         size_t bytes_sent;
         
-        /* imcb's handle */
+        /* imc's handle */
         file_transfer_t *ft;
+
+        /* if we're receiving, this is the sender's socket address */
+        struct sockaddr_storage saddr;
 
 } dcc_file_transfer_t;
@@ -123 +126 @@
 gboolean dccs_send_write( file_transfer_t *file, gpointer data, unsigned int data_size );
 
+file_transfer_t *dcc_request( struct im_connection *ic, char *line );
 #endif

doc/user-guide/commands.xml

@@ -861 +861 @@
 
         </bitlbee-command>
+        
+        <bitlbee-command name="transfers">
+                <short-description>Monitor, cancel, or reject file transfers</short-description>
+                <syntax>transfers [&lt;cancel&gt; id | &lt;reject&gt;]</syntax>
+                
+                <description>
+                        <para>
+                                Without parameters the currently pending file transfers and their status will be listed. Available actions are <emphasis>cancel</emphasis> and <emphasis>reject</emphasis>. See <emphasis>help transfers &lt;action&gt;</emphasis> for more information.
+                        </para>
+
+                        <ircexample>
+                                <ircline nick="ulim">transfers</ircline>
+                        </ircexample>
+                </description>
+                
+                <bitlbee-command name="cancel">
+                        <short-description>Cancels the file transfer with the given id</short-description>
+                        <syntax>transfers &lt;cancel&gt; id</syntax>
+
+                        <description>
+                                <para>Cancels the file transfer with the given id</para>
+                        </description>
+
+                        <ircexample>
+                                <ircline nick="ulim">transfers cancel 1</ircline>
+                                <ircline nick="root">Canceling file transfer for test</ircline>
+                        </ircexample>
+                </bitlbee-command>
+
+                <bitlbee-command name="reject">
+                        <short-description>Rejects all incoming transfers</short-description>
+                        <syntax>transfers &lt;reject&gt;</syntax>
+
+                        <description>
+                                <para>Rejects all incoming (not already transferring) file transfers. Since you probably have only one incoming transfer at a time, no id is neccessary. Or is it?</para>
+                        </description>
+
+                        <ircexample>
+                                <ircline nick="ulim">transfers reject</ircline>
+                        </ircexample>
+                </bitlbee-command>
+        </bitlbee-command>
+        
 </chapter>

irc.c

@@ -28 +28 @@
 #include "crypting.h"
 #include "ipc.h"
+#include "dcc.h"
+
+#include <regex.h>
+#include <netinet/in.h>
 
 static gboolean irc_userping( gpointer _irc, int fd, b_input_condition cond );
@@ -981 +985 @@
                         return( 1 );
                 }
+                else if( g_strncasecmp( s + 1, "DCC", 3 ) == 0 )
+                {
+                        if( u && u->ic && u->ic->acc->prpl->transfer_request )
+                        {
+                                file_transfer_t *ft = dcc_request( u->ic, s + 5 );
+                                if ( ft )
+                                        u->ic->acc->prpl->transfer_request( u->ic, ft, u->handle );
+                        }
+                        return( 1 );
+                }               
                 else
                 {
-                        irc_usermsg( irc, "Non-ACTION CTCP's aren't supported" );
+                        irc_usermsg( irc, "Supported CTCPs are ACTION, VERSION, PING, TYPING, DCC" );
                         return( 0 );
                 }

protocols/ft.h

@@ -29 +29 @@
 typedef enum {
         FT_STATUS_LISTENING     = 1,
-        FT_STATUS_TRANSFERING   = 2,
+        FT_STATUS_TRANSFERRING  = 2,
         FT_STATUS_FINISHED      = 4,
-        FT_STATUS_CANCELED      = 8
+        FT_STATUS_CANCELED      = 8,
+        FT_STATUS_CONNECTING    = 16
 } file_status_t;
 
@@ -61 +62 @@
  */
 typedef struct file_transfer {
+
+        /* Are we sending something? */
+        int sending;
+
         /*
          * The current status of this file transfer.
@@ -131 +136 @@
         void (*out_of_data) ( struct file_transfer *file );
 
+        /*
+         * When sending files, protocols register this function to receive data.
+         */
+        gboolean (*write) (struct file_transfer *file, char *buffer, int len );
+
 } file_transfer_t;
 
@@ -151 +161 @@
 gboolean imcb_file_write( file_transfer_t *file, gpointer data, size_t data_size );
 
+gboolean imcb_file_recv_start( file_transfer_t *ft );
 #endif

protocols/jabber/Makefile

@@ -10 +10 @@
 
 # [SH] Program variables
-objects = conference.o io.o iq.o jabber.o jabber_util.o message.o presence.o sasl.o xmltree.o si.o stream.o
+objects = conference.o io.o iq.o jabber.o jabber_util.o message.o presence.o sasl.o xmltree.o si.o s5bytestream.o
 
 CFLAGS += -Wall

protocols/jabber/iq.c

@@ -168 +168 @@
                 {
                         /* Bytestream Request (stage 2 of file transfer) */
-                        return jabber_bs_request( ic, node, c );
+                        return jabber_bs_recv_request( ic, node, c );
                 } else
                 {

protocols/jabber/jabber.c

@@ -502 +502 @@
         ret->send_typing = jabber_send_typing;
         ret->handle_cmp = g_strcasecmp;
+        ret->transfer_request = jabber_si_transfer_request;
 
         register_protocol( ret );

protocols/jabber/jabber.h

@@ -148 +148 @@
         int receiver_overflow;
         int fd;
+        struct sockaddr_storage saddr;
 };
 
@@ -201 +202 @@
 
 /* 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);
+int jabber_si_handle_request( struct im_connection *ic, struct xt_node *node, struct xt_node *sinode );
+void jabber_si_transfer_request( struct im_connection *ic, file_transfer_t *ft, char *who );
+void jabber_si_free_transfer( file_transfer_t *ft);
+
+/* s5bytestream.c */
+int jabber_bs_recv_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode);
+gboolean jabber_bs_send_start( struct jabber_transfer *tf );
+gboolean jabber_bs_send_write( file_transfer_t *ft, char *buffer, int len );
 
 /* message.c */

protocols/jabber/jabber_util.c

@@ -265 +265 @@
         new = g_new( char, len + 1 );
         for( i = 0; i < len; i ++ )
+        {
+                /* don't normalize the resource */
+                if( orig[i] == '/' )
+                        break;
                 new[i] = tolower( orig[i] );
+        }
+        for( ; i < len; i ++ )
+                new[i] = orig[i];
         
         new[i] = 0;

protocols/jabber/si.c

@@ -26 +26 @@
 
 void jabber_si_answer_request( file_transfer_t *ft );
-
-/* imcb callback */
+int jabber_si_send_request(struct im_connection *ic, char *who, struct jabber_transfer *tf );
+
+/* file_transfer free() callback */
 void jabber_si_free_transfer( file_transfer_t *ft)
 {
@@ -50 +51 @@
 }
 
-/* imcb callback */
+/* file_transfer finished() callback */
 void jabber_si_finished( file_transfer_t *ft )
 {
@@ -58 +59 @@
 }
 
-/* imcb callback */
+/* file_transfer canceled() callback */
 void jabber_si_canceled( file_transfer_t *ft, char *reason )
 {
@@ -76 +77 @@
         xt_free_node( reply );
 
+}
+
+void jabber_si_transfer_request( struct im_connection *ic, file_transfer_t *ft, char *who ) 
+{
+        struct jabber_transfer *tf;
+        struct jabber_data *jd = ic->proto_data;
+
+        imcb_log( ic, "Incoming file from %s : %s %zd bytes", ic->irc->nick, ft->file_name, ft->file_size );
+
+        tf = g_new0( struct jabber_transfer, 1 );
+
+        tf->ic = ic;
+        tf->ft = ft;
+        tf->ft->data = tf;
+        tf->ft->free = jabber_si_free_transfer;
+        tf->ft->finished = jabber_si_finished;
+        ft->write = jabber_bs_send_write;
+
+        jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
+
+        jabber_si_send_request( ic, who, tf );
+
+        imcb_file_recv_start( ft );
 }
 
@@ -136 +160 @@
                                 break;
                         }
+
+                if ( !requestok )
+                        imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
         }
         
@@ -160 +187 @@
 
                 *s = '/';
-        } else 
-                imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
+        }
 
         if ( !requestok )
@@ -245 +271 @@
         xt_free_node( reply );
 }
+
+static xt_status jabber_si_handle_response(struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
+{
+        struct xt_node *c, *d;
+        char *ini_jid, *tgt_jid;
+        GSList *tflist;
+        struct jabber_transfer *tf=NULL;
+        struct jabber_data *jd = ic->proto_data;
+        char *sid;
+
+        if( !( tgt_jid = xt_find_attr( node, "from" ) ) ||
+            !( ini_jid = xt_find_attr( node, "to" ) ) )
+        {
+                imcb_log( ic, "Invalid SI response from=%s to=%s", tgt_jid, ini_jid );
+                return XT_HANDLED;
+        }
+        
+        imcb_log( ic, "GOT RESPONSE TO FILE" );
+        /* All this means we expect something like this: ( I think )
+         * <iq from=... to=...>
+         *      <si xmlns=si>
+         *              <file xmlns=ft/>
+         *              <feature xmlns=feature>
+         *                      <x xmlns=xdata type=submit>
+         *                              <field var=stream-method>
+         *                                      <value>
+         */
+        if( !( tgt_jid = xt_find_attr( node, "from" ) ) ||
+            !( ini_jid = xt_find_attr( node, "to" ) ) ||
+            !( c = xt_find_node( node->children, "si" ) ) ||
+            !( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_SI ) == 0 ) ||
+            !( sid = xt_find_attr( c, "id" ) )||
+            !( d = xt_find_node( c->children, "file" ) ) ||
+            !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FILETRANSFER ) == 0 ) ||
+            !( d = xt_find_node( c->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" ), "submit" ) == 0 ) ||
+            !( d = xt_find_node( d->children, "field" ) ) ||
+            !( strcmp( xt_find_attr( d, "var" ), "stream-method" ) == 0 ) ||
+            !( d = xt_find_node( d->children, "value" ) ) )
+        {
+                imcb_log( ic, "WARNING: Received incomplete Stream Initiation response" );
+                return XT_HANDLED;
+        }
+
+        if( !( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) ) { 
+                /* since we should only have advertised what we can do and the peer should
+                 * only have chosen what we offered, this should never happen */
+                imcb_log( ic, "WARNING: Received invalid Stream Initiation response, method %s", d->text );
+                        
+                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 ) )
+                {
+                        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;
+        }
+
+        tf->ini_jid = g_strdup( ini_jid );
+        tf->tgt_jid = g_strdup( tgt_jid );
+
+        jabber_bs_send_start( tf );
+
+        return XT_HANDLED;
+}
+
+int jabber_si_send_request(struct im_connection *ic, char *who, struct jabber_transfer *tf )
+{
+        struct xt_node *node, *sinode;
+        struct jabber_buddy *bud;
+
+        /* who knows how many bits the future holds :) */
+        char filesizestr[ 1 + ( int ) ( 0.301029995663981198f * sizeof( size_t ) * 8 ) ];
+
+        const char *methods[] = 
+        {       
+                XMLNS_BYTESTREAMS,
+                //XMLNS_IBB,
+                NULL 
+        };
+        const char **m;
+        char *s;
+
+        /* Maybe we should hash this? */
+        tf->sid = g_strdup_printf( "BitlBeeJabberSID%d", tf->ft->local_id );
+        
+        if( ( s = strchr( who, '=' ) ) && jabber_chat_by_name( ic, s + 1 ) )
+                bud = jabber_buddy_by_ext_jid( ic, who, 0 );
+        else
+                bud = jabber_buddy_by_jid( ic, who, 0 );
+
+        /* 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 );
+
+/*      if( mimetype ) 
+                xt_add_attr( node, "mime-type", mimetype ); */
+
+        /* now the file tag */
+/*      if( desc )
+                node = xt_new_node( "desc", descr, NULL ); */
+        node = xt_new_node( "range", NULL, NULL );
+
+        sprintf( filesizestr, "%zd", tf->ft->file_size );
+        node = xt_new_node( "file", NULL, node );
+        xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
+        xt_add_attr( node, "name", tf->ft->file_name );
+        xt_add_attr( node, "size", filesizestr );
+/*      if (hash)
+                xt_add_attr( node, "hash", hash );
+        if (date)
+                xt_add_attr( node, "date", date ); */
+
+        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" );
+
+        for ( m = methods ; *m ; m ++ )
+                xt_add_child( node, xt_new_node( "option", NULL, xt_new_node( "value", (char *)*m, NULL ) ) );
+
+        node = xt_new_node( "x", NULL, node );
+        xt_add_attr( node, "xmlns", XMLNS_XDATA );
+        xt_add_attr( node, "type", "form" );
+
+        node = xt_new_node( "feature", NULL, node );
+        xt_add_attr( node, "xmlns", XMLNS_FEATURE );
+
+        xt_add_child( sinode, node );
+
+        /* and we are there... */
+        node = jabber_make_packet( "iq", "set", bud ? bud->full_jid : who, sinode );
+        jabber_cache_add( ic, node, jabber_si_handle_response );
+        
+        return jabber_write_packet( ic, node );
+}

protocols/nogaim.h

@@ -229 +229 @@
          * - Most protocols will just want to set this to g_strcasecmp().*/
         int (* handle_cmp) (const char *who1, const char *who2);
+
+        /* Incoming transfer request */
+        void (* transfer_request) (struct im_connection *, file_transfer_t *ft, char *handle );
 };