source: protocols/jabber/io.c @ 8fb1263

Last change on this file since 8fb1263 was 8fb1263, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-03-14T17:45:33Z

Don't send bind and session requests at the same time when logging in
because some very picky jabberd's don't like it. (Fixes Bug #569)

  • Property mode set to 100644
File size: 15.8 KB
RevLine 
[21167d2]1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Jabber module - I/O stuff (plain, SSL), queues, etc                      *
5*                                                                           *
6*  Copyright 2006 Wilmer van der Gaast <wilmer@gaast.net>                   *
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"
[42127dc]25#include "ssl_client.h"
[21167d2]26
27static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond );
[0da65d5]28static gboolean jabber_write_queue( struct im_connection *ic );
[21167d2]29
[0da65d5]30int jabber_write_packet( struct im_connection *ic, struct xt_node *node )
[21167d2]31{
32        char *buf;
33        int st;
34       
35        buf = xt_to_string( node );
[0da65d5]36        st = jabber_write( ic, buf, strlen( buf ) );
[21167d2]37        g_free( buf );
38       
39        return st;
40}
41
[0da65d5]42int jabber_write( struct im_connection *ic, char *buf, int len )
[21167d2]43{
[0da65d5]44        struct jabber_data *jd = ic->proto_data;
[cc2cb2d]45        gboolean ret;
[21167d2]46       
[bb95d43]47        if( jd->flags & JFLAG_XMLCONSOLE )
48        {
49                char *msg;
50               
51                msg = g_strdup_printf( "TX: %s", buf );
52                imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 );
53                g_free( msg );
54        }
55       
[21167d2]56        if( jd->tx_len == 0 )
57        {
58                /* If the queue is empty, allocate a new buffer. */
59                jd->tx_len = len;
60                jd->txq = g_memdup( buf, len );
61               
62                /* Try if we can write it immediately so we don't have to do
63                   it via the event handler. If not, add the handler. (In
64                   most cases it probably won't be necessary.) */
[0da65d5]65                if( ( ret = jabber_write_queue( ic ) ) && jd->tx_len > 0 )
66                        jd->w_inpa = b_input_add( jd->fd, GAIM_INPUT_WRITE, jabber_write_callback, ic );
[21167d2]67        }
68        else
69        {
70                /* Just add it to the buffer if it's already filled. The
71                   event handler is already set. */
72                jd->txq = g_renew( char, jd->txq, jd->tx_len + len );
73                memcpy( jd->txq + jd->tx_len, buf, len );
74                jd->tx_len += len;
[cc2cb2d]75               
76                /* The return value for write() doesn't necessarily mean
77                   that everything got sent, it mainly means that the
78                   connection (officially) still exists and can still
79                   be accessed without hitting SIGSEGV. IOW: */
80                ret = TRUE;
[21167d2]81        }
82       
[cc2cb2d]83        return ret;
[21167d2]84}
85
[cc2cb2d]86/* Splitting up in two separate functions: One to use as a callback and one
87   to use in the function above to escape from having to wait for the event
88   handler to call us, if possible.
89   
90   Two different functions are necessary because of the return values: The
91   callback should only return TRUE if the write was successful AND if the
92   buffer is not empty yet (ie. if the handler has to be called again when
93   the socket is ready for more data). */
[21167d2]94static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond )
95{
[0da65d5]96        struct jabber_data *jd = ((struct im_connection *)data)->proto_data;
[cc2cb2d]97       
98        return jd->fd != -1 &&
99               jabber_write_queue( data ) &&
100               jd->tx_len > 0;
101}
102
[0da65d5]103static gboolean jabber_write_queue( struct im_connection *ic )
[cc2cb2d]104{
[0da65d5]105        struct jabber_data *jd = ic->proto_data;
[21167d2]106        int st;
107       
[42127dc]108        if( jd->ssl )
109                st = ssl_write( jd->ssl, jd->txq, jd->tx_len );
110        else
111                st = write( jd->fd, jd->txq, jd->tx_len );
112       
[21167d2]113        if( st == jd->tx_len )
114        {
115                /* We wrote everything, clear the buffer. */
116                g_free( jd->txq );
117                jd->txq = NULL;
118                jd->tx_len = 0;
119               
[cc2cb2d]120                return TRUE;
[21167d2]121        }
[d52111a]122        else if( st == 0 || ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
[21167d2]123        {
[8d74291]124                /* Set fd to -1 to make sure we won't write to it anymore. */
125                closesocket( jd->fd );  /* Shouldn't be necessary after errors? */
126                jd->fd = -1;
127               
[84b045d]128                imcb_error( ic, "Short write() to server" );
[c2fb3809]129                imc_logout( ic, TRUE );
[21167d2]130                return FALSE;
131        }
132        else if( st > 0 )
133        {
134                char *s;
135               
136                s = g_memdup( jd->txq + st, jd->tx_len - st );
137                jd->tx_len -= st;
138                g_free( jd->txq );
139                jd->txq = s;
140               
[8d74291]141                return TRUE;
[21167d2]142        }
143        else
144        {
145                /* Just in case we had EINPROGRESS/EAGAIN: */
146               
147                return TRUE;
148        }
149}
150
151static gboolean jabber_read_callback( gpointer data, gint fd, b_input_condition cond )
152{
[0da65d5]153        struct im_connection *ic = data;
154        struct jabber_data *jd = ic->proto_data;
[21167d2]155        char buf[512];
156        int st;
157       
[8d74291]158        if( jd->fd == -1 )
159                return FALSE;
160       
[42127dc]161        if( jd->ssl )
162                st = ssl_read( jd->ssl, buf, sizeof( buf ) );
163        else
164                st = read( jd->fd, buf, sizeof( buf ) );
165       
[21167d2]166        if( st > 0 )
167        {
168                /* Parse. */
[b56b220]169                if( xt_feed( jd->xt, buf, st ) < 0 )
[21167d2]170                {
[84b045d]171                        imcb_error( ic, "XML stream error" );
[c2fb3809]172                        imc_logout( ic, TRUE );
[21167d2]173                        return FALSE;
174                }
175               
176                /* Execute all handlers. */
[101d84f]177                if( !xt_handle( jd->xt, NULL, 1 ) )
[21167d2]178                {
179                        /* Don't do anything, the handlers should have
[25984f2]180                           aborted the connection already. */
[21167d2]181                        return FALSE;
182                }
183               
[5997488]184                if( jd->flags & JFLAG_STREAM_RESTART )
185                {
186                        jd->flags &= ~JFLAG_STREAM_RESTART;
[0da65d5]187                        jabber_start_stream( ic );
[5997488]188                }
189               
[21167d2]190                /* Garbage collection. */
[101d84f]191                xt_cleanup( jd->xt, NULL, 1 );
[21167d2]192               
193                /* This is a bit hackish, unfortunately. Although xmltree
194                   has nifty event handler stuff, it only calls handlers
195                   when nodes are complete. Since the server should only
196                   send an opening <stream:stream> tag, we have to check
197                   this by hand. :-( */
198                if( !( jd->flags & JFLAG_STREAM_STARTED ) && jd->xt && jd->xt->root )
199                {
200                        if( g_strcasecmp( jd->xt->root->name, "stream:stream" ) == 0 )
201                        {
202                                jd->flags |= JFLAG_STREAM_STARTED;
[8d74291]203                               
204                                /* If there's no version attribute, assume
205                                   this is an old server that can't do SASL
206                                   authentication. */
[0da65d5]207                                if( !sasl_supported( ic ) )
[cc2cb2d]208                                {
209                                        /* If there's no version= tag, we suppose
210                                           this server does NOT implement: XMPP 1.0,
211                                           SASL and TLS. */
[0da65d5]212                                        if( set_getbool( &ic->acc->set, "tls" ) )
[cc2cb2d]213                                        {
[84b045d]214                                                imcb_error( ic, "TLS is turned on for this "
[cc2cb2d]215                                                          "account, but is not supported by this server" );
[c2fb3809]216                                                imc_logout( ic, FALSE );
[cc2cb2d]217                                                return FALSE;
218                                        }
219                                        else
220                                        {
[0da65d5]221                                                return jabber_init_iq_auth( ic );
[cc2cb2d]222                                        }
223                                }
[21167d2]224                        }
225                        else
226                        {
[84b045d]227                                imcb_error( ic, "XML stream error" );
[c2fb3809]228                                imc_logout( ic, TRUE );
[21167d2]229                                return FALSE;
230                        }
231                }
232        }
[d52111a]233        else if( st == 0 || ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
[21167d2]234        {
[8d74291]235                closesocket( jd->fd );
236                jd->fd = -1;
237               
[84b045d]238                imcb_error( ic, "Error while reading from server" );
[c2fb3809]239                imc_logout( ic, TRUE );
[21167d2]240                return FALSE;
241        }
242       
[8a2221a7]243        if( ssl_pending( jd->ssl ) )
244                /* OpenSSL empties the TCP buffers completely but may keep some
245                   data in its internap buffers. select() won't see that, but
246                   ssl_pending() does. */
247                return jabber_read_callback( data, fd, cond );
248        else
249                return TRUE;
[21167d2]250}
251
252gboolean jabber_connected_plain( gpointer data, gint source, b_input_condition cond )
253{
[0da65d5]254        struct im_connection *ic = data;
[21167d2]255       
[b5c8a34]256        if( g_slist_find( jabber_connections, ic ) == NULL )
257                return FALSE;
258       
[21167d2]259        if( source == -1 )
260        {
[84b045d]261                imcb_error( ic, "Could not connect to server" );
[c2fb3809]262                imc_logout( ic, TRUE );
[21167d2]263                return FALSE;
264        }
265       
[84b045d]266        imcb_log( ic, "Connected to server, logging in" );
[21167d2]267       
[0da65d5]268        return jabber_start_stream( ic );
[21167d2]269}
270
[42127dc]271gboolean jabber_connected_ssl( gpointer data, void *source, b_input_condition cond )
272{
[0da65d5]273        struct im_connection *ic = data;
[b5c8a34]274        struct jabber_data *jd;
275       
276        if( g_slist_find( jabber_connections, ic ) == NULL )
277                return FALSE;
278       
279        jd = ic->proto_data;
[42127dc]280       
281        if( source == NULL )
282        {
[c1ed6527]283                /* The SSL connection will be cleaned up by the SSL lib
284                   already, set it to NULL here to prevent a double cleanup: */
285                jd->ssl = NULL;
286               
[84b045d]287                imcb_error( ic, "Could not connect to server" );
[c2fb3809]288                imc_logout( ic, TRUE );
[42127dc]289                return FALSE;
290        }
291       
[84b045d]292        imcb_log( ic, "Connected to server, logging in" );
[42127dc]293       
[0da65d5]294        return jabber_start_stream( ic );
[42127dc]295}
296
[21167d2]297static xt_status jabber_end_of_stream( struct xt_node *node, gpointer data )
298{
[c2fb3809]299        imc_logout( data, TRUE );
[21167d2]300        return XT_ABORT;
301}
302
[8d74291]303static xt_status jabber_pkt_features( struct xt_node *node, gpointer data )
304{
[0da65d5]305        struct im_connection *ic = data;
306        struct jabber_data *jd = ic->proto_data;
[fe7a554]307        struct xt_node *c, *reply;
[e101506]308        int trytls;
[8d74291]309       
[0da65d5]310        trytls = g_strcasecmp( set_getstr( &ic->acc->set, "tls" ), "try" ) == 0;
[8d74291]311        c = xt_find_node( node->children, "starttls" );
[42127dc]312        if( c && !jd->ssl )
[8d74291]313        {
[42127dc]314                /* If the server advertises the STARTTLS feature and if we're
315                   not in a secure connection already: */
316               
317                c = xt_find_node( c->children, "required" );
318               
[0da65d5]319                if( c && ( !trytls && !set_getbool( &ic->acc->set, "tls" ) ) )
[e101506]320                {
[84b045d]321                        imcb_error( ic, "Server requires TLS connections, but TLS is turned off for this account" );
[c2fb3809]322                        imc_logout( ic, FALSE );
[e101506]323                       
324                        return XT_ABORT;
325                }
326               
[42127dc]327                /* Only run this if the tls setting is set to true or try: */
[0da65d5]328                if( ( trytls || set_getbool( &ic->acc->set, "tls" ) ) )
[42127dc]329                {
330                        reply = xt_new_node( "starttls", NULL, NULL );
[47d3ac4]331                        xt_add_attr( reply, "xmlns", XMLNS_TLS );
[0da65d5]332                        if( !jabber_write_packet( ic, reply ) )
[42127dc]333                        {
334                                xt_free_node( reply );
335                                return XT_ABORT;
336                        }
337                        xt_free_node( reply );
338                       
339                        return XT_HANDLED;
340                }
341        }
[e101506]342        else if( !c && !jd->ssl )
[42127dc]343        {
[e101506]344                /* If the server does not advertise the STARTTLS feature and
345                   we're not in a secure connection already: (Servers have a
346                   habit of not advertising <starttls/> anymore when already
347                   using SSL/TLS. */
348               
[0da65d5]349                if( !trytls && set_getbool( &ic->acc->set, "tls" ) )
[e101506]350                {
[84b045d]351                        imcb_error( ic, "TLS is turned on for this account, but is not supported by this server" );
[c2fb3809]352                        imc_logout( ic, FALSE );
[e101506]353                       
354                        return XT_ABORT;
355                }
[8d74291]356        }
357       
[42127dc]358        /* This one used to be in jabber_handlers[], but it has to be done
359           from here to make sure the TLS session will be initialized
360           properly before we attempt SASL authentication. */
361        if( ( c = xt_find_node( node->children, "mechanisms" ) ) )
[0e2d97f]362        {
[42127dc]363                if( sasl_pkt_mechanisms( c, data ) == XT_ABORT )
364                        return XT_ABORT;
[0e2d97f]365        }
[88591fd]366        /* If the server *SEEMS* to support SASL authentication but doesn't
367           support it after all, we should try to do authentication the
368           other way. jabber.com doesn't seem to do SASL while it pretends
369           to be XMPP 1.0 compliant! */
[0da65d5]370        else if( !( jd->flags & JFLAG_AUTHENTICATED ) && sasl_supported( ic ) )
[0e2d97f]371        {
[0da65d5]372                if( !jabber_init_iq_auth( ic ) )
[88591fd]373                        return XT_ABORT;
[0e2d97f]374        }
[42127dc]375       
[fe7a554]376        if( ( c = xt_find_node( node->children, "bind" ) ) )
[8fb1263]377                jd->flags |= JFLAG_WANT_BIND;
[fe7a554]378       
379        if( ( c = xt_find_node( node->children, "session" ) ) )
[8fb1263]380                jd->flags |= JFLAG_WANT_SESSION;
[fe7a554]381       
[8d74291]382        /* This flag is already set if we authenticated via SASL, so now
[fe7a554]383           we can resume the session in the new stream, if we don't have
384           to bind/initialize the session. */
[8fb1263]385        if( jd->flags & JFLAG_AUTHENTICATED && ( jd->flags & ( JFLAG_WANT_BIND | JFLAG_WANT_SESSION ) ) == 0 )
[8d74291]386        {
[0da65d5]387                if( !jabber_get_roster( ic ) )
[8d74291]388                        return XT_ABORT;
389        }
[8fb1263]390        else if( jd->flags & JFLAG_AUTHENTICATED )
391        {
392                return jabber_pkt_bind_sess( ic, NULL, NULL );
393        }
[8d74291]394       
395        return XT_HANDLED;
396}
397
[42127dc]398static xt_status jabber_pkt_proceed_tls( struct xt_node *node, gpointer data )
399{
[0da65d5]400        struct im_connection *ic = data;
401        struct jabber_data *jd = ic->proto_data;
[42127dc]402        char *xmlns;
403       
404        xmlns = xt_find_attr( node, "xmlns" );
405       
406        /* Just ignore it when it doesn't seem to be TLS-related (is that at
407           all possible??). */
[47d3ac4]408        if( !xmlns || strcmp( xmlns, XMLNS_TLS ) != 0 )
[42127dc]409                return XT_HANDLED;
410       
411        /* We don't want event handlers to touch our TLS session while it's
412           still initializing! */
413        b_event_remove( jd->r_inpa );
414        if( jd->tx_len > 0 )
415        {
416                /* Actually the write queue should be empty here, but just
417                   to be sure... */
418                b_event_remove( jd->w_inpa );
419                g_free( jd->txq );
420                jd->txq = NULL;
421                jd->tx_len = 0;
422        }
423        jd->w_inpa = jd->r_inpa = 0;
424       
[84b045d]425        imcb_log( ic, "Converting stream to TLS" );
[42127dc]426       
[af7f046]427        jd->flags |= JFLAG_STARTTLS_DONE;
[0da65d5]428        jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic );
[42127dc]429       
430        return XT_HANDLED;
431}
432
[b56b220]433static xt_status jabber_pkt_stream_error( struct xt_node *node, gpointer data )
434{
[0da65d5]435        struct im_connection *ic = data;
[c2fb3809]436        int allow_reconnect = TRUE;
[1baaef8]437        struct jabber_error *err;
[b56b220]438       
[1baaef8]439        err = jabber_error_parse( node, XMLNS_STREAM_ERROR );
[b56b220]440       
441        /* Tssk... */
[1baaef8]442        if( err->code == NULL )
[b56b220]443        {
[84b045d]444                imcb_error( ic, "Unknown stream error reported by server" );
[c2fb3809]445                imc_logout( ic, allow_reconnect );
[1baaef8]446                jabber_error_free( err );
[b56b220]447                return XT_ABORT;
448        }
449       
450        /* We know that this is a fatal error. If it's a "conflict" error, we
451           should turn off auto-reconnect to make sure we won't get some nasty
452           infinite loop! */
[1baaef8]453        if( strcmp( err->code, "conflict" ) == 0 )
[259edd4]454        {
[84b045d]455                imcb_error( ic, "Account and resource used from a different location" );
[c2fb3809]456                allow_reconnect = FALSE;
[259edd4]457        }
458        else
459        {
[1baaef8]460                imcb_error( ic, "Stream error: %s%s%s", err->code, err->text ? ": " : "",
461                            err->text ? err->text : "" );
[259edd4]462        }
[b56b220]463       
[1baaef8]464        jabber_error_free( err );
[c2fb3809]465        imc_logout( ic, allow_reconnect );
[b56b220]466       
467        return XT_ABORT;
468}
469
[bb95d43]470static xt_status jabber_xmlconsole( struct xt_node *node, gpointer data )
471{
472        struct im_connection *ic = data;
473        struct jabber_data *jd = ic->proto_data;
474       
475        if( jd->flags & JFLAG_XMLCONSOLE )
476        {
477                char *msg, *pkt;
478               
479                pkt = xt_to_string( node );
480                msg = g_strdup_printf( "RX: %s", pkt );
481                imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 );
482                g_free( msg );
483                g_free( pkt );
484        }
485       
486        return XT_NEXT;
487}
488
[21167d2]489static const struct xt_handler_entry jabber_handlers[] = {
[bb95d43]490        { NULL,                 "stream:stream",        jabber_xmlconsole },
[21167d2]491        { "stream:stream",      "<root>",               jabber_end_of_stream },
492        { "message",            "stream:stream",        jabber_pkt_message },
493        { "presence",           "stream:stream",        jabber_pkt_presence },
[8d74291]494        { "iq",                 "stream:stream",        jabber_pkt_iq },
495        { "stream:features",    "stream:stream",        jabber_pkt_features },
[b56b220]496        { "stream:error",       "stream:stream",        jabber_pkt_stream_error },
[42127dc]497        { "proceed",            "stream:stream",        jabber_pkt_proceed_tls },
[5997488]498        { "challenge",          "stream:stream",        sasl_pkt_challenge },
499        { "success",            "stream:stream",        sasl_pkt_result },
500        { "failure",            "stream:stream",        sasl_pkt_result },
[21167d2]501        { NULL,                 NULL,                   NULL }
502};
503
[0da65d5]504gboolean jabber_start_stream( struct im_connection *ic )
[21167d2]505{
[0da65d5]506        struct jabber_data *jd = ic->proto_data;
[21167d2]507        int st;
508        char *greet;
509       
510        /* We'll start our stream now, so prepare everything to receive one
511           from the server too. */
512        xt_free( jd->xt );      /* In case we're RE-starting. */
[4bbcba3]513        jd->xt = xt_new( jabber_handlers, ic );
[21167d2]514       
[8d74291]515        if( jd->r_inpa <= 0 )
[0da65d5]516                jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic );
[21167d2]517       
[af7f046]518        greet = g_strdup_printf( "%s<stream:stream to=\"%s\" xmlns=\"jabber:client\" "
519                                  "xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">", 
520                                  ( jd->flags & JFLAG_STARTTLS_DONE ) ? "" : "<?xml version='1.0' ?>",
521                                  jd->server );
[21167d2]522       
[0da65d5]523        st = jabber_write( ic, greet, strlen( greet ) );
[21167d2]524       
525        g_free( greet );
526       
527        return st;
528}
[4a0614e]529
[0da65d5]530void jabber_end_stream( struct im_connection *ic )
[4a0614e]531{
[0da65d5]532        struct jabber_data *jd = ic->proto_data;
[4a0614e]533       
534        /* Let's only do this if the queue is currently empty, otherwise it'd
535           take too long anyway. */
[5bcf70a]536        if( jd->tx_len == 0 )
537        {
538                char eos[] = "</stream:stream>";
539                struct xt_node *node;
[8d74291]540                int st = 1;
[5bcf70a]541               
[0da65d5]542                if( ic->flags & OPT_LOGGED_IN )
[8d74291]543                {
544                        node = jabber_make_packet( "presence", "unavailable", NULL, NULL );
[0da65d5]545                        st = jabber_write_packet( ic, node );
[8d74291]546                        xt_free_node( node );
547                }
[5bcf70a]548               
549                if( st )
[0da65d5]550                        jabber_write( ic, eos, strlen( eos ) );
[5bcf70a]551        }
[4a0614e]552}
Note: See TracBrowser for help on using the repository browser.