Changeset fa30fa5 for protocols

Timestamp:

2007-12-04T00:53:04Z (16 years ago)

Author:

ulim <a.sporto+bee@…>

Branches:

master

Children:

08135df

Parents:

2c2df7d (diff), dce3903 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Jabber file transfer now also with sending! You can't use a proxy yet when
sending, that's my next task. You can use proxies when receiving though!

I also changed the buffering strategy. Previously receiving continued till some
buffer limit was reached, now only one message is received and receiving stops
till it is delivered. This keeps the buffering space per file transfer to a
minimum(currently 4k). Makes sense when used on a public server. For public
servers a throughput maximum would also be interesting...

Location:

protocols

Files:

• ft.h (modified) (4 diffs)
• jabber/Makefile (modified) (1 diff)
• jabber/iq.c (modified) (1 diff)
• jabber/jabber.c (modified) (1 diff)
• jabber/jabber.h (modified) (2 diffs)
• jabber/jabber_util.c (modified) (1 diff)
• jabber/s5bytestream.c (added)
• jabber/si.c (modified) (8 diffs)
• jabber/stream.c (deleted)
• nogaim.h (modified) (1 diff)

protocols/ft.h

@@ -27 +27 @@
 #define _FT_H
 
+/*
+ * One buffer is needed for each transfer. The receiver stores a message
+ * in it and gives it to the sender. The sender will stall the receiver
+ * till the buffer has been sent out.
+ */
+#define FT_BUFFER_SIZE 2048
+
 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 +69 @@
  */
 typedef struct file_transfer {
+
+        /* Are we sending something? */
+        int sending;
+
         /*
          * The current status of this file transfer.
@@ -126 +138 @@
         
         /*
-         * If set, called when the transfer queue is running empty and
-         * more data can be added.
+         * called by the sending side to indicate that it is writable.
+         * The callee should check if data is available and call the 
+         * function(as seen below) if that is the case.
          */
-        void (*out_of_data) ( struct file_transfer *file );
+        gboolean (*write_request) ( struct file_transfer *file );
+
+        /*
+         * When sending files, protocols register this function to receive data.
+         * This should only be called once after write_request is called. The caller
+         * should not read more data until write_request is called again. This technique
+         * avoids buffering.
+         */
+        gboolean (*write) (struct file_transfer *file, char *buffer, unsigned int len );
+
+        /* The send buffer associated with this transfer.
+         * Since receivers always wait for a write_request call one is enough.
+         */
+        char buffer[FT_BUFFER_SIZE];
 
 } file_transfer_t;
@@ -144 +170 @@
 void imcb_file_canceled( file_transfer_t *file, char *reason );
 
-/*
- * The given buffer is queued for transfer and MUST NOT be freed by the caller.
- * When the method returns false the caller should not invoke this method again
- * until out_of_data has been called.
- */
-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

@@ -146 +146 @@
 
         size_t bytesread, byteswritten;
-        int receiver_overflow;
         int fd;
+        struct sockaddr_storage saddr;
 };
 
@@ -201 +201 @@
 
 /* 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, unsigned 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, "Trying to send %s(%zd bytes) to %s", ft->file_name, ft->file_size, who );
+
+        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 )
@@ -198 +224 @@
 
 /*
- * imcb called the accept callback which probably means that the user accepted this file transfer.
+ * imc 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.
@@ -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, *iq_id;
+        GSList *tflist;
+        struct jabber_transfer *tf=NULL;
+        struct jabber_data *jd = ic->proto_data;
+
+        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;
+        }
+        
+        /* All this means we expect something like this: ( I think )
+         * <iq from=... to=... id=...>
+         *      <si xmlns=si>
+         *      [       <file xmlns=ft/>    ] <-- not neccessary
+         *              <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" ) ) ||
+            !( iq_id   = xt_find_attr( node, "id" ) ) ||
+            !( c = xt_find_node( node->children, "si" ) ) ||
+            !( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_SI ) == 0 ) ||
+/*          !( 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->iq_id, iq_id ) == 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 );
+
+        imcb_log( ic, "File %s: %s accepted the transfer!", tf->ft->file_name, 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 );
+        tf->iq_id = g_strdup( xt_find_attr( node, "id" ) );
+        
+        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 );
 };