Ignore:
Timestamp:
2015-02-20T22:50:54Z (9 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/msn/msn_util.c

    raf359b4 r5ebff60  
    1   /********************************************************************\
     1/********************************************************************\
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
    … …  
    3030#include <ctype.h>
    3131
    32 static char *adlrml_entry( const char *handle_, msn_buddy_flags_t list )
    33 {
    34         char *domain, handle[strlen(handle_)+1];
    35        
    36         strcpy( handle, handle_ );
    37         if( ( domain = strchr( handle, '@' ) ) )
     32static char *adlrml_entry(const char *handle_, msn_buddy_flags_t list)
     33{
     34        char *domain, handle[strlen(handle_) + 1];
     35
     36        strcpy(handle, handle_);
     37        if ((domain = strchr(handle, '@'))) {
    3838                *(domain++) = '\0';
    39         else
     39        } else {
    4040                return NULL;
    41        
    42         return g_markup_printf_escaped( "<ml><d n=\"%s\"><c n=\"%s\" l=\"%d\" t=\"1\"/></d></ml>",
    43                 domain, handle, list );
    44 }
    45 
    46 int msn_buddy_list_add( struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *realname, const char *group )
     41        }
     42
     43        return g_markup_printf_escaped("<ml><d n=\"%s\"><c n=\"%s\" l=\"%d\" t=\"1\"/></d></ml>",
     44                                       domain, handle, list);
     45}
     46
     47int msn_buddy_list_add(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *realname,
     48                       const char *group)
    4749{
    4850        struct msn_data *md = ic->proto_data;
    … …  
    5153        struct msn_buddy_data *bd;
    5254        char *adl;
    53        
     55
    5456        *groupid = '\0';
    5557#if 0
    56         if( group )
    57         {
     58        if (group) {
    5859                int i;
    59                 for( i = 0; i < md->groupcount; i ++ )
    60                         if( g_strcasecmp( md->grouplist[i], group ) == 0 )
    61                         {
    62                                 g_snprintf( groupid, sizeof( groupid ), " %d", i );
     60                for (i = 0; i < md->groupcount; i++) {
     61                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
     62                                g_snprintf(groupid, sizeof(groupid), " %d", i);
    6363                                break;
    6464                        }
    65                
    66                 if( *groupid == '\0' )
    67                 {
     65                }
     66
     67                if (*groupid == '\0') {
    6868                        /* Have to create this group, it doesn't exist yet. */
    6969                        struct msn_groupadd *ga;
    7070                        GSList *l;
    71                        
    72                         for( l = md->grpq; l; l = l->next )
    73                         {
     71
     72                        for (l = md->grpq; l; l = l->next) {
    7473                                ga = l->data;
    75                                 if( g_strcasecmp( ga->group, group ) == 0 )
     74                                if (g_strcasecmp(ga->group, group) == 0) {
    7675                                        break;
    77                         }
    78                        
    79                         ga = g_new0( struct msn_groupadd, 1 );
    80                         ga->who = g_strdup( who );
    81                         ga->group = g_strdup( group );
    82                         md->grpq = g_slist_prepend( md->grpq, ga );
    83                        
    84                         if( l == NULL )
    85                         {
    86                                 char groupname[strlen(group)+1];
    87                                 strcpy( groupname, group );
    88                                 http_encode( groupname );
    89                                 g_snprintf( buf, sizeof( buf ), "ADG %d %s %d\r\n", ++md->trId, groupname, 0 );
    90                                 return msn_write( ic, buf, strlen( buf ) );
    91                         }
    92                         else
    93                         {
     76                                }
     77                        }
     78
     79                        ga = g_new0(struct msn_groupadd, 1);
     80                        ga->who = g_strdup(who);
     81                        ga->group = g_strdup(group);
     82                        md->grpq = g_slist_prepend(md->grpq, ga);
     83
     84                        if (l == NULL) {
     85                                char groupname[strlen(group) + 1];
     86                                strcpy(groupname, group);
     87                                http_encode(groupname);
     88                                g_snprintf(buf, sizeof(buf), "ADG %d %s %d\r\n", ++md->trId, groupname, 0);
     89                                return msn_write(ic, buf, strlen(buf));
     90                        } else {
    9491                                /* This can happen if the user's doing lots of adds to a
    9592                                   new group at once; we're still waiting for the server
    … …  
    10097        }
    10198#endif
    102        
    103         if( !( ( bu = bee_user_by_handle( ic->bee, ic, who ) ) ||
    104                ( bu = bee_user_new( ic->bee, ic, who, 0 ) ) ) ||
    105             !( bd = bu->data ) || bd->flags & list )
     99
     100        if (!((bu = bee_user_by_handle(ic->bee, ic, who)) ||
     101              (bu = bee_user_new(ic->bee, ic, who, 0))) ||
     102            !(bd = bu->data) || bd->flags & list) {
    106103                return 1;
    107        
     104        }
     105
    108106        bd->flags |= list;
    109        
    110         if( list == MSN_BUDDY_FL )
    111                 msn_soap_ab_contact_add( ic, bu );
    112         else
    113                 msn_soap_memlist_edit( ic, who, TRUE, list );
    114        
    115         if( ( adl = adlrml_entry( who, list ) ) )
    116         {
    117                 int st = msn_ns_write( ic, -1, "ADL %d %zd\r\n%s",
    118                                        ++md->trId, strlen( adl ), adl );
    119                 g_free( adl );
    120                
     107
     108        if (list == MSN_BUDDY_FL) {
     109                msn_soap_ab_contact_add(ic, bu);
     110        } else {
     111                msn_soap_memlist_edit(ic, who, TRUE, list);
     112        }
     113
     114        if ((adl = adlrml_entry(who, list))) {
     115                int st = msn_ns_write(ic, -1, "ADL %d %zd\r\n%s",
     116                                      ++md->trId, strlen(adl), adl);
     117                g_free(adl);
     118
    121119                return st;
    122120        }
    123        
     121
    124122        return 1;
    125123}
    126124
    127 int msn_buddy_list_remove( struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *group )
     125int msn_buddy_list_remove(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *group)
    128126{
    129127        struct msn_data *md = ic->proto_data;
    … …  
    132130        struct msn_buddy_data *bd;
    133131        char *adl;
    134        
     132
    135133        *groupid = '\0';
    136134#if 0
    137         if( group )
    138         {
     135        if (group) {
    139136                int i;
    140                 for( i = 0; i < md->groupcount; i ++ )
    141                         if( g_strcasecmp( md->grouplist[i], group ) == 0 )
    142                         {
    143                                 g_snprintf( groupid, sizeof( groupid ), " %d", i );
     137                for (i = 0; i < md->groupcount; i++) {
     138                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
     139                                g_snprintf(groupid, sizeof(groupid), " %d", i);
    144140                                break;
    145141                        }
     142                }
    146143        }
    147144#endif
    148        
    149         if( !( bu = bee_user_by_handle( ic->bee, ic, who ) ) ||
    150             !( bd = bu->data ) || !( bd->flags & list ) )
     145
     146        if (!(bu = bee_user_by_handle(ic->bee, ic, who)) ||
     147            !(bd = bu->data) || !(bd->flags & list)) {
    151148                return 1;
    152        
     149        }
     150
    153151        bd->flags &= ~list;
    154        
    155         if( list == MSN_BUDDY_FL )
    156                 msn_soap_ab_contact_del( ic, bu );
    157         else
    158                 msn_soap_memlist_edit( ic, who, FALSE, list );
    159        
    160         if( ( adl = adlrml_entry( who, list ) ) )
    161         {
    162                 int st = msn_ns_write( ic, -1, "RML %d %zd\r\n%s",
    163                                        ++md->trId, strlen( adl ), adl );
    164                 g_free( adl );
    165                
     152
     153        if (list == MSN_BUDDY_FL) {
     154                msn_soap_ab_contact_del(ic, bu);
     155        } else {
     156                msn_soap_memlist_edit(ic, who, FALSE, list);
     157        }
     158
     159        if ((adl = adlrml_entry(who, list))) {
     160                int st = msn_ns_write(ic, -1, "RML %d %zd\r\n%s",
     161                                      ++md->trId, strlen(adl), adl);
     162                g_free(adl);
     163
    166164                return st;
    167165        }
    168        
     166
    169167        return 1;
    170168}
    171169
    172 struct msn_buddy_ask_data
    173 {
     170struct msn_buddy_ask_data {
    174171        struct im_connection *ic;
    175172        char *handle;
    … …  
    177174};
    178175
    179 static void msn_buddy_ask_yes( void *data )
     176static void msn_buddy_ask_yes(void *data)
    180177{
    181178        struct msn_buddy_ask_data *bla = data;
    182        
    183         msn_buddy_list_add( bla->ic, MSN_BUDDY_AL, bla->handle, bla->realname, NULL );
    184        
    185         imcb_ask_add( bla->ic, bla->handle, NULL );
    186        
    187         g_free( bla->handle );
    188         g_free( bla->realname );
    189         g_free( bla );
    190 }
    191 
    192 static void msn_buddy_ask_no( void *data )
     179
     180        msn_buddy_list_add(bla->ic, MSN_BUDDY_AL, bla->handle, bla->realname, NULL);
     181
     182        imcb_ask_add(bla->ic, bla->handle, NULL);
     183
     184        g_free(bla->handle);
     185        g_free(bla->realname);
     186        g_free(bla);
     187}
     188
     189static void msn_buddy_ask_no(void *data)
    193190{
    194191        struct msn_buddy_ask_data *bla = data;
    195        
    196         msn_buddy_list_add( bla->ic, MSN_BUDDY_BL, bla->handle, bla->realname, NULL );
    197        
    198         g_free( bla->handle );
    199         g_free( bla->realname );
    200         g_free( bla );
    201 }
    202 
    203 void msn_buddy_ask( bee_user_t *bu )
     192
     193        msn_buddy_list_add(bla->ic, MSN_BUDDY_BL, bla->handle, bla->realname, NULL);
     194
     195        g_free(bla->handle);
     196        g_free(bla->realname);
     197        g_free(bla);
     198}
     199
     200void msn_buddy_ask(bee_user_t *bu)
    204201{
    205202        struct msn_buddy_ask_data *bla;
    206203        struct msn_buddy_data *bd = bu->data;
    207204        char buf[1024];
    208        
    209         if( !( bd->flags & MSN_BUDDY_PL ) )
     205
     206        if (!(bd->flags & MSN_BUDDY_PL)) {
    210207                return;
    211        
    212         bla = g_new0( struct msn_buddy_ask_data, 1 );
     208        }
     209
     210        bla = g_new0(struct msn_buddy_ask_data, 1);
    213211        bla->ic = bu->ic;
    214         bla->handle = g_strdup( bu->handle );
    215         bla->realname = g_strdup( bu->fullname );
    216        
    217         g_snprintf( buf, sizeof( buf ),
    218                     "The user %s (%s) wants to add you to his/her buddy list.",
    219                     bu->handle, bu->fullname );
    220         imcb_ask( bu->ic, buf, bla, msn_buddy_ask_yes, msn_buddy_ask_no );
     212        bla->handle = g_strdup(bu->handle);
     213        bla->realname = g_strdup(bu->fullname);
     214
     215        g_snprintf(buf, sizeof(buf),
     216                   "The user %s (%s) wants to add you to his/her buddy list.",
     217                   bu->handle, bu->fullname);
     218        imcb_ask(bu->ic, buf, bla, msn_buddy_ask_yes, msn_buddy_ask_no);
    221219}
    222220
    223221/* *NOT* thread-safe, but that's not a problem for now... */
    224 char **msn_linesplit( char *line )
     222char **msn_linesplit(char *line)
    225223{
    226224        static char **ret = NULL;
    227225        static int size = 3;
    228226        int i, n = 0;
    229        
    230         if( ret == NULL )
    231                 ret = g_new0( char*, size );
    232        
    233         for( i = 0; line[i] && line[i] == ' '; i ++ );
    234         if( line[i] )
    235         {
     227
     228        if (ret == NULL) {
     229                ret = g_new0(char*, size);
     230        }
     231
     232        for (i = 0; line[i] && line[i] == ' '; i++) {
     233                ;
     234        }
     235        if (line[i]) {
    236236                ret[n++] = line + i;
    237                 for( i ++; line[i]; i ++ )
    238                 {
    239                         if( line[i] == ' ' )
     237                for (i++; line[i]; i++) {
     238                        if (line[i] == ' ') {
    240239                                line[i] = 0;
    241                         else if( line[i] != ' ' && !line[i-1] )
     240                        } else if (line[i] != ' ' && !line[i - 1]) {
    242241                                ret[n++] = line + i;
    243                        
    244                         if( n >= size )
    245                                 ret = g_renew( char*, ret, size += 2 );
     242                        }
     243
     244                        if (n >= size) {
     245                                ret = g_renew(char*, ret, size += 2);
     246                        }
    246247                }
    247248        }
    248249        ret[n] = NULL;
    249        
    250         return( ret );
     250
     251        return(ret);
    251252}
    252253
    … …  
    259260                   1: OK */
    260261
    261 int msn_handler( struct msn_handler_data *h )
     262int msn_handler(struct msn_handler_data *h)
    262263{
    263264        int st;
    264        
    265         h->rxq = g_renew( char, h->rxq, h->rxlen + 1024 );
    266         st = read( h->fd, h->rxq + h->rxlen, 1024 );
     265
     266        h->rxq = g_renew(char, h->rxq, h->rxlen + 1024);
     267        st = read(h->fd, h->rxq + h->rxlen, 1024);
    267268        h->rxlen += st;
    268        
    269         if( st <= 0 )
    270                 return( -1 );
    271        
    272         if( getenv( "BITLBEE_DEBUG" ) )
    273         {
    274                 write( 2, "->C:", 4 );
    275                 write( 2, h->rxq + h->rxlen - st, st );
    276         }
    277        
    278         while( st )
    279         {
     269
     270        if (st <= 0) {
     271                return(-1);
     272        }
     273
     274        if (getenv("BITLBEE_DEBUG")) {
     275                write(2, "->C:", 4);
     276                write(2, h->rxq + h->rxlen - st, st);
     277        }
     278
     279        while (st) {
    280280                int i;
    281                
    282                 if( h->msglen == 0 )
    283                 {
    284                         for( i = 0; i < h->rxlen; i ++ )
    285                         {
    286                                 if( h->rxq[i] == '\r' || h->rxq[i] == '\n' )
    287                                 {
     281
     282                if (h->msglen == 0) {
     283                        for (i = 0; i < h->rxlen; i++) {
     284                                if (h->rxq[i] == '\r' || h->rxq[i] == '\n') {
    288285                                        char *cmd_text, **cmd;
    289286                                        int count;
    290                                        
    291                                         cmd_text = g_strndup( h->rxq, i );
    292                                         cmd = msn_linesplit( cmd_text );
    293                                         for( count = 0; cmd[count]; count ++ );
    294                                         st = h->exec_command( h, cmd, count );
    295                                         g_free( cmd_text );
    296                                        
     287
     288                                        cmd_text = g_strndup(h->rxq, i);
     289                                        cmd = msn_linesplit(cmd_text);
     290                                        for (count = 0; cmd[count]; count++) {
     291                                                ;
     292                                        }
     293                                        st = h->exec_command(h, cmd, count);
     294                                        g_free(cmd_text);
     295
    297296                                        /* If the connection broke, don't continue. We don't even exist anymore. */
    298                                         if( !st )
    299                                                 return( 0 );
    300                                        
    301                                         if( h->msglen )
    302                                                 h->cmd_text = g_strndup( h->rxq, i );
    303                                        
     297                                        if (!st) {
     298                                                return(0);
     299                                        }
     300
     301                                        if (h->msglen) {
     302                                                h->cmd_text = g_strndup(h->rxq, i);
     303                                        }
     304
    304305                                        /* Skip to the next non-emptyline */
    305                                         while( i < h->rxlen && ( h->rxq[i] == '\r' || h->rxq[i] == '\n' ) ) i ++;
    306                                        
     306                                        while (i < h->rxlen && (h->rxq[i] == '\r' || h->rxq[i] == '\n')) {
     307                                                i++;
     308                                        }
     309
    307310                                        break;
    308311                                }
    309312                        }
    310                        
     313
    311314                        /* If we reached the end of the buffer, there's still an incomplete command there.
    312315                           Return and wait for more data. */
    313                         if( i == h->rxlen && h->rxq[i-1] != '\r' && h->rxq[i-1] != '\n' )
     316                        if (i == h->rxlen && h->rxq[i - 1] != '\r' && h->rxq[i - 1] != '\n') {
    314317                                break;
    315                 }
    316                 else
    317                 {
     318                        }
     319                } else {
    318320                        char *msg, **cmd;
    319321                        int count;
    320                        
     322
    321323                        /* Do we have the complete message already? */
    322                         if( h->msglen > h->rxlen )
     324                        if (h->msglen > h->rxlen) {
    323325                                break;
    324                        
    325                         msg = g_strndup( h->rxq, h->msglen );
    326                         cmd = msn_linesplit( h->cmd_text );
    327                         for( count = 0; cmd[count]; count ++ );
    328                        
    329                         st = h->exec_message( h, msg, h->msglen, cmd, count );
    330                         g_free( msg );
    331                         g_free( h->cmd_text );
     326                        }
     327
     328                        msg = g_strndup(h->rxq, h->msglen);
     329                        cmd = msn_linesplit(h->cmd_text);
     330                        for (count = 0; cmd[count]; count++) {
     331                                ;
     332                        }
     333
     334                        st = h->exec_message(h, msg, h->msglen, cmd, count);
     335                        g_free(msg);
     336                        g_free(h->cmd_text);
    332337                        h->cmd_text = NULL;
    333                        
    334                         if( !st )
    335                                 return( 0 );
    336                        
     338
     339                        if (!st) {
     340                                return(0);
     341                        }
     342
    337343                        i = h->msglen;
    338344                        h->msglen = 0;
    339345                }
    340                
     346
    341347                /* More data after this block? */
    342                 if( i < h->rxlen )
    343                 {
     348                if (i < h->rxlen) {
    344349                        char *tmp;
    345                        
    346                         tmp = g_memdup( h->rxq + i, h->rxlen - i );
    347                         g_free( h->rxq );
     350
     351                        tmp = g_memdup(h->rxq + i, h->rxlen - i);
     352                        g_free(h->rxq);
    348353                        h->rxq = tmp;
    349354                        h->rxlen -= i;
    350355                        i = 0;
    351                 }
    352                 else
    353                 /* If not, reset the rx queue and get lost. */
    354                 {
    355                         g_free( h->rxq );
    356                         h->rxq = g_new0( char, 1 );
     356                } else {
     357                        /* If not, reset the rx queue and get lost. */
     358                        g_free(h->rxq);
     359                        h->rxq = g_new0(char, 1);
    357360                        h->rxlen = 0;
    358                         return( 1 );
    359                 }
    360         }
    361        
    362         return( 1 );
    363 }
    364 
    365 void msn_msgq_purge( struct im_connection *ic, GSList **list )
     361                        return(1);
     362                }
     363        }
     364
     365        return(1);
     366}
     367
     368void msn_msgq_purge(struct im_connection *ic, GSList **list)
    366369{
    367370        struct msn_message *m;
    … …  
    369372        GSList *l;
    370373        int n = 0;
    371        
     374
    372375        l = *list;
    373         if( l == NULL )
     376        if (l == NULL) {
    374377                return;
    375        
     378        }
     379
    376380        m = l->data;
    377         ret = g_string_sized_new( 1024 );
    378         g_string_printf( ret, "Warning: Cleaning up MSN (switchboard) connection with unsent "
    379                               "messages to %s:", m->who ? m->who : "unknown recipient" );
    380        
    381         while( l )
    382         {
     381        ret = g_string_sized_new(1024);
     382        g_string_printf(ret, "Warning: Cleaning up MSN (switchboard) connection with unsent "
     383                        "messages to %s:", m->who ? m->who : "unknown recipient");
     384
     385        while (l) {
    383386                m = l->data;
    384                
    385                 if( strncmp( m->text, "\r\r\r", 3 ) != 0 )
    386                 {
    387                         g_string_append_printf( ret, "\n%s", m->text );
    388                         n ++;
    389                 }
    390                
    391                 g_free( m->who );
    392                 g_free( m->text );
    393                 g_free( m );
    394                
     387
     388                if (strncmp(m->text, "\r\r\r", 3) != 0) {
     389                        g_string_append_printf(ret, "\n%s", m->text);
     390                        n++;
     391                }
     392
     393                g_free(m->who);
     394                g_free(m->text);
     395                g_free(m);
     396
    395397                l = l->next;
    396398        }
    397         g_slist_free( *list );
     399        g_slist_free(*list);
    398400        *list = NULL;
    399        
    400         if( n > 0 )
    401                 imcb_log( ic, "%s", ret->str );
    402         g_string_free( ret, TRUE );
     401
     402        if (n > 0) {
     403                imcb_log(ic, "%s", ret->str);
     404        }
     405        g_string_free(ret, TRUE);
    403406}
    404407
    405408/* Copied and heavily modified from http://tmsnc.sourceforge.net/chl.c */
    406 char *msn_p11_challenge( char *challenge )
     409char *msn_p11_challenge(char *challenge)
    407410{
    408411        char *output, buf[256];
    … …  
    415418        /* Create the MD5 hash */
    416419        md5_init(&md5c);
    417         md5_append(&md5c, (unsigned char*) challenge, strlen(challenge));
    418         md5_append(&md5c, (unsigned char*) MSNP11_PROD_KEY, strlen(MSNP11_PROD_KEY));
     420        md5_append(&md5c, (unsigned char *) challenge, strlen(challenge));
     421        md5_append(&md5c, (unsigned char *) MSNP11_PROD_KEY, strlen(MSNP11_PROD_KEY));
    419422        md5_finish(&md5c, md5Hash);
    420423
    421424        /* Split it into four integers */
    422         md5Parts = (unsigned int *)md5Hash;
    423         for (i = 0; i < 4; i ++)
    424         { 
     425        md5Parts = (unsigned int *) md5Hash;
     426        for (i = 0; i < 4; i++) {
    425427                md5Parts[i] = GUINT32_TO_LE(md5Parts[i]);
    426                
     428
    427429                /* & each integer with 0x7FFFFFFF */
    428430                /* and save one unmodified array for later */
    … …  
    430432                md5Parts[i] &= 0x7FFFFFFF;
    431433        }
    432        
     434
    433435        /* make a new string and pad with '0' */
    434         n = g_snprintf(buf, sizeof(buf)-5, "%s%s00000000", challenge, MSNP11_PROD_ID);
     436        n = g_snprintf(buf, sizeof(buf) - 5, "%s%s00000000", challenge, MSNP11_PROD_ID);
    435437        /* truncate at an 8-byte boundary */
    436         buf[n&=~7] = '\0';
    437        
     438        buf[n &= ~7] = '\0';
     439
    438440        /* split into integers */
    439         chlStringParts = (unsigned int *)buf;
    440        
     441        chlStringParts = (unsigned int *) buf;
     442
    441443        /* this is magic */
    442         for (i = 0; i < (n / 4) - 1; i += 2)
    443         {
     444        for (i = 0; i < (n / 4) - 1; i += 2) {
    444445                long long temp;
    445446
    446447                chlStringParts[i]   = GUINT32_TO_LE(chlStringParts[i]);
    447                 chlStringParts[i+1] = GUINT32_TO_LE(chlStringParts[i+1]);
    448 
    449                 temp  = (md5Parts[0] * (((0x0E79A9C1 * (long long)chlStringParts[i]) % 0x7FFFFFFF)+nHigh) + md5Parts[1])%0x7FFFFFFF;
    450                 nHigh = (md5Parts[2] * (((long long)chlStringParts[i+1]+temp) % 0x7FFFFFFF) + md5Parts[3]) % 0x7FFFFFFF;
     448                chlStringParts[i + 1] = GUINT32_TO_LE(chlStringParts[i + 1]);
     449
     450                temp  =
     451                        (md5Parts[0] *
     452                         (((0x0E79A9C1 *
     453                            (long long) chlStringParts[i]) % 0x7FFFFFFF) + nHigh) + md5Parts[1]) % 0x7FFFFFFF;
     454                nHigh =
     455                        (md5Parts[2] *
     456                         (((long long) chlStringParts[i + 1] + temp) % 0x7FFFFFFF) + md5Parts[3]) % 0x7FFFFFFF;
    451457                nLow  = nLow + nHigh + temp;
    452458        }
    453         nHigh = (nHigh+md5Parts[1]) % 0x7FFFFFFF;
    454         nLow = (nLow+md5Parts[3]) % 0x7FFFFFFF;
    455        
     459        nHigh = (nHigh + md5Parts[1]) % 0x7FFFFFFF;
     460        nLow = (nLow + md5Parts[3]) % 0x7FFFFFFF;
     461
    456462        newHashParts[0] ^= nHigh;
    457463        newHashParts[1] ^= nLow;
    458464        newHashParts[2] ^= nHigh;
    459465        newHashParts[3] ^= nLow;
    460        
     466
    461467        /* swap more bytes if big endian */
    462         for (i = 0; i < 4; i ++)
    463                 newHashParts[i] = GUINT32_TO_LE(newHashParts[i]);
    464        
     468        for (i = 0; i < 4; i++) {
     469                newHashParts[i] = GUINT32_TO_LE(newHashParts[i]);
     470        }
     471
    465472        /* make a string of the parts */
    466         newHash = (unsigned char *)newHashParts;
    467        
     473        newHash = (unsigned char *) newHashParts;
     474
    468475        /* convert to hexadecimal */
    469476        output = g_new(char, 33);
    470         for (i = 0; i < 16; i ++)
     477        for (i = 0; i < 16; i++) {
    471478                sprintf(output + i * 2, "%02x", newHash[i]);
    472        
     479        }
     480
    473481        return output;
    474482}
    475483
    476 gint msn_domaintree_cmp( gconstpointer a_, gconstpointer b_ )
     484gint msn_domaintree_cmp(gconstpointer a_, gconstpointer b_)
    477485{
    478486        const char *a = a_, *b = b_;
    479487        gint ret;
    480        
    481         if( !( a = strchr( a, '@' ) ) || !( b = strchr( b, '@' ) ) ||
    482             ( ret = strcmp( a, b ) ) == 0 )
    483                 ret = strcmp( a_, b_ );
    484        
     488
     489        if (!(a = strchr(a, '@')) || !(b = strchr(b, '@')) ||
     490            (ret = strcmp(a, b)) == 0) {
     491                ret = strcmp(a_, b_);
     492        }
     493
    485494        return ret;
    486495}
    487496
    488 struct msn_group *msn_group_by_name( struct im_connection *ic, const char *name )
     497struct msn_group *msn_group_by_name(struct im_connection *ic, const char *name)
    489498{
    490499        struct msn_data *md = ic->proto_data;
    491500        GSList *l;
    492        
    493         for( l = md->groups; l; l = l->next )
    494         {
     501
     502        for (l = md->groups; l; l = l->next) {
    495503                struct msn_group *mg = l->data;
    496                
    497                 if( g_strcasecmp( mg->name, name ) == 0 )
     504
     505                if (g_strcasecmp(mg->name, name) == 0) {
    498506                        return mg;
    499         }
    500        
     507                }
     508        }
     509
    501510        return NULL;
    502511}
    503512
    504 struct msn_group *msn_group_by_id( struct im_connection *ic, const char *id )
     513struct msn_group *msn_group_by_id(struct im_connection *ic, const char *id)
    505514{
    506515        struct msn_data *md = ic->proto_data;
    507516        GSList *l;
    508        
    509         for( l = md->groups; l; l = l->next )
    510         {
     517
     518        for (l = md->groups; l; l = l->next) {
    511519                struct msn_group *mg = l->data;
    512                
    513                 if( g_strcasecmp( mg->id, id ) == 0 )
     520
     521                if (g_strcasecmp(mg->id, id) == 0) {
    514522                        return mg;
    515         }
    516        
     523                }
     524        }
     525
    517526        return NULL;
    518527}
    519528
    520 int msn_ns_set_display_name( struct im_connection *ic, const char *value )
     529int msn_ns_set_display_name(struct im_connection *ic, const char *value)
    521530{
    522531        struct msn_data *md = ic->proto_data;
    523         char fn[strlen(value)*3+1];
    524        
    525         strcpy( fn, value );
    526         http_encode( fn );
    527        
     532        char fn[strlen(value) * 3 + 1];
     533
     534        strcpy(fn, value);
     535        http_encode(fn);
     536
    528537        /* Note: We don't actually know if the server accepted the new name,
    529538           and won't give proper feedback yet if it doesn't. */
    530         return msn_ns_write( ic, -1, "PRP %d MFN %s\r\n", ++md->trId, fn );
    531 }
    532 
    533 const char *msn_normalize_handle( const char *handle )
    534 {
    535         if( strncmp( handle, "1:", 2 ) == 0 )
     539        return msn_ns_write(ic, -1, "PRP %d MFN %s\r\n", ++md->trId, fn);
     540}
     541
     542const char *msn_normalize_handle(const char *handle)
     543{
     544        if (strncmp(handle, "1:", 2) == 0) {
    536545                return handle + 2;
    537         else
     546        } else {
    538547                return handle;
    539 }
     548        }
     549}
Note: See TracChangeset for help on using the changeset viewer.