Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • protocols/jabber/si.c

    rdce3903 r2c2df7d  
    2626
    2727void jabber_si_answer_request( file_transfer_t *ft );
    28 int jabber_si_send_request(struct im_connection *ic, char *who, struct jabber_transfer *tf );
    29 
    30 /* file_transfer free() callback */
     28
     29/* imcb callback */
    3130void jabber_si_free_transfer( file_transfer_t *ft)
    3231{
     
    5150}
    5251
    53 /* file_transfer finished() callback */
     52/* imcb callback */
    5453void jabber_si_finished( file_transfer_t *ft )
    5554{
     
    5958}
    6059
    61 /* file_transfer canceled() callback */
     60/* imcb callback */
    6261void jabber_si_canceled( file_transfer_t *ft, char *reason )
    6362{
     
    7776        xt_free_node( reply );
    7877
    79 }
    80 
    81 void jabber_si_transfer_request( struct im_connection *ic, file_transfer_t *ft, char *who )
    82 {
    83         struct jabber_transfer *tf;
    84         struct jabber_data *jd = ic->proto_data;
    85 
    86         imcb_log( ic, "Trying to send %s(%zd bytes) to %s", ft->file_name, ft->file_size, who );
    87 
    88         tf = g_new0( struct jabber_transfer, 1 );
    89 
    90         tf->ic = ic;
    91         tf->ft = ft;
    92         tf->ft->data = tf;
    93         tf->ft->free = jabber_si_free_transfer;
    94         tf->ft->finished = jabber_si_finished;
    95         ft->write = jabber_bs_send_write;
    96 
    97         jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
    98 
    99         jabber_si_send_request( ic, who, tf );
    100 
    101         imcb_file_recv_start( ft );
    10278}
    10379
     
    160136                                break;
    161137                        }
    162 
    163                 if ( !requestok )
    164                         imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
    165138        }
    166139       
     
    187160
    188161                *s = '/';
    189         }
     162        } else
     163                imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
    190164
    191165        if ( !requestok )
     
    224198
    225199/*
    226  * imc called the accept callback which probably means that the user accepted this file transfer.
     200 * imcb called the accept callback which probably means that the user accepted this file transfer.
    227201 * We send our response to the initiator.
    228202 * In the next step, the initiator will send us a request for the given stream type.
     
    271245        xt_free_node( reply );
    272246}
    273 
    274 static xt_status jabber_si_handle_response(struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
    275 {
    276         struct xt_node *c, *d;
    277         char *ini_jid, *tgt_jid, *iq_id;
    278         GSList *tflist;
    279         struct jabber_transfer *tf=NULL;
    280         struct jabber_data *jd = ic->proto_data;
    281 
    282         if( !( tgt_jid = xt_find_attr( node, "from" ) ) ||
    283             !( ini_jid = xt_find_attr( node, "to" ) ) )
    284         {
    285                 imcb_log( ic, "Invalid SI response from=%s to=%s", tgt_jid, ini_jid );
    286                 return XT_HANDLED;
    287         }
    288        
    289         /* All this means we expect something like this: ( I think )
    290          * <iq from=... to=... id=...>
    291          *      <si xmlns=si>
    292          *      [       <file xmlns=ft/>    ] <-- not neccessary
    293          *              <feature xmlns=feature>
    294          *                      <x xmlns=xdata type=submit>
    295          *                              <field var=stream-method>
    296          *                                      <value>
    297          */
    298         if( !( tgt_jid = xt_find_attr( node, "from" ) ) ||
    299             !( ini_jid = xt_find_attr( node, "to" ) ) ||
    300             !( iq_id   = xt_find_attr( node, "id" ) ) ||
    301             !( c = xt_find_node( node->children, "si" ) ) ||
    302             !( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_SI ) == 0 ) ||
    303 /*          !( d = xt_find_node( c->children, "file" ) ) ||
    304             !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FILETRANSFER ) == 0 ) || */
    305             !( d = xt_find_node( c->children, "feature" ) ) ||
    306             !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FEATURE ) == 0 ) ||
    307             !( d = xt_find_node( d->children, "x" ) ) ||
    308             !( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_XDATA ) == 0 ) ||
    309             !( strcmp( xt_find_attr( d, "type" ), "submit" ) == 0 ) ||
    310             !( d = xt_find_node( d->children, "field" ) ) ||
    311             !( strcmp( xt_find_attr( d, "var" ), "stream-method" ) == 0 ) ||
    312             !( d = xt_find_node( d->children, "value" ) ) )
    313         {
    314                 imcb_log( ic, "WARNING: Received incomplete Stream Initiation response" );
    315                 return XT_HANDLED;
    316         }
    317 
    318         if( !( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) ) {
    319                 /* since we should only have advertised what we can do and the peer should
    320                  * only have chosen what we offered, this should never happen */
    321                 imcb_log( ic, "WARNING: Received invalid Stream Initiation response, method %s", d->text );
    322                        
    323                 return XT_HANDLED;
    324         }
    325        
    326         /* Let's see if we can find out what this bytestream should be for... */
    327 
    328         for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
    329         {
    330                 struct jabber_transfer *tft = tflist->data;
    331                 if( ( strcmp( tft->iq_id, iq_id ) == 0 ) )
    332                 {
    333                         tf = tft;
    334                         break;
    335                 }
    336         }
    337 
    338         if (!tf)
    339         {
    340                 imcb_log( ic, "WARNING: Received bytestream request from %s that doesn't match an SI request", ini_jid );
    341                 return XT_HANDLED;
    342         }
    343 
    344         tf->ini_jid = g_strdup( ini_jid );
    345         tf->tgt_jid = g_strdup( tgt_jid );
    346 
    347         imcb_log( ic, "File %s: %s accepted the transfer!", tf->ft->file_name, tgt_jid );
    348 
    349         jabber_bs_send_start( tf );
    350 
    351         return XT_HANDLED;
    352 }
    353 
    354 int jabber_si_send_request(struct im_connection *ic, char *who, struct jabber_transfer *tf )
    355 {
    356         struct xt_node *node, *sinode;
    357         struct jabber_buddy *bud;
    358 
    359         /* who knows how many bits the future holds :) */
    360         char filesizestr[ 1 + ( int ) ( 0.301029995663981198f * sizeof( size_t ) * 8 ) ];
    361 
    362         const char *methods[] =
    363         {       
    364                 XMLNS_BYTESTREAMS,
    365                 //XMLNS_IBB,
    366                 NULL
    367         };
    368         const char **m;
    369         char *s;
    370 
    371         /* Maybe we should hash this? */
    372         tf->sid = g_strdup_printf( "BitlBeeJabberSID%d", tf->ft->local_id );
    373        
    374         if( ( s = strchr( who, '=' ) ) && jabber_chat_by_name( ic, s + 1 ) )
    375                 bud = jabber_buddy_by_ext_jid( ic, who, 0 );
    376         else
    377                 bud = jabber_buddy_by_jid( ic, who, 0 );
    378 
    379         /* start with the SI tag */
    380         sinode = xt_new_node( "si", NULL, NULL );
    381         xt_add_attr( sinode, "xmlns", XMLNS_SI );
    382         xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
    383         xt_add_attr( sinode, "id", tf->sid );
    384 
    385 /*      if( mimetype )
    386                 xt_add_attr( node, "mime-type", mimetype ); */
    387 
    388         /* now the file tag */
    389 /*      if( desc )
    390                 node = xt_new_node( "desc", descr, NULL ); */
    391         node = xt_new_node( "range", NULL, NULL );
    392 
    393         sprintf( filesizestr, "%zd", tf->ft->file_size );
    394         node = xt_new_node( "file", NULL, node );
    395         xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
    396         xt_add_attr( node, "name", tf->ft->file_name );
    397         xt_add_attr( node, "size", filesizestr );
    398 /*      if (hash)
    399                 xt_add_attr( node, "hash", hash );
    400         if (date)
    401                 xt_add_attr( node, "date", date ); */
    402 
    403         xt_add_child( sinode, node );
    404 
    405         /* and finally the feature tag */
    406         node = xt_new_node( "field", NULL, NULL );
    407         xt_add_attr( node, "var", "stream-method" );
    408         xt_add_attr( node, "type", "list-single" );
    409 
    410         for ( m = methods ; *m ; m ++ )
    411                 xt_add_child( node, xt_new_node( "option", NULL, xt_new_node( "value", (char *)*m, NULL ) ) );
    412 
    413         node = xt_new_node( "x", NULL, node );
    414         xt_add_attr( node, "xmlns", XMLNS_XDATA );
    415         xt_add_attr( node, "type", "form" );
    416 
    417         node = xt_new_node( "feature", NULL, node );
    418         xt_add_attr( node, "xmlns", XMLNS_FEATURE );
    419 
    420         xt_add_child( sinode, node );
    421 
    422         /* and we are there... */
    423         node = jabber_make_packet( "iq", "set", bud ? bud->full_jid : who, sinode );
    424         jabber_cache_add( ic, node, jabber_si_handle_response );
    425         tf->iq_id = g_strdup( xt_find_attr( node, "id" ) );
    426        
    427         return jabber_write_packet( ic, node );
    428 }
Note: See TracChangeset for help on using the changeset viewer.