Ignore:
Timestamp:
2015-02-20T22:50:54Z (6 years ago)
Author:
dequis <dx@…>
Branches:
master
Children:
0b9daac, 3d45471, 7733b8c
Parents:
af359b4
git-author:
Indent <please@…> (19-02-15 05:47:20)
git-committer:
dequis <dx@…> (20-02-15 22:50:54)
Message:

Reindent everything to K&R style with tabs

Used uncrustify, with the configuration file in ./doc/uncrustify.cfg

Commit author set to "Indent <please@…>" so that it's easier to
skip while doing git blame.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • protocols/jabber/jabber.c

    raf359b4 r5ebff60  
    5454};
    5555
    56 static void jabber_init( account_t *acc )
     56static void jabber_init(account_t *acc)
    5757{
    5858        set_t *s;
    5959        char str[16];
    60        
    61         s = set_add( &acc->set, "activity_timeout", "600", set_eval_int, acc );
    62        
    63         s = set_add( &acc->set, "oauth", "false", set_eval_oauth, acc );
    64 
    65         s = set_add( &acc->set, "display_name", NULL, NULL, acc );
    66        
    67         g_snprintf( str, sizeof( str ), "%d", jabber_port_list[0] );
    68         s = set_add( &acc->set, "port", str, set_eval_int, acc );
     60
     61        s = set_add(&acc->set, "activity_timeout", "600", set_eval_int, acc);
     62
     63        s = set_add(&acc->set, "oauth", "false", set_eval_oauth, acc);
     64
     65        s = set_add(&acc->set, "display_name", NULL, NULL, acc);
     66
     67        g_snprintf(str, sizeof(str), "%d", jabber_port_list[0]);
     68        s = set_add(&acc->set, "port", str, set_eval_int, acc);
    6969        s->flags |= ACC_SET_OFFLINE_ONLY;
    70        
    71         s = set_add( &acc->set, "priority", "0", set_eval_priority, acc );
    72 
    73         s = set_add( &acc->set, "proxy", "<local>;<auto>", NULL, acc );
    74        
    75         s = set_add( &acc->set, "resource", "BitlBee", NULL, acc );
     70
     71        s = set_add(&acc->set, "priority", "0", set_eval_priority, acc);
     72
     73        s = set_add(&acc->set, "proxy", "<local>;<auto>", NULL, acc);
     74
     75        s = set_add(&acc->set, "resource", "BitlBee", NULL, acc);
    7676        s->flags |= ACC_SET_OFFLINE_ONLY;
    77        
    78         s = set_add( &acc->set, "resource_select", "activity", NULL, acc );
    79        
    80         s = set_add( &acc->set, "sasl", "true", set_eval_bool, acc );
     77
     78        s = set_add(&acc->set, "resource_select", "activity", NULL, acc);
     79
     80        s = set_add(&acc->set, "sasl", "true", set_eval_bool, acc);
    8181        s->flags |= ACC_SET_OFFLINE_ONLY | SET_HIDDEN_DEFAULT;
    82        
    83         s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
     82
     83        s = set_add(&acc->set, "server", NULL, set_eval_account, acc);
    8484        s->flags |= SET_NOSAVE | ACC_SET_OFFLINE_ONLY | SET_NULL_OK;
    85        
    86         s = set_add( &acc->set, "ssl", "false", set_eval_bool, acc );
     85
     86        s = set_add(&acc->set, "ssl", "false", set_eval_bool, acc);
    8787        s->flags |= ACC_SET_OFFLINE_ONLY;
    88        
    89         s = set_add( &acc->set, "tls", "true", set_eval_tls, acc );
     88
     89        s = set_add(&acc->set, "tls", "true", set_eval_tls, acc);
    9090        s->flags |= ACC_SET_OFFLINE_ONLY;
    91        
    92         s = set_add( &acc->set, "tls_verify", "true", set_eval_bool, acc );
     91
     92        s = set_add(&acc->set, "tls_verify", "true", set_eval_bool, acc);
    9393        s->flags |= ACC_SET_OFFLINE_ONLY;
    9494
    95         s = set_add( &acc->set, "user_agent", "BitlBee", NULL, acc );
    96        
    97         s = set_add( &acc->set, "xmlconsole", "false", set_eval_bool, acc );
     95        s = set_add(&acc->set, "user_agent", "BitlBee", NULL, acc);
     96
     97        s = set_add(&acc->set, "xmlconsole", "false", set_eval_bool, acc);
    9898        s->flags |= ACC_SET_OFFLINE_ONLY;
    99        
     99
    100100        acc->flags |= ACC_FLAG_AWAY_MESSAGE | ACC_FLAG_STATUS_MESSAGE |
    101101                      ACC_FLAG_HANDLE_DOMAINS;
    102102}
    103103
    104 static void jabber_generate_id_hash( struct jabber_data *jd );
    105 
    106 static void jabber_login( account_t *acc )
    107 {
    108         struct im_connection *ic = imcb_new( acc );
    109         struct jabber_data *jd = g_new0( struct jabber_data, 1 );
     104static void jabber_generate_id_hash(struct jabber_data *jd);
     105
     106static void jabber_login(account_t *acc)
     107{
     108        struct im_connection *ic = imcb_new(acc);
     109        struct jabber_data *jd = g_new0(struct jabber_data, 1);
    110110        char *s;
    111        
     111
    112112        /* For now this is needed in the _connected() handlers if using
    113113           GLib event handling, to make sure we're not handling events
    114114           on dead connections. */
    115         jabber_connections = g_slist_prepend( jabber_connections, ic );
    116        
     115        jabber_connections = g_slist_prepend(jabber_connections, ic);
     116
    117117        jd->ic = ic;
    118118        ic->proto_data = jd;
    119        
    120         jabber_set_me( ic, acc->user );
    121        
     119
     120        jabber_set_me(ic, acc->user);
     121
    122122        jd->fd = jd->r_inpa = jd->w_inpa = -1;
    123        
    124         if( jd->server == NULL )
    125         {
    126                 imcb_error( ic, "Incomplete account name (format it like <username@jabberserver.name>)" );
    127                 imc_logout( ic, FALSE );
     123
     124        if (jd->server == NULL) {
     125                imcb_error(ic, "Incomplete account name (format it like <username@jabberserver.name>)");
     126                imc_logout(ic, FALSE);
    128127                return;
    129128        }
    130        
    131         if( ( s = strchr( jd->server, '/' ) ) )
    132         {
     129
     130        if ((s = strchr(jd->server, '/'))) {
    133131                *s = 0;
    134                 set_setstr( &acc->set, "resource", s + 1 );
    135                
     132                set_setstr(&acc->set, "resource", s + 1);
     133
    136134                /* Also remove the /resource from the original variable so we
    137135                   won't have to do this again every time. */
    138                 s = strchr( acc->user, '/' );
     136                s = strchr(acc->user, '/');
    139137                *s = 0;
    140138        }
    141        
    142         jd->node_cache = g_hash_table_new_full( g_str_hash, g_str_equal, NULL, jabber_cache_entry_free );
    143         jd->buddies = g_hash_table_new( g_str_hash, g_str_equal );
    144        
    145         if( set_getbool( &acc->set, "oauth" ) )
    146         {
     139
     140        jd->node_cache = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, jabber_cache_entry_free);
     141        jd->buddies = g_hash_table_new(g_str_hash, g_str_equal);
     142
     143        if (set_getbool(&acc->set, "oauth")) {
    147144                GSList *p_in = NULL;
    148145                const char *tok;
    149                
     146
    150147                jd->fd = jd->r_inpa = jd->w_inpa = -1;
    151                
    152                 if( strstr( jd->server, ".facebook.com" ) )
     148
     149                if (strstr(jd->server, ".facebook.com")) {
    153150                        jd->oauth2_service = &oauth2_service_facebook;
    154                 else
     151                } else {
    155152                        jd->oauth2_service = &oauth2_service_google;
    156                
    157                 oauth_params_parse( &p_in, ic->acc->pass );
    158                
     153                }
     154
     155                oauth_params_parse(&p_in, ic->acc->pass);
     156
    159157                /* First see if we have a refresh token, in which case any
    160158                   access token we *might* have has probably expired already
    161159                   anyway. */
    162                 if( ( tok = oauth_params_get( &p_in, "refresh_token" ) ) )
    163                 {
    164                         sasl_oauth2_refresh( ic, tok );
     160                if ((tok = oauth_params_get(&p_in, "refresh_token"))) {
     161                        sasl_oauth2_refresh(ic, tok);
    165162                }
    166163                /* If we don't have a refresh token, let's hope the access
    167164                   token is still usable. */
    168                 else if( ( tok = oauth_params_get( &p_in, "access_token" ) ) )
    169                 {
    170                         jd->oauth2_access_token = g_strdup( tok );
    171                         jabber_connect( ic );
     165                else if ((tok = oauth_params_get(&p_in, "access_token"))) {
     166                        jd->oauth2_access_token = g_strdup(tok);
     167                        jabber_connect(ic);
    172168                }
    173169                /* If we don't have any, start the OAuth process now. Don't
    174170                   even open an XMPP connection yet. */
    175                 else
    176                 {
    177                         sasl_oauth2_init( ic );
     171                else {
     172                        sasl_oauth2_init(ic);
    178173                        ic->flags |= OPT_SLOW_LOGIN;
    179174                }
    180                
    181                 oauth_params_free( &p_in );
    182         }
    183         else
    184                 jabber_connect( ic );
     175
     176                oauth_params_free(&p_in);
     177        } else {
     178                jabber_connect(ic);
     179        }
    185180}
    186181
    187182/* Separate this from jabber_login() so we can do OAuth first if necessary.
    188183   Putting this in io.c would probably be more correct. */
    189 void jabber_connect( struct im_connection *ic )
     184void jabber_connect(struct im_connection *ic)
    190185{
    191186        account_t *acc = ic->acc;
     
    194189        char *connect_to;
    195190        struct ns_srv_reply **srvl = NULL, *srv = NULL;
    196        
     191
    197192        /* Figure out the hostname to connect to. */
    198         if( acc->server && *acc->server )
     193        if (acc->server && *acc->server) {
    199194                connect_to = acc->server;
    200         else if( ( srvl = srv_lookup( "xmpp-client", "tcp", jd->server ) ) ||
    201                  ( srvl = srv_lookup( "jabber-client", "tcp", jd->server ) ) )
    202         {
     195        } else if ((srvl = srv_lookup("xmpp-client", "tcp", jd->server)) ||
     196                   (srvl = srv_lookup("jabber-client", "tcp", jd->server))) {
    203197                /* Find the lowest-priority one. These usually come
    204198                   back in random/shuffled order. Not looking at
    205199                   weights etc for now. */
    206200                srv = *srvl;
    207                 for( i = 1; srvl[i]; i ++ )
    208                         if( srvl[i]->prio < srv->prio )
     201                for (i = 1; srvl[i]; i++) {
     202                        if (srvl[i]->prio < srv->prio) {
    209203                                srv = srvl[i];
    210                
     204                        }
     205                }
     206
    211207                connect_to = srv->name;
    212         }
    213         else
     208        } else {
    214209                connect_to = jd->server;
    215        
    216         imcb_log( ic, "Connecting" );
    217        
    218         for( i = 0; jabber_port_list[i] > 0; i ++ )
    219                 if( set_getint( &acc->set, "port" ) == jabber_port_list[i] )
     210        }
     211
     212        imcb_log(ic, "Connecting");
     213
     214        for (i = 0; jabber_port_list[i] > 0; i++) {
     215                if (set_getint(&acc->set, "port") == jabber_port_list[i]) {
    220216                        break;
    221 
    222         if( jabber_port_list[i] == 0 )
    223         {
    224                 imcb_log( ic, "Illegal port number" );
    225                 imc_logout( ic, FALSE );
     217                }
     218        }
     219
     220        if (jabber_port_list[i] == 0) {
     221                imcb_log(ic, "Illegal port number");
     222                imc_logout(ic, FALSE);
    226223                return;
    227224        }
    228        
     225
    229226        /* For non-SSL connections we can try to use the port # from the SRV
    230227           reply, but let's not do that when using SSL, SSL usually runs on
    231228           non-standard ports... */
    232         if( set_getbool( &acc->set, "ssl" ) )
    233         {
    234                 jd->ssl = ssl_connect( connect_to, set_getint( &acc->set, "port" ), set_getbool( &acc->set, "tls_verify" ), jabber_connected_ssl, ic );
    235                 jd->fd = jd->ssl ? ssl_getfd( jd->ssl ) : -1;
    236         }
    237         else
    238         {
    239                 jd->fd = proxy_connect( connect_to, srv ? srv->port : set_getint( &acc->set, "port" ), jabber_connected_plain, ic );
    240         }
    241         srv_free( srvl );
    242        
    243         if( jd->fd == -1 )
    244         {
    245                 imcb_error( ic, "Could not connect to server" );
    246                 imc_logout( ic, TRUE );
    247                
     229        if (set_getbool(&acc->set, "ssl")) {
     230                jd->ssl = ssl_connect(connect_to, set_getint(&acc->set, "port"), set_getbool(&acc->set,
     231                                                                                             "tls_verify"), jabber_connected_ssl,
     232                                      ic);
     233                jd->fd = jd->ssl ? ssl_getfd(jd->ssl) : -1;
     234        } else {
     235                jd->fd = proxy_connect(connect_to, srv ? srv->port : set_getint(&acc->set,
     236                                                                                "port"), jabber_connected_plain, ic);
     237        }
     238        srv_free(srvl);
     239
     240        if (jd->fd == -1) {
     241                imcb_error(ic, "Could not connect to server");
     242                imc_logout(ic, TRUE);
     243
    248244                return;
    249245        }
    250        
    251         if( set_getbool( &acc->set, "xmlconsole" ) )
    252         {
     246
     247        if (set_getbool(&acc->set, "xmlconsole")) {
    253248                jd->flags |= JFLAG_XMLCONSOLE;
    254249                /* Shouldn't really do this at this stage already, maybe. But
    255250                   I think this shouldn't break anything. */
    256                 imcb_add_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
    257         }
    258        
    259         jabber_generate_id_hash( jd );
     251                imcb_add_buddy(ic, JABBER_XMLCONSOLE_HANDLE, NULL);
     252        }
     253
     254        jabber_generate_id_hash(jd);
    260255}
    261256
    262257/* This generates an unfinished md5_state_t variable. Every time we generate
    263258   an ID, we finish the state by adding a sequence number and take the hash. */
    264 static void jabber_generate_id_hash( struct jabber_data *jd )
     259static void jabber_generate_id_hash(struct jabber_data *jd)
    265260{
    266261        md5_byte_t binbuf[4];
    267262        char *s;
    268        
    269         md5_init( &jd->cached_id_prefix );
    270         md5_append( &jd->cached_id_prefix, (unsigned char *) jd->username, strlen( jd->username ) );
    271         md5_append( &jd->cached_id_prefix, (unsigned char *) jd->server, strlen( jd->server ) );
    272         s = set_getstr( &jd->ic->acc->set, "resource" );
    273         md5_append( &jd->cached_id_prefix, (unsigned char *) s, strlen( s ) );
    274         random_bytes( binbuf, 4 );
    275         md5_append( &jd->cached_id_prefix, binbuf, 4 );
    276 }
    277 
    278 static void jabber_logout( struct im_connection *ic )
    279 {
    280         struct jabber_data *jd = ic->proto_data;
    281        
    282         while( jd->filetransfers )
    283                 imcb_file_canceled( ic, ( ( struct jabber_transfer *) jd->filetransfers->data )->ft, "Logging out" );
    284 
    285         while( jd->streamhosts )
    286         {
     263
     264        md5_init(&jd->cached_id_prefix);
     265        md5_append(&jd->cached_id_prefix, (unsigned char *) jd->username, strlen(jd->username));
     266        md5_append(&jd->cached_id_prefix, (unsigned char *) jd->server, strlen(jd->server));
     267        s = set_getstr(&jd->ic->acc->set, "resource");
     268        md5_append(&jd->cached_id_prefix, (unsigned char *) s, strlen(s));
     269        random_bytes(binbuf, 4);
     270        md5_append(&jd->cached_id_prefix, binbuf, 4);
     271}
     272
     273static void jabber_logout(struct im_connection *ic)
     274{
     275        struct jabber_data *jd = ic->proto_data;
     276
     277        while (jd->filetransfers) {
     278                imcb_file_canceled(ic, (( struct jabber_transfer *) jd->filetransfers->data)->ft, "Logging out");
     279        }
     280
     281        while (jd->streamhosts) {
    287282                jabber_streamhost_t *sh = jd->streamhosts->data;
    288                 jd->streamhosts = g_slist_remove( jd->streamhosts, sh );
    289                 g_free( sh->jid );
    290                 g_free( sh->host );
    291                 g_free( sh );
    292         }
    293 
    294         if( jd->fd >= 0 )
    295                 jabber_end_stream( ic );
    296        
    297         while( ic->groupchats )
    298                 jabber_chat_free( ic->groupchats->data );
    299        
    300         if( jd->r_inpa >= 0 )
    301                 b_event_remove( jd->r_inpa );
    302         if( jd->w_inpa >= 0 )
    303                 b_event_remove( jd->w_inpa );
    304        
    305         if( jd->ssl )
    306                 ssl_disconnect( jd->ssl );
    307         if( jd->fd >= 0 )
    308                 closesocket( jd->fd );
    309        
    310         if( jd->tx_len )
    311                 g_free( jd->txq );
    312        
    313         if( jd->node_cache )
    314                 g_hash_table_destroy( jd->node_cache );
    315        
    316         jabber_buddy_remove_all( ic );
    317        
    318         xt_free( jd->xt );
    319 
    320         md5_free( &jd->cached_id_prefix );
    321        
    322         g_free( jd->oauth2_access_token );
    323         g_free( jd->away_message );
    324         g_free( jd->internal_jid );
    325         g_free( jd->username );
    326         g_free( jd->me );
    327         g_free( jd );
    328        
    329         jabber_connections = g_slist_remove( jabber_connections, ic );
    330 }
    331 
    332 static int jabber_buddy_msg( struct im_connection *ic, char *who, char *message, int flags )
     283                jd->streamhosts = g_slist_remove(jd->streamhosts, sh);
     284                g_free(sh->jid);
     285                g_free(sh->host);
     286                g_free(sh);
     287        }
     288
     289        if (jd->fd >= 0) {
     290                jabber_end_stream(ic);
     291        }
     292
     293        while (ic->groupchats) {
     294                jabber_chat_free(ic->groupchats->data);
     295        }
     296
     297        if (jd->r_inpa >= 0) {
     298                b_event_remove(jd->r_inpa);
     299        }
     300        if (jd->w_inpa >= 0) {
     301                b_event_remove(jd->w_inpa);
     302        }
     303
     304        if (jd->ssl) {
     305                ssl_disconnect(jd->ssl);
     306        }
     307        if (jd->fd >= 0) {
     308                closesocket(jd->fd);
     309        }
     310
     311        if (jd->tx_len) {
     312                g_free(jd->txq);
     313        }
     314
     315        if (jd->node_cache) {
     316                g_hash_table_destroy(jd->node_cache);
     317        }
     318
     319        jabber_buddy_remove_all(ic);
     320
     321        xt_free(jd->xt);
     322
     323        md5_free(&jd->cached_id_prefix);
     324
     325        g_free(jd->oauth2_access_token);
     326        g_free(jd->away_message);
     327        g_free(jd->internal_jid);
     328        g_free(jd->username);
     329        g_free(jd->me);
     330        g_free(jd);
     331
     332        jabber_connections = g_slist_remove(jabber_connections, ic);
     333}
     334
     335static int jabber_buddy_msg(struct im_connection *ic, char *who, char *message, int flags)
    333336{
    334337        struct jabber_data *jd = ic->proto_data;
     
    337340        char *s;
    338341        int st;
    339        
    340         if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
    341                 return jabber_write( ic, message, strlen( message ) );
    342        
    343         if( g_strcasecmp( who, JABBER_OAUTH_HANDLE ) == 0 &&
    344             !( jd->flags & OPT_LOGGED_IN ) && jd->fd == -1 )
    345         {
    346                 if( sasl_oauth2_get_refresh_token( ic, message ) )
    347                 {
     342
     343        if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
     344                return jabber_write(ic, message, strlen(message));
     345        }
     346
     347        if (g_strcasecmp(who, JABBER_OAUTH_HANDLE) == 0 &&
     348            !(jd->flags & OPT_LOGGED_IN) && jd->fd == -1) {
     349                if (sasl_oauth2_get_refresh_token(ic, message)) {
    348350                        return 1;
    349                 }
    350                 else
    351                 {
    352                         imcb_error( ic, "OAuth failure" );
    353                         imc_logout( ic, TRUE );
     351                } else {
     352                        imcb_error(ic, "OAuth failure");
     353                        imc_logout(ic, TRUE);
    354354                        return 0;
    355355                }
    356356        }
    357        
    358         if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
    359                 bud = jabber_buddy_by_ext_jid( ic, who, 0 );
    360         else
    361                 bud = jabber_buddy_by_jid( ic, who, GET_BUDDY_BARE_OK );
    362        
    363         node = xt_new_node( "body", message, NULL );
    364         node = jabber_make_packet( "message", "chat", bud ? bud->full_jid : who, node );
    365        
    366         if( bud && ( jd->flags & JFLAG_WANT_TYPING ) &&
    367             ( ( bud->flags & JBFLAG_DOES_XEP85 ) ||
    368              !( bud->flags & JBFLAG_PROBED_XEP85 ) ) )
    369         {
     357
     358        if ((s = strchr(who, '=')) && jabber_chat_by_jid(ic, s + 1)) {
     359                bud = jabber_buddy_by_ext_jid(ic, who, 0);
     360        } else {
     361                bud = jabber_buddy_by_jid(ic, who, GET_BUDDY_BARE_OK);
     362        }
     363
     364        node = xt_new_node("body", message, NULL);
     365        node = jabber_make_packet("message", "chat", bud ? bud->full_jid : who, node);
     366
     367        if (bud && (jd->flags & JFLAG_WANT_TYPING) &&
     368            ((bud->flags & JBFLAG_DOES_XEP85) ||
     369             !(bud->flags & JBFLAG_PROBED_XEP85))) {
    370370                struct xt_node *act;
    371                
     371
    372372                /* If the user likes typing notification and if we don't know
    373373                   (and didn't probe before) if this resource supports XEP85,
     
    376376                   tag to tell that the user stopped typing (well, that's what
    377377                   we guess when s/he pressed Enter...). */
    378                 act = xt_new_node( "active", NULL, NULL );
    379                 xt_add_attr( act, "xmlns", XMLNS_CHATSTATES );
    380                 xt_add_child( node, act );
    381                
     378                act = xt_new_node("active", NULL, NULL);
     379                xt_add_attr(act, "xmlns", XMLNS_CHATSTATES);
     380                xt_add_child(node, act);
     381
    382382                /* Just make sure we do this only once. */
    383383                bud->flags |= JBFLAG_PROBED_XEP85;
    384384        }
    385        
    386         st = jabber_write_packet( ic, node );
    387         xt_free_node( node );
    388        
     385
     386        st = jabber_write_packet(ic, node);
     387        xt_free_node(node);
     388
    389389        return st;
    390390}
    391391
    392 static GList *jabber_away_states( struct im_connection *ic )
     392static GList *jabber_away_states(struct im_connection *ic)
    393393{
    394394        static GList *l = NULL;
    395395        int i;
    396        
    397         if( l == NULL )
    398                 for( i = 0; jabber_away_state_list[i].full_name; i ++ )
    399                         l = g_list_append( l, (void*) jabber_away_state_list[i].full_name );
    400        
     396
     397        if (l == NULL) {
     398                for (i = 0; jabber_away_state_list[i].full_name; i++) {
     399                        l = g_list_append(l, (void *) jabber_away_state_list[i].full_name);
     400                }
     401        }
     402
    401403        return l;
    402404}
    403405
    404 static void jabber_get_info( struct im_connection *ic, char *who )
     406static void jabber_get_info(struct im_connection *ic, char *who)
    405407{
    406408        struct jabber_buddy *bud;
    407        
    408         bud = jabber_buddy_by_jid( ic, who, GET_BUDDY_FIRST );
    409        
    410         while( bud )
    411         {
    412                 imcb_log( ic, "Buddy %s (%d) information:", bud->full_jid, bud->priority );
    413                 if( bud->away_state )
    414                         imcb_log( ic, "Away state: %s", bud->away_state->full_name );
    415                 imcb_log( ic, "Status message: %s", bud->away_message ? bud->away_message : "(none)" );
    416                
     409
     410        bud = jabber_buddy_by_jid(ic, who, GET_BUDDY_FIRST);
     411
     412        while (bud) {
     413                imcb_log(ic, "Buddy %s (%d) information:", bud->full_jid, bud->priority);
     414                if (bud->away_state) {
     415                        imcb_log(ic, "Away state: %s", bud->away_state->full_name);
     416                }
     417                imcb_log(ic, "Status message: %s", bud->away_message ? bud->away_message : "(none)");
     418
    417419                bud = bud->next;
    418420        }
    419        
    420         jabber_get_vcard( ic, bud ? bud->full_jid : who );
    421 }
    422 
    423 static void jabber_set_away( struct im_connection *ic, char *state_txt, char *message )
    424 {
    425         struct jabber_data *jd = ic->proto_data;
    426        
     421
     422        jabber_get_vcard(ic, bud ? bud->full_jid : who);
     423}
     424
     425static void jabber_set_away(struct im_connection *ic, char *state_txt, char *message)
     426{
     427        struct jabber_data *jd = ic->proto_data;
     428
    427429        /* state_txt == NULL -> Not away.
    428430           Unknown state -> fall back to the first defined away state. */
    429         if( state_txt == NULL )
     431        if (state_txt == NULL) {
    430432                jd->away_state = NULL;
    431         else if( ( jd->away_state = jabber_away_state_by_name( state_txt ) ) == NULL )
     433        } else if ((jd->away_state = jabber_away_state_by_name(state_txt)) == NULL) {
    432434                jd->away_state = jabber_away_state_list;
    433        
    434         g_free( jd->away_message );
    435         jd->away_message = ( message && *message ) ? g_strdup( message ) : NULL;
    436        
    437         presence_send_update( ic );
    438 }
    439 
    440 static void jabber_add_buddy( struct im_connection *ic, char *who, char *group )
    441 {
    442         struct jabber_data *jd = ic->proto_data;
    443        
    444         if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
    445         {
     435        }
     436
     437        g_free(jd->away_message);
     438        jd->away_message = (message && *message) ? g_strdup(message) : NULL;
     439
     440        presence_send_update(ic);
     441}
     442
     443static void jabber_add_buddy(struct im_connection *ic, char *who, char *group)
     444{
     445        struct jabber_data *jd = ic->proto_data;
     446
     447        if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
    446448                jd->flags |= JFLAG_XMLCONSOLE;
    447                 imcb_add_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
     449                imcb_add_buddy(ic, JABBER_XMLCONSOLE_HANDLE, NULL);
    448450                return;
    449451        }
    450        
    451         if( jabber_add_to_roster( ic, who, NULL, group ) )
    452                 presence_send_request( ic, who, "subscribe" );
    453 }
    454 
    455 static void jabber_remove_buddy( struct im_connection *ic, char *who, char *group )
    456 {
    457         struct jabber_data *jd = ic->proto_data;
    458        
    459         if( g_strcasecmp( who, JABBER_XMLCONSOLE_HANDLE ) == 0 )
    460         {
     452
     453        if (jabber_add_to_roster(ic, who, NULL, group)) {
     454                presence_send_request(ic, who, "subscribe");
     455        }
     456}
     457
     458static void jabber_remove_buddy(struct im_connection *ic, char *who, char *group)
     459{
     460        struct jabber_data *jd = ic->proto_data;
     461
     462        if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
    461463                jd->flags &= ~JFLAG_XMLCONSOLE;
    462464                /* Not necessary for now. And for now the code isn't too
     
    467469                return;
    468470        }
    469        
     471
    470472        /* We should always do this part. Clean up our administration a little bit. */
    471         jabber_buddy_remove_bare( ic, who );
    472        
    473         if( jabber_remove_from_roster( ic, who ) )
    474                 presence_send_request( ic, who, "unsubscribe" );
    475 }
    476 
    477 static struct groupchat *jabber_chat_join_( struct im_connection *ic, const char *room, const char *nick, const char *password, set_t **sets )
     473        jabber_buddy_remove_bare(ic, who);
     474
     475        if (jabber_remove_from_roster(ic, who)) {
     476                presence_send_request(ic, who, "unsubscribe");
     477        }
     478}
     479
     480static struct groupchat *jabber_chat_join_(struct im_connection *ic, const char *room, const char *nick,
     481                                           const char *password, set_t **sets)
    478482{
    479483        struct jabber_data *jd = ic->proto_data;
    480484        char *final_nick;
    481        
     485
    482486        /* Ignore the passed nick parameter if we have our own default */
    483         if ( !( final_nick = set_getstr( sets, "nick" ) ) &&
    484              !( final_nick = set_getstr( &ic->acc->set, "display_name" ) ) ) {
     487        if (!(final_nick = set_getstr(sets, "nick")) &&
     488            !(final_nick = set_getstr(&ic->acc->set, "display_name"))) {
    485489                /* Well, whatever, actually use the provided default, then */
    486490                final_nick = (char *) nick;
    487491        }
    488492
    489         if( strchr( room, '@' ) == NULL )
    490                 imcb_error( ic, "%s is not a valid Jabber room name. Maybe you mean %s@conference.%s?",
    491                             room, room, jd->server );
    492         else if( jabber_chat_by_jid( ic, room ) )
    493                 imcb_error( ic, "Already present in chat `%s'", room );
    494         else
    495                 return jabber_chat_join( ic, room, final_nick, set_getstr( sets, "password" ) );
    496        
     493        if (strchr(room, '@') == NULL) {
     494                imcb_error(ic, "%s is not a valid Jabber room name. Maybe you mean %s@conference.%s?",
     495                           room, room, jd->server);
     496        } else if (jabber_chat_by_jid(ic, room)) {
     497                imcb_error(ic, "Already present in chat `%s'", room);
     498        } else {
     499                return jabber_chat_join(ic, room, final_nick, set_getstr(sets, "password"));
     500        }
     501
    497502        return NULL;
    498503}
    499504
    500 static struct groupchat *jabber_chat_with_( struct im_connection *ic, char *who )
    501 {
    502         return jabber_chat_with( ic, who );
    503 }
    504 
    505 static void jabber_chat_msg_( struct groupchat *c, char *message, int flags )
    506 {
    507         if( c && message )
    508                 jabber_chat_msg( c, message, flags );
    509 }
    510 
    511 static void jabber_chat_topic_( struct groupchat *c, char *topic )
    512 {
    513         if( c && topic )
    514                 jabber_chat_topic( c, topic );
    515 }
    516 
    517 static void jabber_chat_leave_( struct groupchat *c )
    518 {
    519         if( c )
    520                 jabber_chat_leave( c, NULL );
    521 }
    522 
    523 static void jabber_chat_invite_( struct groupchat *c, char *who, char *msg )
     505static struct groupchat *jabber_chat_with_(struct im_connection *ic, char *who)
     506{
     507        return jabber_chat_with(ic, who);
     508}
     509
     510static void jabber_chat_msg_(struct groupchat *c, char *message, int flags)
     511{
     512        if (c && message) {
     513                jabber_chat_msg(c, message, flags);
     514        }
     515}
     516
     517static void jabber_chat_topic_(struct groupchat *c, char *topic)
     518{
     519        if (c && topic) {
     520                jabber_chat_topic(c, topic);
     521        }
     522}
     523
     524static void jabber_chat_leave_(struct groupchat *c)
     525{
     526        if (c) {
     527                jabber_chat_leave(c, NULL);
     528        }
     529}
     530
     531static void jabber_chat_invite_(struct groupchat *c, char *who, char *msg)
    524532{
    525533        struct jabber_data *jd = c->ic->proto_data;
     
    527535        gchar *msg_alt = NULL;
    528536
    529         if( msg == NULL )
    530                 msg_alt = g_strdup_printf( "%s invited you to %s", jd->me, jc->name );
    531        
    532         if( c && who )
    533                 jabber_chat_invite( c, who, msg ? msg : msg_alt );
    534        
    535         g_free( msg_alt );
    536 }
    537 
    538 static void jabber_keepalive( struct im_connection *ic )
     537        if (msg == NULL) {
     538                msg_alt = g_strdup_printf("%s invited you to %s", jd->me, jc->name);
     539        }
     540
     541        if (c && who) {
     542                jabber_chat_invite(c, who, msg ? msg : msg_alt);
     543        }
     544
     545        g_free(msg_alt);
     546}
     547
     548static void jabber_keepalive(struct im_connection *ic)
    539549{
    540550        /* Just any whitespace character is enough as a keepalive for XMPP sessions. */
    541         if( !jabber_write( ic, "\n", 1 ) )
     551        if (!jabber_write(ic, "\n", 1)) {
    542552                return;
    543        
     553        }
     554
    544555        /* This runs the garbage collection every minute, which means every packet
    545556           is in the cache for about a minute (which should be enough AFAIK). */
    546         jabber_cache_clean( ic );
    547 }
    548 
    549 static int jabber_send_typing( struct im_connection *ic, char *who, int typing )
     557        jabber_cache_clean(ic);
     558}
     559
     560static int jabber_send_typing(struct im_connection *ic, char *who, int typing)
    550561{
    551562        struct jabber_data *jd = ic->proto_data;
    552563        struct jabber_buddy *bud;
    553        
     564
    554565        /* Enable typing notification related code from now. */
    555566        jd->flags |= JFLAG_WANT_TYPING;
    556        
    557         if( ( bud = jabber_buddy_by_jid( ic, who, 0 ) ) == NULL )
    558         {
     567
     568        if ((bud = jabber_buddy_by_jid(ic, who, 0)) == NULL) {
    559569                /* Sending typing notifications to unknown buddies is
    560570                   unsupported for now. Shouldn't be a problem, I think. */
    561571                return 0;
    562572        }
    563        
    564         if( bud->flags & JBFLAG_DOES_XEP85 )
    565         {
     573
     574        if (bud->flags & JBFLAG_DOES_XEP85) {
    566575                /* We're only allowed to send this stuff if we know the other
    567576                   side supports it. */
    568                
     577
    569578                struct xt_node *node;
    570579                char *type;
    571580                int st;
    572                
    573                 if( typing & OPT_TYPING )
     581
     582                if (typing & OPT_TYPING) {
    574583                        type = "composing";
    575                 else if( typing & OPT_THINKING )
     584                } else if (typing & OPT_THINKING) {
    576585                        type = "paused";
    577                 else
     586                } else {
    578587                        type = "active";
    579                
    580                 node = xt_new_node( type, NULL, NULL );
    581                 xt_add_attr( node, "xmlns", XMLNS_CHATSTATES );
    582                 node = jabber_make_packet( "message", "chat", bud->full_jid, node );
    583                
    584                 st = jabber_write_packet( ic, node );
    585                 xt_free_node( node );
    586                
     588                }
     589
     590                node = xt_new_node(type, NULL, NULL);
     591                xt_add_attr(node, "xmlns", XMLNS_CHATSTATES);
     592                node = jabber_make_packet("message", "chat", bud->full_jid, node);
     593
     594                st = jabber_write_packet(ic, node);
     595                xt_free_node(node);
     596
    587597                return st;
    588598        }
    589        
     599
    590600        return 1;
    591601}
    592602
    593 void jabber_chat_add_settings( account_t *acc, set_t **head )
     603void jabber_chat_add_settings(account_t *acc, set_t **head)
    594604{
    595605        /* Meh. Stupid room passwords. Not trying to obfuscate/hide
    596606           them from the user for now. */
    597         set_add( head, "password", NULL, NULL, NULL );
    598 }
    599 
    600 void jabber_chat_free_settings( account_t *acc, set_t **head )
    601 {
    602         set_del( head, "password" );
    603 }
    604 
    605 GList *jabber_buddy_action_list( bee_user_t *bu )
     607        set_add(head, "password", NULL, NULL, NULL);
     608}
     609
     610void jabber_chat_free_settings(account_t *acc, set_t **head)
     611{
     612        set_del(head, "password");
     613}
     614
     615GList *jabber_buddy_action_list(bee_user_t *bu)
    606616{
    607617        static GList *ret = NULL;
    608        
    609         if( ret == NULL )
    610         {
     618
     619        if (ret == NULL) {
    611620                static const struct buddy_action ba[2] = {
    612621                        { "VERSION", "Get client (version) information" },
    613622                };
    614                
    615                 ret = g_list_prepend( ret, (void*) ba + 0 );
    616         }
    617        
     623
     624                ret = g_list_prepend(ret, (void *) ba + 0);
     625        }
     626
    618627        return ret;
    619628}
    620629
    621 void *jabber_buddy_action( struct bee_user *bu, const char *action, char * const args[], void *data )
    622 {
    623         if( g_strcasecmp( action, "VERSION" ) == 0 )
    624         {
     630void *jabber_buddy_action(struct bee_user *bu, const char *action, char * const args[], void *data)
     631{
     632        if (g_strcasecmp(action, "VERSION") == 0) {
    625633                struct jabber_buddy *bud;
    626                
    627                 if( ( bud = jabber_buddy_by_ext_jid( bu->ic, bu->handle, 0 ) ) == NULL )
    628                         bud = jabber_buddy_by_jid( bu->ic, bu->handle, GET_BUDDY_FIRST );
    629                 for( ; bud; bud = bud->next )
    630                         jabber_iq_version_send( bu->ic, bud, data );
    631         }
    632        
     634
     635                if ((bud = jabber_buddy_by_ext_jid(bu->ic, bu->handle, 0)) == NULL) {
     636                        bud = jabber_buddy_by_jid(bu->ic, bu->handle, GET_BUDDY_FIRST);
     637                }
     638                for (; bud; bud = bud->next) {
     639                        jabber_iq_version_send(bu->ic, bud, data);
     640                }
     641        }
     642
    633643        return NULL;
    634644}
    635645
    636 gboolean jabber_handle_is_self( struct im_connection *ic, const char *who ) {
    637         struct jabber_data *jd = ic->proto_data;
    638         return ( ( g_strcasecmp( who, ic->acc->user ) == 0 ) ||
    639                  ( jd->internal_jid &&
    640                    g_strcasecmp( who, jd->internal_jid ) == 0 ) );
     646gboolean jabber_handle_is_self(struct im_connection *ic, const char *who)
     647{
     648        struct jabber_data *jd = ic->proto_data;
     649
     650        return ((g_strcasecmp(who, ic->acc->user) == 0) ||
     651                (jd->internal_jid &&
     652                 g_strcasecmp(who, jd->internal_jid) == 0));
    641653}
    642654
    643655void jabber_initmodule()
    644656{
    645         struct prpl *ret = g_new0( struct prpl, 1 );
    646        
     657        struct prpl *ret = g_new0(struct prpl, 1);
     658
    647659        ret->name = "jabber";
    648660        ret->mms = 0;                        /* no limit */
     
    673685        ret->buddy_action = jabber_buddy_action;
    674686
    675         register_protocol( ret );
    676 }
     687        register_protocol(ret);
     688}
Note: See TracChangeset for help on using the changeset viewer.