Changes in / [94d52d64:fc5d06d]


Ignore:
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • configure

    r94d52d64 rfc5d06d  
    135135        [ -z "$CFLAGS" ] && CFLAGS=-g
    136136        echo 'DEBUG=1' >> Makefile.settings
    137         echo '#define DEBUG' >> config.h
     137        CFLAGS="$CFLAGS -DDEBUG"
    138138else
    139139        [ -z "$CFLAGS" ] && CFLAGS="-O2 -fno-strict-aliasing"
  • protocols/jabber/conference.c

    r94d52d64 rfc5d06d  
    2424#include "jabber.h"
    2525
     26static xt_status jabber_chat_join_failed( struct im_connection *ic, struct xt_node *node, struct xt_node *orig );
     27
    2628struct groupchat *jabber_chat_join( struct im_connection *ic, char *room, char *nick, char *password )
    2729{
     
    3537        xt_add_attr( node, "xmlns", XMLNS_MUC );
    3638        node = jabber_make_packet( "presence", NULL, roomjid, node );
     39        jabber_cache_add( ic, node, jabber_chat_join_failed );
    3740       
    3841        if( !jabber_write_packet( ic, node ) )
    3942        {
    4043                g_free( roomjid );
    41                 xt_free_node( node );
    4244                return NULL;
    4345        }
    44         xt_free_node( node );
    4546       
    4647        jc = g_new0( struct jabber_chat, 1 );
     
    6364       
    6465        return c;
     66}
     67
     68static xt_status jabber_chat_join_failed( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
     69{
     70        struct jabber_error *err;
     71        struct jabber_buddy *bud;
     72        char *room;
     73       
     74        room = xt_find_attr( orig, "to" );
     75        bud = jabber_buddy_by_jid( ic, room, 0 );
     76       
     77        err = jabber_error_parse( xt_find_node( node->children, "error" ), XMLNS_STANZA_ERROR );
     78        if( err )
     79        {
     80                imcb_error( ic, "Error joining groupchat %s: %s%s%s",
     81                            bud->bare_jid, err->code, err->text ? ": " : "",
     82                            err->text ? err->text : "" );
     83                jabber_error_free( err );
     84        }
     85       
     86        if( bud )
     87                jabber_chat_free( jabber_chat_by_jid( ic, bud->bare_jid ) );
     88}
     89
     90struct groupchat *jabber_chat_by_jid( struct im_connection *ic, const char *name )
     91{
     92        char *normalized = jabber_normalize( name );
     93        struct groupchat *ret;
     94        struct jabber_chat *jc;
     95       
     96        for( ret = ic->groupchats; ret; ret = ret->next )
     97        {
     98                jc = ret->data;
     99                if( strcmp( normalized, jc->name ) == 0 )
     100                        break;
     101        }
     102        g_free( normalized );
     103       
     104        return ret;
    65105}
    66106
     
    148188        char *s;
    149189       
    150         if( ( chat = jabber_chat_by_name( ic, bud->bare_jid ) ) == NULL )
     190        if( ( chat = jabber_chat_by_jid( ic, bud->bare_jid ) ) == NULL )
    151191        {
    152192                /* How could this happen?? We could do kill( self, 11 )
     
    250290                return;
    251291        }
    252         else if( ( chat = jabber_chat_by_name( ic, bud->bare_jid ) ) == NULL )
     292        else if( ( chat = jabber_chat_by_jid( ic, bud->bare_jid ) ) == NULL )
    253293        {
    254294                /* How could this happen?? We could do kill( self, 11 )
  • protocols/jabber/iq.c

    r94d52d64 rfc5d06d  
    3131{
    3232        struct im_connection *ic = data;
    33         struct jabber_data *jd = ic->proto_data;
    3433        struct xt_node *c, *reply = NULL;
    3534        char *type, *s;
     
    4746        if( strcmp( type, "result" ) == 0 || strcmp( type, "error" ) == 0 )
    4847        {
    49                 struct jabber_cache_entry *entry;
    50                
    51                 if( ( s = xt_find_attr( node, "id" ) ) == NULL ||
    52                     strncmp( s, jd->cached_id_prefix, strlen( jd->cached_id_prefix ) ) != 0 )
    53                 {
    54                         /* Silently ignore it, without an ID (or a non-cache
    55                            ID) we don't know how to handle the packet and we
    56                            probably don't have to. */
    57                         return XT_HANDLED;
    58                 }
    59                
    60                 entry = g_hash_table_lookup( jd->node_cache, s );
    61                
    62                 if( entry == NULL )
    63                         imcb_log( ic, "WARNING: Received IQ-%s packet with unknown/expired ID %s!", type, s );
    64                 else if( entry->func )
    65                         return entry->func( ic, node, entry->node );
     48                return jabber_cache_handle_packet( ic, node );
    6649        }
    6750        else if( strcmp( type, "get" ) == 0 )
  • protocols/jabber/jabber.c

    r94d52d64 rfc5d06d  
    226226        jd->cached_id_prefix = g_strdup_printf( "%s%s", JABBER_CACHED_ID, s );
    227227        g_free( s );
    228        
    229         printf( "%s\n", jd->cached_id_prefix );
    230228}
    231229
     
    272270                return jabber_write( ic, message, strlen( message ) );
    273271       
    274         if( ( s = strchr( who, '=' ) ) && jabber_chat_by_name( ic, s + 1 ) )
     272        if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
    275273                bud = jabber_buddy_by_ext_jid( ic, who, 0 );
    276274        else
     
    399397        if( strchr( room, '@' ) == NULL )
    400398                imcb_error( ic, "Invalid room name: %s", room );
    401         else if( jabber_chat_by_name( ic, room ) )
     399        else if( jabber_chat_by_jid( ic, room ) )
    402400                imcb_error( ic, "Already present in chat `%s'", room );
    403401        else
  • protocols/jabber/jabber.h

    r94d52d64 rfc5d06d  
    185185void jabber_cache_entry_free( gpointer entry );
    186186void jabber_cache_clean( struct im_connection *ic );
     187xt_status jabber_cache_handle_packet( struct im_connection *ic, struct xt_node *node );
    187188const struct jabber_away_state *jabber_away_state_by_code( char *code );
    188189const struct jabber_away_state *jabber_away_state_by_name( char *name );
     
    207208int jabber_buddy_remove( struct im_connection *ic, char *full_jid );
    208209int jabber_buddy_remove_bare( struct im_connection *ic, char *bare_jid );
    209 struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name );
    210210time_t jabber_get_timestamp( struct xt_node *xt );
    211211struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns );
     
    230230/* conference.c */
    231231struct groupchat *jabber_chat_join( struct im_connection *ic, char *room, char *nick, char *password );
     232struct groupchat *jabber_chat_by_jid( struct im_connection *ic, const char *name );
    232233void jabber_chat_free( struct groupchat *c );
    233234int jabber_chat_msg( struct groupchat *ic, char *message, int flags );
  • protocols/jabber/jabber_util.c

    r94d52d64 rfc5d06d  
    179179                return FALSE;
    180180        }
     181}
     182
     183xt_status jabber_cache_handle_packet( struct im_connection *ic, struct xt_node *node )
     184{
     185        struct jabber_data *jd = ic->proto_data;
     186        struct jabber_cache_entry *entry;
     187        char *s;
     188       
     189        if( ( s = xt_find_attr( node, "id" ) ) == NULL ||
     190            strncmp( s, jd->cached_id_prefix, strlen( jd->cached_id_prefix ) ) != 0 )
     191        {
     192                /* Silently ignore it, without an ID (or a non-cache
     193                   ID) we don't know how to handle the packet and we
     194                   probably don't have to. */
     195                return XT_HANDLED;
     196        }
     197       
     198        entry = g_hash_table_lookup( jd->node_cache, s );
     199       
     200        if( entry == NULL )
     201        {
     202                imcb_log( ic, "WARNING: Received %s-%s packet with unknown/expired ID %s!",
     203                              node->name, xt_find_attr( node, "type" ) ? : "(no type)", s );
     204        }
     205        else if( entry->func )
     206        {
     207                return entry->func( ic, node, entry->node );
     208        }
     209       
     210        return XT_HANDLED;
    181211}
    182212
     
    584614}
    585615
    586 struct groupchat *jabber_chat_by_name( struct im_connection *ic, const char *name )
    587 {
    588         char *normalized = jabber_normalize( name );
    589         struct groupchat *ret;
    590         struct jabber_chat *jc;
    591        
    592         for( ret = ic->groupchats; ret; ret = ret->next )
    593         {
    594                 jc = ret->data;
    595                 if( strcmp( normalized, jc->name ) == 0 )
    596                         break;
    597         }
    598         g_free( normalized );
    599        
    600         return ret;
    601 }
    602 
    603616time_t jabber_get_timestamp( struct xt_node *xt )
    604617{
     
    652665struct jabber_error *jabber_error_parse( struct xt_node *node, char *xmlns )
    653666{
    654         struct jabber_error *err = g_new0( struct jabber_error, 1 );
     667        struct jabber_error *err;
    655668        struct xt_node *c;
    656669        char *s;
    657670       
     671        if( node == NULL )
     672                return NULL;
     673       
     674        err = g_new0( struct jabber_error, 1 );
    658675        err->type = xt_find_attr( node, "type" );
    659676       
  • protocols/jabber/presence.c

    r94d52d64 rfc5d06d  
    4040        {
    4141                *s = 0;
    42                 if( jabber_chat_by_name( ic, from ) )
     42                if( jabber_chat_by_jid( ic, from ) )
    4343                        is_chat = 1;
    4444                *s = '/';
     
    164164        else if( strcmp( type, "error" ) == 0 )
    165165        {
     166                return jabber_cache_handle_packet( ic, node );
     167               
     168                /*
    166169                struct jabber_error *err;
    167                
    168170                if( ( c = xt_find_node( node->children, "error" ) ) )
    169171                {
     
    173175                                    err->text ? err->text : "" );
    174176                        jabber_error_free( err );
    175                 }
    176                 /* What else to do with it? */
     177                } */
    177178        }
    178179       
Note: See TracChangeset for help on using the changeset viewer.