source: protocols/jabber/s5bytestream.c @ 4aa0f6b

Last change on this file since 4aa0f6b was 4aa0f6b, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-06-07T14:31:07Z

Merging killerbee stuff, bringing all the bleeding-edge stuff together.

  • 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        bt->tf->watch_in = 0;
572        /* MUST always return FALSE! */
573        return FALSE;
574}
575
576/*
577 * After the SOCKS5 handshake succeeds we need to inform the initiator which streamhost we chose.
578 * If he is the streamhost himself, he might already know that. However, if it's a proxy,
579 * the initiator will have to make a connection himself.
580 */
581void jabber_bs_recv_answer_request( struct bs_transfer *bt )
582{
583        struct jabber_transfer *tf = bt->tf;
584        struct xt_node *reply;
585
586        imcb_log( tf->ic, "File %s: established SOCKS5 connection to %s:%s", 
587                  tf->ft->file_name, 
588                  bt->sh->host,
589                  bt->sh->port );
590
591        tf->ft->data = tf;
592        tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_recv_read, bt );
593        tf->ft->write_request = jabber_bs_recv_write_request;
594
595        reply = xt_new_node( "streamhost-used", NULL, NULL );
596        xt_add_attr( reply, "jid", bt->sh->jid );
597
598        reply = xt_new_node( "query", NULL, reply );
599        xt_add_attr( reply, "xmlns", XMLNS_BYTESTREAMS );
600
601        reply = jabber_make_packet( "iq", "result", tf->ini_jid, reply );
602
603        xt_add_attr( reply, "id", tf->iq_id );
604               
605        if( !jabber_write_packet( tf->ic, reply ) )
606                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream response" );
607        xt_free_node( reply );
608}
609
610/*
611 * This function is called from write_request directly. If no data is available, it will install itself
612 * as a watcher for input on fd and once that happens, deliver the data and unschedule itself again.
613 */
614gboolean jabber_bs_recv_read( gpointer data, gint fd, b_input_condition cond )
615{
616        int ret;
617        struct bs_transfer *bt = data;
618        struct jabber_transfer *tf = bt->tf;
619
620        if( fd != -1 ) /* called via event thread */
621        {
622                tf->watch_in = 0;
623                ASSERTSOCKOP( ret = recv( fd, tf->ft->buffer, sizeof( tf->ft->buffer ), 0 ) , "Receiving" );
624        }
625        else
626        {
627                /* called directly. There might not be any data available. */
628                if( ( ( ret = recv( tf->fd, tf->ft->buffer, sizeof( tf->ft->buffer ), 0 ) ) == -1 ) &&
629                    ( errno != EAGAIN ) )
630                    return jabber_bs_abort( bt, "Receiving: %s", strerror( errno ) );
631
632                if( ( ret == -1 ) && ( errno == EAGAIN ) )
633                {
634                        tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_recv_read, bt );
635                        return FALSE;
636                }
637        }
638
639        /* shouldn't happen since we know the file size */
640        if( ret == 0 )
641                return jabber_bs_abort( bt, "Remote end closed connection" );
642       
643        tf->bytesread += ret;
644
645        if( tf->bytesread >= tf->ft->file_size )
646                imcb_file_finished( tf->ic, tf->ft );
647
648        tf->ft->write( tf->ft, tf->ft->buffer, ret );   
649
650        return FALSE;
651}
652
653/*
654 * imc callback that is invoked when it is ready to receive some data.
655 */
656gboolean jabber_bs_recv_write_request( file_transfer_t *ft )
657{
658        struct jabber_transfer *tf = ft->data;
659
660        if( tf->watch_in )
661        {
662                imcb_file_canceled( tf->ic, ft, "BUG in jabber file transfer: write_request called when already watching for input" );
663                return FALSE;
664        }
665       
666        jabber_bs_recv_read( tf->streamhandle, -1 , 0 );
667
668        return TRUE;
669}
670
671/*
672 * Issues a write_request to imc.
673 * */
674gboolean jabber_bs_send_can_write( gpointer data, gint fd, b_input_condition cond )
675{
676        struct bs_transfer *bt = data;
677
678        bt->tf->watch_out = 0;
679
680        bt->tf->ft->write_request( bt->tf->ft );
681
682        return FALSE;
683}
684
685/*
686 * This should only be called if we can write, so just do it.
687 * Add a write watch so we can write more during the next cycle (if possible).
688 */
689gboolean jabber_bs_send_write( file_transfer_t *ft, char *buffer, unsigned int len )
690{
691        struct jabber_transfer *tf = ft->data;
692        struct bs_transfer *bt = tf->streamhandle;
693        int ret;
694
695        if( tf->watch_out )
696                return jabber_bs_abort( bt, "BUG: write() called while watching " );
697       
698        /* TODO: catch broken pipe */
699        ASSERTSOCKOP( ret = send( tf->fd, buffer, len, 0 ), "Sending" );
700
701        tf->byteswritten += ret;
702       
703        /* TODO: this should really not be fatal */
704        if( ret < len )
705                return jabber_bs_abort( bt, "send() sent %d instead of %d (send buffer too big!)", ret, len );
706
707        if( tf->byteswritten >= ft->file_size )
708                imcb_file_finished( tf->ic, ft );
709        else
710                bt->tf->watch_out = b_input_add( tf->fd, B_EV_IO_WRITE, jabber_bs_send_can_write, bt );
711               
712        return TRUE;
713}
714
715/*
716 * Handles the reply by the receiver containing the used streamhost.
717 */
718static xt_status jabber_bs_send_handle_reply(struct im_connection *ic, struct xt_node *node, struct xt_node *orig ) {
719        struct jabber_transfer *tf = NULL;
720        struct jabber_data *jd = ic->proto_data;
721        struct bs_transfer *bt;
722        GSList *tflist;
723        struct xt_node *c;
724        char *sid, *jid;
725
726        if( !( c = xt_find_node( node->children, "query" ) ) ||
727            !( c = xt_find_node( c->children, "streamhost-used" ) ) ||
728            !( jid = xt_find_attr( c, "jid" ) ) )
729
730        {
731                imcb_log( ic, "WARNING: Received incomplete bytestream reply" );
732                return XT_HANDLED;
733        }
734       
735        if( !( c = xt_find_node( orig->children, "query" ) ) ||
736            !( sid = xt_find_attr( c, "sid" ) ) )
737        {
738                imcb_log( ic, "WARNING: Error parsing request corresponding to the incoming bytestream reply" );
739                return XT_HANDLED;
740        }
741
742        /* Let's see if we can find out what this bytestream should be for... */
743
744        for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
745        {
746                struct jabber_transfer *tft = tflist->data;
747                if( ( strcmp( tft->sid, sid ) == 0 ) )
748                {
749                        tf = tft;
750                        break;
751                }
752        }
753
754        if( !tf )
755        {
756                imcb_log( ic, "WARNING: Received SOCKS5 bytestream reply to unknown request" );
757                return XT_HANDLED;
758        }
759
760        bt = tf->streamhandle;
761
762        tf->accepted = TRUE;
763
764        if( strcmp( jid, tf->ini_jid ) == 0 )
765        {
766                /* we're streamhost and target */
767                if( bt->phase == BS_PHASE_REPLY )
768                {
769                        /* handshake went through, let's start transferring */
770                        tf->ft->write_request( tf->ft );
771                }
772        } else
773        {
774                /* using a proxy, abort listen */
775
776                if( tf->watch_in )
777                {
778                        b_event_remove( tf->watch_in );
779                        tf->watch_in = 0;
780                }
781               
782                if( tf->fd != -1 ) {
783                        closesocket( tf->fd );
784                        tf->fd = -1;
785                }
786
787                if ( bt->connect_timeout )
788                {
789                        b_event_remove( bt->connect_timeout );
790                        bt->connect_timeout = 0;
791                }
792
793                GSList *shlist;
794                for( shlist = jd->streamhosts ; shlist ; shlist = g_slist_next( shlist ) )
795                {
796                        jabber_streamhost_t *sh = shlist->data;
797                        if( strcmp( sh->jid, jid ) == 0 )
798                        {
799                                bt->sh = sh;
800                                jabber_bs_recv_handshake( bt, -1, 0 );
801                                return XT_HANDLED;
802                        }
803                }
804
805                imcb_log( ic, "WARNING: Received SOCKS5 bytestream reply with unknown streamhost %s", jid );
806        }
807
808        return XT_HANDLED;
809}
810
811/*
812 * Tell the proxy to activate the stream. Looks like this:
813 *
814 * <iq type=set>
815 *      <query xmlns=bs sid=sid>
816 *              <activate>tgt_jid</activate>
817 *      </query>
818 * </iq>
819 */
820void jabber_bs_send_activate( struct bs_transfer *bt )
821{
822        struct xt_node *node;
823
824        node = xt_new_node( "activate", bt->tf->tgt_jid, NULL );
825        node = xt_new_node( "query", NULL, node );
826        xt_add_attr( node, "xmlns", XMLNS_BYTESTREAMS );
827        xt_add_attr( node, "sid", bt->tf->sid );
828        node = jabber_make_packet( "iq", "set", bt->sh->jid, node );
829
830        jabber_cache_add( bt->tf->ic, node, jabber_bs_send_handle_activate );
831
832        jabber_write_packet( bt->tf->ic, node );
833}
834
835/*
836 * The proxy has activated the bytestream.
837 * We can finally start pushing some data out.
838 */
839static xt_status jabber_bs_send_handle_activate( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
840{
841        char *sid;
842        GSList *tflist;
843        struct jabber_transfer *tf = NULL;
844        struct xt_node *query;
845        struct jabber_data *jd = ic->proto_data;
846
847        query = xt_find_node( orig->children, "query" );
848        sid = xt_find_attr( query, "sid" );
849
850        for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
851        {
852                struct jabber_transfer *tft = tflist->data;
853                if( ( strcmp( tft->sid, sid ) == 0 ) )
854                {
855                        tf = tft;
856                        break;
857                }
858        }
859
860        if( !tf )
861        {
862                imcb_log( ic, "WARNING: Received SOCKS5 bytestream activation for unknown stream" );
863                return XT_HANDLED;
864        }
865
866        imcb_log( tf->ic, "File %s: SOCKS5 handshake and activation successful! Transfer about to start...", tf->ft->file_name );
867
868        /* handshake went through, let's start transferring */
869        tf->ft->write_request( tf->ft );
870
871        return XT_HANDLED;
872}
873
874jabber_streamhost_t *jabber_si_parse_proxy( struct im_connection *ic, char *proxy )
875{
876        char *host, *port, *jid;
877        jabber_streamhost_t *sh;
878
879        if( ( ( host = strchr( proxy, ',' ) ) == 0 ) ||
880             ( ( port = strchr( host+1, ',' ) ) == 0 ) ) {
881                imcb_log( ic, "Error parsing proxy setting: \"%s\" (ignored)", proxy );
882                return NULL;
883        }
884       
885        jid = proxy;
886        *host++ = '\0';
887        *port++ = '\0';
888
889        sh = g_new0( jabber_streamhost_t, 1 );
890        sh->jid = g_strdup( jid );
891        sh->host = g_strdup( host );
892        strcpy( sh->port, port );
893
894        return sh;
895}
896
897void jabber_si_set_proxies( struct bs_transfer *bt )
898{
899        struct jabber_transfer *tf = bt->tf;
900        struct jabber_data *jd = tf->ic->proto_data;
901        char *proxysetting = g_strdup ( set_getstr( &tf->ic->acc->set, "proxy" ) );
902        char *proxy, *next, *errmsg = NULL;
903        char port[6];
904        char host[HOST_NAME_MAX+1];
905        jabber_streamhost_t *sh, *sh2;
906        GSList *streamhosts = jd->streamhosts;
907
908        proxy = proxysetting;
909        while ( proxy && ( *proxy!='\0' ) ) {
910                if( ( next = strchr( proxy, ';' ) ) )
911                        *next++ = '\0'; 
912               
913                if( strcmp( proxy, "<local>" ) == 0 ) {
914                        if( ( tf->fd = ft_listen( &tf->saddr, host, port, FALSE, &errmsg ) ) != -1 ) {
915                                sh = g_new0( jabber_streamhost_t, 1 );
916                                sh->jid = g_strdup( tf->ini_jid );
917                                sh->host = g_strdup( host );
918                                strcpy( sh->port, port );
919                                bt->streamhosts = g_slist_append( bt->streamhosts, sh );
920
921                                bt->tf->watch_in = b_input_add( tf->fd, B_EV_IO_READ, jabber_bs_send_handshake, bt );
922                                bt->connect_timeout = b_timeout_add( JABBER_BS_LISTEN_TIMEOUT * 1000, jabber_bs_connect_timeout, bt );
923                        } else {
924                                imcb_log( tf->ic, "Transferring file %s: couldn't listen locally(non fatal, check your ft_listen setting in bitlbee.conf): %s",
925                                          tf->ft->file_name,
926                                          errmsg );
927                        }
928                } else if( strcmp( proxy, "<auto>" ) == 0 ) {
929                        while ( streamhosts ) {
930                                sh = g_new0( jabber_streamhost_t, 1 );
931                                sh2 = streamhosts->data;
932                                sh->jid = g_strdup( sh2->jid );
933                                sh->host = g_strdup( sh2->host );
934                                strcpy( sh->port, sh2->port );
935                                bt->streamhosts = g_slist_append( bt->streamhosts, sh );
936                                streamhosts = g_slist_next( streamhosts );
937                        }
938                } else if( ( sh = jabber_si_parse_proxy( tf->ic, proxy ) ) )
939                        bt->streamhosts = g_slist_append( bt->streamhosts, sh );
940                proxy = next;
941        }
942}
943
944/*
945 * Starts a bytestream.
946 */
947gboolean jabber_bs_send_start( struct jabber_transfer *tf )
948{
949        struct bs_transfer *bt;
950        sha1_state_t sha;
951        char hash_hex[41];
952        unsigned char hash[20];
953        int i,ret;
954
955        /* SHA1( SID + Initiator JID + Target JID ) is given to the streamhost which it will match against the initiator's value */
956        sha1_init( &sha );
957        sha1_append( &sha, (unsigned char*) tf->sid, strlen( tf->sid ) );
958        sha1_append( &sha, (unsigned char*) tf->ini_jid, strlen( tf->ini_jid ) );
959        sha1_append( &sha, (unsigned char*) tf->tgt_jid, strlen( tf->tgt_jid ) );
960        sha1_finish( &sha, hash );
961       
962        for( i = 0; i < 20; i ++ )
963                sprintf( hash_hex + i * 2, "%02x", hash[i] );
964               
965        bt = g_new0( struct bs_transfer, 1 );
966        bt->tf = tf;
967        bt->phase = BS_PHASE_CONNECT;
968        bt->pseudoadr = g_strdup( hash_hex );
969        tf->streamhandle = bt;
970        tf->ft->free = jabber_bs_free_transfer;
971        tf->ft->canceled = jabber_bs_canceled;
972
973        jabber_si_set_proxies( bt );
974
975        ret = jabber_bs_send_request( tf, bt->streamhosts);
976
977        return ret;
978}
979
980gboolean jabber_bs_send_request( struct jabber_transfer *tf, GSList *streamhosts )
981{
982        struct xt_node *shnode, *query, *iq;
983
984        query = xt_new_node( "query", NULL, NULL );
985        xt_add_attr( query, "xmlns", XMLNS_BYTESTREAMS );
986        xt_add_attr( query, "sid", tf->sid );
987        xt_add_attr( query, "mode", "tcp" );
988
989        while( streamhosts ) {
990                jabber_streamhost_t *sh = streamhosts->data;
991                shnode = xt_new_node( "streamhost", NULL, NULL );
992                xt_add_attr( shnode, "jid", sh->jid );
993                xt_add_attr( shnode, "host", sh->host );
994                xt_add_attr( shnode, "port", sh->port );
995
996                xt_add_child( query, shnode );
997
998                streamhosts = g_slist_next( streamhosts );
999        }
1000
1001
1002        iq = jabber_make_packet( "iq", "set", tf->tgt_jid, query );
1003        xt_add_attr( iq, "from", tf->ini_jid );
1004
1005        jabber_cache_add( tf->ic, iq, jabber_bs_send_handle_reply );
1006
1007        if( !jabber_write_packet( tf->ic, iq ) )
1008                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream request" );
1009        return TRUE;
1010}
1011
1012gboolean jabber_bs_send_handshake_abort(struct bs_transfer *bt, char *error )
1013{
1014        struct jabber_transfer *tf = bt->tf;
1015        struct jabber_data *jd = tf->ic->proto_data;
1016
1017        /* TODO: did the receiver get here somehow??? */
1018        imcb_log( tf->ic, "Transferring file %s: SOCKS5 handshake failed: %s", 
1019                  tf->ft->file_name, 
1020                  error );
1021
1022        if( jd->streamhosts==NULL ) /* we're done here unless we have a proxy to try */
1023                imcb_file_canceled( tf->ic, tf->ft, error );
1024
1025        /* MUST always return FALSE! */
1026        return FALSE;
1027}
1028
1029/*
1030 * SOCKS5BYTESTREAM protocol for the sender
1031 */
1032gboolean jabber_bs_send_handshake( gpointer data, gint fd, b_input_condition cond )
1033{
1034        struct bs_transfer *bt = data;
1035        struct jabber_transfer *tf = bt->tf;
1036        short revents;
1037
1038        if ( !jabber_bs_poll( bt, fd, &revents ) )
1039                return FALSE;
1040       
1041        switch( bt->phase ) 
1042        {
1043        case BS_PHASE_CONNECT:
1044                {
1045                        struct sockaddr_storage clt_addr;
1046                        socklen_t ssize = sizeof( clt_addr );
1047                       
1048                        /* Connect */
1049
1050                        ASSERTSOCKOP( tf->fd = accept( fd, (struct sockaddr *) &clt_addr, &ssize ), "Accepting connection" );
1051
1052                        closesocket( fd );
1053                        fd = tf->fd;
1054                        sock_make_nonblocking( fd );
1055                       
1056                        bt->phase = BS_PHASE_CONNECTED;
1057
1058                        bt->tf->watch_in = b_input_add( fd, B_EV_IO_READ, jabber_bs_send_handshake, bt );
1059                        return FALSE;
1060                }
1061        case BS_PHASE_CONNECTED:
1062                {
1063                        int ret, have_noauth=FALSE;
1064                        struct {
1065                                unsigned char ver;
1066                                unsigned char method;
1067                        } socks5_auth_reply = { .ver = 5, .method = 0 };
1068                        struct {
1069                                unsigned char ver;
1070                                unsigned char nmethods;
1071                                unsigned char method;
1072                        } socks5_hello;
1073
1074                        if( !( ret = jabber_bs_peek( bt, &socks5_hello, sizeof( socks5_hello ) ) ) )
1075                                return FALSE;
1076
1077                        if( ret < sizeof( socks5_hello ) )
1078                                return TRUE;
1079
1080                        if( !( socks5_hello.ver == 5 ) ||
1081                            !( socks5_hello.nmethods >= 1 ) ||
1082                            !( socks5_hello.nmethods < 32 ) )
1083                                return jabber_bs_abort( bt, "Invalid auth request ver=%d nmethods=%d method=%d", socks5_hello.ver, socks5_hello.nmethods, socks5_hello.method );
1084
1085                        have_noauth = socks5_hello.method == 0;
1086
1087                        if( socks5_hello.nmethods > 1 )
1088                        {
1089                                char mbuf[32];
1090                                int i;
1091                                ASSERTSOCKOP( ret = recv( fd, mbuf, socks5_hello.nmethods - 1, 0 ) , "Receiving auth methods" );
1092                                if( ret < ( socks5_hello.nmethods - 1 ) )
1093                                        return jabber_bs_abort( bt, "Partial auth request");
1094                                for( i = 0 ; !have_noauth && ( i < socks5_hello.nmethods - 1 ) ; i ++ )
1095                                        if( mbuf[i] == 0 )
1096                                                have_noauth = TRUE;
1097                        }
1098                       
1099                        if( !have_noauth )
1100                                return jabber_bs_abort( bt, "Auth request didn't include no authentication" );
1101
1102                        ASSERTSOCKOP( send( fd, &socks5_auth_reply, sizeof( socks5_auth_reply ) , 0 ), "Sending auth reply" );
1103
1104                        bt->phase = BS_PHASE_REQUEST;
1105
1106                        return TRUE;
1107                }
1108        case BS_PHASE_REQUEST:
1109                {
1110                        struct socks5_message socks5_connect;
1111                        int msgsize = sizeof( struct socks5_message );
1112                        int ret;
1113
1114                        if( !( ret = jabber_bs_peek( bt, &socks5_connect, msgsize ) ) )
1115                                return FALSE;
1116
1117                        if( ret < msgsize )
1118                                return TRUE;
1119
1120                        if( !( socks5_connect.ver == 5) ||
1121                            !( socks5_connect.cmdrep.cmd == 1 ) ||
1122                            !( socks5_connect.atyp == 3 ) ||
1123                            !(socks5_connect.addrlen == 40 ) )
1124                                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 );
1125                        if( !( memcmp( socks5_connect.address, bt->pseudoadr, 40 ) == 0 ) )
1126                                return jabber_bs_abort( bt, "SOCKS5 Connect message contained wrong digest");
1127
1128                        socks5_connect.cmdrep.rep = 0;
1129
1130                        ASSERTSOCKOP( send( fd, &socks5_connect, msgsize, 0 ), "Sending connect reply" );
1131
1132                        bt->phase = BS_PHASE_REPLY;
1133
1134                        imcb_log( tf->ic, "File %s: SOCKS5 handshake successful! Transfer about to start...", tf->ft->file_name );
1135
1136                        if( tf->accepted )
1137                        {
1138                                /* streamhost-used message came already in(possible?), let's start sending */
1139                                tf->ft->write_request( tf->ft );
1140                        }
1141
1142                        tf->watch_in = 0;
1143                        return FALSE;
1144
1145                }
1146        default:
1147                /* BUG */
1148                imcb_log( bt->tf->ic, "BUG in file transfer code: undefined handshake phase" );
1149
1150                bt->tf->watch_in = 0;
1151                return FALSE;
1152        }
1153}
1154#undef ASSERTSOCKOP
Note: See TracBrowser for help on using the repository browser.