source: protocols/jabber/jabber_util.c @ 87f525e

Last change on this file since 87f525e was 8661caa, checked in by ulim <a.sporto+bee@…>, at 2008-08-04T14:45:24Z

merged in upstream r410.

Only conflict was the correction of jabber normalization which I had already done.

  • Property mode set to 100644
File size: 20.2 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#include "md5.h"
26#include "base64.h"
27
28static unsigned int next_id = 1;
29
30char *set_eval_priority( set_t *set, char *value )
31{
32        account_t *acc = set->data;
33        int i;
34       
35        if( sscanf( value, "%d", &i ) == 1 )
36        {
37                /* Priority is a signed 8-bit integer, according to RFC 3921. */
38                if( i < -128 || i > 127 )
39                        return NULL;
40        }
41        else
42                return NULL;
43       
44        /* Only run this stuff if the account is online ATM,
45           and if the setting seems to be acceptable. */
46        if( acc->ic )
47        {
48                /* Although set_eval functions usually are very nice and
49                   convenient, they have one disadvantage: If I would just
50                   call p_s_u() now to send the new prio setting, it would
51                   send the old setting because the set->value gets changed
52                   after the (this) eval returns a non-NULL value.
53                   
54                   So now I can choose between implementing post-set
55                   functions next to evals, or just do this little hack: */
56               
57                g_free( set->value );
58                set->value = g_strdup( value );
59               
60                /* (Yes, sorry, I prefer the hack. :-P) */
61               
62                presence_send_update( acc->ic );
63        }
64       
65        return value;
66}
67
68char *set_eval_tls( set_t *set, char *value )
69{
70        if( g_strcasecmp( value, "try" ) == 0 )
71                return value;
72        else
73                return set_eval_bool( set, value );
74}
75
76struct xt_node *jabber_make_packet( char *name, char *type, char *to, struct xt_node *children )
77{
78        struct xt_node *node;
79       
80        node = xt_new_node( name, NULL, children );
81       
82        if( type )
83                xt_add_attr( node, "type", type );
84        if( to )
85                xt_add_attr( node, "to", to );
86       
87        /* IQ packets should always have an ID, so let's generate one. It
88           might get overwritten by jabber_cache_add() if this packet has
89           to be saved until we receive a response. Cached packets get
90           slightly different IDs so we can recognize them. */
91        if( strcmp( name, "iq" ) == 0 )
92        {
93                char *id = g_strdup_printf( "%s%05x", JABBER_PACKET_ID, ( next_id++ ) & 0xfffff );
94                xt_add_attr( node, "id", id );
95                g_free( id );
96        }
97       
98        return node;
99}
100
101struct xt_node *jabber_make_error_packet( struct xt_node *orig, char *err_cond, char *err_type, char *err_code )
102{
103        struct xt_node *node, *c;
104        char *to;
105       
106        /* Create the "defined-condition" tag. */
107        c = xt_new_node( err_cond, NULL, NULL );
108        xt_add_attr( c, "xmlns", XMLNS_STANZA_ERROR );
109       
110        /* Put it in an <error> tag. */
111        c = xt_new_node( "error", NULL, c );
112        xt_add_attr( c, "type", err_type );
113       
114        /* Add the error code, if present */
115        if (err_code)
116                xt_add_attr( c, "code", err_code );
117       
118        /* To make the actual error packet, we copy the original packet and
119           add our <error>/type="error" tag. Including the original packet
120           is recommended, so let's just do it. */
121        node = xt_dup( orig );
122        xt_add_child( node, c );
123        xt_add_attr( node, "type", "error" );
124       
125        /* Return to sender. */
126        if( ( to = xt_find_attr( node, "from" ) ) )
127        {
128                xt_add_attr( node, "to", to );
129                xt_remove_attr( node, "from" );
130        }
131               
132        return node;
133}
134
135/* Cache a node/packet for later use. Mainly useful for IQ packets if you need
136   them when you receive the response. Use this BEFORE sending the packet so
137   it'll get a new id= tag, and do NOT free() the packet after sending it! */
138void jabber_cache_add( struct im_connection *ic, struct xt_node *node, jabber_cache_event func )
139{
140        struct jabber_data *jd = ic->proto_data;
141        struct jabber_cache_entry *entry = g_new0( struct jabber_cache_entry, 1 );
142        md5_state_t id_hash;
143        md5_byte_t id_sum[16];
144        char *id, *asc_hash;
145       
146        next_id ++;
147       
148        id_hash = jd->cached_id_prefix;
149        md5_append( &id_hash, (md5_byte_t*) &next_id, sizeof( next_id ) );
150        md5_finish( &id_hash, id_sum );
151        asc_hash = base64_encode( id_sum, 12 );
152       
153        id = g_strdup_printf( "%s%s", JABBER_CACHED_ID, asc_hash );
154        xt_add_attr( node, "id", id );
155        g_free( id );
156        g_free( asc_hash );
157       
158        entry->node = node;
159        entry->func = func;
160        entry->saved_at = time( NULL );
161        g_hash_table_insert( jd->node_cache, xt_find_attr( node, "id" ), entry );
162}
163
164void jabber_cache_entry_free( gpointer data )
165{
166        struct jabber_cache_entry *entry = data;
167       
168        xt_free_node( entry->node );
169        g_free( entry );
170}
171
172gboolean jabber_cache_clean_entry( gpointer key, gpointer entry, gpointer nullpointer );
173
174/* This one should be called from time to time (from keepalive, in this case)
175   to make sure things don't stay in the node cache forever. By marking nodes
176   during the first run and deleting marked nodes during a next run, every
177   node should be available in the cache for at least a minute (assuming the
178   function is indeed called every minute). */
179void jabber_cache_clean( struct im_connection *ic )
180{
181        struct jabber_data *jd = ic->proto_data;
182        time_t threshold = time( NULL ) - JABBER_CACHE_MAX_AGE;
183       
184        g_hash_table_foreach_remove( jd->node_cache, jabber_cache_clean_entry, &threshold );
185}
186
187gboolean jabber_cache_clean_entry( gpointer key, gpointer entry_, gpointer threshold_ )
188{
189        struct jabber_cache_entry *entry = entry_;
190        time_t *threshold = threshold_;
191       
192        return entry->saved_at < *threshold;
193}
194
195xt_status jabber_cache_handle_packet( struct im_connection *ic, struct xt_node *node )
196{
197        struct jabber_data *jd = ic->proto_data;
198        struct jabber_cache_entry *entry;
199        char *s;
200       
201        if( ( s = xt_find_attr( node, "id" ) ) == NULL ||
202            strncmp( s, JABBER_CACHED_ID, strlen( JABBER_CACHED_ID ) ) != 0 )
203        {
204                /* Silently ignore it, without an ID (or a non-cache
205                   ID) we don't know how to handle the packet and we
206                   probably don't have to. */
207                return XT_HANDLED;
208        }
209       
210        entry = g_hash_table_lookup( jd->node_cache, s );
211       
212        if( entry == NULL )
213        {
214                /*
215                There's no longer an easy way to see if we generated this
216                one or someone else, and there's a ten-minute timeout anyway,
217                so meh.
218               
219                imcb_log( ic, "Warning: Received %s-%s packet with unknown/expired ID %s!",
220                              node->name, xt_find_attr( node, "type" ) ? : "(no type)", s );
221                */
222        }
223        else if( entry->func )
224        {
225                return entry->func( ic, node, entry->node );
226        }
227       
228        return XT_HANDLED;
229}
230
231const struct jabber_away_state jabber_away_state_list[] =
232{
233        { "away",  "Away" },
234        { "chat",  "Free for Chat" },
235        { "dnd",   "Do not Disturb" },
236        { "xa",    "Extended Away" },
237        { "",      "Online" },
238        { "",      NULL }
239};
240
241const struct jabber_away_state *jabber_away_state_by_code( char *code )
242{
243        int i;
244       
245        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
246                if( g_strcasecmp( jabber_away_state_list[i].code, code ) == 0 )
247                        return jabber_away_state_list + i;
248       
249        return NULL;
250}
251
252const struct jabber_away_state *jabber_away_state_by_name( char *name )
253{
254        int i;
255       
256        for( i = 0; jabber_away_state_list[i].full_name; i ++ )
257                if( g_strcasecmp( jabber_away_state_list[i].full_name, name ) == 0 )
258                        return jabber_away_state_list + i;
259       
260        return NULL;
261}
262
263struct jabber_buddy_ask_data
264{
265        struct im_connection *ic;
266        char *handle;
267        char *realname;
268};
269
270static void jabber_buddy_ask_yes( void *data )
271{
272        struct jabber_buddy_ask_data *bla = data;
273       
274        presence_send_request( bla->ic, bla->handle, "subscribed" );
275       
276        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
277                imcb_ask_add( bla->ic, bla->handle, NULL );
278       
279        g_free( bla->handle );
280        g_free( bla );
281}
282
283static void jabber_buddy_ask_no( void *data )
284{
285        struct jabber_buddy_ask_data *bla = data;
286       
287        presence_send_request( bla->ic, bla->handle, "subscribed" );
288       
289        g_free( bla->handle );
290        g_free( bla );
291}
292
293void jabber_buddy_ask( struct im_connection *ic, char *handle )
294{
295        struct jabber_buddy_ask_data *bla = g_new0( struct jabber_buddy_ask_data, 1 );
296        char *buf;
297       
298        bla->ic = ic;
299        bla->handle = g_strdup( handle );
300       
301        buf = g_strdup_printf( "The user %s wants to add you to his/her buddy list.", handle );
302        imcb_ask( ic, buf, bla, jabber_buddy_ask_yes, jabber_buddy_ask_no );
303        g_free( buf );
304}
305
306/* Returns a new string. Don't leak it! */
307char *jabber_normalize( const char *orig )
308{
309        int len, i;
310        char *new;
311       
312        len = strlen( orig );
313        new = g_new( char, len + 1 );
314       
315        /* So it turns out the /resource part is case sensitive. Yeah, and
316           it's Unicode but feck Unicode. :-P So stop once we see a slash. */
317        for( i = 0; i < len && orig[i] != '/' ; i ++ )
318                new[i] = tolower( orig[i] );
319        for( ; orig[i]; i ++ )
320                new[i] = orig[i];
321       
322        new[i] = 0;
323        return new;
324}
325
326/* Adds a buddy/resource to our list. Returns NULL if full_jid is not really a
327   FULL jid or if we already have this buddy/resource. XXX: No, great, actually
328   buddies from transports don't (usually) have resources. So we'll really have
329   to deal with that properly. Set their ->resource property to NULL. Do *NOT*
330   allow to mix this stuff, though... */
331struct jabber_buddy *jabber_buddy_add( struct im_connection *ic, char *full_jid_ )
332{
333        struct jabber_data *jd = ic->proto_data;
334        struct jabber_buddy *bud, *new, *bi;
335        char *s, *full_jid;
336       
337        full_jid = jabber_normalize( full_jid_ );
338       
339        if( ( s = strchr( full_jid, '/' ) ) )
340                *s = 0;
341       
342        new = g_new0( struct jabber_buddy, 1 );
343       
344        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
345        {
346                /* If this is a transport buddy or whatever, it can't have more
347                   than one instance, so this is always wrong: */
348                if( s == NULL || bud->resource == NULL )
349                {
350                        if( s ) *s = '/';
351                        g_free( new );
352                        g_free( full_jid );
353                        return NULL;
354                }
355               
356                new->bare_jid = bud->bare_jid;
357               
358                /* We already have another resource for this buddy, add the
359                   new one to the list. */
360                for( bi = bud; bi; bi = bi->next )
361                {
362                        /* Check for dupes. */
363                        if( strcmp( bi->resource, s + 1 ) == 0 )
364                        {
365                                *s = '/';
366                                g_free( new );
367                                g_free( full_jid );
368                                return NULL;
369                        }
370                        /* Append the new item to the list. */
371                        else if( bi->next == NULL )
372                        {
373                                bi->next = new;
374                                break;
375                        }
376                }
377        }
378        else
379        {
380                /* Keep in mind that full_jid currently isn't really
381                   a full JID... */
382                new->bare_jid = g_strdup( full_jid );
383                g_hash_table_insert( jd->buddies, new->bare_jid, new );
384        }
385       
386        if( s )
387        {
388                *s = '/';
389                new->full_jid = full_jid;
390                new->resource = strchr( new->full_jid, '/' ) + 1;
391        }
392        else
393        {
394                /* Let's waste some more bytes of RAM instead of to make
395                   memory management a total disaster here. And it saves
396                   me one g_free() call in this function. :-P */
397                new->full_jid = full_jid;
398        }
399       
400        return new;
401}
402
403/* Finds a buddy from our structures. Can find both full- and bare JIDs. When
404   asked for a bare JID, it uses the "resource_select" setting to see which
405   resource to pick. */
406struct jabber_buddy *jabber_buddy_by_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
407{
408        struct jabber_data *jd = ic->proto_data;
409        struct jabber_buddy *bud;
410        char *s, *jid;
411       
412        jid = jabber_normalize( jid_ );
413       
414        if( ( s = strchr( jid, '/' ) ) )
415        {
416                int bare_exists = 0;
417               
418                *s = 0;
419                if( ( bud = g_hash_table_lookup( jd->buddies, jid ) ) )
420                {
421                        /* Just return the first one for this bare JID. */
422                        if( flags & GET_BUDDY_FIRST )
423                        {
424                                *s = '/';
425                                g_free( jid );
426                                return bud;
427                        }
428                       
429                        /* Is this one of those no-resource buddies? */
430                        if( bud->resource == NULL )
431                        {
432                                *s = '/';
433                                g_free( jid );
434                                return NULL;
435                        }
436                       
437                        /* See if there's an exact match. */
438                        for( ; bud; bud = bud->next )
439                                if( strcmp( bud->resource, s + 1 ) == 0 )
440                                        break;
441                }
442                else
443                {
444                        /* This variable tells the if down here that the bare
445                           JID already exists and we should feel free to add
446                           more resources, if the caller asked for that. */
447                        bare_exists = 1;
448                }
449               
450                if( bud == NULL && ( flags & GET_BUDDY_CREAT ) &&
451                    ( !bare_exists || imcb_find_buddy( ic, jid ) ) )
452                {
453                        *s = '/';
454                        bud = jabber_buddy_add( ic, jid );
455                }
456               
457                g_free( jid );
458                return bud;
459        }
460        else
461        {
462                struct jabber_buddy *best_prio, *best_time;
463                char *set;
464               
465                bud = g_hash_table_lookup( jd->buddies, jid );
466               
467                g_free( jid );
468               
469                if( bud == NULL )
470                        /* No match. Create it now? */
471                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
472                                   jabber_buddy_add( ic, jid_ ) : NULL;
473                else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )
474                        /* We want an exact match, so in thise case there shouldn't be a /resource. */
475                        return NULL;
476                else if( bud->resource == NULL || bud->next == NULL )
477                        /* No need for selection if there's only one option. */
478                        return bud;
479                else if( flags & GET_BUDDY_FIRST )
480                        /* Looks like the caller doesn't care about details. */
481                        return bud;
482               
483                best_prio = best_time = bud;
484                for( ; bud; bud = bud->next )
485                {
486                        if( bud->priority > best_prio->priority )
487                                best_prio = bud;
488                        if( bud->last_act > best_time->last_act )
489                                best_time = bud;
490                }
491               
492                if( ( set = set_getstr( &ic->acc->set, "resource_select" ) ) == NULL )
493                        return NULL;
494                else if( strcmp( set, "activity" ) == 0 )
495                        return best_time;
496                else /* if( strcmp( set, "priority" ) == 0 ) */
497                        return best_prio;
498        }
499}
500
501/* I'm keeping a separate ext_jid attribute to save a JID that makes sense
502   to export to BitlBee. This is mainly for groupchats right now. It's
503   a bit of a hack, but I just think having the user nickname in the hostname
504   part of the hostmask doesn't look nice on IRC. Normally you can convert
505   a normal JID to ext_jid by swapping the part before and after the / and
506   replacing the / with a =. But there should be some stripping (@s are
507   allowed in Jabber nicks...). */
508struct jabber_buddy *jabber_buddy_by_ext_jid( struct im_connection *ic, char *jid_, get_buddy_flags_t flags )
509{
510        struct jabber_buddy *bud;
511        char *s, *jid;
512       
513        jid = jabber_normalize( jid_ );
514       
515        if( ( s = strchr( jid, '=' ) ) == NULL )
516                return NULL;
517       
518        for( bud = jabber_buddy_by_jid( ic, s + 1, GET_BUDDY_FIRST ); bud; bud = bud->next )
519        {
520                /* Hmmm, could happen if not all people in the chat are anonymized? */
521                if( bud->ext_jid == NULL )
522                        continue;
523               
524                if( strcmp( bud->ext_jid, jid ) == 0 )
525                        break;
526        }
527       
528        g_free( jid );
529       
530        return bud;
531}
532
533/* Remove one specific full JID from our list. Use this when a buddy goes
534   off-line (because (s)he can still be online from a different location.
535   XXX: See above, we should accept bare JIDs too... */
536int jabber_buddy_remove( struct im_connection *ic, char *full_jid_ )
537{
538        struct jabber_data *jd = ic->proto_data;
539        struct jabber_buddy *bud, *prev, *bi;
540        char *s, *full_jid;
541       
542        full_jid = jabber_normalize( full_jid_ );
543       
544        if( ( s = strchr( full_jid, '/' ) ) )
545                *s = 0;
546       
547        if( ( bud = g_hash_table_lookup( jd->buddies, full_jid ) ) )
548        {
549                /* If there's only one item in the list (and if the resource
550                   matches), removing it is simple. (And the hash reference
551                   should be removed too!) */
552                if( bud->next == NULL &&
553                    ( ( s == NULL && bud->resource == NULL ) ||
554                      ( bud->resource && s && strcmp( bud->resource, s + 1 ) == 0 ) ) )
555                {
556                        g_hash_table_remove( jd->buddies, bud->bare_jid );
557                        g_free( bud->bare_jid );
558                        g_free( bud->ext_jid );
559                        g_free( bud->full_jid );
560                        g_free( bud->away_message );
561                        g_free( bud );
562                       
563                        g_free( full_jid );
564                       
565                        return 1;
566                }
567                else if( s == NULL || bud->resource == NULL )
568                {
569                        /* Tried to remove a bare JID while this JID does seem
570                           to have resources... (Or the opposite.) *sigh* */
571                        g_free( full_jid );
572                        return 0;
573                }
574                else
575                {
576                        for( bi = bud, prev = NULL; bi; bi = (prev=bi)->next )
577                                if( strcmp( bi->resource, s + 1 ) == 0 )
578                                        break;
579                       
580                        g_free( full_jid );
581                       
582                        if( bi )
583                        {
584                                if( prev )
585                                        prev->next = bi->next;
586                                else
587                                        /* The hash table should point at the second
588                                           item, because we're removing the first. */
589                                        g_hash_table_replace( jd->buddies, bi->bare_jid, bi->next );
590                               
591                                g_free( bi->ext_jid );
592                                g_free( bi->full_jid );
593                                g_free( bi->away_message );
594                                g_free( bi );
595                               
596                                return 1;
597                        }
598                        else
599                        {
600                                return 0;
601                        }
602                }
603        }
604        else
605        {
606                g_free( full_jid );
607                return 0;
608        }
609}
610
611/* Remove a buddy completely; removes all resources that belong to the
612   specified bare JID. Use this when removing someone from the contact
613   list, for example. */
614int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid )
615{
616        struct jabber_data *jd = ic->proto_data;
617        struct jabber_buddy *bud, *next;
618       
619        if( strchr( bare_jid, '/' ) )
620                return 0;
621       
622        if( ( bud = jabber_buddy_by_jid( ic, bare_jid, GET_BUDDY_FIRST ) ) )
623        {
624                /* Most important: Remove the hash reference. We don't know
625                   this buddy anymore. */
626                g_hash_table_remove( jd->buddies, bud->bare_jid );
627                g_free( bud->bare_jid );
628               
629                /* Deallocate the linked list of resources. */
630                while( bud )
631                {
632                        /* ext_jid && anonymous means that this buddy is
633                           specific to one groupchat (the one we're
634                           currently cleaning up) so it can be deleted
635                           completely. */
636                        if( bud->ext_jid && bud->flags & JBFLAG_IS_ANONYMOUS )
637                                imcb_remove_buddy( ic, bud->ext_jid, NULL );
638                       
639                        next = bud->next;
640                        g_free( bud->ext_jid );
641                        g_free( bud->full_jid );
642                        g_free( bud->away_message );
643                        g_free( bud );
644                        bud = next;
645                }
646               
647                return 1;
648        }
649        else
650        {
651                return 0;
652        }
653}
654
655time_t jabber_get_timestamp( struct xt_node *xt )
656{
657        struct tm tp, utc;
658        struct xt_node *c;
659        time_t res, tres;
660        char *s = NULL;
661       
662        for( c = xt->children; ( c = xt_find_node( c, "x" ) ); c = c->next )
663        {
664                if( ( s = xt_find_attr( c, "xmlns" ) ) && strcmp( s, XMLNS_DELAY ) == 0 )
665                        break;
666        }
667       
668        if( !c || !( s = xt_find_attr( c, "stamp" ) ) )
669                return 0;
670       
671        memset( &tp, 0, sizeof( tp ) );
672        if( sscanf( s, "%4d%2d%2dT%2d:%2d:%2d", &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
673                                                &tp.tm_hour, &tp.tm_min, &tp.tm_sec ) != 6 )
674                return 0;
675       
676        tp.tm_year -= 1900;
677        tp.tm_mon --;
678        tp.tm_isdst = -1; /* GRRRRRRRRRRR */
679       
680        res = mktime( &tp );
681        /* Problem is, mktime() just gave us the GMT timestamp for the
682           given local time... While the given time WAS NOT local. So
683           we should fix this now.
684       
685           Now I could choose between messing with environment variables
686           (kludgy) or using timegm() (not portable)... Or doing the
687           following, which I actually prefer... */
688        gmtime_r( &res, &utc );
689        utc.tm_isdst = -1; /* Once more: GRRRRRRRRRRRRRRRRRR!!! */
690        if( utc.tm_hour == tp.tm_hour && utc.tm_min == tp.tm_min )
691                /* Sweet! We're in UTC right now... */
692                return res;
693       
694        tres = mktime( &utc );
695        res += res - tres;
696       
697        /* Yes, this is a hack. And it will go wrong around DST changes.
698           BUT this is more likely to be threadsafe than messing with
699           environment variables, and possibly more portable... */
700       
701        return res;
702}
703
704struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns )
705{
706        struct jabber_error *err;
707        struct xt_node *c;
708        char *s;
709       
710        if( node == NULL )
711                return NULL;
712       
713        err = g_new0( struct jabber_error, 1 );
714        err->type = xt_find_attr( node, "type" );
715       
716        for( c = node->children; c; c = c->next )
717        {
718                if( !( s = xt_find_attr( c, "xmlns" ) ) ||
719                    strcmp( s, xmlns ) != 0 )
720                        continue;
721               
722                if( strcmp( c->name, "text" ) != 0 )
723                {
724                        err->code = c->name;
725                }
726                /* Only use the text if it doesn't have an xml:lang attribute,
727                   if it's empty or if it's set to something English. */
728                else if( !( s = xt_find_attr( c, "xml:lang" ) ) ||
729                         !*s || strncmp( s, "en", 2 ) == 0 )
730                {
731                        err->text = c->text;
732                }
733        }
734       
735        return err;
736}
737
738void jabber_error_free( struct jabber_error *err )
739{
740        g_free( err );
741}
Note: See TracBrowser for help on using the repository browser.