Changeset 5ebff60 for storage_xml.c


Ignore:
Timestamp:
2015-02-20T22:50:54Z (5 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
  • storage_xml.c

    raf359b4 r5ebff60  
    1   /********************************************************************\
     1/********************************************************************\
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
     
    3333#include <glib/gstdio.h>
    3434
    35 typedef enum
    36 {
     35typedef enum {
    3736        XML_PASS_CHECK_ONLY = -1,
    3837        XML_PASS_UNKNOWN = 0,
     
    4443#define XML_FORMAT_VERSION "1"
    4544
    46 struct xml_parsedata
    47 {
     45struct xml_parsedata {
    4846        irc_t *irc;
    49         char given_nick[MAX_NICK_LENGTH+1];
     47        char given_nick[MAX_NICK_LENGTH + 1];
    5048        char *given_pass;
    5149};
    5250
    53 static void xml_init( void )
    54 {
    55         if( g_access( global.conf->configdir, F_OK ) != 0 )
    56                 log_message( LOGLVL_WARNING, "The configuration directory `%s' does not exist. Configuration won't be saved.", global.conf->configdir );
    57         else if( g_access( global.conf->configdir, F_OK ) != 0 ||
    58                  g_access( global.conf->configdir, W_OK ) != 0 )
    59                 log_message( LOGLVL_WARNING, "Permission problem: Can't read/write from/to `%s'.", global.conf->configdir );
    60 }
    61 
    62 static void handle_settings( struct xt_node *node, set_t **head )
     51static void xml_init(void)
     52{
     53        if (g_access(global.conf->configdir, F_OK) != 0) {
     54                log_message(LOGLVL_WARNING,
     55                            "The configuration directory `%s' does not exist. Configuration won't be saved.",
     56                            global.conf->configdir);
     57        } else if (g_access(global.conf->configdir, F_OK) != 0 ||
     58                   g_access(global.conf->configdir, W_OK) != 0) {
     59                log_message(LOGLVL_WARNING, "Permission problem: Can't read/write from/to `%s'.",
     60                            global.conf->configdir);
     61        }
     62}
     63
     64static void handle_settings(struct xt_node *node, set_t **head)
    6365{
    6466        struct xt_node *c;
    65        
    66         for( c = node->children; ( c = xt_find_node( c, "setting" ) ); c = c->next )
    67         {
    68                 char *name = xt_find_attr( c, "name" );
    69                
    70                 if( !name )
     67
     68        for (c = node->children; (c = xt_find_node(c, "setting")); c = c->next) {
     69                char *name = xt_find_attr(c, "name");
     70
     71                if (!name) {
    7172                        continue;
    72                
    73                 if( strcmp( node->name, "account" ) == 0 )
    74                 {
    75                         set_t *s = set_find( head, name );
    76                         if( s && ( s->flags & ACC_SET_ONLINE_ONLY ) )
     73                }
     74
     75                if (strcmp(node->name, "account") == 0) {
     76                        set_t *s = set_find(head, name);
     77                        if (s && (s->flags & ACC_SET_ONLINE_ONLY)) {
    7778                                continue; /* U can't touch this! */
    78                 }
    79                 set_setstr( head, name, c->text );
    80         }
    81 }
    82 
    83 static xt_status handle_account( struct xt_node *node, gpointer data )
     79                        }
     80                }
     81                set_setstr(head, name, c->text);
     82        }
     83}
     84
     85static xt_status handle_account(struct xt_node *node, gpointer data)
    8486{
    8587        struct xml_parsedata *xd = data;
     
    9193        account_t *acc;
    9294        struct xt_node *c;
    93        
    94         handle = xt_find_attr( node, "handle" );
    95         pass_b64 = xt_find_attr( node, "password" );
    96         server = xt_find_attr( node, "server" );
    97         autoconnect = xt_find_attr( node, "autoconnect" );
    98         tag = xt_find_attr( node, "tag" );
    99        
    100         protocol = xt_find_attr( node, "protocol" );
    101         if( protocol )
    102         {
    103                 prpl = find_protocol( protocol );
    104                 local = protocol_account_islocal( protocol );
    105         }
    106        
    107         if( !handle || !pass_b64 || !protocol || !prpl )
     95
     96        handle = xt_find_attr(node, "handle");
     97        pass_b64 = xt_find_attr(node, "password");
     98        server = xt_find_attr(node, "server");
     99        autoconnect = xt_find_attr(node, "autoconnect");
     100        tag = xt_find_attr(node, "tag");
     101
     102        protocol = xt_find_attr(node, "protocol");
     103        if (protocol) {
     104                prpl = find_protocol(protocol);
     105                local = protocol_account_islocal(protocol);
     106        }
     107
     108        if (!handle || !pass_b64 || !protocol || !prpl) {
    108109                return XT_ABORT;
    109         else if( ( pass_len = base64_decode( pass_b64, (unsigned char**) &pass_cr ) ) &&
    110                  arc_decode( pass_cr, pass_len, &password, xd->given_pass ) >= 0 )
    111         {
    112                 acc = account_add( xd->irc->b, prpl, handle, password );
    113                 if( server )
    114                         set_setstr( &acc->set, "server", server );
    115                 if( autoconnect )
    116                         set_setstr( &acc->set, "auto_connect", autoconnect );
    117                 if( tag )
    118                         set_setstr( &acc->set, "tag", tag );
    119                 if( local )
     110        } else if ((pass_len = base64_decode(pass_b64, (unsigned char **) &pass_cr)) &&
     111                   arc_decode(pass_cr, pass_len, &password, xd->given_pass) >= 0) {
     112                acc = account_add(xd->irc->b, prpl, handle, password);
     113                if (server) {
     114                        set_setstr(&acc->set, "server", server);
     115                }
     116                if (autoconnect) {
     117                        set_setstr(&acc->set, "auto_connect", autoconnect);
     118                }
     119                if (tag) {
     120                        set_setstr(&acc->set, "tag", tag);
     121                }
     122                if (local) {
    120123                        acc->flags |= ACC_FLAG_LOCAL;
    121         }
    122         else
     124                }
     125        } else {
    123126                return XT_ABORT;
    124        
    125         g_free( pass_cr );
    126         g_free( password );
    127        
    128         handle_settings( node, &acc->set );
    129        
    130         for( c = node->children; ( c = xt_find_node( c, "buddy" ) ); c = c->next )
    131         {
     127        }
     128
     129        g_free(pass_cr);
     130        g_free(password);
     131
     132        handle_settings(node, &acc->set);
     133
     134        for (c = node->children; (c = xt_find_node(c, "buddy")); c = c->next) {
    132135                char *handle, *nick;
    133                
    134                 handle = xt_find_attr( c, "handle" );
    135                 nick = xt_find_attr( c, "nick" );
    136                
    137                 if( handle && nick )
    138                         nick_set_raw( acc, handle, nick );
    139                 else
     136
     137                handle = xt_find_attr(c, "handle");
     138                nick = xt_find_attr(c, "nick");
     139
     140                if (handle && nick) {
     141                        nick_set_raw(acc, handle, nick);
     142                } else {
    140143                        return XT_ABORT;
    141         }       
     144                }
     145        }
    142146        return XT_HANDLED;
    143147}
    144148
    145 static xt_status handle_channel( struct xt_node *node, gpointer data )
     149static xt_status handle_channel(struct xt_node *node, gpointer data)
    146150{
    147151        struct xml_parsedata *xd = data;
    148152        irc_channel_t *ic;
    149153        char *name, *type;
    150        
    151         name = xt_find_attr( node, "name" );
    152         type = xt_find_attr( node, "type" );
    153        
    154         if( !name || !type )
     154
     155        name = xt_find_attr(node, "name");
     156        type = xt_find_attr(node, "type");
     157
     158        if (!name || !type) {
    155159                return XT_ABORT;
    156        
     160        }
     161
    157162        /* The channel may exist already, for example if it's &bitlbee.
    158163           Also, it's possible that the user just reconnected and the
    159164           IRC client already rejoined all channels it was in. They
    160165           should still get the right settings. */
    161         if( ( ic = irc_channel_by_name( xd->irc, name ) ) ||
    162             ( ic = irc_channel_new( xd->irc, name ) ) )
    163                 set_setstr( &ic->set, "type", type );
    164        
    165         handle_settings( node, &ic->set );
    166        
     166        if ((ic = irc_channel_by_name(xd->irc, name)) ||
     167            (ic = irc_channel_new(xd->irc, name))) {
     168                set_setstr(&ic->set, "type", type);
     169        }
     170
     171        handle_settings(node, &ic->set);
     172
    167173        return XT_HANDLED;
    168174}
     
    174180};
    175181
    176 static storage_status_t xml_load_real( irc_t *irc, const char *my_nick, const char *password, xml_pass_st action )
     182static storage_status_t xml_load_real(irc_t *irc, const char *my_nick, const char *password, xml_pass_st action)
    177183{
    178184        struct xml_parsedata xd[1];
     
    182188        struct xt_node *node;
    183189        storage_status_t ret = STORAGE_OTHER_ERROR;
    184        
     190
    185191        xd->irc = irc;
    186         strncpy( xd->given_nick, my_nick, MAX_NICK_LENGTH );
     192        strncpy(xd->given_nick, my_nick, MAX_NICK_LENGTH);
    187193        xd->given_nick[MAX_NICK_LENGTH] = '\0';
    188         nick_lc( NULL, xd->given_nick );
    189         xd->given_pass = (char*) password;
    190        
    191         fn = g_strconcat( global.conf->configdir, xd->given_nick, ".xml", NULL );
    192         if( ( fd = open( fn, O_RDONLY ) ) < 0 )
     194        nick_lc(NULL, xd->given_nick);
     195        xd->given_pass = (char *) password;
     196
     197        fn = g_strconcat(global.conf->configdir, xd->given_nick, ".xml", NULL);
     198        if ((fd = open(fn, O_RDONLY)) < 0) {
     199                ret = STORAGE_NO_SUCH_USER;
     200                goto error;
     201        }
     202
     203        xp = xt_new(handlers, xd);
     204        while ((st = read(fd, buf, sizeof(buf))) > 0) {
     205                st = xt_feed(xp, buf, st);
     206                if (st != 1) {
     207                        break;
     208                }
     209        }
     210        close(fd);
     211        if (st != 0) {
     212                goto error;
     213        }
     214
     215        node = xp->root;
     216        if (node == NULL || node->next != NULL || strcmp(node->name, "user") != 0) {
     217                goto error;
     218        }
     219
    193220        {
    194                 ret = STORAGE_NO_SUCH_USER;
    195                 goto error;
    196         }
    197        
    198         xp = xt_new( handlers, xd );
    199         while( ( st = read( fd, buf, sizeof( buf ) ) ) > 0 )
    200         {
    201                 st = xt_feed( xp, buf, st );
    202                 if( st != 1 )
    203                         break;
    204         }
    205         close( fd );
    206         if( st != 0 )
    207                 goto error;
    208        
    209         node = xp->root;
    210         if( node == NULL || node->next != NULL || strcmp( node->name, "user" ) != 0 )
    211                 goto error;
    212        
    213         {
    214                 char *nick = xt_find_attr( node, "nick" );
    215                 char *pass = xt_find_attr( node, "password" );
    216                
    217                 if( !nick || !pass )
    218                 {
     221                char *nick = xt_find_attr(node, "nick");
     222                char *pass = xt_find_attr(node, "password");
     223
     224                if (!nick || !pass) {
    219225                        goto error;
    220                 }
    221                 else if( ( st = md5_verify_password( xd->given_pass, pass ) ) != 0 )
    222                 {
     226                } else if ((st = md5_verify_password(xd->given_pass, pass)) != 0) {
    223227                        ret = STORAGE_INVALID_PASSWORD;
    224228                        goto error;
    225229                }
    226230        }
    227        
    228         if( action == XML_PASS_CHECK_ONLY )
    229         {
     231
     232        if (action == XML_PASS_CHECK_ONLY) {
    230233                ret = STORAGE_OK;
    231234                goto error;
    232235        }
    233        
     236
    234237        /* DO NOT call xt_handle() before verifying the password! */
    235         if( xt_handle( xp, NULL, 1 ) == XT_HANDLED )
     238        if (xt_handle(xp, NULL, 1) == XT_HANDLED) {
    236239                ret = STORAGE_OK;
    237        
    238         handle_settings( node, &xd->irc->b->set );
    239        
     240        }
     241
     242        handle_settings(node, &xd->irc->b->set);
     243
    240244error:
    241         xt_free( xp );
    242         g_free( fn );
     245        xt_free(xp);
     246        g_free(fn);
    243247        return ret;
    244248}
    245249
    246 static storage_status_t xml_load( irc_t *irc, const char *password )
    247 {
    248         return xml_load_real( irc, irc->user->nick, password, XML_PASS_UNKNOWN );
    249 }
    250 
    251 static storage_status_t xml_check_pass( const char *my_nick, const char *password )
    252 {
    253         return xml_load_real( NULL, my_nick, password, XML_PASS_CHECK_ONLY );
    254 }
    255 
    256 
    257 static gboolean xml_generate_nick( gpointer key, gpointer value, gpointer data );
    258 static void xml_generate_settings( struct xt_node *cur, set_t **head );
    259 
    260 struct xt_node *xml_generate( irc_t *irc )
     250static storage_status_t xml_load(irc_t *irc, const char *password)
     251{
     252        return xml_load_real(irc, irc->user->nick, password, XML_PASS_UNKNOWN);
     253}
     254
     255static storage_status_t xml_check_pass(const char *my_nick, const char *password)
     256{
     257        return xml_load_real(NULL, my_nick, password, XML_PASS_CHECK_ONLY);
     258}
     259
     260
     261static gboolean xml_generate_nick(gpointer key, gpointer value, gpointer data);
     262static void xml_generate_settings(struct xt_node *cur, set_t **head);
     263
     264struct xt_node *xml_generate(irc_t *irc)
    261265{
    262266        char *pass_buf = NULL;
     
    266270        GSList *l;
    267271        struct xt_node *root, *cur;
    268        
     272
    269273        /* Generate a salted md5sum of the password. Use 5 bytes for the salt
    270274           (to prevent dictionary lookups of passwords) to end up with a 21-
    271275           byte password hash, more convenient for base64 encoding. */
    272         random_bytes( pass_md5 + 16, 5 );
    273         md5_init( &md5_state );
    274         md5_append( &md5_state, (md5_byte_t*) irc->password, strlen( irc->password ) );
    275         md5_append( &md5_state, pass_md5 + 16, 5 ); /* Add the salt. */
    276         md5_finish( &md5_state, pass_md5 );
     276        random_bytes(pass_md5 + 16, 5);
     277        md5_init(&md5_state);
     278        md5_append(&md5_state, (md5_byte_t *) irc->password, strlen(irc->password));
     279        md5_append(&md5_state, pass_md5 + 16, 5);  /* Add the salt. */
     280        md5_finish(&md5_state, pass_md5);
    277281        /* Save the hash in base64-encoded form. */
    278         pass_buf = base64_encode( pass_md5, 21 );
    279        
    280         root = cur = xt_new_node( "user", NULL, NULL );
    281         xt_add_attr( cur, "nick", irc->user->nick );
    282         xt_add_attr( cur, "password", pass_buf );
    283         xt_add_attr( cur, "version", XML_FORMAT_VERSION );
    284        
    285         g_free( pass_buf );
    286        
    287         xml_generate_settings( cur, &irc->b->set );
    288        
    289         for( acc = irc->b->accounts; acc; acc = acc->next )
    290         {
     282        pass_buf = base64_encode(pass_md5, 21);
     283
     284        root = cur = xt_new_node("user", NULL, NULL);
     285        xt_add_attr(cur, "nick", irc->user->nick);
     286        xt_add_attr(cur, "password", pass_buf);
     287        xt_add_attr(cur, "version", XML_FORMAT_VERSION);
     288
     289        g_free(pass_buf);
     290
     291        xml_generate_settings(cur, &irc->b->set);
     292
     293        for (acc = irc->b->accounts; acc; acc = acc->next) {
    291294                unsigned char *pass_cr;
    292295                char *pass_b64;
    293296                int pass_len;
    294                
    295                 pass_len = arc_encode( acc->pass, strlen( acc->pass ), (unsigned char**) &pass_cr, irc->password, 12 );
    296                 pass_b64 = base64_encode( pass_cr, pass_len );
    297                 g_free( pass_cr );
    298                
    299                 cur = xt_new_node( "account", NULL, NULL );
    300                 xt_add_attr( cur, "protocol", acc->prpl->name );
    301                 xt_add_attr( cur, "handle", acc->user );
    302                 xt_add_attr( cur, "password", pass_b64 );
    303                 xt_add_attr( cur, "autoconnect", acc->auto_connect ? "true" : "false" );
    304                 xt_add_attr( cur, "tag", acc->tag );
    305                 if( acc->server && acc->server[0] )
    306                         xt_add_attr( cur, "server", acc->server );
    307                
    308                 g_free( pass_b64 );
    309                
     297
     298                pass_len = arc_encode(acc->pass, strlen(acc->pass), (unsigned char **) &pass_cr, irc->password, 12);
     299                pass_b64 = base64_encode(pass_cr, pass_len);
     300                g_free(pass_cr);
     301
     302                cur = xt_new_node("account", NULL, NULL);
     303                xt_add_attr(cur, "protocol", acc->prpl->name);
     304                xt_add_attr(cur, "handle", acc->user);
     305                xt_add_attr(cur, "password", pass_b64);
     306                xt_add_attr(cur, "autoconnect", acc->auto_connect ? "true" : "false");
     307                xt_add_attr(cur, "tag", acc->tag);
     308                if (acc->server && acc->server[0]) {
     309                        xt_add_attr(cur, "server", acc->server);
     310                }
     311
     312                g_free(pass_b64);
     313
    310314                /* This probably looks pretty strange. g_hash_table_foreach
    311315                   is quite a PITA already (but it can't get much better in
     
    315319                   return TRUE on write errors. Which means, if we found
    316320                   something, there was an error. :-) */
    317                 g_hash_table_find( acc->nicks, xml_generate_nick, cur );
    318                
    319                 xml_generate_settings( cur, &acc->set );
    320                
    321                 xt_add_child( root, cur );
    322         }
    323        
    324         for( l = irc->channels; l; l = l->next )
    325         {
     321                g_hash_table_find(acc->nicks, xml_generate_nick, cur);
     322
     323                xml_generate_settings(cur, &acc->set);
     324
     325                xt_add_child(root, cur);
     326        }
     327
     328        for (l = irc->channels; l; l = l->next) {
    326329                irc_channel_t *ic = l->data;
    327                
    328                 if( ic->flags & IRC_CHANNEL_TEMP )
     330
     331                if (ic->flags & IRC_CHANNEL_TEMP) {
    329332                        continue;
    330                
    331                 cur = xt_new_node( "channel", NULL, NULL );
    332                 xt_add_attr( cur, "name", ic->name );
    333                 xt_add_attr( cur, "type", set_getstr( &ic->set, "type" ) );
    334                
    335                 xml_generate_settings( cur, &ic->set );
    336                
    337                 xt_add_child( root, cur );
    338         }
    339        
     333                }
     334
     335                cur = xt_new_node("channel", NULL, NULL);
     336                xt_add_attr(cur, "name", ic->name);
     337                xt_add_attr(cur, "type", set_getstr(&ic->set, "type"));
     338
     339                xml_generate_settings(cur, &ic->set);
     340
     341                xt_add_child(root, cur);
     342        }
     343
    340344        return root;
    341345}
    342346
    343 static gboolean xml_generate_nick( gpointer key, gpointer value, gpointer data )
    344 {
    345         struct xt_node *node = xt_new_node( "buddy", NULL, NULL );
    346         xt_add_attr( node, "handle", key );
    347         xt_add_attr( node, "nick", value );
    348         xt_add_child( (struct xt_node *) data, node );
    349        
     347static gboolean xml_generate_nick(gpointer key, gpointer value, gpointer data)
     348{
     349        struct xt_node *node = xt_new_node("buddy", NULL, NULL);
     350
     351        xt_add_attr(node, "handle", key);
     352        xt_add_attr(node, "nick", value);
     353        xt_add_child((struct xt_node *) data, node);
     354
    350355        return FALSE;
    351356}
    352357
    353 static void xml_generate_settings( struct xt_node *cur, set_t **head )
     358static void xml_generate_settings(struct xt_node *cur, set_t **head)
    354359{
    355360        set_t *set;
    356        
    357         for( set = *head; set; set = set->next )
    358                 if( set->value && !( set->flags & SET_NOSAVE ) )
    359                 {
     361
     362        for (set = *head; set; set = set->next) {
     363                if (set->value && !(set->flags & SET_NOSAVE)) {
    360364                        struct xt_node *xset;
    361                         xt_add_child( cur, xset = xt_new_node( "setting", set->value, NULL ) );
    362                         xt_add_attr( xset, "name", set->key );
    363                 }
    364 }
    365 
    366 static storage_status_t xml_save( irc_t *irc, int overwrite )
     365                        xt_add_child(cur, xset = xt_new_node("setting", set->value, NULL));
     366                        xt_add_attr(xset, "name", set->key);
     367                }
     368        }
     369}
     370
     371static storage_status_t xml_save(irc_t *irc, int overwrite)
    367372{
    368373        storage_status_t ret = STORAGE_OK;
     
    371376        size_t len;
    372377        int fd;
    373        
    374         path2 = g_strdup( irc->user->nick );
    375         nick_lc( NULL, path2 );
    376         g_snprintf( path, sizeof( path ) - 20, "%s%s%s", global.conf->configdir, path2, ".xml" );
    377         g_free( path2 );
    378        
    379         if( !overwrite && g_access( path, F_OK ) == 0 )
     378
     379        path2 = g_strdup(irc->user->nick);
     380        nick_lc(NULL, path2);
     381        g_snprintf(path, sizeof(path) - 20, "%s%s%s", global.conf->configdir, path2, ".xml");
     382        g_free(path2);
     383
     384        if (!overwrite && g_access(path, F_OK) == 0) {
    380385                return STORAGE_ALREADY_EXISTS;
    381        
    382         strcat( path, ".XXXXXX" );
    383         if( ( fd = mkstemp( path ) ) < 0 )
    384         {
    385                 irc_rootmsg( irc, "Error while opening configuration file." );
     386        }
     387
     388        strcat(path, ".XXXXXX");
     389        if ((fd = mkstemp(path)) < 0) {
     390                irc_rootmsg(irc, "Error while opening configuration file.");
    386391                return STORAGE_OTHER_ERROR;
    387392        }
    388        
    389         tree = xml_generate( irc );
    390         xml = xt_to_string_i( tree );
    391         len = strlen( xml );
    392         if( write( fd, xml, len ) != len ||
    393             fsync( fd ) != 0 || /* #559 */
    394             close( fd ) != 0 )
    395                 goto error;
    396        
    397         path2 = g_strndup( path, strlen( path ) - 7 );
    398         if( rename( path, path2 ) != 0 )
    399         {
    400                 g_free( path2 );
    401                 goto error;
    402         }
    403         g_free( path2 );
    404        
     393
     394        tree = xml_generate(irc);
     395        xml = xt_to_string_i(tree);
     396        len = strlen(xml);
     397        if (write(fd, xml, len) != len ||
     398            fsync(fd) != 0 ||  /* #559 */
     399            close(fd) != 0) {
     400                goto error;
     401        }
     402
     403        path2 = g_strndup(path, strlen(path) - 7);
     404        if (rename(path, path2) != 0) {
     405                g_free(path2);
     406                goto error;
     407        }
     408        g_free(path2);
     409
    405410        goto finish;
    406411
    407412error:
    408         irc_rootmsg( irc, "Write error. Disk full?" );
     413        irc_rootmsg(irc, "Write error. Disk full?");
    409414        ret = STORAGE_OTHER_ERROR;
    410415
    411 finish: 
    412         close( fd );
    413         unlink( path );
    414         g_free( xml );
    415         xt_free_node( tree );
    416        
     416finish:
     417        close(fd);
     418        unlink(path);
     419        g_free(xml);
     420        xt_free_node(tree);
     421
    417422        return ret;
    418423}
    419424
    420425
    421 static storage_status_t xml_remove( const char *nick, const char *password )
     426static storage_status_t xml_remove(const char *nick, const char *password)
    422427{
    423428        char s[512], *lc;
    424429        storage_status_t status;
    425430
    426         status = xml_check_pass( nick, password );
    427         if( status != STORAGE_OK )
     431        status = xml_check_pass(nick, password);
     432        if (status != STORAGE_OK) {
    428433                return status;
    429 
    430         lc = g_strdup( nick );
    431         nick_lc( NULL, lc );
    432         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, lc, ".xml" );
    433         g_free( lc );
    434        
    435         if( unlink( s ) == -1 )
     434        }
     435
     436        lc = g_strdup(nick);
     437        nick_lc(NULL, lc);
     438        g_snprintf(s, 511, "%s%s%s", global.conf->configdir, lc, ".xml");
     439        g_free(lc);
     440
     441        if (unlink(s) == -1) {
    436442                return STORAGE_OTHER_ERROR;
    437        
     443        }
     444
    438445        return STORAGE_OK;
    439446}
Note: See TracChangeset for help on using the changeset viewer.