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

Last change on this file since 2ff2076 was 2ff2076, checked in by ulim <a.sporto+bee@…>, at 2007-12-03T14:28:45Z

Intermediate commit. Sending seems to work. TODOs:

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