source: protocols/jabber/jabber.c @ 81186cab

Last change on this file since 81186cab was 17a6ee9, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-04-11T14:37:06Z

Including DCC stuff again, with a wonderful extra layer of abstraction.
Some hooks are missing so sending files doesn't work yet. Receiving also
still seems to have some issues. On the plus side, at least the MSN/Jabber
modules work again.

  • Property mode set to 100644
File size: 15.7 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Jabber module - Main file                                                *
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 <glib.h>
25#include <string.h>
26#include <unistd.h>
27#include <ctype.h>
28#include <stdio.h>
29
30#include "ssl_client.h"
31#include "xmltree.h"
32#include "bitlbee.h"
33#include "jabber.h"
34#include "md5.h"
35
36GSList *jabber_connections;
37
38/* First enty is the default */
39static const int jabber_port_list[] = {
40        5222,
41        5223,
42        5220,
43        5221,
44        5224,
45        5225,
46        5226,
47        5227,
48        5228,
49        5229,
50        80,
51        443,
52        0
53};
54
55static void jabber_init( account_t *acc )
56{
57        set_t *s;
58        char str[16];
59       
60        s = set_add( &acc->set, "activity_timeout", "600", set_eval_int, acc );
61       
62        g_snprintf( str, sizeof( str ), "%d", jabber_port_list[0] );
63        s = set_add( &acc->set, "port", str, set_eval_int, acc );
64        s->flags |= ACC_SET_OFFLINE_ONLY;
65       
66        s = set_add( &acc->set, "priority", "0", set_eval_priority, acc );
67
68        s = set_add( &acc->set, "proxy", "<local>;<auto>", NULL, acc );
69       
70        s = set_add( &acc->set, "resource", "BitlBee", NULL, acc );
71        s->flags |= ACC_SET_OFFLINE_ONLY;
72       
73        s = set_add( &acc->set, "resource_select", "activity", NULL, acc );
74       
75        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
76        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY | SET_NULL_OK;
77       
78        s = set_add( &acc->set, "ssl", "false", set_eval_bool, acc );
79        s->flags |= ACC_SET_OFFLINE_ONLY;
80       
81        s = set_add( &acc->set, "tls", "try", set_eval_tls, acc );
82        s->flags |= ACC_SET_OFFLINE_ONLY;
83       
84        s = set_add( &acc->set, "xmlconsole", "false", set_eval_bool, acc );
85        s->flags |= ACC_SET_OFFLINE_ONLY;
86       
87        acc->flags |= ACC_FLAG_AWAY_MESSAGE | ACC_FLAG_STATUS_MESSAGE;
88}
89
90static void jabber_generate_id_hash( struct jabber_data *jd );
91
92static void jabber_login( account_t *acc )
93{
94        struct im_connection *ic = imcb_new( acc );
95        struct jabber_data *jd = g_new0( struct jabber_data, 1 );
96        struct ns_srv_reply *srv = NULL;
97        char *connect_to, *s;
98        int i;
99       
100        /* For now this is needed in the _connected() handlers if using
101           GLib event handling, to make sure we're not handling events
102           on dead connections. */
103        jabber_connections = g_slist_prepend( jabber_connections, ic );
104       
105        jd->ic = ic;
106        ic->proto_data = jd;
107       
108        jd->username = g_strdup( acc->user );
109        jd->server = strchr( jd->username, '@' );
110       
111        jd->fd = jd->r_inpa = jd->w_inpa = -1;
112       
113        if( jd->server == NULL )
114        {
115                imcb_error( ic, "Incomplete account name (format it like <username@jabberserver.name>)" );
116                imc_logout( ic, FALSE );
117                return;
118        }
119       
120        /* So don't think of free()ing jd->server.. :-) */
121        *jd->server = 0;
122        jd->server ++;
123       
124        if( ( s = strchr( jd->server, '/' ) ) )
125        {
126                *s = 0;
127                set_setstr( &acc->set, "resource", s + 1 );
128               
129                /* Also remove the /resource from the original variable so we
130                   won't have to do this again every time. */
131                s = strchr( acc->user, '/' );
132                *s = 0;
133        }
134       
135        /* This code isn't really pretty. Backwards compatibility never is... */
136        s = acc->server;
137        while( s )
138        {
139                static int had_port = 0;
140               
141                if( strncmp( s, "ssl", 3 ) == 0 )
142                {
143                        set_setstr( &acc->set, "ssl", "true" );
144                       
145                        /* Flush this part so that (if this was the first
146                           part of the server string) acc->server gets
147                           flushed. We don't want to have to do this another
148                           time. :-) */
149                        *s = 0;
150                        s ++;
151                       
152                        /* Only set this if the user didn't specify a custom
153                           port number already... */
154                        if( !had_port )
155                                set_setint( &acc->set, "port", 5223 );
156                }
157                else if( isdigit( *s ) )
158                {
159                        int i;
160                       
161                        /* The first character is a digit. It could be an
162                           IP address though. Only accept this as a port#
163                           if there are only digits. */
164                        for( i = 0; isdigit( s[i] ); i ++ );
165                       
166                        /* If the first non-digit character is a colon or
167                           the end of the string, save the port number
168                           where it should be. */
169                        if( s[i] == ':' || s[i] == 0 )
170                        {
171                                sscanf( s, "%d", &i );
172                                set_setint( &acc->set, "port", i );
173                               
174                                /* See above. */
175                                *s = 0;
176                                s ++;
177                        }
178                       
179                        had_port = 1;
180                }
181               
182                s = strchr( s, ':' );
183                if( s )
184                {
185                        *s = 0;
186                        s ++;
187                }
188        }
189       
190        jd->node_cache = g_hash_table_new_full( g_str_hash, g_str_equal, NULL, jabber_cache_entry_free );
191        jd->buddies = g_hash_table_new( g_str_hash, g_str_equal );
192       
193        /* Figure out the hostname to connect to. */
194        if( acc->server && *acc->server )
195                connect_to = acc->server;
196        else if( ( srv = srv_lookup( "xmpp-client", "tcp", jd->server ) ) ||
197                 ( srv = srv_lookup( "jabber-client", "tcp", jd->server ) ) )
198                connect_to = srv->name;
199        else
200                connect_to = jd->server;
201       
202        imcb_log( ic, "Connecting" );
203       
204        for( i = 0; jabber_port_list[i] > 0; i ++ )
205                if( set_getint( &acc->set, "port" ) == jabber_port_list[i] )
206                        break;
207
208        if( jabber_port_list[i] == 0 )
209        {
210                imcb_log( ic, "Illegal port number" );
211                imc_logout( ic, FALSE );
212                return;
213        }
214       
215        /* For non-SSL connections we can try to use the port # from the SRV
216           reply, but let's not do that when using SSL, SSL usually runs on
217           non-standard ports... */
218        if( set_getbool( &acc->set, "ssl" ) )
219        {
220                jd->ssl = ssl_connect( connect_to, set_getint( &acc->set, "port" ), jabber_connected_ssl, ic );
221                jd->fd = jd->ssl ? ssl_getfd( jd->ssl ) : -1;
222        }
223        else
224        {
225                jd->fd = proxy_connect( connect_to, srv ? srv->port : set_getint( &acc->set, "port" ), jabber_connected_plain, ic );
226        }
227        g_free( srv );
228       
229        if( jd->fd == -1 )
230        {
231                imcb_error( ic, "Could not connect to server" );
232                imc_logout( ic, TRUE );
233               
234                return;
235        }
236       
237        if( set_getbool( &acc->set, "xmlconsole" ) )
238        {
239                jd->flags |= JFLAG_XMLCONSOLE;
240                /* Shouldn't really do this at this stage already, maybe. But
241                   I think this shouldn't break anything. */
242                imcb_add_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
243        }
244       
245        jabber_generate_id_hash( jd );
246}
247
248/* This generates an unfinished md5_state_t variable. Every time we generate
249   an ID, we finish the state by adding a sequence number and take the hash. */
250static void jabber_generate_id_hash( struct jabber_data *jd )
251{
252        md5_byte_t binbuf[4];
253        char *s;
254       
255        md5_init( &jd->cached_id_prefix );
256        md5_append( &jd->cached_id_prefix, (unsigned char *) jd->username, strlen( jd->username ) );
257        md5_append( &jd->cached_id_prefix, (unsigned char *) jd->server, strlen( jd->server ) );
258        s = set_getstr( &jd->ic->acc->set, "resource" );
259        md5_append( &jd->cached_id_prefix, (unsigned char *) s, strlen( s ) );
260        random_bytes( binbuf, 4 );
261        md5_append( &jd->cached_id_prefix, binbuf, 4 );
262}
263
264static void jabber_logout( struct im_connection *ic )
265{
266        struct jabber_data *jd = ic->proto_data;
267       
268        while( jd->filetransfers )
269                imcb_file_canceled( ic, ( ( struct jabber_transfer *) jd->filetransfers->data )->ft, "Logging out" );
270
271        while( jd->streamhosts )
272        {
273                jabber_streamhost_t *sh = jd->streamhosts->data;
274                jd->streamhosts = g_slist_remove( jd->streamhosts, sh );
275                g_free( sh->jid );
276                g_free( sh->host );
277                g_free( sh );
278        }
279
280        if( jd->fd >= 0 )
281                jabber_end_stream( ic );
282       
283        while( ic->groupchats )
284                jabber_chat_free( ic->groupchats );
285       
286        if( jd->r_inpa >= 0 )
287                b_event_remove( jd->r_inpa );
288        if( jd->w_inpa >= 0 )
289                b_event_remove( jd->w_inpa );
290       
291        if( jd->ssl )
292                ssl_disconnect( jd->ssl );
293        if( jd->fd >= 0 )
294                closesocket( jd->fd );
295       
296        if( jd->tx_len )
297                g_free( jd->txq );
298       
299        if( jd->node_cache )
300                g_hash_table_destroy( jd->node_cache );
301       
302        xt_free( jd->xt );
303       
304        g_free( jd->away_message );
305        g_free( jd->username );
306        g_free( jd );
307       
308        jabber_connections = g_slist_remove( jabber_connections, ic );
309}
310
311static int jabber_buddy_msg( struct im_connection *ic, char *who, char *message, int flags )
312{
313        struct jabber_data *jd = ic->proto_data;
314        struct jabber_buddy *bud;
315        struct xt_node *node;
316        char *s;
317        int st;
318       
319        if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
320                return jabber_write( ic, message, strlen( message ) );
321       
322        if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
323                bud = jabber_buddy_by_ext_jid( ic, who, 0 );
324        else
325                bud = jabber_buddy_by_jid( ic, who, GET_BUDDY_BARE_OK );
326       
327        node = xt_new_node( "body", message, NULL );
328        node = jabber_make_packet( "message", "chat", bud ? bud->full_jid : who, node );
329       
330        if( bud && ( jd->flags & JFLAG_WANT_TYPING ) &&
331            ( ( bud->flags & JBFLAG_DOES_XEP85 ) ||
332             !( bud->flags & JBFLAG_PROBED_XEP85 ) ) )
333        {
334                struct xt_node *act;
335               
336                /* If the user likes typing notification and if we don't know
337                   (and didn't probe before) if this resource supports XEP85,
338                   include a probe in this packet now. Also, if we know this
339                   buddy does support XEP85, we have to send this <active/>
340                   tag to tell that the user stopped typing (well, that's what
341                   we guess when s/he pressed Enter...). */
342                act = xt_new_node( "active", NULL, NULL );
343                xt_add_attr( act, "xmlns", XMLNS_CHATSTATES );
344                xt_add_child( node, act );
345               
346                /* Just make sure we do this only once. */
347                bud->flags |= JBFLAG_PROBED_XEP85;
348        }
349       
350        st = jabber_write_packet( ic, node );
351        xt_free_node( node );
352       
353        return st;
354}
355
356static GList *jabber_away_states( struct im_connection *ic )
357{
358        static GList *l = NULL;
359        int i;
360       
361        if( l == NULL )
362                for( i = 0; jabber_away_state_list[i].full_name; i ++ )
363                        l = g_list_append( l, (void*) jabber_away_state_list[i].full_name );
364       
365        return l;
366}
367
368static void jabber_get_info( struct im_connection *ic, char *who )
369{
370        struct jabber_buddy *bud;
371       
372        bud = jabber_buddy_by_jid( ic, who, GET_BUDDY_FIRST );
373       
374        while( bud )
375        {
376                imcb_log( ic, "Buddy %s (%d) information:", bud->full_jid, bud->priority );
377                if( bud->away_state )
378                        imcb_log( ic, "Away state: %s", bud->away_state->full_name );
379                imcb_log( ic, "Status message: %s", bud->away_message ? : "(none)" );
380               
381                bud = bud->next;
382        }
383       
384        jabber_get_vcard( ic, bud ? bud->full_jid : who );
385}
386
387static void jabber_set_away( struct im_connection *ic, char *state_txt, char *message )
388{
389        struct jabber_data *jd = ic->proto_data;
390       
391        /* state_txt == NULL -> Not away.
392           Unknown state -> fall back to the first defined away state. */
393        jd->away_state = state_txt ? jabber_away_state_by_name( state_txt )
394                         ? : jabber_away_state_list : NULL;
395       
396        g_free( jd->away_message );
397        jd->away_message = ( message && *message ) ? g_strdup( message ) : NULL;
398       
399        presence_send_update( ic );
400}
401
402static void jabber_add_buddy( struct im_connection *ic, char *who, char *group )
403{
404        struct jabber_data *jd = ic->proto_data;
405       
406        if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
407        {
408                jd->flags |= JFLAG_XMLCONSOLE;
409                imcb_add_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
410                return;
411        }
412       
413        if( jabber_add_to_roster( ic, who, NULL ) )
414                presence_send_request( ic, who, "subscribe" );
415}
416
417static void jabber_remove_buddy( struct im_connection *ic, char *who, char *group )
418{
419        struct jabber_data *jd = ic->proto_data;
420       
421        if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
422        {
423                jd->flags &= ~JFLAG_XMLCONSOLE;
424                /* Not necessary for now. And for now the code isn't too
425                   happy if the buddy is completely gone right after calling
426                   this function already.
427                imcb_remove_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
428                */
429                return;
430        }
431       
432        /* We should always do this part. Clean up our administration a little bit. */
433        jabber_buddy_remove_bare( ic, who );
434       
435        if( jabber_remove_from_roster( ic, who ) )
436                presence_send_request( ic, who, "unsubscribe" );
437}
438
439static struct groupchat *jabber_chat_join_( struct im_connection *ic, const char *room, const char *nick, const char *password )
440{
441        if( strchr( room, '@' ) == NULL )
442                imcb_error( ic, "Invalid room name: %s", room );
443        else if( jabber_chat_by_jid( ic, room ) )
444                imcb_error( ic, "Already present in chat `%s'", room );
445        else
446                return jabber_chat_join( ic, room, nick, password );
447       
448        return NULL;
449}
450
451static void jabber_chat_msg_( struct groupchat *c, char *message, int flags )
452{
453        if( c && message )
454                jabber_chat_msg( c, message, flags );
455}
456
457static void jabber_chat_topic_( struct groupchat *c, char *topic )
458{
459        if( c && topic )
460                jabber_chat_topic( c, topic );
461}
462
463static void jabber_chat_leave_( struct groupchat *c )
464{
465        if( c )
466                jabber_chat_leave( c, NULL );
467}
468
469static void jabber_chat_invite_( struct groupchat *c, char *who, char *msg )
470{
471        struct jabber_chat *jc = c->data;
472        gchar *msg_alt = NULL;
473
474        if( msg == NULL )
475                msg_alt = g_strdup_printf( "%s invited you to %s", c->ic->acc->user, jc->name );
476       
477        if( c && who )
478                jabber_chat_invite( c, who, msg ? msg : msg_alt );
479       
480        g_free( msg_alt );
481}
482
483static void jabber_keepalive( struct im_connection *ic )
484{
485        /* Just any whitespace character is enough as a keepalive for XMPP sessions. */
486        jabber_write( ic, "\n", 1 );
487       
488        /* This runs the garbage collection every minute, which means every packet
489           is in the cache for about a minute (which should be enough AFAIK). */
490        jabber_cache_clean( ic );
491}
492
493static int jabber_send_typing( struct im_connection *ic, char *who, int typing )
494{
495        struct jabber_data *jd = ic->proto_data;
496        struct jabber_buddy *bud;
497       
498        /* Enable typing notification related code from now. */
499        jd->flags |= JFLAG_WANT_TYPING;
500       
501        if( ( bud = jabber_buddy_by_jid( ic, who, 0 ) ) == NULL )
502        {
503                /* Sending typing notifications to unknown buddies is
504                   unsupported for now. Shouldn't be a problem, I think. */
505                return 0;
506        }
507       
508        if( bud->flags & JBFLAG_DOES_XEP85 )
509        {
510                /* We're only allowed to send this stuff if we know the other
511                   side supports it. */
512               
513                struct xt_node *node;
514                char *type;
515                int st;
516               
517                if( typing & OPT_TYPING )
518                        type = "composing";
519                else if( typing & OPT_THINKING )
520                        type = "paused";
521                else
522                        type = "active";
523               
524                node = xt_new_node( type, NULL, NULL );
525                xt_add_attr( node, "xmlns", XMLNS_CHATSTATES );
526                node = jabber_make_packet( "message", "chat", bud->full_jid, node );
527               
528                st = jabber_write_packet( ic, node );
529                xt_free_node( node );
530               
531                return st;
532        }
533       
534        return 1;
535}
536
537void jabber_initmodule()
538{
539        struct prpl *ret = g_new0( struct prpl, 1 );
540       
541        ret->name = "jabber";
542        ret->login = jabber_login;
543        ret->init = jabber_init;
544        ret->logout = jabber_logout;
545        ret->buddy_msg = jabber_buddy_msg;
546        ret->away_states = jabber_away_states;
547        ret->set_away = jabber_set_away;
548//      ret->set_info = jabber_set_info;
549        ret->get_info = jabber_get_info;
550        ret->add_buddy = jabber_add_buddy;
551        ret->remove_buddy = jabber_remove_buddy;
552        ret->chat_msg = jabber_chat_msg_;
553        ret->chat_topic = jabber_chat_topic_;
554        ret->chat_invite = jabber_chat_invite_;
555        ret->chat_leave = jabber_chat_leave_;
556        ret->chat_join = jabber_chat_join_;
557        ret->keepalive = jabber_keepalive;
558        ret->send_typing = jabber_send_typing;
559        ret->handle_cmp = g_strcasecmp;
560        ret->transfer_request = jabber_si_transfer_request;
561
562        register_protocol( ret );
563}
Note: See TracBrowser for help on using the repository browser.