source: protocols/jabber/jabber_util.c @ 2758cfe

Last change on this file since 2758cfe was 6286f80, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-04-26T04:41:34Z

Prepared the Jabber module for anonymous rooms, but the BitlBee core
doesn't deal with it very well, and I don't really know yet how I'll
solve this... :-(

  • Property mode set to 100644
File size: 16.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        char *id = g_strdup_printf( "%s%05x", JABBER_CACHED_ID, ( next_id++ ) & 0xfffff );
136        struct jabber_cache_entry *entry = g_new0( struct jabber_cache_entry, 1 );
137       
138        xt_add_attr( node, "id", id );
139        g_free( id );
140       
141        entry->node = node;
142        entry->func = func;
143        g_hash_table_insert( jd->node_cache, xt_find_attr( node, "id" ), entry );
144}
145
146void jabber_cache_entry_free( gpointer data )
147{
148        struct jabber_cache_entry *entry = data;
149       
150        xt_free_node( entry->node );
151        g_free( entry );
152}
153
154gboolean jabber_cache_clean_entry( gpointer key, gpointer entry, gpointer nullpointer );
155
156/* This one should be called from time to time (from keepalive, in this case)
157   to make sure things don't stay in the node cache forever. By marking nodes
158   during the first run and deleting marked nodes during a next run, every
159   node should be available in the cache for at least a minute (assuming the
160   function is indeed called every minute). */
161void jabber_cache_clean( struct im_connection *ic )
162{
163        struct jabber_data *jd = ic->proto_data;
164       
165        g_hash_table_foreach_remove( jd->node_cache, jabber_cache_clean_entry, NULL );
166}
167
168gboolean jabber_cache_clean_entry( gpointer key, gpointer entry_, gpointer nullpointer )
169{
170        struct jabber_cache_entry *entry = entry_;
171        struct xt_node *node = entry->node;
172       
173        if( node->flags & XT_SEEN )
174                return TRUE;
175        else
176        {
177                node->flags |= XT_SEEN;
178                return FALSE;
179        }
180}
181
182const struct jabber_away_state jabber_away_state_list[] =
183{
184        { "away",  "Away" },
185        { "chat",  "Free for Chat" },
186        { "dnd",   "Do not Disturb" },
187        { "xa",    "Extended Away" },
188        { "",      "Online" },
189        { "",      NULL }
190};
191
192const struct jabber_away_state *jabber_away_state_by_code( char *code )
193{
194        int i;
195       
196        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
197                if( g_strcasecmp( jabber_away_state_list[i].code, code ) == 0 )
198                        return jabber_away_state_list + i;
199       
200        return NULL;
201}
202
203const struct jabber_away_state *jabber_away_state_by_name( char *name )
204{
205        int i;
206       
207        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
208                if( g_strcasecmp( jabber_away_state_list[i].full_name, name ) == 0 )
209                        return jabber_away_state_list + i;
210       
211        return NULL;
212}
213
214struct jabber_buddy_ask_data
215{
216        struct im_connection *ic;
217        char *handle;
218        char *realname;
219};
220
221static void jabber_buddy_ask_yes( gpointer w, struct jabber_buddy_ask_data *bla )
222{
223        presence_send_request( bla->ic, bla->handle, "subscribed" );
224       
225        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
226                imcb_ask_add( bla->ic, bla->handle, NULL );
227       
228        g_free( bla->handle );
229        g_free( bla );
230}
231
232static void jabber_buddy_ask_no( gpointer w, struct jabber_buddy_ask_data *bla )
233{
234        presence_send_request( bla->ic, bla->handle, "subscribed" );
235       
236        g_free( bla->handle );
237        g_free( bla );
238}
239
240void jabber_buddy_ask( struct im_connection *ic, char *handle )
241{
242        struct jabber_buddy_ask_data *bla = g_new0( struct jabber_buddy_ask_data, 1 );
243        char *buf;
244       
245        bla->ic = ic;
246        bla->handle = g_strdup( handle );
247       
248        buf = g_strdup_printf( "The user %s wants to add you to his/her buddy list.", handle );
249        imcb_ask( ic, buf, bla, jabber_buddy_ask_yes, jabber_buddy_ask_no );
250        g_free( buf );
251}
252
253/* Returns a new string. Don't leak it! */
254char *jabber_normalize( const char *orig )
255{
256        int len, i;
257        char *new;
258       
259        len = strlen( orig );
260        new = g_new( char, len + 1 );
261        for( i = 0; i < len; i ++ )
262                new[i] = tolower( orig[i] );
263       
264        new[i] = 0;
265        return new;
266}
267
268/* Adds a buddy/resource to our list. Returns NULL if full_jid is not really a
269   FULL jid or if we already have this buddy/resource. XXX: No, great, actually
270   buddies from transports don't (usually) have resources. So we'll really have
271   to deal with that properly. Set their ->resource property to NULL. Do *NOT*
272   allow to mix this stuff, though... */
273struct jabber_buddy *jabber_buddy_add( struct im_connection *ic, char *full_jid_ )
274{
275        struct jabber_data *jd = ic->proto_data;
276        struct jabber_buddy *bud, *new, *bi;
277        char *s, *full_jid;
278       
279        full_jid = jabber_normalize( full_jid_ );
280       
281        if( ( s = strchr( full_jid, '/' ) ) )
282                *s = 0;
283       
284        new = g_new0( struct jabber_buddy, 1 );
285       
286        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
287        {
288                /* If this is a transport buddy or whatever, it can't have more
289                   than one instance, so this is always wrong: */
290                if( s == NULL || bud->resource == NULL )
291                {
292                        if( s ) *s = '/';
293                        g_free( new );
294                        g_free( full_jid );
295                        return NULL;
296                }
297               
298                new->bare_jid = bud->bare_jid;
299               
300                /* We already have another resource for this buddy, add the
301                   new one to the list. */
302                for( bi = bud; bi; bi = bi->next )
303                {
304                        /* Check for dupes. */
305                        if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
306                        {
307                                *s = '/';
308                                g_free( new );
309                                g_free( full_jid );
310                                return NULL;
311                        }
312                        /* Append the new item to the list. */
313                        else if( bi->next == NULL )
314                        {
315                                bi->next = new;
316                                break;
317                        }
318                }
319        }
320        else
321        {
322                new->bare_jid = g_strdup( full_jid );
323                g_hash_table_insert( jd->buddies, new->bare_jid, new );
324        }
325       
326        if( s )
327        {
328                *s = '/';
329                new->full_jid = full_jid;
330                new->resource = strchr( new->full_jid, '/' ) + 1;
331        }
332        else
333        {
334                /* Let's waste some more bytes of RAM instead of to make
335                   memory management a total disaster here.. */
336                new->full_jid = full_jid;
337        }
338       
339        return new;
340}
341
342/* Finds a buddy from our structures. Can find both full- and bare JIDs. When
343   asked for a bare JID, it uses the "resource_select" setting to see which
344   resource to pick. */
345struct jabber_buddy *jabber_buddy_by_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
346{
347        struct jabber_data *jd = ic->proto_data;
348        struct jabber_buddy *bud;
349        char *s, *jid;
350       
351        jid = jabber_normalize( jid_ );
352       
353        if( ( s = strchr( jid, '/' ) ) )
354        {
355                int none_found = 0;
356               
357                *s = 0;
358                if( ( bud = g_hash_table_lookup( jd->buddies, jid ) ) )
359                {
360                        /* Is this one of those no-resource buddies? */
361                        if( bud->resource == NULL )
362                        {
363                                g_free( jid );
364                                return NULL;
365                        }
366                        else
367                        {
368                                /* See if there's an exact match. */
369                                for( ; bud; bud = bud->next )
370                                        if( g_strcasecmp( bud->resource, s + 1 ) == 0 )
371                                                break;
372                        }
373                }
374                else
375                {
376                        /* This hack is there to make sure that O_CREAT will
377                           work if there's already another resouce present
378                           for this JID, even if it's an unknown buddy. This
379                           is done to handle conferences properly. */
380                        none_found = 1;
381                }
382               
383                if( bud == NULL && ( flags & GET_BUDDY_CREAT ) && ( imcb_find_buddy( ic, jid ) || !none_found ) )
384                {
385                        *s = '/';
386                        bud = jabber_buddy_add( ic, jid );
387                }
388               
389                g_free( jid );
390                return bud;
391        }
392        else
393        {
394                struct jabber_buddy *best_prio, *best_time;
395                char *set;
396               
397                bud = g_hash_table_lookup( jd->buddies, jid );
398               
399                g_free( jid );
400               
401                if( bud == NULL )
402                        /* No match. Create it now? */
403                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
404                                   jabber_buddy_add( ic, jid_ ) : NULL;
405                else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )
406                        /* We want an exact match, so in thise case there shouldn't be a /resource. */
407                        return NULL;
408                else if( ( bud->resource == NULL || bud->next == NULL ) )
409                        /* No need for selection if there's only one option. */
410                        return bud;
411               
412                best_prio = best_time = bud;
413                for( ; bud; bud = bud->next )
414                {
415                        if( bud->priority > best_prio->priority )
416                                best_prio = bud;
417                        if( bud->last_act > best_time->last_act )
418                                best_time = bud;
419                }
420               
421                if( ( set = set_getstr( &ic->acc->set, "resource_select" ) ) == NULL )
422                        return NULL;
423                else if( strcmp( set, "activity" ) == 0 )
424                        return best_time;
425                else /* if( strcmp( set, "priority" ) == 0 ) */
426                        return best_prio;
427        }
428}
429
430/* Remove one specific full JID from our list. Use this when a buddy goes
431   off-line (because (s)he can still be online from a different location.
432   XXX: See above, we should accept bare JIDs too... */
433int jabber_buddy_remove( struct im_connection *ic, char *full_jid_ )
434{
435        struct jabber_data *jd = ic->proto_data;
436        struct jabber_buddy *bud, *prev, *bi;
437        char *s, *full_jid;
438       
439        full_jid = jabber_normalize( full_jid_ );
440       
441        if( ( s = strchr( full_jid, '/' ) ) )
442                *s = 0;
443       
444        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
445        {
446                /* If there's only one item in the list (and if the resource
447                   matches), removing it is simple. (And the hash reference
448                   should be removed too!) */
449                if( bud->next == NULL && ( ( s == NULL || bud->resource == NULL ) || g_strcasecmp( bud->resource, s + 1 ) == 0 ) )
450                {
451                        g_hash_table_remove( jd->buddies, bud->bare_jid );
452                        g_free( bud->bare_jid );
453                        g_free( bud->ext_jid );
454                        g_free( bud->full_jid );
455                        g_free( bud->away_message );
456                        g_free( bud );
457                       
458                        g_free( full_jid );
459                       
460                        return 1;
461                }
462                else if( s == NULL || bud->resource == NULL )
463                {
464                        /* Tried to remove a bare JID while this JID does seem
465                           to have resources... (Or the opposite.) *sigh* */
466                        g_free( full_jid );
467                        return 0;
468                }
469                else
470                {
471                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
472                                if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
473                                        break;
474                       
475                        g_free( full_jid );
476                       
477                        if( bi )
478                        {
479                                if( prev )
480                                        prev->next = bi->next;
481                                else
482                                        /* The hash table should point at the second
483                                           item, because we're removing the first. */
484                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
485                               
486                                g_free( bi->ext_jid );
487                                g_free( bi->full_jid );
488                                g_free( bi->away_message );
489                                g_free( bi );
490                               
491                                return 1;
492                        }
493                        else
494                        {
495                                return 0;
496                        }
497                }
498        }
499        else
500        {
501                g_free( full_jid );
502                return 0;
503        }
504}
505
506/* Remove a buddy completely; removes all resources that belong to the
507   specified bare JID. Use this when removing someone from the contact
508   list, for example. */
509int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid_ )
510{
511        struct jabber_data *jd = ic->proto_data;
512        struct jabber_buddy *bud, *next;
513        char *bare_jid;
514       
515        if( strchr( bare_jid_, '/' ) )
516                return 0;
517       
518        bare_jid = jabber_normalize( bare_jid_ );
519       
520        if( ( bud = g_hash_table_lookup( jd->buddies, bare_jid ) ) )
521        {
522                /* Most important: Remove the hash reference. We don't know
523                   this buddy anymore. */
524                g_hash_table_remove( jd->buddies, bud->bare_jid );
525               
526                /* Deallocate the linked list of resources. */
527                while( bud )
528                {
529                        next = bud->next;
530                        g_free( bud->ext_jid );
531                        g_free( bud->full_jid );
532                        g_free( bud->away_message );
533                        g_free( bud );
534                        bud = next;
535                }
536               
537                g_free( bare_jid );
538                return 1;
539        }
540        else
541        {
542                g_free( bare_jid );
543                return 0;
544        }
545}
546
547struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name )
548{
549        char *normalized = jabber_normalize( name );
550        struct groupchat *ret;
551        struct jabber_chat *jc;
552       
553        for( ret = ic->groupchats; ret; ret = ret->next )
554        {
555                jc = ret->data;
556                if( strcmp( normalized, jc->name ) == 0 )
557                        break;
558        }
559        g_free( normalized );
560       
561        return ret;
562}
563
564time_t jabber_get_timestamp( struct xt_node *xt )
565{
566        struct tm tp, utc;
567        struct xt_node *c;
568        time_t res, tres;
569        char *s = NULL;
570       
571        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
572        {
573                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
574                        break;
575        }
576       
577        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
578                return 0;
579       
580        memset( &tp, 0, sizeof( tp ) );
581        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
582                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
583                return 0;
584       
585        tp.tm_year -= 1900;
586        tp.tm_mon --;
587        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
588       
589        res = mktime( &tp );
590        /* Problem is, mktime() just gave us the GMT timestamp for the
591           given local time... While the given time WAS NOT local. So
592           we should fix this now.
593       
594           Now I could choose between messing with environment variables
595           (kludgy) or using timegm() (not portable)... Or doing the
596           following, which I actually prefer... */
597        gmtime_r( &res, &utc );
598        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
599        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
600                /* Sweet! We're in UTC right now... */
601                return res;
602       
603        tres = mktime( &utc );
604        res += res - tres;
605       
606        /* Yes, this is a hack. And it will go wrong around DST changes.
607           BUT this is more likely to be threadsafe than messing with
608           environment variables, and possibly more portable... */
609       
610        return res;
611}
Note: See TracBrowser for help on using the repository browser.