Changeset 6aaa221


Ignore:
Timestamp:
2005-12-13T23:21:21Z (19 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
22bf64e
Parents:
ab4afba (diff), d3307e2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

More work on the storage abstraction layer from Jelmer.

Files:
11 edited

Legend:

Unmodified
Added
Removed

  • bitlbee.h

    rab4afba r6aaa221  
    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

    rab4afba r6aaa221  
    8686int cmd_identify( irc_t *irc, char **cmd )
    8787{
    88         storage_status_t status = global.storage->load( irc->nick, cmd[1], irc );
     88        storage_status_t status = storage_load( irc->nick, cmd[1], irc );
    8989       
    9090        switch (status) {
    … …  
    102102                break;
    103103        }
    104        
     104
    105105        return( 0 );
    106106}
    … …  
    115115
    116116        irc_setpass( irc, cmd[1] );
    117         switch( global.storage->save( irc, FALSE )) {
     117        switch( storage_save( irc, FALSE )) {
    118118                case STORAGE_ALREADY_EXISTS:
    119119                        irc_usermsg( irc, "Nick is already registered" );
    … …  
    136136        storage_status_t status;
    137137       
    138         status = global.storage->remove (irc->nick, cmd[1]);
     138        status = storage_remove (irc->nick, cmd[1]);
    139139        switch (status) {
    140140        case STORAGE_NO_SUCH_USER:
    … …  
    616616int cmd_save( irc_t *irc, char **cmd )
    617617{
    618         if( global.storage->save( irc, TRUE ) == STORAGE_OK )
     618        if( storage_save( irc, TRUE ) == STORAGE_OK )
    619619                irc_usermsg( irc, "Configuration saved" );
    620620        else

  • conf.c

    rab4afba r6aaa221  
    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

    rab4afba r6aaa221  
    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;

  • crypting.c

    rab4afba r6aaa221  
    2929   the programs will be built. */
    3030
    31 #ifndef CRYPTING_MAIN
    32 #define BITLBEE_CORE
    33 #include "bitlbee.h"
    34 #include "irc.h"
    3531#include "md5.h"
    3632#include "crypting.h"
    … …  
    3834#include <stdio.h>
    3935#include <stdlib.h>
    40 
    41 #else
    42 
    43 typedef struct irc
    44 {
    45         char *password;
    46 } irc_t;
    47 
    48 #include "md5.h"
    49 #include "crypting.h"
    50 #include <string.h>
    51 #include <stdio.h>
    52 #include <stdlib.h>
    53 
    54 #endif
    5536
    5637/*\
    … …  
    8364
    8465
    85 char *hashpass (irc_t *irc) {
     66char *hashpass (const char *password)
     67{
    8668        md5_state_t md5state;
    8769        md5_byte_t digest[16];
    … …  
    9072        char *rv;
    9173       
    92         if (irc->password == NULL) return (NULL);
     74        if (password == NULL) return (NULL);
    9375       
    94         rv = (char *)g_malloc (33);
    95         memset (rv, 0, 33);
     76        rv = g_new0 (char, 33);
    9677       
    9778        md5_init (&md5state);
    98         md5_append (&md5state, (unsigned char *)irc->password, strlen (irc->password));
     79        md5_append (&md5state, (const unsigned char *)password, strlen (password));
    9980        md5_finish (&md5state, digest);
    10081       
    … …  
    10889}
    10990
    110 char *obfucrypt (irc_t *irc, char *line)
     91char *obfucrypt (char *line, const char *password)
    11192{
    11293        int i, j;
    11394        char *rv;
    11495       
    115         if (irc->password == NULL) return (NULL);
     96        if (password == NULL) return (NULL);
    11697       
    117         rv = g_new0(char, strlen (line) + 1);
     98        rv = g_new0 (char, strlen (line) + 1);
    11899       
    119100        i = j = 0;
    … …  
    121102                /* Encrypt/obfuscate the line, using the password */
    122103                if (*(signed char*)line < 0) *line = - (*line);
    123                 if (((signed char*)irc->password)[i] < 0) irc->password[i] = - irc->password[i];
    124104               
    125                 rv[j] = *line + irc->password[i]; /* Overflow intended */
     105                rv[j] = *line + password[i]; /* Overflow intended */
    126106               
    127107                line++;
    128                 if (!irc->password[++i]) i = 0;
     108                if (!password[++i]) i = 0;
    129109                j++;
    130110        }
    … …  
    133113}
    134114
    135 char *deobfucrypt (irc_t *irc, char *line)
     115char *deobfucrypt (char *line, const char *password)
    136116{
    137117        int i, j;
    138118        char *rv;
    139119       
    140         if (irc->password == NULL) return (NULL);
     120        if (password == NULL) return (NULL);
    141121       
    142         rv = g_new0(char, strlen (line) + 1);
     122        rv = g_new0 (char, strlen (line) + 1);
    143123       
    144124        i = j = 0;
    145125        while (*line) {
    146126                /* Decrypt/deobfuscate the line, using the pass */
    147                 rv[j] = *line - irc->password[i]; /* Overflow intended */
     127                rv[j] = *line - password[i]; /* Overflow intended */
    148128               
    149129                line++;
    150                 if (!irc->password[++i]) i = 0;
     130                if (!password[++i]) i = 0;
    151131                j++;
    152132        }
    … …  
    162142int main( int argc, char *argv[] )
    163143{
    164         irc_t *irc = g_new0( irc_t, 1 );
    165144        char *hash, *action, line[256];
    166         char* (*func)( irc_t *, char * );
     145        char* (*func)( char *, const char * );
    167146       
    168147        if( argc < 2 )
    … …  
    174153        }
    175154       
    176         irc->password = g_strdup( argv[1] );
    177        
    178         hash = hashpass( irc );
     155        hash = hashpass( argv[1] );
    179156        action = argv[0] + strlen( argv[0] ) - strlen( "encode" );
    180157       
    … …  
    208185                fgetc( stdin );
    209186               
    210                 out = func( irc, line );
     187                out = func( line, argv[1] );
    211188                printf( "%s\n", out );
    212189                g_free( out );

  • crypting.h

    rab4afba r6aaa221  
    2525
    2626int checkpass (const char *password, const char *md5sum);
    27 char *hashpass (irc_t *irc);
    28 char *obfucrypt (irc_t *irc, char *line);
    29 char *deobfucrypt (irc_t *irc, char *line);
     27char *hashpass (const char *password);
     28char *obfucrypt (char *line, const char *password);
     29char *deobfucrypt (char *line, const char *password);

  • irc.c

    rab4afba r6aaa221  
    161161       
    162162        if( irc->status >= USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) )
    163                 if( !global.storage->save( irc, TRUE ) )
     163                if( storage_save( irc, TRUE ) != STORAGE_OK )
    164164                        irc_usermsg( irc, "Error while saving settings!" );
    165165       

  • storage.c

    rab4afba r6aaa221  
    3838}
    3939
    40 storage_t *storage_init(const char *name)
     40static storage_t *storage_init_single(const char *name)
    4141{
    4242        GList *gl;
    … …  
    5757        return st;
    5858}
     59
     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
     82storage_status_t storage_check_pass (const char *nick, const char *password)
     83{
     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;
     98}
     99
     100storage_status_t storage_load (const char *nick, const char *password, irc_t * irc)
     101{
     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;
     120}
     121
     122storage_status_t storage_save (irc_t *irc, int overwrite)
     123{
     124        return ((storage_t *)global.storage->data)->save(irc, overwrite);
     125}
     126
     127storage_status_t storage_remove (const char *nick, const char *password)
     128{
     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;
     146}
     147
     148storage_status_t storage_rename (const char *onick, const char *nnick, const char *password)
     149{
     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;
     185}

  • storage.h

    rab4afba r6aaa221  
    5353} storage_t;
    5454
     55storage_status_t storage_check_pass (const char *nick, const char *password);
     56
     57storage_status_t storage_load (const char *nick, const char *password, irc_t * irc);
     58storage_status_t storage_save (irc_t *irc, int overwrite);
     59storage_status_t storage_remove (const char *nick, const char *password);
     60
     61storage_status_t storage_rename (const char *onick, const char *nnick, const char *password);
     62
    5563void register_storage_backend(storage_t *);
    56 storage_t *storage_init(const char *name);
     64GList *storage_init(const char *primary, char **migrate);
    5765
    5866#endif /* __STORAGE_H__ */

  • storage_text.c

    rab4afba r6aaa221  
    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

    rab4afba r6aaa221  
    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.