source: protocols/jabber/jabber_util.c @ 3e6764a

Last change on this file since 3e6764a was 3e6764a, checked in by Wilmer van der Gaast <wilmer@…>, at 2008-06-21T23:34:11Z

Added jabber_util unittests (buddy_add/_by_jid only ATM).

  • Property mode set to 100644
File size: 19.6 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Jabber module - Misc. stuff                                              *
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"
25
26static unsigned int next_id = 1;
27
28char *set_eval_priority( set_t *set, char *value )
29{
30        account_t *acc = set->data;
31        int i;
32       
33        if( sscanf( value, "%d", &i ) == 1 )
34        {
35                /* Priority is a signed 8-bit integer, according to RFC 3921. */
36                if( i < -128 || i > 127 )
37                        return NULL;
38        }
39        else
40                return NULL;
41       
42        /* Only run this stuff if the account is online ATM,
43           and if the setting seems to be acceptable. */
44        if( acc->ic )
45        {
46                /* Although set_eval functions usually are very nice and
47                   convenient, they have one disadvantage: If I would just
48                   call p_s_u() now to send the new prio setting, it would
49                   send the old setting because the set->value gets changed
50                   after the (this) eval returns a non-NULL value.
51                   
52                   So now I can choose between implementing post-set
53                   functions next to evals, or just do this little hack: */
54               
55                g_free( set->value );
56                set->value = g_strdup( value );
57               
58                /* (Yes, sorry, I prefer the hack. :-P) */
59               
60                presence_send_update( acc->ic );
61        }
62       
63        return value;
64}
65
66char *set_eval_tls( set_t *set, char *value )
67{
68        if( g_strcasecmp( value, "try" ) == 0 )
69                return value;
70        else
71                return set_eval_bool( set, value );
72}
73
74struct xt_node *jabber_make_packet( char *name, char *type, char *to, struct xt_node *children )
75{
76        struct xt_node *node;
77       
78        node = xt_new_node( name, NULL, children );
79       
80        if( type )
81                xt_add_attr( node, "type", type );
82        if( to )
83                xt_add_attr( node, "to", to );
84       
85        /* IQ packets should always have an ID, so let's generate one. It
86           might get overwritten by jabber_cache_add() if this packet has
87           to be saved until we receive a response. Cached packets get
88           slightly different IDs so we can recognize them. */
89        if( strcmp( name, "iq" ) == 0 )
90        {
91                char *id = g_strdup_printf( "%s%05x", JABBER_PACKET_ID, ( next_id++ ) & 0xfffff );
92                xt_add_attr( node, "id", id );
93                g_free( id );
94        }
95       
96        return node;
97}
98
99struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type )
100{
101        struct xt_node *node, *c;
102        char *to;
103       
104        /* Create the "defined-condition" tag. */
105        c = xt_new_node( err_cond, NULL, NULL );
106        xt_add_attr( c, "xmlns", XMLNS_STANZA_ERROR );
107       
108        /* Put it in an <error> tag. */
109        c = xt_new_node( "error", NULL, c );
110        xt_add_attr( c, "type", err_type );
111       
112        /* To make the actual error packet, we copy the original packet and
113           add our <error>/type="error" tag. Including the original packet
114           is recommended, so let's just do it. */
115        node = xt_dup( orig );
116        xt_add_child( node, c );
117        xt_add_attr( node, "type", "error" );
118       
119        /* Return to sender. */
120        if( ( to = xt_find_attr( node, "from" ) ) )
121        {
122                xt_add_attr( node, "to", to );
123                xt_remove_attr( node, "from" );
124        }
125               
126        return node;
127}
128
129/* Cache a node/packet for later use. Mainly useful for IQ packets if you need
130   them when you receive the response. Use this BEFORE sending the packet so
131   it'll get a new id= tag, and do NOT free() the packet after sending it! */
132void jabber_cache_add( struct im_connection *ic, struct xt_node *node, jabber_cache_event func )
133{
134        struct jabber_data *jd = ic->proto_data;
135        struct jabber_cache_entry *entry = g_new0( struct jabber_cache_entry, 1 );
136        char *id;
137       
138        id = g_strdup_printf( "%s%05x", jd->cached_id_prefix, ( next_id++ ) & 0xfffff );
139        xt_add_attr( node, "id", id );
140        g_free( id );
141       
142        entry->node = node;
143        entry->func = func;
144        entry->saved_at = time( NULL );
145        g_hash_table_insert( jd->node_cache, xt_find_attr( node, "id" ), entry );
146}
147
148void jabber_cache_entry_free( gpointer data )
149{
150        struct jabber_cache_entry *entry = data;
151       
152        xt_free_node( entry->node );
153        g_free( entry );
154}
155
156gboolean jabber_cache_clean_entry( gpointer key, gpointer entry, gpointer nullpointer );
157
158/* This one should be called from time to time (from keepalive, in this case)
159   to make sure things don't stay in the node cache forever. By marking nodes
160   during the first run and deleting marked nodes during a next run, every
161   node should be available in the cache for at least a minute (assuming the
162   function is indeed called every minute). */
163void jabber_cache_clean( struct im_connection *ic )
164{
165        struct jabber_data *jd = ic->proto_data;
166        time_t threshold = time( NULL ) - JABBER_CACHE_MAX_AGE;
167       
168        g_hash_table_foreach_remove( jd->node_cache, jabber_cache_clean_entry, &threshold );
169}
170
171gboolean jabber_cache_clean_entry( gpointer key, gpointer entry_, gpointer threshold_ )
172{
173        struct jabber_cache_entry *entry = entry_;
174        time_t *threshold = threshold_;
175       
176        return entry->saved_at < *threshold;
177}
178
179xt_status jabber_cache_handle_packet( struct im_connection *ic, struct xt_node *node )
180{
181        struct jabber_data *jd = ic->proto_data;
182        struct jabber_cache_entry *entry;
183        char *s;
184       
185        if( ( s = xt_find_attr( node, "id" ) ) == NULL ||
186            strncmp( s, jd->cached_id_prefix, strlen( jd->cached_id_prefix ) ) != 0 )
187        {
188                /* Silently ignore it, without an ID (or a non-cache
189                   ID) we don't know how to handle the packet and we
190                   probably don't have to. */
191                return XT_HANDLED;
192        }
193       
194        entry = g_hash_table_lookup( jd->node_cache, s );
195       
196        if( entry == NULL )
197        {
198                imcb_log( ic, "Warning: Received %s-%s packet with unknown/expired ID %s!",
199                              node->name, xt_find_attr( node, "type" ) ? : "(no type)", s );
200        }
201        else if( entry->func )
202        {
203                return entry->func( ic, node, entry->node );
204        }
205       
206        return XT_HANDLED;
207}
208
209const struct jabber_away_state jabber_away_state_list[] =
210{
211        { "away",  "Away" },
212        { "chat",  "Free for Chat" },
213        { "dnd",   "Do not Disturb" },
214        { "xa",    "Extended Away" },
215        { "",      "Online" },
216        { "",      NULL }
217};
218
219const struct jabber_away_state *jabber_away_state_by_code( char *code )
220{
221        int i;
222       
223        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
224                if( g_strcasecmp( jabber_away_state_list[i].code, code ) == 0 )
225                        return jabber_away_state_list + i;
226       
227        return NULL;
228}
229
230const struct jabber_away_state *jabber_away_state_by_name( char *name )
231{
232        int i;
233       
234        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
235                if( g_strcasecmp( jabber_away_state_list[i].full_name, name ) == 0 )
236                        return jabber_away_state_list + i;
237       
238        return NULL;
239}
240
241struct jabber_buddy_ask_data
242{
243        struct im_connection *ic;
244        char *handle;
245        char *realname;
246};
247
248static void jabber_buddy_ask_yes( void *data )
249{
250        struct jabber_buddy_ask_data *bla = data;
251       
252        presence_send_request( bla->ic, bla->handle, "subscribed" );
253       
254        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
255                imcb_ask_add( bla->ic, bla->handle, NULL );
256       
257        g_free( bla->handle );
258        g_free( bla );
259}
260
261static void jabber_buddy_ask_no( void *data )
262{
263        struct jabber_buddy_ask_data *bla = data;
264       
265        presence_send_request( bla->ic, bla->handle, "subscribed" );
266       
267        g_free( bla->handle );
268        g_free( bla );
269}
270
271void jabber_buddy_ask( struct im_connection *ic, char *handle )
272{
273        struct jabber_buddy_ask_data *bla = g_new0( struct jabber_buddy_ask_data, 1 );
274        char *buf;
275       
276        bla->ic = ic;
277        bla->handle = g_strdup( handle );
278       
279        buf = g_strdup_printf( "The user %s wants to add you to his/her buddy list.", handle );
280        imcb_ask( ic, buf, bla, jabber_buddy_ask_yes, jabber_buddy_ask_no );
281        g_free( buf );
282}
283
284/* Returns a new string. Don't leak it! */
285char *jabber_normalize( const char *orig )
286{
287        int len, i;
288        char *new;
289       
290        len = strlen( orig );
291        new = g_new( char, len + 1 );
292        for( i = 0; i < len; i ++ )
293                new[i] = tolower( orig[i] );
294       
295        new[i] = 0;
296        return new;
297}
298
299/* Adds a buddy/resource to our list. Returns NULL if full_jid is not really a
300   FULL jid or if we already have this buddy/resource. XXX: No, great, actually
301   buddies from transports don't (usually) have resources. So we'll really have
302   to deal with that properly. Set their ->resource property to NULL. Do *NOT*
303   allow to mix this stuff, though... */
304struct jabber_buddy *jabber_buddy_add( struct im_connection *ic, char *full_jid_ )
305{
306        struct jabber_data *jd = ic->proto_data;
307        struct jabber_buddy *bud, *new, *bi;
308        char *s, *full_jid;
309       
310        full_jid = jabber_normalize( full_jid_ );
311       
312        if( ( s = strchr( full_jid, '/' ) ) )
313                *s = 0;
314       
315        new = g_new0( struct jabber_buddy, 1 );
316       
317        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
318        {
319                /* If this is a transport buddy or whatever, it can't have more
320                   than one instance, so this is always wrong: */
321                if( s == NULL || bud->resource == NULL )
322                {
323                        if( s ) *s = '/';
324                        g_free( new );
325                        g_free( full_jid );
326                        return NULL;
327                }
328               
329                new->bare_jid = bud->bare_jid;
330               
331                /* We already have another resource for this buddy, add the
332                   new one to the list. */
333                for( bi = bud; bi; bi = bi->next )
334                {
335                        /* Check for dupes. */
336                        if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
337                        {
338                                *s = '/';
339                                g_free( new );
340                                g_free( full_jid );
341                                return NULL;
342                        }
343                        /* Append the new item to the list. */
344                        else if( bi->next == NULL )
345                        {
346                                bi->next = new;
347                                break;
348                        }
349                }
350        }
351        else
352        {
353                /* Keep in mind that full_jid currently isn't really
354                   a full JID... */
355                new->bare_jid = g_strdup( full_jid );
356                g_hash_table_insert( jd->buddies, new->bare_jid, new );
357        }
358       
359        if( s )
360        {
361                *s = '/';
362                new->full_jid = full_jid;
363                new->resource = strchr( new->full_jid, '/' ) + 1;
364        }
365        else
366        {
367                /* Let's waste some more bytes of RAM instead of to make
368                   memory management a total disaster here. And it saves
369                   me one g_free() call in this function. :-P */
370                new->full_jid = full_jid;
371        }
372       
373        return new;
374}
375
376/* Finds a buddy from our structures. Can find both full- and bare JIDs. When
377   asked for a bare JID, it uses the "resource_select" setting to see which
378   resource to pick. */
379struct jabber_buddy *jabber_buddy_by_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
380{
381        struct jabber_data *jd = ic->proto_data;
382        struct jabber_buddy *bud;
383        char *s, *jid;
384       
385        jid = jabber_normalize( jid_ );
386       
387        if( ( s = strchr( jid, '/' ) ) )
388        {
389                int none_found = 0;
390               
391                *s = 0;
392                if( ( bud = g_hash_table_lookup( jd->buddies, jid ) ) )
393                {
394                        /* Just return the first one for this bare JID. */
395                        if( flags & GET_BUDDY_FIRST )
396                        {
397                                *s = '/';
398                                g_free( jid );
399                                return bud;
400                        }
401                       
402                        /* Is this one of those no-resource buddies? */
403                        if( bud->resource == NULL )
404                        {
405                                *s = '/';
406                                g_free( jid );
407                                return NULL;
408                        }
409                       
410                        /* See if there's an exact match. */
411                        for( ; bud; bud = bud->next )
412                                if( g_strcasecmp( bud->resource, s + 1 ) == 0 )
413                                        break;
414                }
415                else
416                {
417                        /* This hack is there to make sure that O_CREAT will
418                           work if there's already another resouce present
419                           for this JID, even if it's an unknown buddy. This
420                           is done to handle conferences properly. */
421                        none_found = 1;
422                        /* TODO(wilmer): Find out what I was thinking when I
423                           wrote this??? And then fix it. This makes me sad... */
424                }
425               
426                if( bud == NULL && ( flags & GET_BUDDY_CREAT ) && ( imcb_find_buddy( ic, jid ) || !none_found ) )
427                {
428                        *s = '/';
429                        bud = jabber_buddy_add( ic, jid );
430                }
431               
432                g_free( jid );
433                return bud;
434        }
435        else
436        {
437                struct jabber_buddy *best_prio, *best_time;
438                char *set;
439               
440                bud = g_hash_table_lookup( jd->buddies, jid );
441               
442                g_free( jid );
443               
444                if( bud == NULL )
445                        /* No match. Create it now? */
446                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
447                                   jabber_buddy_add( ic, jid_ ) : NULL;
448                else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )
449                        /* We want an exact match, so in thise case there shouldn't be a /resource. */
450                        return NULL;
451                else if( ( bud->resource == NULL || bud->next == NULL ) )
452                        /* No need for selection if there's only one option. */
453                        return bud;
454                else if( flags & GET_BUDDY_FIRST )
455                        /* Looks like the caller doesn't care about details. */
456                        return bud;
457               
458                best_prio = best_time = bud;
459                for( ; bud; bud = bud->next )
460                {
461                        if( bud->priority > best_prio->priority )
462                                best_prio = bud;
463                        if( bud->last_act > best_time->last_act )
464                                best_time = bud;
465                }
466               
467                if( ( set = set_getstr( &ic->acc->set, "resource_select" ) ) == NULL )
468                        return NULL;
469                else if( strcmp( set, "activity" ) == 0 )
470                        return best_time;
471                else /* if( strcmp( set, "priority" ) == 0 ) */
472                        return best_prio;
473        }
474}
475
476/* I'm keeping a separate ext_jid attribute to save a JID that makes sense
477   to export to BitlBee. This is mainly for groupchats right now. It's
478   a bit of a hack, but I just think having the user nickname in the hostname
479   part of the hostmask doesn't look nice on IRC. Normally you can convert
480   a normal JID to ext_jid by swapping the part before and after the / and
481   replacing the / with a =. But there should be some stripping (@s are
482   allowed in Jabber nicks...). */
483struct jabber_buddy *jabber_buddy_by_ext_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
484{
485        struct jabber_buddy *bud;
486        char *s, *jid;
487       
488        jid = jabber_normalize( jid_ );
489       
490        if( ( s = strchr( jid, '=' ) ) == NULL )
491                return NULL;
492       
493        for( bud = jabber_buddy_by_jid( ic, s + 1, GET_BUDDY_FIRST ); bud; bud = bud->next )
494        {
495                /* Hmmm, could happen if not all people in the chat are anonymized? */
496                if( bud->ext_jid == NULL )
497                        continue;
498               
499                if( strcmp( bud->ext_jid, jid ) == 0 )
500                        break;
501        }
502       
503        g_free( jid );
504       
505        return bud;
506}
507
508/* Remove one specific full JID from our list. Use this when a buddy goes
509   off-line (because (s)he can still be online from a different location.
510   XXX: See above, we should accept bare JIDs too... */
511int jabber_buddy_remove( struct im_connection *ic, char *full_jid_ )
512{
513        struct jabber_data *jd = ic->proto_data;
514        struct jabber_buddy *bud, *prev, *bi;
515        char *s, *full_jid;
516       
517        full_jid = jabber_normalize( full_jid_ );
518       
519        if( ( s = strchr( full_jid, '/' ) ) )
520                *s = 0;
521       
522        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
523        {
524                /* If there's only one item in the list (and if the resource
525                   matches), removing it is simple. (And the hash reference
526                   should be removed too!) */
527                if( bud->next == NULL &&
528                    ( ( s == NULL && bud->resource == NULL ) ||
529                      ( bud->resource && s && g_strcasecmp( bud->resource, s + 1 ) == 0 ) ) )
530                {
531                        g_hash_table_remove( jd->buddies, bud->bare_jid );
532                        g_free( bud->bare_jid );
533                        g_free( bud->ext_jid );
534                        g_free( bud->full_jid );
535                        g_free( bud->away_message );
536                        g_free( bud );
537                       
538                        g_free( full_jid );
539                       
540                        return 1;
541                }
542                else if( s == NULL || bud->resource == NULL )
543                {
544                        /* Tried to remove a bare JID while this JID does seem
545                           to have resources... (Or the opposite.) *sigh* */
546                        g_free( full_jid );
547                        return 0;
548                }
549                else
550                {
551                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
552                                if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
553                                        break;
554                       
555                        g_free( full_jid );
556                       
557                        if( bi )
558                        {
559                                if( prev )
560                                        prev->next = bi->next;
561                                else
562                                        /* The hash table should point at the second
563                                           item, because we're removing the first. */
564                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
565                               
566                                g_free( bi->ext_jid );
567                                g_free( bi->full_jid );
568                                g_free( bi->away_message );
569                                g_free( bi );
570                               
571                                return 1;
572                        }
573                        else
574                        {
575                                return 0;
576                        }
577                }
578        }
579        else
580        {
581                g_free( full_jid );
582                return 0;
583        }
584}
585
586/* Remove a buddy completely; removes all resources that belong to the
587   specified bare JID. Use this when removing someone from the contact
588   list, for example. */
589int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid )
590{
591        struct jabber_data *jd = ic->proto_data;
592        struct jabber_buddy *bud, *next;
593       
594        if( strchr( bare_jid, '/' ) )
595                return 0;
596       
597        if( ( bud = jabber_buddy_by_jid( ic, bare_jid, GET_BUDDY_FIRST ) ) )
598        {
599                /* Most important: Remove the hash reference. We don't know
600                   this buddy anymore. */
601                g_hash_table_remove( jd->buddies, bud->bare_jid );
602                g_free( bud->bare_jid );
603               
604                /* Deallocate the linked list of resources. */
605                while( bud )
606                {
607                        /* ext_jid && anonymous means that this buddy is
608                           specific to one groupchat (the one we're
609                           currently cleaning up) so it can be deleted
610                           completely. */
611                        if( bud->ext_jid && bud->flags & JBFLAG_IS_ANONYMOUS )
612                                imcb_remove_buddy( ic, bud->ext_jid, NULL );
613                       
614                        next = bud->next;
615                        g_free( bud->ext_jid );
616                        g_free( bud->full_jid );
617                        g_free( bud->away_message );
618                        g_free( bud );
619                        bud = next;
620                }
621               
622                return 1;
623        }
624        else
625        {
626                return 0;
627        }
628}
629
630time_t jabber_get_timestamp( struct xt_node *xt )
631{
632        struct tm tp, utc;
633        struct xt_node *c;
634        time_t res, tres;
635        char *s = NULL;
636       
637        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
638        {
639                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
640                        break;
641        }
642       
643        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
644                return 0;
645       
646        memset( &tp, 0, sizeof( tp ) );
647        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
648                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
649                return 0;
650       
651        tp.tm_year -= 1900;
652        tp.tm_mon --;
653        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
654       
655        res = mktime( &tp );
656        /* Problem is, mktime() just gave us the GMT timestamp for the
657           given local time... While the given time WAS NOT local. So
658           we should fix this now.
659       
660           Now I could choose between messing with environment variables
661           (kludgy) or using timegm() (not portable)... Or doing the
662           following, which I actually prefer... */
663        gmtime_r( &res, &utc );
664        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
665        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
666                /* Sweet! We're in UTC right now... */
667                return res;
668       
669        tres = mktime( &utc );
670        res += res - tres;
671       
672        /* Yes, this is a hack. And it will go wrong around DST changes.
673           BUT this is more likely to be threadsafe than messing with
674           environment variables, and possibly more portable... */
675       
676        return res;
677}
678
679struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns )
680{
681        struct jabber_error *err;
682        struct xt_node *c;
683        char *s;
684       
685        if( node == NULL )
686                return NULL;
687       
688        err = g_new0( struct jabber_error, 1 );
689        err->type = xt_find_attr( node, "type" );
690       
691        for( c = node->children; c; c = c->next )
692        {
693                if( !( s = xt_find_attr( c, "xmlns" ) ) ||
694                    strcmp( s, xmlns ) != 0 )
695                        continue;
696               
697                if( strcmp( c->name, "text" ) != 0 )
698                {
699                        err->code = c->name;
700                }
701                /* Only use the text if it doesn't have an xml:lang attribute,
702                   if it's empty or if it's set to something English. */
703                else if( !( s = xt_find_attr( c, "xml:lang" ) ) ||
704                         !*s || strncmp( s, "en", 2 ) == 0 )
705                {
706                        err->text = c->text;
707                }
708        }
709       
710        return err;
711}
712
713void jabber_error_free( struct jabber_error *err )
714{
715        g_free( err );
716}
Note: See TracBrowser for help on using the repository browser.