Changes in / [b8ef1b1:1aa0bb5]


Ignore:
Files:
3 added
16 edited

Legend:

Unmodified
Added
Removed
  • .bzrignore

    rb8ef1b1 r1aa0bb5  
    88build-arch-stamp
    99tags
     10decode
     11encode
  • Makefile

    rb8ef1b1 r1aa0bb5  
    1010
    1111# Program variables
    12 objects = account.o bitlbee.o commands.o conf.o crypting.o help.o ini.o irc.o log.o nick.o query.o set.o unix.o url.o user.o
     12objects = account.o bitlbee.o commands.o conf.o crypting.o help.o ini.o irc.o log.o nick.o query.o set.o unix.o url.o user.o storage_text.o storage.o
    1313subdirs = protocols
    1414
  • bitlbee.c

    rb8ef1b1 r1aa0bb5  
    2727#include "bitlbee.h"
    2828#include "commands.h"
    29 #include "crypting.h"
    3029#include "protocols/nogaim.h"
    3130#include "help.h"
     
    244243}
    245244
    246 int bitlbee_load( irc_t *irc, char* password )
    247 {
    248         char s[512];
    249         char *line;
    250         int proto;
    251         char nick[MAX_NICK_LENGTH+1];
    252         FILE *fp;
    253         user_t *ru = user_find( irc, ROOT_NICK );
    254        
    255         if( irc->status == USTATUS_IDENTIFIED )
    256                 return( 1 );
    257        
    258         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    259         fp = fopen( s, "r" );
    260         if( !fp ) return( 0 );
    261        
    262         fscanf( fp, "%32[^\n]s", s );
    263         if( setpass( irc, password, s ) < 0 )
    264         {
    265                 fclose( fp );
    266                 return( -1 );
    267         }
    268        
    269         /* Do this now. If the user runs with AuthMode = Registered, the
    270            account command will not work otherwise. */
    271         irc->status = USTATUS_IDENTIFIED;
    272        
    273         while( fscanf( fp, "%511[^\n]s", s ) > 0 )
    274         {
    275                 fgetc( fp );
    276                 line = deobfucrypt( irc, s );
    277                 root_command_string( irc, ru, line, 0 );
    278                 g_free( line );
    279         }
    280         fclose( fp );
    281        
    282         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    283         fp = fopen( s, "r" );
    284         if( !fp ) return( 0 );
    285         while( fscanf( fp, "%s %d %s", s, &proto, nick ) > 0 )
    286         {
    287                 http_decode( s );
    288                 nick_set( irc, s, proto, nick );
    289         }
    290         fclose( fp );
    291        
    292         if( set_getint( irc, "auto_connect" ) )
    293         {
    294                 strcpy( s, "account on" );      /* Can't do this directly because r_c_s alters the string */
    295                 root_command_string( irc, ru, s, 0 );
    296         }
    297        
    298         return( 1 );
    299 }
    300 
    301 int bitlbee_save( irc_t *irc )
    302 {
    303         char s[512];
    304         char path[512], new_path[512];
    305         char *line;
    306         nick_t *n;
    307         set_t *set;
    308         mode_t ou = umask( 0077 );
    309         account_t *a;
    310         FILE *fp;
    311         char *hash;
    312        
    313         /*\
    314          *  [SH] Nothing should be saved if no password is set, because the
    315          *  password is not set if it was wrong, or if one is not identified
    316          *  yet. This means that a malicious user could easily overwrite
    317          *  files owned by someone else:
    318          *  a Bad Thing, methinks
    319         \*/
    320 
    321         /* [WVG] No? Really? */
    322 
    323         /*\
    324          *  [SH] Okay, okay, it wasn't really Wilmer who said that, it was
    325          *  me. I just thought it was funny.
    326         \*/
    327        
    328         hash = hashpass( irc );
    329         if( hash == NULL )
    330         {
    331                 irc_usermsg( irc, "Please register yourself if you want to save your settings." );
    332                 return( 0 );
    333         }
    334        
    335         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks~" );
    336         fp = fopen( path, "w" );
    337         if( !fp ) return( 0 );
    338         for( n = irc->nicks; n; n = n->next )
    339         {
    340                 strcpy( s, n->handle );
    341                 s[169] = 0; /* Prevent any overflow (169 ~ 512 / 3) */
    342                 http_encode( s );
    343                 g_snprintf( s + strlen( s ), 510 - strlen( s ), " %d %s", n->proto, n->nick );
    344                 if( fprintf( fp, "%s\n", s ) != strlen( s ) + 1 )
    345                 {
    346                         irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    347                         fclose( fp );
    348                         return( 0 );
    349                 }
    350         }
    351         if( fclose( fp ) != 0 )
    352         {
    353                 irc_usermsg( irc, "fclose() reported an error. Disk full?" );
    354                 return( 0 );
    355         }
    356  
    357         g_snprintf( new_path, 512, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    358         if( unlink( new_path ) != 0 )
    359         {
    360                 if( errno != ENOENT )
    361                 {
    362                         irc_usermsg( irc, "Error while removing old .nicks file" );
    363                         return( 0 );
    364                 }
    365         }
    366         if( rename( path, new_path ) != 0 )
    367         {
    368                 irc_usermsg( irc, "Error while renaming new .nicks file" );
    369                 return( 0 );
    370         }
    371        
    372         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts~" );
    373         fp = fopen( path, "w" );
    374         if( !fp ) return( 0 );
    375         if( fprintf( fp, "%s", hash ) != strlen( hash ) )
    376         {
    377                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    378                 fclose( fp );
    379                 return( 0 );
    380         }
    381         g_free( hash );
    382 
    383         for( a = irc->accounts; a; a = a->next )
    384         {
    385                 if( a->protocol == PROTO_OSCAR || a->protocol == PROTO_ICQ || a->protocol == PROTO_TOC )
    386                         g_snprintf( s, sizeof( s ), "account add oscar \"%s\" \"%s\" %s", a->user, a->pass, a->server );
    387                 else
    388                         g_snprintf( s, sizeof( s ), "account add %s \"%s\" \"%s\" \"%s\"",
    389                                     proto_name[a->protocol], a->user, a->pass, a->server ? a->server : "" );
    390                
    391                 line = obfucrypt( irc, s );
    392                 if( *line )
    393                 {
    394                         if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    395                         {
    396                                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    397                                 fclose( fp );
    398                                 return( 0 );
    399                         }
    400                 }
    401                 g_free( line );
    402         }
    403        
    404         for( set = irc->set; set; set = set->next )
    405         {
    406                 if( set->value && set->def )
    407                 {
    408                         g_snprintf( s, sizeof( s ), "set %s \"%s\"", set->key, set->value );
    409                         line = obfucrypt( irc, s );
    410                         if( *line )
    411                         {
    412                                 if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    413                                 {
    414                                         irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    415                                         fclose( fp );
    416                                         return( 0 );
    417                                 }
    418                         }
    419                         g_free( line );
    420                 }
    421         }
    422        
    423         if( strcmp( irc->mynick, ROOT_NICK ) != 0 )
    424         {
    425                 g_snprintf( s, sizeof( s ), "rename %s %s", ROOT_NICK, irc->mynick );
    426                 line = obfucrypt( irc, s );
    427                 if( *line )
    428                 {
    429                         if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    430                         {
    431                                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    432                                 fclose( fp );
    433                                 return( 0 );
    434                         }
    435                 }
    436                 g_free( line );
    437         }
    438         if( fclose( fp ) != 0 )
    439         {
    440                 irc_usermsg( irc, "fclose() reported an error. Disk full?" );
    441                 return( 0 );
    442         }
    443        
    444         g_snprintf( new_path, 512, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    445         if( unlink( new_path ) != 0 )
    446         {
    447                 if( errno != ENOENT )
    448                 {
    449                         irc_usermsg( irc, "Error while removing old .accounts file" );
    450                         return( 0 );
    451                 }
    452         }
    453         if( rename( path, new_path ) != 0 )
    454         {
    455                 irc_usermsg( irc, "Error while renaming new .accounts file" );
    456                 return( 0 );
    457         }
    458        
    459         umask( ou );
    460        
    461         return( 1 );
    462 }
    463 
    464245void bitlbee_shutdown( gpointer data )
    465246{
  • bitlbee.h

    rb8ef1b1 r1aa0bb5  
    100100
    101101#include "irc.h"
     102#include "storage.h"
    102103#include "set.h"
    103104#include "protocols/nogaim.h"
     
    115116        help_t *help;
    116117        conf_t *conf;
     118        storage_t *storage;
    117119        char *helpfile;
    118120        GMainLoop *loop;
     
    127129int root_command_string( irc_t *irc, user_t *u, char *command, int flags );
    128130int root_command( irc_t *irc, char *command[] );
    129 int bitlbee_load( irc_t *irc, char *password );
    130 int bitlbee_save( irc_t *irc );
    131131void bitlbee_shutdown( gpointer data );
    132132double gettime( void );
  • commands.c

    rb8ef1b1 r1aa0bb5  
    8686int cmd_identify( irc_t *irc, char **cmd )
    8787{
    88         int checkie = bitlbee_load( irc, cmd[1] );
    89        
    90         if( checkie == -1 )
    91         {
     88        storage_status_t status = global.storage->load( irc->nick, cmd[1], irc );
     89       
     90        switch (status) {
     91        case STORAGE_INVALID_PASSWORD:
    9292                irc_usermsg( irc, "Incorrect password" );
    93         }
    94         else if( checkie == 0 )
    95         {
     93                break;
     94        case STORAGE_NO_SUCH_USER:
    9695                irc_usermsg( irc, "The nick is (probably) not registered" );
    97         }
    98         else if( checkie == 1 )
    99         {
     96                break;
     97        case STORAGE_OK:
    10098                irc_usermsg( irc, "Password accepted" );
    101         }
    102         else
    103         {
     99                break;
     100        default:
    104101                irc_usermsg( irc, "Something very weird happened" );
     102                break;
    105103        }
    106104       
     
    110108int cmd_register( irc_t *irc, char **cmd )
    111109{
    112         int checkie;
    113         char path[512];
    114        
    115110        if( global.conf->authmode == AUTHMODE_REGISTERED )
    116111        {
     
    118113                return( 0 );
    119114        }
    120        
    121         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    122         checkie = access( path, F_OK );
    123        
    124         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    125         checkie += access( path, F_OK );
    126        
    127         if( checkie == -2 )
    128         {
    129                 setpassnc( irc, cmd[1] );
    130                 root_command_string( irc, user_find( irc, irc->mynick ), "save", 0 );
    131                 irc->status = USTATUS_IDENTIFIED;
    132         }
    133         else
    134         {
    135                 irc_usermsg( irc, "Nick is already registered" );
     115
     116        irc_setpass( irc, cmd[1] );
     117        switch( global.storage->save( irc, FALSE )) {
     118                case STORAGE_ALREADY_EXISTS:
     119                        irc_usermsg( irc, "Nick is already registered" );
     120                        break;
     121                       
     122                case STORAGE_OK:
     123                        irc->status = USTATUS_IDENTIFIED;
     124                        break;
     125
     126                default:
     127                        irc_usermsg( irc, "Error registering" );
     128                        break;
    136129        }
    137130       
     
    141134int cmd_drop( irc_t *irc, char **cmd )
    142135{
    143         char s[512];
    144         FILE *fp;
    145        
    146         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    147         fp = fopen( s, "r" );
    148         if( !fp )
    149         {
     136        storage_status_t status;
     137       
     138        status = global.storage->remove (irc->nick, cmd[1]);
     139        switch (status) {
     140        case STORAGE_NO_SUCH_USER:
    150141                irc_usermsg( irc, "That account does not exist" );
    151142                return( 0 );
    152         }
    153        
    154         fscanf( fp, "%32[^\n]s", s );
    155         fclose( fp );
    156         if( setpass( irc, cmd[1], s ) < 0 )
    157         {
    158                 irc_usermsg( irc, "Incorrect password" );
    159                 return( 0 );
    160         }
    161        
    162         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    163         unlink( s );
    164        
    165         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    166         unlink( s );
    167        
    168         setpassnc( irc, NULL );
    169         irc_usermsg( irc, "Files belonging to account `%s' removed", irc->nick );
    170        
    171         return( 0 );
     143        case STORAGE_INVALID_PASSWORD:
     144                irc_usermsg( irc, "Password invalid" );
     145                return( 0 );
     146        case STORAGE_OK:
     147                irc_setpass( irc, NULL );
     148                irc_usermsg( irc, "Account `%s' removed", irc->nick );
     149                return( 0 );
     150        default:
     151                irc_usermsg( irc, "Error: '%d'", status );
     152                return( 0 );
     153        }
    172154}
    173155
     
    634616int cmd_save( irc_t *irc, char **cmd )
    635617{
    636         if( bitlbee_save( irc ) )
     618        if( global.storage->save( irc, TRUE ) == STORAGE_OK )
    637619                irc_usermsg( irc, "Configuration saved" );
    638620        else
  • conf.c

    rb8ef1b1 r1aa0bb5  
    5050        conf->nofork = 0;
    5151        conf->verbose = 0;
     52        conf->storage = "text";
    5253        conf->runmode = RUNMODE_INETD;
    5354        conf->authmode = AUTHMODE_OPEN;
     
    198199                                conf->motdfile = g_strdup( ini->value );
    199200                        }
     201                        else if( g_strcasecmp( ini->key, "storage" ) == 0 )
     202                        {
     203                                g_free( conf->storage );
     204                                conf->storage = g_strdup( ini->value );
     205                        }
    200206                        else if( g_strcasecmp( ini->key, "pinginterval" ) == 0 )
    201207                        {
  • conf.h

    rb8ef1b1 r1aa0bb5  
    4242        char *configdir;
    4343        char *motdfile;
     44        char *storage;
    4445        int ping_interval;
    4546        int ping_timeout;
  • crypting.c

    rb8ef1b1 r1aa0bb5  
    4646} irc_t;
    4747
    48 #define set_add( a, b, c, d )
    49 #define set_find( a, b ) NULL
    50 
    5148#include "md5.h"
    5249#include "crypting.h"
     
    5552#include <stdlib.h>
    5653
    57 #define irc_usermsg
    58 
    5954#endif
    6055
     
    6560\*/
    6661
    67 /* USE WITH CAUTION!
    68    Sets pass without checking */
    69 void setpassnc (irc_t *irc, char *pass) {
    70         if (!set_find (irc, "password"))
    71                 set_add (irc, "password", NULL, passchange);
    72        
    73         if (irc->password) g_free (irc->password);
    74        
    75         if (pass) {
    76                 irc->password = g_strdup (pass);
    77                 irc_usermsg (irc, "Password successfully changed");
    78         } else {
    79                 irc->password = NULL;
    80         }
    81 }
    82 
    83 char *passchange (irc_t *irc, void *set, char *value) {
    84         setpassnc (irc, value);
    85         return (NULL);
    86 }
    87 
    88 int setpass (irc_t *irc, char *pass, char* md5sum) {
     62int checkpass (const char *pass, const char *md5sum)
     63{
    8964        md5_state_t md5state;
    9065        md5_byte_t digest[16];
     
    10378                if (digits[1] != md5sum[j + 1]) return (-1);
    10479        }
    105        
    106         /* If pass is correct, we end up here and we set the pass */
    107         setpassnc (irc, pass);
    108        
    109         return (0);
    110 }
     80
     81        return( 0 );
     82}
     83
    11184
    11285char *hashpass (irc_t *irc) {
     
    135108}
    136109
    137 char *obfucrypt (irc_t *irc, char *line) {
     110char *obfucrypt (irc_t *irc, char *line)
     111{
    138112        int i, j;
    139113        char *rv;
     
    141115        if (irc->password == NULL) return (NULL);
    142116       
    143         rv = (char *)g_malloc (strlen (line) + 1);
    144         memset (rv, '\0', strlen (line) + 1);
     117        rv = g_new0(char, strlen (line) + 1);
    145118       
    146119        i = j = 0;
     
    160133}
    161134
    162 char *deobfucrypt (irc_t *irc, char *line) {
     135char *deobfucrypt (irc_t *irc, char *line)
     136{
    163137        int i, j;
    164138        char *rv;
     
    166140        if (irc->password == NULL) return (NULL);
    167141       
    168         rv = (char *)g_malloc (strlen (line) + 1);
    169         memset (rv, '\0', strlen (line) + 1);
     142        rv = g_new0(char, strlen (line) + 1);
    170143       
    171144        i = j = 0;
     
    189162int main( int argc, char *argv[] )
    190163{
    191         irc_t *irc = g_malloc( sizeof( irc_t ) );
     164        irc_t *irc = g_new0( irc_t, 1 );
    192165        char *hash, *action, line[256];
    193166        char* (*func)( irc_t *, char * );
     
    201174        }
    202175       
    203         memset( irc, 0, sizeof( irc_t ) );
    204176        irc->password = g_strdup( argv[1] );
    205177       
  • crypting.h

    rb8ef1b1 r1aa0bb5  
    2424*/
    2525
    26 void setpassnc (irc_t *irc, char *pass); /* USE WITH CAUTION! */
    27 char *passchange (irc_t *irc, void *set, char *value);
    28 int setpass (irc_t *irc, char *pass, char* md5sum);
     26int checkpass (const char *password, const char *md5sum);
    2927char *hashpass (irc_t *irc);
    3028char *obfucrypt (irc_t *irc, char *line);
  • irc.c

    rb8ef1b1 r1aa0bb5  
    3131
    3232GSList *irc_connection_list = NULL;
     33
     34static char *passchange (irc_t *irc, void *set, char *value)
     35{
     36        irc_setpass (irc, value);
     37        return (NULL);
     38}
    3339
    3440irc_t *irc_new( int fd )
     
    129135        set_add( irc, "to_char", ": ", set_eval_to_char );
    130136        set_add( irc, "typing_notice", "false", set_eval_bool );
     137        set_add( irc, "password", NULL, passchange);
    131138       
    132139        conf_loaddefaults( irc );
     
    154161       
    155162        if( irc->status >= USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) )
    156                 if( !bitlbee_save( irc ) )
     163                if( !global.storage->save( irc, TRUE ) )
    157164                        irc_usermsg( irc, "Error while saving settings!" );
    158165       
     
    259266        if( global.conf->runmode == RUNMODE_INETD )
    260267                g_main_quit( global.loop );
     268}
     269
     270/* USE WITH CAUTION!
     271   Sets pass without checking */
     272void irc_setpass (irc_t *irc, const char *pass)
     273{
     274        if (irc->password) g_free (irc->password);
     275       
     276        if (pass) {
     277                irc->password = g_strdup (pass);
     278                irc_usermsg (irc, "Password successfully changed");
     279        } else {
     280                irc->password = NULL;
     281        }
    261282}
    262283
  • irc.h

    rb8ef1b1 r1aa0bb5  
    137137void irc_whois( irc_t *irc, char *nick );
    138138int irc_away( irc_t *irc, char *away );
     139void irc_setpass( irc_t *irc, const char *pass ); /* USE WITH CAUTION! */
    139140
    140141int irc_send( irc_t *irc, char *nick, char *s, int flags );
  • nick.c

    rb8ef1b1 r1aa0bb5  
    2727#include "bitlbee.h"
    2828
    29 void nick_set( irc_t *irc, char *handle, int proto, char *nick )
     29void nick_set( irc_t *irc, const char *handle, int proto, const char *nick )
    3030{
    3131        nick_t *m = NULL, *n = irc->nicks;
     
    5656}
    5757
    58 char *nick_get( irc_t *irc, char *handle, int proto, const char *realname )
     58char *nick_get( irc_t *irc, const char *handle, int proto, const char *realname )
    5959{
    6060        static char nick[MAX_NICK_LENGTH+1];
     
    129129}
    130130
    131 void nick_del( irc_t *irc, char *nick )
     131void nick_del( irc_t *irc, const char *nick )
    132132{
    133133        nick_t *l = NULL, *n = irc->nicks;
     
    176176}
    177177
    178 int nick_ok( char *nick )
    179 {
    180         char *s;
     178int nick_ok( const char *nick )
     179{
     180        const char *s;
    181181       
    182182        /* Empty/long nicks are not allowed */
     
    237237}
    238238
    239 int nick_cmp( char *a, char *b )
     239int nick_cmp( const char *a, const char *b )
    240240{
    241241        char aa[1024] = "", bb[1024] = "";
     
    253253}
    254254
    255 char *nick_dup( char *nick )
    256 {
    257         char *cp;
    258        
    259         cp = g_new0 ( char, MAX_NICK_LENGTH + 1 );
    260         strncpy( cp, nick, MAX_NICK_LENGTH );
    261        
    262         return( cp );
    263 }
     255char *nick_dup( const char *nick )
     256{
     257        return g_strndup( nick, MAX_NICK_LENGTH );
     258}
  • nick.h

    rb8ef1b1 r1aa0bb5  
    3232} nick_t;
    3333
    34 void nick_set( irc_t *irc, char *handle, int proto, char *nick );
    35 char *nick_get( irc_t *irc, char *handle, int proto, const char *realname );
    36 void nick_del( irc_t *irc, char *nick );
     34void nick_set( irc_t *irc, const char *handle, int proto, const char *nick );
     35char *nick_get( irc_t *irc, const char *handle, int proto, const char *realname );
     36void nick_del( irc_t *irc, const char *nick );
    3737void nick_strip( char *nick );
    3838
    39 int nick_ok( char *nick );
     39int nick_ok( const char *nick );
    4040int nick_lc( char *nick );
    4141int nick_uc( char *nick );
    42 int nick_cmp( char *a, char *b );
    43 char *nick_dup( char *nick );
     42int nick_cmp( const char *a, const char *b );
     43char *nick_dup( const char *nick );
  • protocols/proxy.c

    rb8ef1b1 r1aa0bb5  
    5050#define GAIM_ERR_COND   (G_IO_HUP | G_IO_ERR | G_IO_NVAL)
    5151
    52 /*FIXME*               
    53         #ifndef _WIN32
    54                 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
    55                         closesocket(fd);
    56                         g_free(phb);
    57                         return -1;
    58                 }
    59                 fcntl(fd, F_SETFL, 0);
    60 #endif*/
    61 
    6252char proxyhost[128] = "";
    6353int proxyport = 0;
     
    8373
    8474
    85 static struct sockaddr_in *gaim_gethostbyname(char *host, int port)
     75static struct sockaddr_in *gaim_gethostbyname(const char *host, int port)
    8676{
    8777        static struct sockaddr_in sin;
     
    154144}
    155145
    156 static int proxy_connect_none(char *host, unsigned short port, struct PHB *phb)
     146static int proxy_connect_none(const char *host, unsigned short port, struct PHB *phb)
    157147{
    158148        struct sockaddr_in *sin;
     
    281271}
    282272
    283 static int proxy_connect_http(char *host, unsigned short port, struct PHB *phb)
     273static int proxy_connect_http(const char *host, unsigned short port, struct PHB *phb)
    284274{
    285275        phb->host = g_strdup(host);
     
    365355}
    366356
    367 static int proxy_connect_socks4(char *host, unsigned short port, struct PHB *phb)
     357static int proxy_connect_socks4(const char *host, unsigned short port, struct PHB *phb)
    368358{
    369359        phb->host = g_strdup(host);
     
    547537}
    548538
    549 static int proxy_connect_socks5(char *host, unsigned short port, struct PHB *phb)
     539static int proxy_connect_socks5(const char *host, unsigned short port, struct PHB *phb)
    550540{
    551541        phb->host = g_strdup(host);
     
    588578}
    589579
    590 int proxy_connect(char *host, int port, GaimInputFunction func, gpointer data)
     580int proxy_connect(const char *host, int port, GaimInputFunction func, gpointer data)
    591581{
    592582        struct PHB *phb;
  • protocols/proxy.h

    rb8ef1b1 r1aa0bb5  
    5656G_MODULE_EXPORT void gaim_input_remove(gint);
    5757
    58 G_MODULE_EXPORT int proxy_connect(char *host, int port, GaimInputFunction func, gpointer data);
     58G_MODULE_EXPORT int proxy_connect(const char *host, int port, GaimInputFunction func, gpointer data);
    5959
    6060#endif /* _PROXY_H_ */
  • unix.c

    rb8ef1b1 r1aa0bb5  
    5252       
    5353        global.helpfile = g_strdup( HELP_FILE );
    54        
     54
    5555        global.conf = conf_load( argc, argv );
    5656        if( global.conf == NULL )
    5757                return( 1 );
    58        
     58
     59
    5960        if( global.conf->runmode == RUNMODE_INETD )
    6061        {
     
    7071        if( i != 0 )
    7172                return( i );
     73
     74        global.storage = storage_init( global.conf->storage );
     75        if ( global.storage == NULL) {
     76                log_message( LOGLVL_ERROR, "No such storage backend '%s'", global.conf->storage );
     77                return( 1 );
     78        }
     79       
    7280       
    7381        /* Catch some signals to tell the user what's happening before quitting */
     
    8795        if( !getuid() || !geteuid() )
    8896                log_message( LOGLVL_WARNING, "BitlBee is running with root privileges. Why?" );
    89         if( access( global.conf->configdir, F_OK ) != 0 )
    90                 log_message( LOGLVL_WARNING, "The configuration directory %s does not exist. Configuration won't be saved.", CONFIG );
    91         else if( access( global.conf->configdir, R_OK ) != 0 || access( global.conf->configdir, W_OK ) != 0 )
    92                 log_message( LOGLVL_WARNING, "Permission problem: Can't read/write from/to %s.", global.conf->configdir );
    9397        if( help_init( &(global.help) ) == NULL )
    9498                log_message( LOGLVL_WARNING, "Error opening helpfile %s.", HELP_FILE );
Note: See TracChangeset for help on using the changeset viewer.