source: protocols/jabber/jabber_util.c @ 4306d8b

Last change on this file since 4306d8b was 4306d8b, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-12-02T16:43:57Z

Removed retarded printf() (ARGH) and moved the event handling handling of
IQ packets to jabber_util so I can reuse it for certain presence packets.

  • Property mode set to 100644
File size: 19.5 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        g_hash_table_insert( jd->node_cache, xt_find_attr( node, "id" ), entry );
145}
146
147void jabber_cache_entry_free( gpointer data )
148{
149        struct jabber_cache_entry *entry = data;
150       
151        xt_free_node( entry->node );
152        g_free( entry );
153}
154
155gboolean jabber_cache_clean_entry( gpointer key, gpointer entry, gpointer nullpointer );
156
157/* This one should be called from time to time (from keepalive, in this case)
158   to make sure things don't stay in the node cache forever. By marking nodes
159   during the first run and deleting marked nodes during a next run, every
160   node should be available in the cache for at least a minute (assuming the
161   function is indeed called every minute). */
162void jabber_cache_clean( struct im_connection *ic )
163{
164        struct jabber_data *jd = ic->proto_data;
165       
166        g_hash_table_foreach_remove( jd->node_cache, jabber_cache_clean_entry, NULL );
167}
168
169gboolean jabber_cache_clean_entry( gpointer key, gpointer entry_, gpointer nullpointer )
170{
171        struct jabber_cache_entry *entry = entry_;
172        struct xt_node *node = entry->node;
173       
174        if( node->flags & XT_SEEN )
175                return TRUE;
176        else
177        {
178                node->flags |= XT_SEEN;
179                return FALSE;
180        }
181}
182
183xt_status jabber_cache_handle_packet( struct im_connection *ic, struct xt_node *node )
184{
185        struct jabber_data *jd = ic->proto_data;
186        struct jabber_cache_entry *entry;
187        char *s;
188       
189        if( ( s = xt_find_attr( node, "id" ) ) == NULL ||
190            strncmp( s, jd->cached_id_prefix, strlen( jd->cached_id_prefix ) ) != 0 )
191        {
192                /* Silently ignore it, without an ID (or a non-cache
193                   ID) we don't know how to handle the packet and we
194                   probably don't have to. */
195                return XT_HANDLED;
196        }
197       
198        entry = g_hash_table_lookup( jd->node_cache, s );
199       
200        if( entry == NULL )
201        {
202                imcb_log( ic, "WARNING: Received %s-%s packet with unknown/expired ID %s!",
203                              node->name, xt_find_attr( node, "type" ) ? : "(no type)", s );
204        }
205        else if( entry->func )
206        {
207                return entry->func( ic, node, entry->node );
208        }
209       
210        return XT_HANDLED;
211}
212
213const struct jabber_away_state jabber_away_state_list[] =
214{
215        { "away",  "Away" },
216        { "chat",  "Free for Chat" },
217        { "dnd",   "Do not Disturb" },
218        { "xa",    "Extended Away" },
219        { "",      "Online" },
220        { "",      NULL }
221};
222
223const struct jabber_away_state *jabber_away_state_by_code( char *code )
224{
225        int i;
226       
227        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
228                if( g_strcasecmp( jabber_away_state_list[i].code, code ) == 0 )
229                        return jabber_away_state_list + i;
230       
231        return NULL;
232}
233
234const struct jabber_away_state *jabber_away_state_by_name( char *name )
235{
236        int i;
237       
238        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
239                if( g_strcasecmp( jabber_away_state_list[i].full_name, name ) == 0 )
240                        return jabber_away_state_list + i;
241       
242        return NULL;
243}
244
245struct jabber_buddy_ask_data
246{
247        struct im_connection *ic;
248        char *handle;
249        char *realname;
250};
251
252static void jabber_buddy_ask_yes( gpointer w, struct jabber_buddy_ask_data *bla )
253{
254        presence_send_request( bla->ic, bla->handle, "subscribed" );
255       
256        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
257                imcb_ask_add( bla->ic, bla->handle, NULL );
258       
259        g_free( bla->handle );
260        g_free( bla );
261}
262
263static void jabber_buddy_ask_no( gpointer w, struct jabber_buddy_ask_data *bla )
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                        /* Is this one of those no-resource buddies? */
395                        if( bud->resource == NULL )
396                        {
397                                g_free( jid );
398                                return NULL;
399                        }
400                        else
401                        {
402                                /* See if there's an exact match. */
403                                for( ; bud; bud = bud->next )
404                                        if( g_strcasecmp( bud->resource, s + 1 ) == 0 )
405                                                break;
406                        }
407                }
408                else
409                {
410                        /* This hack is there to make sure that O_CREAT will
411                           work if there's already another resouce present
412                           for this JID, even if it's an unknown buddy. This
413                           is done to handle conferences properly. */
414                        none_found = 1;
415                }
416               
417                if( bud == NULL && ( flags & GET_BUDDY_CREAT ) && ( imcb_find_buddy( ic, jid ) || !none_found ) )
418                {
419                        *s = '/';
420                        bud = jabber_buddy_add( ic, jid );
421                }
422               
423                g_free( jid );
424                return bud;
425        }
426        else
427        {
428                struct jabber_buddy *best_prio, *best_time;
429                char *set;
430               
431                bud = g_hash_table_lookup( jd->buddies, jid );
432               
433                g_free( jid );
434               
435                if( bud == NULL )
436                        /* No match. Create it now? */
437                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
438                                   jabber_buddy_add( ic, jid_ ) : NULL;
439                else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )
440                        /* We want an exact match, so in thise case there shouldn't be a /resource. */
441                        return NULL;
442                else if( ( bud->resource == NULL || bud->next == NULL ) )
443                        /* No need for selection if there's only one option. */
444                        return bud;
445               
446                best_prio = best_time = bud;
447                for( ; bud; bud = bud->next )
448                {
449                        if( bud->priority > best_prio->priority )
450                                best_prio = bud;
451                        if( bud->last_act > best_time->last_act )
452                                best_time = bud;
453                }
454               
455                if( ( set = set_getstr( &ic->acc->set, "resource_select" ) ) == NULL )
456                        return NULL;
457                else if( strcmp( set, "activity" ) == 0 )
458                        return best_time;
459                else /* if( strcmp( set, "priority" ) == 0 ) */
460                        return best_prio;
461        }
462}
463
464/* I'm keeping a separate ext_jid attribute to save a JID that makes sense
465   to export to BitlBee. This is mainly for groupchats right now. It's
466   a bit of a hack, but I just think having the user nickname in the hostname
467   part of the hostmask doesn't look nice on IRC. Normally you can convert
468   a normal JID to ext_jid by swapping the part before and after the / and
469   replacing the / with a =. But there should be some stripping (@s are
470   allowed in Jabber nicks...). */
471struct jabber_buddy *jabber_buddy_by_ext_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
472{
473        struct jabber_buddy *bud;
474        char *s, *jid;
475       
476        jid = jabber_normalize( jid_ );
477       
478        if( ( s = strchr( jid, '=' ) ) == NULL )
479                return NULL;
480       
481        for( bud = jabber_buddy_by_jid( ic, s + 1, GET_BUDDY_FIRST ); bud; bud = bud->next )
482        {
483                /* Hmmm, could happen if not all people in the chat are anonymized? */
484                if( bud->ext_jid == NULL )
485                        continue;
486               
487                if( strcmp( bud->ext_jid, jid ) == 0 )
488                        break;
489        }
490       
491        g_free( jid );
492       
493        return bud;
494}
495
496/* Remove one specific full JID from our list. Use this when a buddy goes
497   off-line (because (s)he can still be online from a different location.
498   XXX: See above, we should accept bare JIDs too... */
499int jabber_buddy_remove( struct im_connection *ic, char *full_jid_ )
500{
501        struct jabber_data *jd = ic->proto_data;
502        struct jabber_buddy *bud, *prev, *bi;
503        char *s, *full_jid;
504       
505        full_jid = jabber_normalize( full_jid_ );
506       
507        if( ( s = strchr( full_jid, '/' ) ) )
508                *s = 0;
509       
510        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
511        {
512                /* If there's only one item in the list (and if the resource
513                   matches), removing it is simple. (And the hash reference
514                   should be removed too!) */
515                if( bud->next == NULL && ( ( s == NULL || bud->resource == NULL ) || g_strcasecmp( bud->resource, s + 1 ) == 0 ) )
516                {
517                        g_hash_table_remove( jd->buddies, bud->bare_jid );
518                        g_free( bud->bare_jid );
519                        g_free( bud->ext_jid );
520                        g_free( bud->full_jid );
521                        g_free( bud->away_message );
522                        g_free( bud );
523                       
524                        g_free( full_jid );
525                       
526                        return 1;
527                }
528                else if( s == NULL || bud->resource == NULL )
529                {
530                        /* Tried to remove a bare JID while this JID does seem
531                           to have resources... (Or the opposite.) *sigh* */
532                        g_free( full_jid );
533                        return 0;
534                }
535                else
536                {
537                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
538                                if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
539                                        break;
540                       
541                        g_free( full_jid );
542                       
543                        if( bi )
544                        {
545                                if( prev )
546                                        prev->next = bi->next;
547                                else
548                                        /* The hash table should point at the second
549                                           item, because we're removing the first. */
550                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
551                               
552                                g_free( bi->ext_jid );
553                                g_free( bi->full_jid );
554                                g_free( bi->away_message );
555                                g_free( bi );
556                               
557                                return 1;
558                        }
559                        else
560                        {
561                                return 0;
562                        }
563                }
564        }
565        else
566        {
567                g_free( full_jid );
568                return 0;
569        }
570}
571
572/* Remove a buddy completely; removes all resources that belong to the
573   specified bare JID. Use this when removing someone from the contact
574   list, for example. */
575int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid )
576{
577        struct jabber_data *jd = ic->proto_data;
578        struct jabber_buddy *bud, *next;
579       
580        if( strchr( bare_jid, '/' ) )
581                return 0;
582       
583        if( ( bud = jabber_buddy_by_jid( ic, bare_jid, GET_BUDDY_FIRST ) ) )
584        {
585                /* Most important: Remove the hash reference. We don't know
586                   this buddy anymore. */
587                g_hash_table_remove( jd->buddies, bud->bare_jid );
588                g_free( bud->bare_jid );
589               
590                /* Deallocate the linked list of resources. */
591                while( bud )
592                {
593                        /* ext_jid && anonymous means that this buddy is
594                           specific to one groupchat (the one we're
595                           currently cleaning up) so it can be deleted
596                           completely. */
597                        if( bud->ext_jid && bud->flags & JBFLAG_IS_ANONYMOUS )
598                                imcb_remove_buddy( ic, bud->ext_jid, NULL );
599                       
600                        next = bud->next;
601                        g_free( bud->ext_jid );
602                        g_free( bud->full_jid );
603                        g_free( bud->away_message );
604                        g_free( bud );
605                        bud = next;
606                }
607               
608                return 1;
609        }
610        else
611        {
612                return 0;
613        }
614}
615
616struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name )
617{
618        char *normalized = jabber_normalize( name );
619        struct groupchat *ret;
620        struct jabber_chat *jc;
621       
622        for( ret = ic->groupchats; ret; ret = ret->next )
623        {
624                jc = ret->data;
625                if( strcmp( normalized, jc->name ) == 0 )
626                        break;
627        }
628        g_free( normalized );
629       
630        return ret;
631}
632
633time_t jabber_get_timestamp( struct xt_node *xt )
634{
635        struct tm tp, utc;
636        struct xt_node *c;
637        time_t res, tres;
638        char *s = NULL;
639       
640        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
641        {
642                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
643                        break;
644        }
645       
646        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
647                return 0;
648       
649        memset( &tp, 0, sizeof( tp ) );
650        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
651                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
652                return 0;
653       
654        tp.tm_year -= 1900;
655        tp.tm_mon --;
656        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
657       
658        res = mktime( &tp );
659        /* Problem is, mktime() just gave us the GMT timestamp for the
660           given local time... While the given time WAS NOT local. So
661           we should fix this now.
662       
663           Now I could choose between messing with environment variables
664           (kludgy) or using timegm() (not portable)... Or doing the
665           following, which I actually prefer... */
666        gmtime_r( &res, &utc );
667        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
668        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
669                /* Sweet! We're in UTC right now... */
670                return res;
671       
672        tres = mktime( &utc );
673        res += res - tres;
674       
675        /* Yes, this is a hack. And it will go wrong around DST changes.
676           BUT this is more likely to be threadsafe than messing with
677           environment variables, and possibly more portable... */
678       
679        return res;
680}
681
682struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns )
683{
684        struct jabber_error *err = g_new0( struct jabber_error, 1 );
685        struct xt_node *c;
686        char *s;
687       
688        err->type = xt_find_attr( node, "type" );
689       
690        for( c = node->children; c; c = c->next )
691        {
692                if( !( s = xt_find_attr( c, "xmlns" ) ) ||
693                    strcmp( s, xmlns ) != 0 )
694                        continue;
695               
696                if( strcmp( c->name, "text" ) != 0 )
697                {
698                        err->code = c->name;
699                }
700                /* Only use the text if it doesn't have an xml:lang attribute,
701                   if it's empty or if it's set to something English. */
702                else if( !( s = xt_find_attr( c, "xml:lang" ) ) ||
703                         !*s || strncmp( s, "en", 2 ) == 0 )
704                {
705                        err->text = c->text;
706                }
707        }
708       
709        return err;
710}
711
712void jabber_error_free( struct jabber_error *err )
713{
714        g_free( err );
715}
Note: See TracBrowser for help on using the repository browser.