close Warning: Failed to sync with repository "(default)": [Errno 12] Cannot allocate memory; repository information may be out of date. Look in the Trac log for more information including mitigation strategies.

source: protocols/jabber/s5bytestream.c @ 6ddb223

Last change on this file since 6ddb223 was f1f7b5e, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-07-24T22:50:23Z

Take the local address from the IM/IRC connection when setting up a listening
socket for file transfers.
  • Property mode set to 100644
File size: 32.9 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Jabber module - SOCKS5 Bytestreams ( XEP-0065 )                          *
5*                                                                           *
6*  Copyright 2007 Uli Meis <a.sporto+bee@gmail.com>                         *
7*                                                                           *
8*  This program is free software; you can redistribute it and/or modify     *
9*  it under the terms of the GNU General Public License as published by     *
10*  the Free Software Foundation; either version 2 of the License, or        *
11*  (at your option) any later version.                                      *
12*                                                                           *
13*  This program is distributed in the hope that it will be useful,          *
14*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
15*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
16*  GNU General Public License for more details.                             *
17*                                                                           *
18*  You should have received a copy of the GNU General Public License along  *
19*  with this program; if not, write to the Free Software Foundation, Inc.,  *
20*  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.              *
21*                                                                           *
22\***************************************************************************/
23
24#include "jabber.h"
25#include "sha1.h"
26#include "lib/ftutil.h"
27#include <poll.h>
28
29struct bs_transfer {
30
31        struct jabber_transfer *tf;
32
33        jabber_streamhost_t *sh;
34        GSList *streamhosts;
35
36        enum 
37        { 
38                BS_PHASE_CONNECT, 
39                BS_PHASE_CONNECTED, 
40                BS_PHASE_REQUEST, 
41                BS_PHASE_REPLY
42        } phase;
43
44        /* SHA1( SID + Initiator JID + Target JID) */
45        char *pseudoadr;
46
47        gint connect_timeout;
48       
49        char peek_buf[64];
50        int peek_buf_len;
51};
52
53struct socks5_message
54{
55        unsigned char ver;
56        union
57        {
58                unsigned char cmd;
59                unsigned char rep;
60        } cmdrep;
61        unsigned char rsv;
62        unsigned char atyp;
63        unsigned char addrlen;
64        unsigned char address[40];
65        in_port_t port;
66} __attribute__ ((packed)); 
67
68char *socks5_reply_code[] = {
69        "succeeded",
70        "general SOCKS server failure",
71        "connection not allowed by ruleset",
72        "Network unreachable",
73        "Host unreachable",
74        "Connection refused",
75        "TTL expired",
76        "Command not supported",
77        "Address type not supported",
78        "unassigned"};
79
80/* connect() timeout in seconds. */
81#define JABBER_BS_CONTIMEOUT 15
82/* listen timeout */
83#define JABBER_BS_LISTEN_TIMEOUT  90
84
85/* very useful */
86#define ASSERTSOCKOP(op, msg) \
87        if( (op) == -1 ) \
88                return jabber_bs_abort( bt , msg ": %s", strerror( errno ) );
89
90gboolean jabber_bs_abort( struct bs_transfer *bt, char *format, ... );
91void jabber_bs_canceled( file_transfer_t *ft , char *reason );
92void jabber_bs_free_transfer( file_transfer_t *ft );
93gboolean jabber_bs_connect_timeout( gpointer data, gint fd, b_input_condition cond );
94gboolean jabber_bs_poll( struct bs_transfer *bt, int fd, short *revents );
95gboolean jabber_bs_peek( struct bs_transfer *bt, void *buffer, int buflen );
96
97void jabber_bs_recv_answer_request( struct bs_transfer *bt );
98gboolean jabber_bs_recv_read( gpointer data, gint fd, b_input_condition cond );
99gboolean jabber_bs_recv_write_request( file_transfer_t *ft );
100gboolean jabber_bs_recv_handshake( gpointer data, gint fd, b_input_condition cond );
101gboolean jabber_bs_recv_handshake_abort( struct bs_transfer *bt, char *error );
102int jabber_bs_recv_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode );
103
104gboolean jabber_bs_send_handshake_abort( struct bs_transfer *bt, char *error );
105gboolean jabber_bs_send_request( struct jabber_transfer *tf, GSList *streamhosts );
106gboolean jabber_bs_send_handshake( gpointer data, gint fd, b_input_condition cond );
107static xt_status jabber_bs_send_handle_activate( struct im_connection *ic, struct xt_node *node, struct xt_node *orig );
108void jabber_bs_send_activate( struct bs_transfer *bt );
109
110/*
111 * Frees a bs_transfer struct and calls the SI free function
112 */
113void jabber_bs_free_transfer( file_transfer_t *ft) {
114        struct jabber_transfer *tf = ft->data;
115        struct bs_transfer *bt = tf->streamhandle;
116        jabber_streamhost_t *sh;
117
118        if ( bt->connect_timeout )
119        {
120                b_event_remove( bt->connect_timeout );
121                bt->connect_timeout = 0;
122        }
123
124        if ( tf->watch_in )
125                b_event_remove( tf->watch_in );
126       
127        if( tf->watch_out )
128                b_event_remove( tf->watch_out );
129       
130        g_free( bt->pseudoadr );
131
132        while( bt->streamhosts )
133        {
134                sh = bt->streamhosts->data;
135                bt->streamhosts = g_slist_remove( bt->streamhosts, sh );
136                g_free( sh->jid );
137                g_free( sh->host );
138                g_free( sh );
139        }
140       
141        g_free( bt );
142
143        jabber_si_free_transfer( ft );
144}
145
146/*
147 * Checks if buflen data is available on the socket and
148 * writes it to buffer if that's the case.
149 */
150gboolean jabber_bs_peek( struct bs_transfer *bt, void *buffer, int buflen )
151{
152        int ret;
153        int fd = bt->tf->fd;
154
155        if( buflen > sizeof( bt->peek_buf ) )
156                return jabber_bs_abort( bt, "BUG: %d > sizeof(peek_buf)", buflen );
157
158        ASSERTSOCKOP( ret = recv( fd, bt->peek_buf + bt->peek_buf_len,
159                buflen - bt->peek_buf_len, 0 ), "recv() on SOCKS5 connection" );
160
161        if( ret == 0 )
162                return jabber_bs_abort( bt, "Remote end closed connection" );
163       
164        bt->peek_buf_len += ret;
165        memcpy( buffer, bt->peek_buf, bt->peek_buf_len );
166       
167        if( bt->peek_buf_len == buflen )
168        {
169                /* If we have everything the caller wanted, reset the peek buffer. */
170                bt->peek_buf_len = 0;
171                return buflen;
172        }
173        else
174                return bt->peek_buf_len;
175}
176
177
178/*
179 * This function is scheduled in bs_handshake via b_timeout_add after a (non-blocking) connect().
180 */
181gboolean jabber_bs_connect_timeout( gpointer data, gint fd, b_input_condition cond )
182{
183        struct bs_transfer *bt = data;
184
185        bt->connect_timeout = 0;
186
187        jabber_bs_abort( bt, "no connection after %d seconds", bt->tf->ft->sending ? JABBER_BS_LISTEN_TIMEOUT : JABBER_BS_CONTIMEOUT );
188
189        return FALSE;
190}
191
192/*
193 * Polls the socket, checks for errors and removes a connect timer
194 * if there is one.
195 */
196gboolean jabber_bs_poll( struct bs_transfer *bt, int fd, short *revents )
197{
198        struct pollfd pfd = { .fd = fd, .events = POLLHUP|POLLERR };
199       
200        if ( bt->connect_timeout )
201        {
202                b_event_remove( bt->connect_timeout );
203                bt->connect_timeout = 0;
204        }
205
206        ASSERTSOCKOP( poll( &pfd, 1, 0 ), "poll()" )
207
208        if( pfd.revents & POLLERR )
209        {
210                int sockerror;
211                socklen_t errlen = sizeof( sockerror );
212
213                if ( getsockopt( fd, SOL_SOCKET, SO_ERROR, &sockerror, &errlen ) )
214                        return jabber_bs_abort( bt, "getsockopt() failed, unknown socket error during SOCKS5 handshake (weird!)" );
215
216                if ( bt->phase == BS_PHASE_CONNECTED )
217                        return jabber_bs_abort( bt, "connect failed: %s", strerror( sockerror ) );
218
219                return jabber_bs_abort( bt, "Socket error during SOCKS5 handshake(weird!): %s", strerror( sockerror ) );
220        }
221
222        if( pfd.revents & POLLHUP )
223                return jabber_bs_abort( bt, "Remote end closed connection" );
224       
225        *revents = pfd.revents;
226       
227        return TRUE;
228}
229
230/*
231 * Used for receive and send path.
232 */
233gboolean jabber_bs_abort( struct bs_transfer *bt, char *format, ... )
234{
235        va_list params;
236        va_start( params, format );
237        char error[128];
238
239        if( vsnprintf( error, 128, format, params ) < 0 )
240                sprintf( error, "internal error parsing error string (BUG)" );
241        va_end( params );
242        if( bt->tf->ft->sending )
243                return jabber_bs_send_handshake_abort( bt, error );
244        else
245                return jabber_bs_recv_handshake_abort( bt, error );
246}
247
248/* Bad luck */
249void jabber_bs_canceled( file_transfer_t *ft , char *reason )
250{
251        struct jabber_transfer *tf = ft->data;
252
253        imcb_log( tf->ic, "File transfer aborted: %s", reason );
254}
255
256/*
257 * Parses an incoming bytestream request and calls jabber_bs_handshake on success.
258 */
259int jabber_bs_recv_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode)
260{
261        char *sid, *ini_jid, *tgt_jid, *mode, *iq_id;
262        struct jabber_data *jd = ic->proto_data;
263        struct jabber_transfer *tf = NULL;
264        GSList *tflist;
265        struct bs_transfer *bt;
266        GSList *shlist=NULL;
267        struct xt_node *shnode;
268
269        sha1_state_t sha;
270        char hash_hex[41];
271        unsigned char hash[20];
272        int i;
273       
274        if( !(iq_id   = xt_find_attr( node, "id" ) ) ||
275            !(ini_jid = xt_find_attr( node, "from" ) ) ||
276            !(tgt_jid = xt_find_attr( node, "to" ) ) ||
277            !(sid     = xt_find_attr( qnode, "sid" ) ) )
278        {
279                imcb_log( ic, "WARNING: Received incomplete SI bytestream request");
280                return XT_HANDLED;
281        }
282
283        if( ( mode = xt_find_attr( qnode, "mode" ) ) &&
284              ( strcmp( mode, "tcp" ) != 0 ) ) 
285        {
286                imcb_log( ic, "WARNING: Received SI Request for unsupported bytestream mode %s", xt_find_attr( qnode, "mode" ) );
287                return XT_HANDLED;
288        }
289
290        shnode = qnode->children;
291        while( ( shnode = xt_find_node( shnode, "streamhost" ) ) )
292        {
293                char *jid, *host, *port_s;
294                int port;
295                if( ( jid = xt_find_attr( shnode, "jid" ) ) &&
296                    ( host = xt_find_attr( shnode, "host" ) ) &&
297                    ( port_s = xt_find_attr( shnode, "port" ) ) &&
298                    ( sscanf( port_s, "%d", &port ) == 1 ) )
299                {
300                        jabber_streamhost_t *sh = g_new0( jabber_streamhost_t, 1 );
301                        sh->jid = g_strdup(jid);
302                        sh->host = g_strdup(host);
303                        sprintf( sh->port, "%u", port );
304                        shlist = g_slist_append( shlist, sh );
305                }
306                shnode = shnode->next;
307        }
308       
309        if( !shlist )
310        {
311                imcb_log( ic, "WARNING: Received incomplete SI bytestream request, no parseable streamhost entries");
312                return XT_HANDLED;
313        }
314
315        /* Let's see if we can find out what this bytestream should be for... */
316
317        for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
318        {
319                struct jabber_transfer *tft = tflist->data;
320                if( ( strcmp( tft->sid, sid ) == 0 ) &&
321                    ( strcmp( tft->ini_jid, ini_jid ) == 0 ) &&
322                    ( strcmp( tft->tgt_jid, tgt_jid ) == 0 ) )
323                {
324                        tf = tft;
325                        break;
326                }
327        }
328
329        if (!tf) 
330        {
331                imcb_log( ic, "WARNING: Received bytestream request from %s that doesn't match an SI request", ini_jid );
332                return XT_HANDLED;
333        }
334
335        /* iq_id and canceled can be reused since SI is done */
336        g_free( tf->iq_id );
337        tf->iq_id = g_strdup( iq_id );
338
339        tf->ft->canceled = jabber_bs_canceled;
340
341        /* SHA1( SID + Initiator JID + Target JID ) is given to the streamhost which it will match against the initiator's value */
342        sha1_init( &sha );
343        sha1_append( &sha, (unsigned char*) sid, strlen( sid ) );
344        sha1_append( &sha, (unsigned char*) ini_jid, strlen( ini_jid ) );
345        sha1_append( &sha, (unsigned char*) tgt_jid, strlen( tgt_jid ) );
346        sha1_finish( &sha, hash );
347       
348        for( i = 0; i < 20; i ++ )
349                sprintf( hash_hex + i * 2, "%02x", hash[i] );
350               
351        bt = g_new0( struct bs_transfer, 1 );
352        bt->tf = tf;
353        bt->streamhosts = shlist;
354        bt->sh = shlist->data;
355        bt->phase = BS_PHASE_CONNECT;
356        bt->pseudoadr = g_strdup( hash_hex );
357        tf->streamhandle = bt;
358        tf->ft->free = jabber_bs_free_transfer;
359
360        jabber_bs_recv_handshake( bt, -1, 0 ); 
361
362        return XT_HANDLED;
363}
364
365/*
366 * This is what a protocol handshake can look like in cooperative multitasking :)
367 * Might be confusing at first because it's called from different places and is recursing.
368 * (places being the event thread, bs_request, bs_handshake_abort, and itself)
369 *
370 * All in all, it turned out quite nice :)
371 */
372gboolean jabber_bs_recv_handshake( gpointer data, gint fd, b_input_condition cond )
373{
374
375        struct bs_transfer *bt = data;
376        short revents;
377        int gret;
378
379        if ( ( fd != -1 ) && !jabber_bs_poll( bt, fd, &revents ) )
380                return FALSE;
381       
382        switch( bt->phase ) 
383        {
384        case BS_PHASE_CONNECT:
385                {
386                        struct addrinfo hints, *rp;
387
388                        memset( &hints, 0, sizeof( struct addrinfo ) );
389                        hints.ai_socktype = SOCK_STREAM;
390
391                        if ( ( gret = getaddrinfo( bt->sh->host, bt->sh->port, &hints, &rp ) ) != 0 )
392                                return jabber_bs_abort( bt, "getaddrinfo() failed: %s", gai_strerror( gret ) );
393
394                        ASSERTSOCKOP( bt->tf->fd = fd = socket( rp->ai_family, rp->ai_socktype, 0 ), "Opening socket" );
395
396                        sock_make_nonblocking( fd );
397
398                        imcb_log( bt->tf->ic, "File %s: Connecting to streamhost %s:%s", bt->tf->ft->file_name, bt->sh->host, bt->sh->port );
399
400                        if( ( connect( fd, rp->ai_addr, rp->ai_addrlen ) == -1 ) &&
401                            ( errno != EINPROGRESS ) )
402                                return jabber_bs_abort( bt , "connect() failed: %s", strerror( errno ) );
403
404                        freeaddrinfo( rp );
405
406                        bt->phase = BS_PHASE_CONNECTED;
407                       
408                        bt->tf->watch_out = b_input_add( fd, B_EV_IO_WRITE, jabber_bs_recv_handshake, bt );
409
410                        /* since it takes forever(3mins?) till connect() fails on itself we schedule a timeout */
411                        bt->connect_timeout = b_timeout_add( JABBER_BS_CONTIMEOUT * 1000, jabber_bs_connect_timeout, bt );
412
413                        bt->tf->watch_in = 0;
414                        return FALSE;
415                }
416        case BS_PHASE_CONNECTED:
417                {
418                        struct {
419                                unsigned char ver;
420                                unsigned char nmethods;
421                                unsigned char method;
422                        } socks5_hello = {
423                                .ver = 5,
424                                .nmethods = 1,
425                                .method = 0x00 /* no auth */
426                                /* one could also implement username/password. If you know
427                                 * a jabber client or proxy that actually does it, tell me.
428                                 */
429                        };
430                       
431                        ASSERTSOCKOP( send( fd, &socks5_hello, sizeof( socks5_hello ) , 0 ), "Sending auth request" );
432
433                        bt->phase = BS_PHASE_REQUEST;
434
435                        bt->tf->watch_in = b_input_add( fd, B_EV_IO_READ, jabber_bs_recv_handshake, bt );
436
437                        bt->tf->watch_out = 0;
438                        return FALSE;
439                }
440        case BS_PHASE_REQUEST:
441                {
442                        struct socks5_message socks5_connect = 
443                        {
444                                .ver = 5,
445                                .cmdrep.cmd = 0x01,
446                                .rsv = 0,
447                                .atyp = 0x03,
448                                .addrlen = strlen( bt->pseudoadr ),
449                                .port = 0
450                        };
451                        int ret;
452                        char buf[2];
453
454                        /* If someone's trying to be funny and sends only one byte at a time we'll fail :) */
455                        ASSERTSOCKOP( ret = recv( fd, buf, 2, 0 ) , "Receiving auth reply" );
456
457                        if( !( ret == 2 ) ||
458                            !( buf[0] == 5 ) ||
459                            !( buf[1] == 0 ) )
460                                return jabber_bs_abort( bt, "Auth not accepted by streamhost (reply: len=%d, ver=%d, status=%d)",
461                                                                        ret, buf[0], buf[1] );
462
463                        /* copy hash into connect message */
464                        memcpy( socks5_connect.address, bt->pseudoadr, socks5_connect.addrlen );
465
466                        ASSERTSOCKOP( send( fd, &socks5_connect, sizeof( struct socks5_message ), 0 ) , "Sending SOCKS5 Connect" );
467
468                        bt->phase = BS_PHASE_REPLY;
469
470                        return TRUE;
471                }
472        case BS_PHASE_REPLY:
473                {
474                        struct socks5_message socks5_reply;
475                        int ret;
476
477                        if ( !( ret = jabber_bs_peek( bt, &socks5_reply, sizeof( struct socks5_message ) ) ) )
478                                return FALSE;
479
480                        if ( ret < 5 ) /* header up to address length */
481                                return TRUE;
482                        else if( ret < sizeof( struct socks5_message ) )
483                        {
484                                /* Either a buggy proxy or just one that doesnt regard
485                                 * the SHOULD in XEP-0065 saying the reply SHOULD
486                                 * contain the address. We'll take it, so make sure the
487                                 * next jabber_bs_peek starts with an empty buffer. */
488                                bt->peek_buf_len = 0;
489                        }
490
491                        if( !( socks5_reply.ver == 5 ) ||
492                            !( socks5_reply.cmdrep.rep == 0 ) ) {
493                                char errstr[128] = "";
494                                if( ( socks5_reply.ver == 5 ) && ( socks5_reply.cmdrep.rep < 
495                                    ( sizeof( socks5_reply_code ) / sizeof( socks5_reply_code[0] ) ) ) ) {
496                                        sprintf( errstr, "with \"%s\" ", socks5_reply_code[ socks5_reply.cmdrep.rep ] );
497                                }
498                                return jabber_bs_abort( bt, "SOCKS5 CONNECT failed %s(reply: ver=%d, rep=%d, atyp=%d, addrlen=%d)", 
499                                        errstr,
500                                        socks5_reply.ver,
501                                        socks5_reply.cmdrep.rep,
502                                        socks5_reply.atyp,
503                                        socks5_reply.addrlen);
504                        }
505                       
506                        /* usually a proxy sends back the 40 bytes address but I encountered at least one (of jabber.cz)
507                         * that sends atyp=0 addrlen=0 and only 6 bytes (one less than one would expect).
508                         * Therefore I removed the wait for more bytes. Since we don't care about what else the proxy
509                         * is sending, it shouldnt matter */
510
511                        if( bt->tf->ft->sending )
512                                jabber_bs_send_activate( bt );
513                        else
514                                jabber_bs_recv_answer_request( bt );
515
516                        return FALSE;
517                }
518        default:
519                /* BUG */
520                imcb_log( bt->tf->ic, "BUG in file transfer code: undefined handshake phase" );
521
522                bt->tf->watch_in = 0;
523                return FALSE;
524        }
525}
526
527/*
528 * If the handshake failed we can try the next streamhost, if there is one.
529 * An intelligent sender would probably specify himself as the first streamhost and
530 * a proxy as the second (Kopete and PSI are examples here). That way, a (potentially)
531 * slow proxy is only used if neccessary. This of course also means, that the timeout
532 * per streamhost should be kept short. If one or two firewalled adresses are specified,
533 * they have to timeout first before a proxy is tried.
534 */
535gboolean jabber_bs_recv_handshake_abort( struct bs_transfer *bt, char *error )
536{
537        struct jabber_transfer *tf = bt->tf;
538        struct xt_node *reply, *iqnode;
539        GSList *shlist;
540
541        imcb_log( tf->ic, "Transferring file %s: connection to streamhost %s:%s failed (%s)", 
542                  tf->ft->file_name, 
543                  bt->sh->host,
544                  bt->sh->port,
545                  error );
546
547        /* Alright, this streamhost failed, let's try the next... */
548        bt->phase = BS_PHASE_CONNECT;
549        shlist = g_slist_find( bt->streamhosts, bt->sh );
550        if( shlist && shlist->next )
551        {
552                bt->sh = shlist->next->data;
553                return jabber_bs_recv_handshake( bt, -1, 0 );
554        }
555
556
557        /* out of stream hosts */
558
559        iqnode = jabber_make_packet( "iq", "result", tf->ini_jid, NULL );
560        reply = jabber_make_error_packet( iqnode, "item-not-found", "cancel" , "404" );
561        xt_free_node( iqnode );
562
563        xt_add_attr( reply, "id", tf->iq_id );
564               
565        if( !jabber_write_packet( tf->ic, reply ) )
566                imcb_log( tf->ic, "WARNING: Error transmitting bytestream response" );
567        xt_free_node( reply );
568
569        imcb_file_canceled( tf->ic, tf->ft, "couldn't connect to any streamhosts" );
570
571        /* MUST always return FALSE! */
572        return FALSE;
573}
574
575/*
576 * After the SOCKS5 handshake succeeds we need to inform the initiator which streamhost we chose.
577 * If he is the streamhost himself, he might already know that. However, if it's a proxy,
578 * the initiator will have to make a connection himself.
579 */
580void jabber_bs_recv_answer_request( struct bs_transfer *bt )
581{
582        struct jabber_transfer *tf = bt->tf;
583        struct xt_node *reply;
584
585        imcb_log( tf->ic, "File %s: established SOCKS5 connection to %s:%s", 
586                  tf->ft->file_name, 
587                  bt->sh->host,
588                  bt->sh->port );
589
590        tf->ft->data = tf;
591        tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_recv_read, bt );
592        tf->ft->write_request = jabber_bs_recv_write_request;
593
594        reply = xt_new_node( "streamhost-used", NULL, NULL );
595        xt_add_attr( reply, "jid", bt->sh->jid );
596
597        reply = xt_new_node( "query", NULL, reply );
598        xt_add_attr( reply, "xmlns", XMLNS_BYTESTREAMS );
599
600        reply = jabber_make_packet( "iq", "result", tf->ini_jid, reply );
601
602        xt_add_attr( reply, "id", tf->iq_id );
603               
604        if( !jabber_write_packet( tf->ic, reply ) )
605                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream response" );
606        xt_free_node( reply );
607}
608
609/*
610 * This function is called from write_request directly. If no data is available, it will install itself
611 * as a watcher for input on fd and once that happens, deliver the data and unschedule itself again.
612 */
613gboolean jabber_bs_recv_read( gpointer data, gint fd, b_input_condition cond )
614{
615        int ret;
616        struct bs_transfer *bt = data;
617        struct jabber_transfer *tf = bt->tf;
618
619        if( fd != -1 ) /* called via event thread */
620        {
621                tf->watch_in = 0;
622                ASSERTSOCKOP( ret = recv( fd, tf->ft->buffer, sizeof( tf->ft->buffer ), 0 ) , "Receiving" );
623        }
624        else
625        {
626                /* called directly. There might not be any data available. */
627                if( ( ( ret = recv( tf->fd, tf->ft->buffer, sizeof( tf->ft->buffer ), 0 ) ) == -1 ) &&
628                    ( errno != EAGAIN ) )
629                    return jabber_bs_abort( bt, "Receiving: %s", strerror( errno ) );
630
631                if( ( ret == -1 ) && ( errno == EAGAIN ) )
632                {
633                        tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_recv_read, bt );
634                        return FALSE;
635                }
636        }
637
638        /* shouldn't happen since we know the file size */
639        if( ret == 0 )
640                return jabber_bs_abort( bt, "Remote end closed connection" );
641       
642        tf->bytesread += ret;
643
644        if( tf->bytesread >= tf->ft->file_size )
645                imcb_file_finished( tf->ic, tf->ft );
646
647        tf->ft->write( tf->ft, tf->ft->buffer, ret );   
648
649        return FALSE;
650}
651
652/*
653 * imc callback that is invoked when it is ready to receive some data.
654 */
655gboolean jabber_bs_recv_write_request( file_transfer_t *ft )
656{
657        struct jabber_transfer *tf = ft->data;
658
659        if( tf->watch_in )
660        {
661                imcb_file_canceled( tf->ic, ft, "BUG in jabber file transfer: write_request called when already watching for input" );
662                return FALSE;
663        }
664       
665        jabber_bs_recv_read( tf->streamhandle, -1 , 0 );
666
667        return TRUE;
668}
669
670/*
671 * Issues a write_request to imc.
672 * */
673gboolean jabber_bs_send_can_write( gpointer data, gint fd, b_input_condition cond )
674{
675        struct bs_transfer *bt = data;
676
677        bt->tf->watch_out = 0;
678
679        bt->tf->ft->write_request( bt->tf->ft );
680
681        return FALSE;
682}
683
684/*
685 * This should only be called if we can write, so just do it.
686 * Add a write watch so we can write more during the next cycle (if possible).
687 */
688gboolean jabber_bs_send_write( file_transfer_t *ft, char *buffer, unsigned int len )
689{
690        struct jabber_transfer *tf = ft->data;
691        struct bs_transfer *bt = tf->streamhandle;
692        int ret;
693
694        if( tf->watch_out )
695                return jabber_bs_abort( bt, "BUG: write() called while watching " );
696       
697        /* TODO: catch broken pipe */
698        ASSERTSOCKOP( ret = send( tf->fd, buffer, len, 0 ), "Sending" );
699
700        tf->byteswritten += ret;
701       
702        /* TODO: this should really not be fatal */
703        if( ret < len )
704                return jabber_bs_abort( bt, "send() sent %d instead of %d (send buffer too big!)", ret, len );
705
706        if( tf->byteswritten >= ft->file_size )
707                imcb_file_finished( tf->ic, ft );
708        else
709                bt->tf->watch_out = b_input_add( tf->fd, B_EV_IO_WRITE, jabber_bs_send_can_write, bt );
710               
711        return TRUE;
712}
713
714/*
715 * Handles the reply by the receiver containing the used streamhost.
716 */
717static xt_status jabber_bs_send_handle_reply(struct im_connection *ic, struct xt_node *node, struct xt_node *orig ) {
718        struct jabber_transfer *tf = NULL;
719        struct jabber_data *jd = ic->proto_data;
720        struct bs_transfer *bt;
721        GSList *tflist;
722        struct xt_node *c;
723        char *sid, *jid;
724
725        if( !( c = xt_find_node( node->children, "query" ) ) ||
726            !( c = xt_find_node( c->children, "streamhost-used" ) ) ||
727            !( jid = xt_find_attr( c, "jid" ) ) )
728
729        {
730                imcb_log( ic, "WARNING: Received incomplete bytestream reply" );
731                return XT_HANDLED;
732        }
733       
734        if( !( c = xt_find_node( orig->children, "query" ) ) ||
735            !( sid = xt_find_attr( c, "sid" ) ) )
736        {
737                imcb_log( ic, "WARNING: Error parsing request corresponding to the incoming bytestream reply" );
738                return XT_HANDLED;
739        }
740
741        /* Let's see if we can find out what this bytestream should be for... */
742
743        for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
744        {
745                struct jabber_transfer *tft = tflist->data;
746                if( ( strcmp( tft->sid, sid ) == 0 ) )
747                {
748                        tf = tft;
749                        break;
750                }
751        }
752
753        if( !tf )
754        {
755                imcb_log( ic, "WARNING: Received SOCKS5 bytestream reply to unknown request" );
756                return XT_HANDLED;
757        }
758
759        bt = tf->streamhandle;
760
761        tf->accepted = TRUE;
762
763        if( strcmp( jid, tf->ini_jid ) == 0 )
764        {
765                /* we're streamhost and target */
766                if( bt->phase == BS_PHASE_REPLY )
767                {
768                        /* handshake went through, let's start transferring */
769                        tf->ft->write_request( tf->ft );
770                }
771        } else
772        {
773                /* using a proxy, abort listen */
774
775                if( tf->watch_in )
776                {
777                        b_event_remove( tf->watch_in );
778                        tf->watch_in = 0;
779                }
780               
781                if( tf->fd != -1 ) {
782                        closesocket( tf->fd );
783                        tf->fd = -1;
784                }
785
786                if ( bt->connect_timeout )
787                {
788                        b_event_remove( bt->connect_timeout );
789                        bt->connect_timeout = 0;
790                }
791
792                GSList *shlist;
793                for( shlist = jd->streamhosts ; shlist ; shlist = g_slist_next( shlist ) )
794                {
795                        jabber_streamhost_t *sh = shlist->data;
796                        if( strcmp( sh->jid, jid ) == 0 )
797                        {
798                                bt->sh = sh;
799                                jabber_bs_recv_handshake( bt, -1, 0 );
800                                return XT_HANDLED;
801                        }
802                }
803
804                imcb_log( ic, "WARNING: Received SOCKS5 bytestream reply with unknown streamhost %s", jid );
805        }
806
807        return XT_HANDLED;
808}
809
810/*
811 * Tell the proxy to activate the stream. Looks like this:
812 *
813 * <iq type=set>
814 *      <query xmlns=bs sid=sid>
815 *              <activate>tgt_jid</activate>
816 *      </query>
817 * </iq>
818 */
819void jabber_bs_send_activate( struct bs_transfer *bt )
820{
821        struct xt_node *node;
822
823        node = xt_new_node( "activate", bt->tf->tgt_jid, NULL );
824        node = xt_new_node( "query", NULL, node );
825        xt_add_attr( node, "xmlns", XMLNS_BYTESTREAMS );
826        xt_add_attr( node, "sid", bt->tf->sid );
827        node = jabber_make_packet( "iq", "set", bt->sh->jid, node );
828
829        jabber_cache_add( bt->tf->ic, node, jabber_bs_send_handle_activate );
830
831        jabber_write_packet( bt->tf->ic, node );
832}
833
834/*
835 * The proxy has activated the bytestream.
836 * We can finally start pushing some data out.
837 */
838static xt_status jabber_bs_send_handle_activate( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
839{
840        char *sid;
841        GSList *tflist;
842        struct jabber_transfer *tf = NULL;
843        struct xt_node *query;
844        struct jabber_data *jd = ic->proto_data;
845
846        query = xt_find_node( orig->children, "query" );
847        sid = xt_find_attr( query, "sid" );
848
849        for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
850        {
851                struct jabber_transfer *tft = tflist->data;
852                if( ( strcmp( tft->sid, sid ) == 0 ) )
853                {
854                        tf = tft;
855                        break;
856                }
857        }
858
859        if( !tf )
860        {
861                imcb_log( ic, "WARNING: Received SOCKS5 bytestream activation for unknown stream" );
862                return XT_HANDLED;
863        }
864
865        imcb_log( tf->ic, "File %s: SOCKS5 handshake and activation successful! Transfer about to start...", tf->ft->file_name );
866
867        /* handshake went through, let's start transferring */
868        tf->ft->write_request( tf->ft );
869
870        return XT_HANDLED;
871}
872
873jabber_streamhost_t *jabber_si_parse_proxy( struct im_connection *ic, char *proxy )
874{
875        char *host, *port, *jid;
876        jabber_streamhost_t *sh;
877
878        if( ( ( host = strchr( proxy, ',' ) ) == 0 ) ||
879             ( ( port = strchr( host+1, ',' ) ) == 0 ) ) {
880                imcb_log( ic, "Error parsing proxy setting: \"%s\" (ignored)", proxy );
881                return NULL;
882        }
883       
884        jid = proxy;
885        *host++ = '\0';
886        *port++ = '\0';
887
888        sh = g_new0( jabber_streamhost_t, 1 );
889        sh->jid = g_strdup( jid );
890        sh->host = g_strdup( host );
891        strcpy( sh->port, port );
892
893        return sh;
894}
895
896void jabber_si_set_proxies( struct bs_transfer *bt )
897{
898        struct jabber_transfer *tf = bt->tf;
899        struct jabber_data *jd = tf->ic->proto_data;
900        char *proxysetting = g_strdup ( set_getstr( &tf->ic->acc->set, "proxy" ) );
901        char *proxy, *next, *errmsg = NULL;
902        char port[6];
903        char host[HOST_NAME_MAX+1];
904        jabber_streamhost_t *sh, *sh2;
905        GSList *streamhosts = jd->streamhosts;
906
907        proxy = proxysetting;
908        while ( proxy && ( *proxy!='\0' ) ) {
909                if( ( next = strchr( proxy, ';' ) ) )
910                        *next++ = '\0'; 
911               
912                if( strcmp( proxy, "<local>" ) == 0 ) {
913                        if( ( tf->fd = ft_listen( &tf->saddr, host, port, jd->fd, FALSE, &errmsg ) ) != -1 ) {
914                                sh = g_new0( jabber_streamhost_t, 1 );
915                                sh->jid = g_strdup( tf->ini_jid );
916                                sh->host = g_strdup( host );
917                                strcpy( sh->port, port );
918                                bt->streamhosts = g_slist_append( bt->streamhosts, sh );
919
920                                bt->tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_send_handshake, bt );
921                                bt->connect_timeout = b_timeout_add( JABBER_BS_LISTEN_TIMEOUT * 1000, jabber_bs_connect_timeout, bt );
922                        } else {
923                                imcb_log( tf->ic, "Transferring file %s: couldn't listen locally(non fatal, check your ft_listen setting in bitlbee.conf): %s",
924                                          tf->ft->file_name,
925                                          errmsg );
926                        }
927                } else if( strcmp( proxy, "<auto>" ) == 0 ) {
928                        while ( streamhosts ) {
929                                sh = g_new0( jabber_streamhost_t, 1 );
930                                sh2 = streamhosts->data;
931                                sh->jid = g_strdup( sh2->jid );
932                                sh->host = g_strdup( sh2->host );
933                                strcpy( sh->port, sh2->port );
934                                bt->streamhosts = g_slist_append( bt->streamhosts, sh );
935                                streamhosts = g_slist_next( streamhosts );
936                        }
937                } else if( ( sh = jabber_si_parse_proxy( tf->ic, proxy ) ) )
938                        bt->streamhosts = g_slist_append( bt->streamhosts, sh );
939                proxy = next;
940        }
941}
942
943/*
944 * Starts a bytestream.
945 */
946gboolean jabber_bs_send_start( struct jabber_transfer *tf )
947{
948        struct bs_transfer *bt;
949        sha1_state_t sha;
950        char hash_hex[41];
951        unsigned char hash[20];
952        int i,ret;
953
954        /* SHA1( SID + Initiator JID + Target JID ) is given to the streamhost which it will match against the initiator's value */
955        sha1_init( &sha );
956        sha1_append( &sha, (unsigned char*) tf->sid, strlen( tf->sid ) );
957        sha1_append( &sha, (unsigned char*) tf->ini_jid, strlen( tf->ini_jid ) );
958        sha1_append( &sha, (unsigned char*) tf->tgt_jid, strlen( tf->tgt_jid ) );
959        sha1_finish( &sha, hash );
960       
961        for( i = 0; i < 20; i ++ )
962                sprintf( hash_hex + i * 2, "%02x", hash[i] );
963               
964        bt = g_new0( struct bs_transfer, 1 );
965        bt->tf = tf;
966        bt->phase = BS_PHASE_CONNECT;
967        bt->pseudoadr = g_strdup( hash_hex );
968        tf->streamhandle = bt;
969        tf->ft->free = jabber_bs_free_transfer;
970        tf->ft->canceled = jabber_bs_canceled;
971
972        jabber_si_set_proxies( bt );
973
974        ret = jabber_bs_send_request( tf, bt->streamhosts);
975
976        return ret;
977}
978
979gboolean jabber_bs_send_request( struct jabber_transfer *tf, GSList *streamhosts )
980{
981        struct xt_node *shnode, *query, *iq;
982
983        query = xt_new_node( "query", NULL, NULL );
984        xt_add_attr( query, "xmlns", XMLNS_BYTESTREAMS );
985        xt_add_attr( query, "sid", tf->sid );
986        xt_add_attr( query, "mode", "tcp" );
987
988        while( streamhosts ) {
989                jabber_streamhost_t *sh = streamhosts->data;
990                shnode = xt_new_node( "streamhost", NULL, NULL );
991                xt_add_attr( shnode, "jid", sh->jid );
992                xt_add_attr( shnode, "host", sh->host );
993                xt_add_attr( shnode, "port", sh->port );
994
995                xt_add_child( query, shnode );
996
997                streamhosts = g_slist_next( streamhosts );
998        }
999
1000
1001        iq = jabber_make_packet( "iq", "set", tf->tgt_jid, query );
1002        xt_add_attr( iq, "from", tf->ini_jid );
1003
1004        jabber_cache_add( tf->ic, iq, jabber_bs_send_handle_reply );
1005
1006        if( !jabber_write_packet( tf->ic, iq ) )
1007                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream request" );
1008        return TRUE;
1009}
1010
1011gboolean jabber_bs_send_handshake_abort(struct bs_transfer *bt, char *error )
1012{
1013        struct jabber_transfer *tf = bt->tf;
1014        struct jabber_data *jd = tf->ic->proto_data;
1015
1016        /* TODO: did the receiver get here somehow??? */
1017        imcb_log( tf->ic, "Transferring file %s: SOCKS5 handshake failed: %s", 
1018                  tf->ft->file_name, 
1019                  error );
1020
1021        if( jd->streamhosts==NULL ) /* we're done here unless we have a proxy to try */
1022                imcb_file_canceled( tf->ic, tf->ft, error );
1023
1024        /* MUST always return FALSE! */
1025        return FALSE;
1026}
1027
1028/*
1029 * SOCKS5BYTESTREAM protocol for the sender
1030 */
1031gboolean jabber_bs_send_handshake( gpointer data, gint fd, b_input_condition cond )
1032{
1033        struct bs_transfer *bt = data;
1034        struct jabber_transfer *tf = bt->tf;
1035        short revents;
1036
1037        if ( !jabber_bs_poll( bt, fd, &revents ) )
1038                return FALSE;
1039       
1040        switch( bt->phase ) 
1041        {
1042        case BS_PHASE_CONNECT:
1043                {
1044                        struct sockaddr_storage clt_addr;
1045                        socklen_t ssize = sizeof( clt_addr );
1046                       
1047                        /* Connect */
1048
1049                        ASSERTSOCKOP( tf->fd = accept( fd, (struct sockaddr *) &clt_addr, &ssize ), "Accepting connection" );
1050
1051                        closesocket( fd );
1052                        fd = tf->fd;
1053                        sock_make_nonblocking( fd );
1054                       
1055                        bt->phase = BS_PHASE_CONNECTED;
1056
1057                        bt->tf->watch_in = b_input_add( fd, B_EV_IO_READ, jabber_bs_send_handshake, bt );
1058                        return FALSE;
1059                }
1060        case BS_PHASE_CONNECTED:
1061                {
1062                        int ret, have_noauth=FALSE;
1063                        struct {
1064                                unsigned char ver;
1065                                unsigned char method;
1066                        } socks5_auth_reply = { .ver = 5, .method = 0 };
1067                        struct {
1068                                unsigned char ver;
1069                                unsigned char nmethods;
1070                                unsigned char method;
1071                        } socks5_hello;
1072
1073                        if( !( ret = jabber_bs_peek( bt, &socks5_hello, sizeof( socks5_hello ) ) ) )
1074                                return FALSE;
1075
1076                        if( ret < sizeof( socks5_hello ) )
1077                                return TRUE;
1078
1079                        if( !( socks5_hello.ver == 5 ) ||
1080                            !( socks5_hello.nmethods >= 1 ) ||
1081                            !( socks5_hello.nmethods < 32 ) )
1082                                return jabber_bs_abort( bt, "Invalid auth request ver=%d nmethods=%d method=%d", socks5_hello.ver, socks5_hello.nmethods, socks5_hello.method );
1083
1084                        have_noauth = socks5_hello.method == 0;
1085
1086                        if( socks5_hello.nmethods > 1 )
1087                        {
1088                                char mbuf[32];
1089                                int i;
1090                                ASSERTSOCKOP( ret = recv( fd, mbuf, socks5_hello.nmethods - 1, 0 ) , "Receiving auth methods" );
1091                                if( ret < ( socks5_hello.nmethods - 1 ) )
1092                                        return jabber_bs_abort( bt, "Partial auth request");
1093                                for( i = 0 ; !have_noauth && ( i < socks5_hello.nmethods - 1 ) ; i ++ )
1094                                        if( mbuf[i] == 0 )
1095                                                have_noauth = TRUE;
1096                        }
1097                       
1098                        if( !have_noauth )
1099                                return jabber_bs_abort( bt, "Auth request didn't include no authentication" );
1100
1101                        ASSERTSOCKOP( send( fd, &socks5_auth_reply, sizeof( socks5_auth_reply ) , 0 ), "Sending auth reply" );
1102
1103                        bt->phase = BS_PHASE_REQUEST;
1104
1105                        return TRUE;
1106                }
1107        case BS_PHASE_REQUEST:
1108                {
1109                        struct socks5_message socks5_connect;
1110                        int msgsize = sizeof( struct socks5_message );
1111                        int ret;
1112
1113                        if( !( ret = jabber_bs_peek( bt, &socks5_connect, msgsize ) ) )
1114                                return FALSE;
1115
1116                        if( ret < msgsize )
1117                                return TRUE;
1118
1119                        if( !( socks5_connect.ver == 5) ||
1120                            !( socks5_connect.cmdrep.cmd == 1 ) ||
1121                            !( socks5_connect.atyp == 3 ) ||
1122                            !(socks5_connect.addrlen == 40 ) )
1123                                return jabber_bs_abort( bt, "Invalid SOCKS5 Connect message (addrlen=%d, ver=%d, cmd=%d, atyp=%d)", socks5_connect.addrlen, socks5_connect.ver, socks5_connect.cmdrep.cmd, socks5_connect.atyp );
1124                        if( !( memcmp( socks5_connect.address, bt->pseudoadr, 40 ) == 0 ) )
1125                                return jabber_bs_abort( bt, "SOCKS5 Connect message contained wrong digest");
1126
1127                        socks5_connect.cmdrep.rep = 0;
1128
1129                        ASSERTSOCKOP( send( fd, &socks5_connect, msgsize, 0 ), "Sending connect reply" );
1130
1131                        bt->phase = BS_PHASE_REPLY;
1132
1133                        imcb_log( tf->ic, "File %s: SOCKS5 handshake successful! Transfer about to start...", tf->ft->file_name );
1134
1135                        if( tf->accepted )
1136                        {
1137                                /* streamhost-used message came already in(possible?), let's start sending */
1138                                tf->ft->write_request( tf->ft );
1139                        }
1140
1141                        tf->watch_in = 0;
1142                        return FALSE;
1143
1144                }
1145        default:
1146                /* BUG */
1147                imcb_log( bt->tf->ic, "BUG in file transfer code: undefined handshake phase" );
1148
1149                bt->tf->watch_in = 0;
1150                return FALSE;
1151        }
1152}
1153#undef ASSERTSOCKOP
Note: See TracBrowser for help on using the repository browser.