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

Last change on this file since 2c2df7d was 2c2df7d, checked in by ulim <a.sporto+bee@…>, at 2007-11-28T21:07:30Z

Initial import of jabber file receive and DCC send support. This introduces
only a few changes to bitlbees code, mainly the addition of the "transfers"
command.

This is known to work with Kopete, Psi, and Pidgin (formerly known as gaim).
At least with Pidgin also over a proxy. DCC has only been tested with irssi.
IPV6 is untested but should work.

Currently, only receiving via SOCKS5BYTESREAMS is implemented. I'm not sure if
the alternative(in-band bytestreams IBB) is worth implementing since I didn't
see a client yet that can do it. Additionally, it is probably very slow and
needs support by the server as well.

  • Property mode set to 100644
File size: 18.8 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                new[i] = tolower( orig[i] );
268       
269        new[i] = 0;
270        return new;
271}
272
273/* Adds a buddy/resource to our list. Returns NULL if full_jid is not really a
274   FULL jid or if we already have this buddy/resource. XXX: No, great, actually
275   buddies from transports don't (usually) have resources. So we'll really have
276   to deal with that properly. Set their ->resource property to NULL. Do *NOT*
277   allow to mix this stuff, though... */
278struct jabber_buddy *jabber_buddy_add( struct im_connection *ic, char *full_jid_ )
279{
280        struct jabber_data *jd = ic->proto_data;
281        struct jabber_buddy *bud, *new, *bi;
282        char *s, *full_jid;
283       
284        full_jid = jabber_normalize( full_jid_ );
285       
286        if( ( s = strchr( full_jid, '/' ) ) )
287                *s = 0;
288       
289        new = g_new0( struct jabber_buddy, 1 );
290       
291        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
292        {
293                /* If this is a transport buddy or whatever, it can't have more
294                   than one instance, so this is always wrong: */
295                if( s == NULL || bud->resource == NULL )
296                {
297                        if( s ) *s = '/';
298                        g_free( new );
299                        g_free( full_jid );
300                        return NULL;
301                }
302               
303                new->bare_jid = bud->bare_jid;
304               
305                /* We already have another resource for this buddy, add the
306                   new one to the list. */
307                for( bi = bud; bi; bi = bi->next )
308                {
309                        /* Check for dupes. */
310                        if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
311                        {
312                                *s = '/';
313                                g_free( new );
314                                g_free( full_jid );
315                                return NULL;
316                        }
317                        /* Append the new item to the list. */
318                        else if( bi->next == NULL )
319                        {
320                                bi->next = new;
321                                break;
322                        }
323                }
324        }
325        else
326        {
327                /* Keep in mind that full_jid currently isn't really
328                   a full JID... */
329                new->bare_jid = g_strdup( full_jid );
330                g_hash_table_insert( jd->buddies, new->bare_jid, new );
331        }
332       
333        if( s )
334        {
335                *s = '/';
336                new->full_jid = full_jid;
337                new->resource = strchr( new->full_jid, '/' ) + 1;
338        }
339        else
340        {
341                /* Let's waste some more bytes of RAM instead of to make
342                   memory management a total disaster here. And it saves
343                   me one g_free() call in this function. :-P */
344                new->full_jid = full_jid;
345        }
346       
347        return new;
348}
349
350/* Finds a buddy from our structures. Can find both full- and bare JIDs. When
351   asked for a bare JID, it uses the "resource_select" setting to see which
352   resource to pick. */
353struct jabber_buddy *jabber_buddy_by_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
354{
355        struct jabber_data *jd = ic->proto_data;
356        struct jabber_buddy *bud;
357        char *s, *jid;
358       
359        jid = jabber_normalize( jid_ );
360       
361        if( ( s = strchr( jid, '/' ) ) )
362        {
363                int none_found = 0;
364               
365                *s = 0;
366                if( ( bud = g_hash_table_lookup( jd->buddies, jid ) ) )
367                {
368                        /* Is this one of those no-resource buddies? */
369                        if( bud->resource == NULL )
370                        {
371                                g_free( jid );
372                                return NULL;
373                        }
374                        else
375                        {
376                                /* See if there's an exact match. */
377                                for( ; bud; bud = bud->next )
378                                        if( g_strcasecmp( bud->resource, s + 1 ) == 0 )
379                                                break;
380                        }
381                }
382                else
383                {
384                        /* This hack is there to make sure that O_CREAT will
385                           work if there's already another resouce present
386                           for this JID, even if it's an unknown buddy. This
387                           is done to handle conferences properly. */
388                        none_found = 1;
389                }
390               
391                if( bud == NULL && ( flags & GET_BUDDY_CREAT ) && ( imcb_find_buddy( ic, jid ) || !none_found ) )
392                {
393                        *s = '/';
394                        bud = jabber_buddy_add( ic, jid );
395                }
396               
397                g_free( jid );
398                return bud;
399        }
400        else
401        {
402                struct jabber_buddy *best_prio, *best_time;
403                char *set;
404               
405                bud = g_hash_table_lookup( jd->buddies, jid );
406               
407                g_free( jid );
408               
409                if( bud == NULL )
410                        /* No match. Create it now? */
411                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
412                                   jabber_buddy_add( ic, jid_ ) : NULL;
413                else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )
414                        /* We want an exact match, so in thise case there shouldn't be a /resource. */
415                        return NULL;
416                else if( ( bud->resource == NULL || bud->next == NULL ) )
417                        /* No need for selection if there's only one option. */
418                        return bud;
419               
420                best_prio = best_time = bud;
421                for( ; bud; bud = bud->next )
422                {
423                        if( bud->priority > best_prio->priority )
424                                best_prio = bud;
425                        if( bud->last_act > best_time->last_act )
426                                best_time = bud;
427                }
428               
429                if( ( set = set_getstr( &ic->acc->set, "resource_select" ) ) == NULL )
430                        return NULL;
431                else if( strcmp( set, "activity" ) == 0 )
432                        return best_time;
433                else /* if( strcmp( set, "priority" ) == 0 ) */
434                        return best_prio;
435        }
436}
437
438/* I'm keeping a separate ext_jid attribute to save a JID that makes sense
439   to export to BitlBee. This is mainly for groupchats right now. It's
440   a bit of a hack, but I just think having the user nickname in the hostname
441   part of the hostmask doesn't look nice on IRC. Normally you can convert
442   a normal JID to ext_jid by swapping the part before and after the / and
443   replacing the / with a =. But there should be some stripping (@s are
444   allowed in Jabber nicks...). */
445struct jabber_buddy *jabber_buddy_by_ext_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
446{
447        struct jabber_buddy *bud;
448        char *s, *jid;
449       
450        jid = jabber_normalize( jid_ );
451       
452        if( ( s = strchr( jid, '=' ) ) == NULL )
453                return NULL;
454       
455        for( bud = jabber_buddy_by_jid( ic, s + 1, GET_BUDDY_FIRST ); bud; bud = bud->next )
456        {
457                /* Hmmm, could happen if not all people in the chat are anonymized? */
458                if( bud->ext_jid == NULL )
459                        continue;
460               
461                if( strcmp( bud->ext_jid, jid ) == 0 )
462                        break;
463        }
464       
465        g_free( jid );
466       
467        return bud;
468}
469
470/* Remove one specific full JID from our list. Use this when a buddy goes
471   off-line (because (s)he can still be online from a different location.
472   XXX: See above, we should accept bare JIDs too... */
473int jabber_buddy_remove( struct im_connection *ic, char *full_jid_ )
474{
475        struct jabber_data *jd = ic->proto_data;
476        struct jabber_buddy *bud, *prev, *bi;
477        char *s, *full_jid;
478       
479        full_jid = jabber_normalize( full_jid_ );
480       
481        if( ( s = strchr( full_jid, '/' ) ) )
482                *s = 0;
483       
484        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
485        {
486                /* If there's only one item in the list (and if the resource
487                   matches), removing it is simple. (And the hash reference
488                   should be removed too!) */
489                if( bud->next == NULL && ( ( s == NULL || bud->resource == NULL ) || g_strcasecmp( bud->resource, s + 1 ) == 0 ) )
490                {
491                        g_hash_table_remove( jd->buddies, bud->bare_jid );
492                        g_free( bud->bare_jid );
493                        g_free( bud->ext_jid );
494                        g_free( bud->full_jid );
495                        g_free( bud->away_message );
496                        g_free( bud );
497                       
498                        g_free( full_jid );
499                       
500                        return 1;
501                }
502                else if( s == NULL || bud->resource == NULL )
503                {
504                        /* Tried to remove a bare JID while this JID does seem
505                           to have resources... (Or the opposite.) *sigh* */
506                        g_free( full_jid );
507                        return 0;
508                }
509                else
510                {
511                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
512                                if( g_strcasecmp( bi->resource, s + 1 ) == 0 )
513                                        break;
514                       
515                        g_free( full_jid );
516                       
517                        if( bi )
518                        {
519                                if( prev )
520                                        prev->next = bi->next;
521                                else
522                                        /* The hash table should point at the second
523                                           item, because we're removing the first. */
524                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
525                               
526                                g_free( bi->ext_jid );
527                                g_free( bi->full_jid );
528                                g_free( bi->away_message );
529                                g_free( bi );
530                               
531                                return 1;
532                        }
533                        else
534                        {
535                                return 0;
536                        }
537                }
538        }
539        else
540        {
541                g_free( full_jid );
542                return 0;
543        }
544}
545
546/* Remove a buddy completely; removes all resources that belong to the
547   specified bare JID. Use this when removing someone from the contact
548   list, for example. */
549int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid )
550{
551        struct jabber_data *jd = ic->proto_data;
552        struct jabber_buddy *bud, *next;
553       
554        if( strchr( bare_jid, '/' ) )
555                return 0;
556       
557        if( ( bud = jabber_buddy_by_jid( ic, bare_jid, GET_BUDDY_FIRST ) ) )
558        {
559                /* Most important: Remove the hash reference. We don't know
560                   this buddy anymore. */
561                g_hash_table_remove( jd->buddies, bud->bare_jid );
562                g_free( bud->bare_jid );
563               
564                /* Deallocate the linked list of resources. */
565                while( bud )
566                {
567                        /* ext_jid && anonymous means that this buddy is
568                           specific to one groupchat (the one we're
569                           currently cleaning up) so it can be deleted
570                           completely. */
571                        if( bud->ext_jid && bud->flags & JBFLAG_IS_ANONYMOUS )
572                                imcb_remove_buddy( ic, bud->ext_jid, NULL );
573                       
574                        next = bud->next;
575                        g_free( bud->ext_jid );
576                        g_free( bud->full_jid );
577                        g_free( bud->away_message );
578                        g_free( bud );
579                        bud = next;
580                }
581               
582                return 1;
583        }
584        else
585        {
586                return 0;
587        }
588}
589
590struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name )
591{
592        char *normalized = jabber_normalize( name );
593        struct groupchat *ret;
594        struct jabber_chat *jc;
595       
596        for( ret = ic->groupchats; ret; ret = ret->next )
597        {
598                jc = ret->data;
599                if( strcmp( normalized, jc->name ) == 0 )
600                        break;
601        }
602        g_free( normalized );
603       
604        return ret;
605}
606
607time_t jabber_get_timestamp( struct xt_node *xt )
608{
609        struct tm tp, utc;
610        struct xt_node *c;
611        time_t res, tres;
612        char *s = NULL;
613       
614        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
615        {
616                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
617                        break;
618        }
619       
620        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
621                return 0;
622       
623        memset( &tp, 0, sizeof( tp ) );
624        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
625                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
626                return 0;
627       
628        tp.tm_year -= 1900;
629        tp.tm_mon --;
630        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
631       
632        res = mktime( &tp );
633        /* Problem is, mktime() just gave us the GMT timestamp for the
634           given local time... While the given time WAS NOT local. So
635           we should fix this now.
636       
637           Now I could choose between messing with environment variables
638           (kludgy) or using timegm() (not portable)... Or doing the
639           following, which I actually prefer... */
640        gmtime_r( &res, &utc );
641        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
642        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
643                /* Sweet! We're in UTC right now... */
644                return res;
645       
646        tres = mktime( &utc );
647        res += res - tres;
648       
649        /* Yes, this is a hack. And it will go wrong around DST changes.
650           BUT this is more likely to be threadsafe than messing with
651           environment variables, and possibly more portable... */
652       
653        return res;
654}
655
656struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns )
657{
658        struct jabber_error *err = g_new0( struct jabber_error, 1 );
659        struct xt_node *c;
660        char *s;
661       
662        err->type = xt_find_attr( node, "type" );
663       
664        for( c = node->children; c; c = c->next )
665        {
666                if( !( s = xt_find_attr( c, "xmlns" ) ) ||
667                    strcmp( s, xmlns ) != 0 )
668                        continue;
669               
670                if( strcmp( c->name, "text" ) != 0 )
671                {
672                        err->code = c->name;
673                }
674                /* Only use the text if it doesn't have an xml:lang attribute,
675                   if it's empty or if it's set to something English. */
676                else if( !( s = xt_find_attr( c, "xml:lang" ) ) ||
677                         !*s || strncmp( s, "en", 2 ) == 0 )
678                {
679                        err->text = c->text;
680                }
681        }
682       
683        return err;
684}
685
686void jabber_error_free( struct jabber_error *err )
687{
688        g_free( err );
689}
Note: See TracBrowser for help on using the repository browser.