Changeset b73ac9c


Ignore:
Timestamp:
2005-12-13T23:05:27Z (14 years ago)
Author:
Jelmer Vernooij <jelmer@…>
Branches:
master
Children:
d3307e2
Parents:
a301379c
Message:

Add support for 'primary' and 'migrate' account storages.
Fix two bugs in the text storage backend that were introduced by my previous
changes.

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.h

    ra301379c rb73ac9c  
    116116        help_t *help;
    117117        conf_t *conf;
    118         storage_t *storage;
     118        GList *storage; /* The first backend in the list will be used for saving */
    119119        char *helpfile;
    120120        GMainLoop *loop;
  • commands.c

    ra301379c rb73ac9c  
    102102                break;
    103103        }
    104        
     104
    105105        return( 0 );
    106106}
  • conf.c

    ra301379c rb73ac9c  
    5050        conf->nofork = 0;
    5151        conf->verbose = 0;
    52         conf->storage = "text";
     52        conf->primary_storage = "text";
    5353        conf->runmode = RUNMODE_INETD;
    5454        conf->authmode = AUTHMODE_OPEN;
     
    199199                                conf->motdfile = g_strdup( ini->value );
    200200                        }
    201                         else if( g_strcasecmp( ini->key, "storage" ) == 0 )
    202                         {
    203                                 g_free( conf->storage );
    204                                 conf->storage = g_strdup( ini->value );
     201                        else if( g_strcasecmp( ini->key, "account_storage" ) == 0 )
     202                        {
     203                                g_free( conf->primary_storage );
     204                                conf->primary_storage = g_strdup( ini->value );
     205                        }
     206                        else if( g_strcasecmp( ini->key, "account_storage_migrate" ) == 0 )
     207                        {
     208                                g_strfreev( conf->migrate_storage );
     209                                conf->migrate_storage = g_strsplit( ini->value, " \t,;", -1 );
    205210                        }
    206211                        else if( g_strcasecmp( ini->key, "pinginterval" ) == 0 )
  • conf.h

    ra301379c rb73ac9c  
    4242        char *configdir;
    4343        char *motdfile;
    44         char *storage;
     44        char *primary_storage;
     45        char **migrate_storage;
    4546        int ping_interval;
    4647        int ping_timeout;
  • irc.c

    ra301379c rb73ac9c  
    161161       
    162162        if( irc->status >= USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) )
    163                 if( !storage_save( irc, TRUE ) )
     163                if( storage_save( irc, TRUE ) != STORAGE_OK )
    164164                        irc_usermsg( irc, "Error while saving settings!" );
    165165       
  • storage.c

    ra301379c rb73ac9c  
    3838}
    3939
    40 storage_t *storage_init(const char *name)
     40static storage_t *storage_init_single(const char *name)
    4141{
    4242        GList *gl;
     
    5858}
    5959
     60GList *storage_init(const char *primary, char **migrate)
     61{
     62        GList *ret = NULL;
     63        int i;
     64        storage_t *storage;
     65
     66        storage = storage_init_single(primary);
     67        if (storage == NULL)
     68                return NULL;
     69
     70        ret = g_list_append(ret, storage);
     71
     72        for (i = 0; migrate && migrate[i]; i++) {
     73                storage = storage_init_single(migrate[i]);
     74       
     75                if (storage)
     76                        ret = g_list_append(ret, storage);
     77        }
     78
     79        return ret;
     80}
     81
    6082storage_status_t storage_check_pass (const char *nick, const char *password)
    6183{
    62         return global.storage->check_pass(nick, password);
     84        GList *gl;
     85       
     86        /* Loop until we don't get NO_SUCH_USER */
     87
     88        for (gl = global.storage; gl; gl = gl->next) {
     89                storage_t *st = gl->data;
     90                storage_status_t status;
     91
     92                status = st->check_pass(nick, password);
     93                if (status != STORAGE_NO_SUCH_USER)
     94                        return status;
     95        }
     96       
     97        return STORAGE_NO_SUCH_USER;
    6398}
    6499
    65100storage_status_t storage_load (const char *nick, const char *password, irc_t * irc)
    66101{
    67         return global.storage->load(nick, password, irc);
     102        GList *gl;
     103       
     104        /* Loop until we don't get NO_SUCH_USER */
     105        for (gl = global.storage; gl; gl = gl->next) {
     106                storage_t *st = gl->data;
     107                storage_status_t status;
     108
     109                status = st->load(nick, password, irc);
     110                if (status == STORAGE_OK) {
     111                        irc_setpass(irc, password);
     112                        return status;
     113                }
     114               
     115                if (status != STORAGE_NO_SUCH_USER)
     116                        return status;
     117        }
     118       
     119        return STORAGE_NO_SUCH_USER;
    68120}
    69121
    70122storage_status_t storage_save (irc_t *irc, int overwrite)
    71123{
    72         return global.storage->save(irc, overwrite);
     124        return ((storage_t *)global.storage->data)->save(irc, overwrite);
    73125}
    74126
    75127storage_status_t storage_remove (const char *nick, const char *password)
    76128{
    77         return global.storage->remove(nick, password);
     129        GList *gl;
     130        storage_status_t ret = STORAGE_OK;
     131       
     132        /* Remove this account from all storage backends. If this isn't
     133         * done, the account will still be usable, it'd just be
     134         * loaded from a different backend. */
     135        for (gl = global.storage; gl; gl = gl->next) {
     136                storage_t *st = gl->data;
     137                storage_status_t status;
     138
     139                status = st->remove(nick, password);
     140                if (status != STORAGE_NO_SUCH_USER &&
     141                        status != STORAGE_OK)
     142                        ret = status;
     143        }
     144       
     145        return ret;
    78146}
    79147
    80148storage_status_t storage_rename (const char *onick, const char *nnick, const char *password)
    81149{
    82         return global.storage->rename(onick, nnick, password);
     150        storage_status_t status;
     151        GList *gl = global.storage;
     152        storage_t *primary_storage = gl->data;
     153        irc_t *irc;
     154
     155        /* First, try to rename in the current write backend, assuming onick
     156         * is stored there */
     157        status = primary_storage->rename(onick, nnick, password);
     158        if (status != STORAGE_NO_SUCH_USER)
     159                return status;
     160
     161        /* Try to load from a migration backend and save to the current backend.
     162         * Explicitly remove the account from the migration backend as otherwise
     163         * it'd still be usable under the old name */
     164       
     165        irc = g_new0(irc_t, 1);
     166        status = storage_load(onick, password, irc);
     167        if (status != STORAGE_OK) {
     168                irc_free(irc);
     169                return status;
     170        }
     171
     172        g_free(irc->nick);
     173        irc->nick = g_strdup(nnick);
     174
     175        status = storage_save(irc, FALSE);
     176        if (status != STORAGE_OK) {
     177                irc_free(irc);
     178                return status;
     179        }
     180        irc_free(irc);
     181
     182        storage_remove(onick, password);
     183
     184        return STORAGE_OK;
    83185}
  • storage.h

    ra301379c rb73ac9c  
    6262
    6363void register_storage_backend(storage_t *);
    64 storage_t *storage_init(const char *name);
     64GList *storage_init(const char *primary, char **migrate);
    6565
    6666#endif /* __STORAGE_H__ */
  • storage_text.c

    ra301379c rb73ac9c  
    6767        {
    6868                fgetc( fp );
    69                 line = deobfucrypt( irc, s );
     69                line = deobfucrypt( s, password );
     70                if (line == NULL) return STORAGE_OTHER_ERROR;
    7071                root_command_string( irc, ru, line, 0 );
    7172                g_free( line );
     
    129130        \*/
    130131       
    131         hash = hashpass( irc );
     132        hash = hashpass( irc->password );
    132133        if( hash == NULL )
    133134        {
    134135                irc_usermsg( irc, "Please register yourself if you want to save your settings." );
    135                 return( 0 );
     136                return STORAGE_OTHER_ERROR;
    136137        }
    137138       
     
    192193                                    proto_name[a->protocol], a->user, a->pass, a->server ? a->server : "" );
    193194               
    194                 line = obfucrypt( irc, s );
     195                line = obfucrypt( s, irc->password );
    195196                if( *line )
    196197                {
     
    210211                {
    211212                        g_snprintf( s, sizeof( s ), "set %s \"%s\"", set->key, set->value );
    212                         line = obfucrypt( irc, s );
     213                        line = obfucrypt( s, irc->password );
    213214                        if( *line )
    214215                        {
     
    227228        {
    228229                g_snprintf( s, sizeof( s ), "rename %s %s", ROOT_NICK, irc->mynick );
    229                 line = obfucrypt( irc, s );
     230                line = obfucrypt( s, irc->password );
    230231                if( *line )
    231232                {
     
    270271        FILE *fp;
    271272       
    272         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, nick, ".nicks" );
     273        g_snprintf( s, 511, "%s%s%s", global.conf->configdir, nick, ".accounts" );
    273274        fp = fopen( s, "r" );
    274275        if (!fp)
  • unix.c

    ra301379c rb73ac9c  
    7272                return( i );
    7373
    74         global.storage = storage_init( global.conf->storage );
     74        global.storage = storage_init( global.conf->primary_storage,
     75                                                                   global.conf->migrate_storage );
    7576        if ( global.storage == NULL) {
    76                 log_message( LOGLVL_ERROR, "No such storage backend '%s'", global.conf->storage );
     77                log_message( LOGLVL_ERROR, "Unable to load storage backend '%s'", global.conf->primary_storage );
    7778                return( 1 );
    7879        }
Note: See TracChangeset for help on using the changeset viewer.