source: protocols/jabber/jabber_util.c @ 2d317bb

Last change on this file since 2d317bb was 43671b9, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-04-22T23:39:37Z

You can send messages too now. But it's still very kludgy and doesn't work
with anonymous rooms (ie about 95% of all available Jabber chatrooms?).

  • Property mode set to 100644
File size: 16.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        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->full_jid );
454                        g_free( bud->away_message );
455                        g_free( bud );
456                       
457                        g_free( full_jid );
458                       
459                        return 1;
460                }
461                else if( s == NULL || bud->resource == NULL )
462                {
463                        /* Tried to remove a bare JID while this JID does seem
464                           to have resources... (Or the opposite.) *sigh* */
465                        g_free( full_jid );
466                        return 0;
467                }
468                else
469                {
470                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
471                                if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
472                                        break;
473                       
474                        g_free( full_jid );
475                       
476                        if( bi )
477                        {
478                                if( prev )
479                                        prev->next = bi->next;
480                                else
481                                        /* The hash table should point at the second
482                                           item, because we're removing the first. */
483                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
484                               
485                                g_free( bi->full_jid );
486                                g_free( bi->away_message );
487                                g_free( bi );
488                               
489                                return 1;
490                        }
491                        else
492                        {
493                                return 0;
494                        }
495                }
496        }
497        else
498        {
499                g_free( full_jid );
500                return 0;
501        }
502}
503
504/* Remove a buddy completely; removes all resources that belong to the
505   specified bare JID. Use this when removing someone from the contact
506   list, for example. */
507int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid_ )
508{
509        struct jabber_data *jd = ic->proto_data;
510        struct jabber_buddy *bud, *next;
511        char *bare_jid;
512       
513        if( strchr( bare_jid_, '/' ) )
514                return 0;
515       
516        bare_jid = jabber_normalize( bare_jid_ );
517       
518        if( ( bud = g_hash_table_lookup( jd->buddies, bare_jid ) ) )
519        {
520                /* Most important: Remove the hash reference. We don't know
521                   this buddy anymore. */
522                g_hash_table_remove( jd->buddies, bud->bare_jid );
523               
524                /* Deallocate the linked list of resources. */
525                while( bud )
526                {
527                        next = bud->next;
528                        g_free( bud->full_jid );
529                        g_free( bud->away_message );
530                        g_free( bud );
531                        bud = next;
532                }
533               
534                g_free( bare_jid );
535                return 1;
536        }
537        else
538        {
539                g_free( bare_jid );
540                return 0;
541        }
542}
543
544struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name )
545{
546        char *normalized = jabber_normalize( name );
547        struct groupchat *ret;
548        struct jabber_chat *jc;
549       
550        for( ret = ic->groupchats; ret; ret = ret->next )
551        {
552                jc = ret->data;
553                if( strcmp( normalized, jc->name ) == 0 )
554                        break;
555        }
556        g_free( normalized );
557       
558        return ret;
559}
560
561time_t jabber_get_timestamp( struct xt_node *xt )
562{
563        struct tm tp, utc;
564        struct xt_node *c;
565        time_t res, tres;
566        char *s = NULL;
567       
568        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
569        {
570                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
571                        break;
572        }
573       
574        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
575                return 0;
576       
577        memset( &tp, 0, sizeof( tp ) );
578        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
579                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
580                return 0;
581       
582        tp.tm_year -= 1900;
583        tp.tm_mon --;
584        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
585       
586        res = mktime( &tp );
587        /* Problem is, mktime() just gave us the GMT timestamp for the
588           given local time... While the given time WAS NOT local. So
589           we should fix this now.
590       
591           Now I could choose between messing with environment variables
592           (kludgy) or using timegm() (not portable)... Or doing the
593           following, which I actually prefer... */
594        gmtime_r( &res, &utc );
595        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
596        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
597                /* Sweet! We're in UTC right now... */
598                return res;
599       
600        tres = mktime( &utc );
601        res += res - tres;
602       
603        /* Yes, this is a hack. And it will go wrong around DST changes.
604           BUT this is more likely to be threadsafe than messing with
605           environment variables, and possibly more portable... */
606       
607        return res;
608}
Note: See TracBrowser for help on using the repository browser.