Changes in / [fef6116:3f9440d]


Ignore:
Files:
22 added
30 deleted
27 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    rfef6116 r3f9440d  
    1010
    1111# Program variables
    12 objects = account.o bitlbee.o conf.o crypting.o help.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) unix.o user.o
     12objects = account.o bitlbee.o conf.o crypting.o help.o ini.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o storage_text.o unix.o url.o user.o util.o
    1313headers = account.h bitlbee.h commands.h conf.h config.h crypting.h help.h ini.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h url.h user.h protocols/http_client.h protocols/md5.h protocols/nogaim.h protocols/proxy.h protocols/sha.h protocols/ssl_client.h
    14 subdirs = protocols lib
     14subdirs = protocols
    1515
    1616# Expansion of variables
     
    4242
    4343distclean: clean $(subdirs)
    44         rm -f Makefile.settings config.h bitlbee.pc
     44        rm -f Makefile.settings config.h
    4545        find . -name 'DEADJOE' -o -name '*.orig' -o -name '*.rej' -o -name '*~' -exec rm -f {} \;
    4646
  • account.c

    rfef6116 r3f9440d  
    2828#include "account.h"
    2929
    30 char *set_eval_account( set_t *set, char *value );
    31 
    3230account_t *account_add( irc_t *irc, struct prpl *prpl, char *user, char *pass )
    3331{
    3432        account_t *a;
    35         set_t *s;
    3633       
    3734        if( irc->accounts )
    3835        {
    3936                for( a = irc->accounts; a->next; a = a->next );
    40                 a = a->next = g_new0( account_t, 1 );
     37                a = a->next = g_new0 ( account_t, 1 );
    4138        }
    4239        else
     
    4845        a->user = g_strdup( user );
    4946        a->pass = g_strdup( pass );
    50         a->auto_connect = 1;
    5147        a->irc = irc;
    5248       
    53         s = set_add( &a->set, "auto_connect", NULL, set_eval_account, a );
    54         s->flags |= ACC_SET_NOSAVE;
    55        
    56         s = set_add( &a->set, "password", NULL, set_eval_account, a );
    57         s->flags |= ACC_SET_NOSAVE;
    58        
    59         s = set_add( &a->set, "server", NULL, set_eval_account, a );
    60         s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
    61        
    62         s = set_add( &a->set, "username", NULL, set_eval_account, a );
    63         s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
    64         set_setstr( &a->set, "username", user );
    65        
    6649        return( a );
    67 }
    68 
    69 char *set_eval_account( set_t *set, char *value )
    70 {
    71         account_t *acc = set->data;
    72        
    73         /* Double-check: We refuse to edit on-line accounts. */
    74         if( set->flags & ACC_SET_OFFLINE_ONLY && acc->gc )
    75                 return NULL;
    76        
    77         if( strcmp( set->key, "username" ) == 0 )
    78         {
    79                 g_free( acc->user );
    80                 acc->user = g_strdup( value );
    81                 return value;
    82         }
    83         else if( strcmp( set->key, "password" ) == 0 )
    84         {
    85                 g_free( acc->pass );
    86                 acc->pass = g_strdup( value );
    87                 return NULL;    /* password shouldn't be visible in plaintext! */
    88         }
    89         else if( strcmp( set->key, "server" ) == 0 )
    90         {
    91                 g_free( acc->server );
    92                 if( *value )
    93                         acc->server = g_strdup( value );
    94                 else
    95                         acc->server = NULL;
    96                 return value;
    97         }
    98         else if( strcmp( set->key, "auto_connect" ) == 0 )
    99         {
    100                 if( !is_bool( value ) )
    101                         return NULL;
    102                
    103                 acc->auto_connect = bool2int( value );
    104                 return value;
    105         }
    106        
    107         return NULL;
    10850}
    10951
     
    187129                        }
    188130                       
    189                         while( a->set )
    190                                 set_del( &a->set, a->set->key );
    191                        
    192131                        g_free( a->user );
    193132                        g_free( a->pass );
     
    203142void account_on( irc_t *irc, account_t *a )
    204143{
     144        struct aim_user *u;
     145       
    205146        if( a->gc )
    206147        {
     
    211152        cancel_auto_reconnect( a );
    212153       
     154        u = g_new0 ( struct aim_user, 1 );
     155        u->irc = irc;
     156        u->prpl = a->prpl;
     157        strncpy( u->username, a->user, sizeof( u->username ) - 1 );
     158        strncpy( u->password, a->pass, sizeof( u->password ) - 1 );
     159        if( a->server) strncpy( u->proto_opt[0], a->server, sizeof( u->proto_opt[0] ) - 1 );
     160       
     161        a->gc = (struct gaim_connection *) u; /* Bit hackish :-/ */
    213162        a->reconnect = 0;
    214         a->prpl->login( a );
     163       
     164        a->prpl->login( u );
    215165}
    216166
  • account.h

    rfef6116 r3f9440d  
    3434        char *server;
    3535       
    36         int auto_connect;
    3736        int reconnect;
    38        
    39         set_t *set;
    4037       
    4138        struct irc *irc;
     
    5047void account_off( irc_t *irc, account_t *a );
    5148
    52 #define ACC_SET_NOSAVE          1
    53 #define ACC_SET_OFFLINE_ONLY    2
    54 
    5549#endif
  • bitlbee.c

    rfef6116 r3f9440d  
    291291                        irc_t *irc;
    292292                       
    293                         /* Since we're fork()ing here, let's make sure we won't
    294                            get the same random numbers as the parent/siblings. */
    295                         srand( time( NULL ) ^ getpid() );
    296                        
    297293                        /* Close the listening socket, we're a client. */
    298294                        close( global.listen_socket );
  • bitlbee.h

    rfef6116 r3f9440d  
    130130#include "query.h"
    131131#include "sock.h"
    132 #include "misc.h"
     132#include "util.h"
    133133#include "proxy.h"
    134134
  • conf.c

    rfef6116 r3f9440d  
    3434#include "ipc.h"
    3535
    36 #include "proxy.h"
     36#include "protocols/proxy.h"
    3737
    3838char *CONF_FILE;
     
    5555        conf->nofork = 0;
    5656        conf->verbose = 0;
    57         conf->primary_storage = "xml";
    58         conf->migrate_storage = g_strsplit( "text", ",", -1 );
     57        conf->primary_storage = "text";
    5958        conf->runmode = RUNMODE_INETD;
    6059        conf->authmode = AUTHMODE_OPEN;
     
    323322                if( g_strcasecmp( ini->section, "defaults" ) == 0 )
    324323                {
    325                         set_t *s = set_find( &irc->set, ini->key );
     324                        set_t *s = set_find( irc, ini->key );
    326325                       
    327326                        if( s )
  • configure

    rfef6116 r3f9440d  
    3131
    3232events=glib
    33 ldap=auto
    3433ssl=auto
    3534
     
    6766
    6867--ipv6=0/1      IPv6 socket support                     $ipv6
    69 
    70 --ldap=0/1/auto LDAP support                            $ldap
    7168
    7269--events=...    Event handler (glib, libevent)          $events
     
    144141fi
    145142
    146 echo CFLAGS+=-I`pwd` -I`pwd`/lib -I`pwd`/protocols -I. >> Makefile.settings
     143echo CFLAGS+=-I`pwd` -I`pwd`/protocols -I. >> Makefile.settings
    147144
    148145echo CFLAGS+=-DHAVE_CONFIG_H >> Makefile.settings
    149146
    150147if [ -n "$CC" ]; then
    151         CC=$CC
     148        echo "CC=$CC" >> Makefile.settings;
    152149elif type gcc > /dev/null 2> /dev/null; then
    153         CC=gcc
     150        echo "CC=gcc" >> Makefile.settings;
    154151elif type cc > /dev/null 2> /dev/null; then
    155         CC=cc
     152        echo "CC=cc" >> Makefile.settings;
    156153else
    157154        echo 'Cannot find a C compiler, aborting.'
    158155        exit 1;
    159156fi
    160 
    161 echo "CC=$CC" >> Makefile.settings;
    162157
    163158if [ -n "$LD" ]; then
     
    237232}
    238233
    239 detect_ldap()
    240 {
    241         TMPFILE=`mktemp`
    242         if $CC -o $TMPFILE -shared -lldap 2>/dev/null >/dev/null; then
    243                 cat<<EOF>>Makefile.settings
    244 EFLAGS+=-lldap
    245 CFLAGS+=
    246 EOF
    247                 ldap=1
    248                 rm -f $TMPFILE
    249                 ret=1
     234if [ "$msn" = 1 -o "$jabber" = 1 ]; then
     235        if [ "$ssl" = "auto" ]; then
     236                detect_gnutls
     237                if [ "$ret" = "0" ]; then
     238                        detect_nss
     239                fi;
     240        elif [ "$ssl" = "gnutls" ]; then
     241                detect_gnutls;
     242        elif [ "$ssl" = "nss" ]; then
     243                detect_nss;
     244        elif [ "$ssl" = "openssl" ]; then
     245                echo
     246                echo 'No detection code exists for OpenSSL. Make sure that you have a complete'
     247                echo 'install of OpenSSL (including devel/header files) before reporting'
     248                echo 'compilation problems.'
     249                echo
     250                echo 'Also, keep in mind that the OpenSSL is, according to some people, not'
     251                echo 'completely GPL-compatible. Using GnuTLS or NSS is recommended and better'
     252                echo 'supported by us. However, on many BSD machines, OpenSSL can be considered'
     253                echo 'part of the operating system, which makes it GPL-compatible.'
     254                echo
     255                echo 'For more info, see: http://www.openssl.org/support/faq.html#LEGAL2'
     256                echo '                    http://www.gnome.org/~markmc/openssl-and-the-gpl.html'
     257                echo
     258                echo 'Please note that distributing a BitlBee binary which links to OpenSSL is'
     259                echo 'probably illegal. If you want to create and distribute a binary BitlBee'
     260                echo 'package, you really should use GnuTLS or NSS instead.'
     261                echo
     262                echo 'Also, the OpenSSL license requires us to say this:'
     263                echo ' *    "This product includes software developed by the OpenSSL Project'
     264                echo ' *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"'
     265               
     266                echo 'EFLAGS+=-lssl -lcrypto' >> Makefile.settings
     267               
     268                ret=1;
     269        elif [ "$ssl" = "bogus" ]; then
     270                echo
     271                echo 'Using bogus SSL code. This will not make the MSN module work, but it will'
     272                echo 'allow you to use the Jabber module - although without working SSL support.'
     273               
     274                ret=1;
    250275        else
    251                 ldap=0
    252                 ret=0
    253         fi
    254 }
    255 
    256 if [ "$ssl" = "auto" ]; then
    257         detect_gnutls
    258         if [ "$ret" = "0" ]; then
    259                 detect_nss
    260         fi
    261 elif [ "$ssl" = "gnutls" ]; then
    262         detect_gnutls
    263 elif [ "$ssl" = "nss" ]; then
    264         detect_nss
    265 elif [ "$ssl" = "openssl" ]; then
    266         echo
    267         echo 'No detection code exists for OpenSSL. Make sure that you have a complete'
    268         echo 'install of OpenSSL (including devel/header files) before reporting'
    269         echo 'compilation problems.'
    270         echo
    271         echo 'Also, keep in mind that the OpenSSL is, according to some people, not'
    272         echo 'completely GPL-compatible. Using GnuTLS or NSS is recommended and better'
    273         echo 'supported by us. However, on many BSD machines, OpenSSL can be considered'
    274         echo 'part of the operating system, which makes it GPL-compatible.'
    275         echo
    276         echo 'For more info, see: http://www.openssl.org/support/faq.html#LEGAL2'
    277         echo '                    http://www.gnome.org/~markmc/openssl-and-the-gpl.html'
    278         echo
    279         echo 'Please note that distributing a BitlBee binary which links to OpenSSL is'
    280         echo 'probably illegal. If you want to create and distribute a binary BitlBee'
    281         echo 'package, you really should use GnuTLS or NSS instead.'
    282         echo
    283         echo 'Also, the OpenSSL license requires us to say this:'
    284         echo ' *    "This product includes software developed by the OpenSSL Project'
    285         echo ' *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"'
    286        
    287         echo 'EFLAGS+=-lssl -lcrypto' >> Makefile.settings
    288        
    289         ret=1
    290 elif [ "$ssl" = "bogus" ]; then
    291         echo
    292         echo 'Using bogus SSL code. This means some features have to be disabled.'
    293        
    294         ## Yes, you, at the console! How can you authenticate if you don't have any SSL!?
    295         if [ "$msn" = "1" ]; then
    296                 echo
    297                 echo 'Real SSL support is necessary for MSN authentication, will build without'
    298                 echo 'MSN protocol support.'
    299                 msn=0
     276                echo
     277                echo 'ERROR: Unknown SSL library specified.'
     278                exit 1;
    300279        fi
    301280       
    302         ret=1
    303 else
    304         echo
    305         echo 'ERROR: Unknown SSL library specified.'
    306         exit 1
    307 fi
    308 
    309 if [ "$ret" = "0" ]; then
    310         echo
    311         echo 'ERROR: Could not find a suitable SSL library (GnuTLS, libnss or OpenSSL).'
    312         echo '       Please note that this script doesn'\''t have detection code for OpenSSL,'
    313         echo '       so if you want to use that, you have to select it by hand. If you don'\''t'
    314         echo '       need SSL support, you can select the "bogus" SSL library. (--ssl=bogus)'
     281        if [ "$ret" = "0" ]; then
     282                echo
     283                echo 'ERROR: Could not find a suitable SSL library (GnuTLS, libnss or OpenSSL).'
     284                echo '       This is necessary for MSN and full Jabber support. To continue,'
     285                echo '       install a suitable SSL library or disable MSN support (--msn=0).'
     286                echo '       If you want Jabber without SSL support you can try --ssl=bogus.'
     287               
     288                exit 1;
     289        fi;
    315290       
    316         exit 1
    317 fi;
    318 
    319 echo 'SSL_CLIENT=ssl_'$ssl'.o' >> Makefile.settings
    320 
    321 STORAGES="text xml"
    322 
    323 if [ "$ldap" = "auto" ]; then
    324         detect_ldap
    325 fi
    326 
    327 if [ "$ldap" = 0 ]; then
    328         echo "#undef WITH_LDAP" >> config.h
    329 elif [ "$ldap" = 1 ]; then
    330         echo "#define WITH_LDAP 1" >> config.h
    331         STORAGES="$STORAGES ldap"
    332 fi
    333 
    334 for i in $STORAGES; do
    335         STORAGE_OBJS="$STORAGE_OBJS storage_$i.o"
    336 done
    337 echo "STORAGE_OBJS="$STORAGE_OBJS >> Makefile.settings
     291        echo 'SSL_CLIENT=ssl_'$ssl'.o' >> Makefile.settings
     292fi
    338293
    339294if [ "$strip" = 0 ]; then
     
    349304        elif type strip > /dev/null 2> /dev/null; then
    350305                echo "STRIP=strip" >> Makefile.settings;
     306        elif /bin/test -x /usr/ccs/bin/strip; then
     307                echo "STRIP=/usr/ccs/bin/strip" >> Makefile.settings;
    351308        else
    352309                echo
     
    427384if [ "$protocols" = "PROTOCOLS = " ]; then
    428385        echo "WARNING: You haven't selected any communication protocol to compile!"
    429         echo "         BitlBee will run, but you will be unable to connect to IM servers!"
     386        echo "         Bitlbee will run, but you will be unable to connect to IM servers!"
    430387fi
    431388
     
    462419
    463420if [ "$debug" = "1" ]; then
    464         echo '  Debugging enabled.'
    465 else
    466         echo '  Debugging disabled.'
     421        echo '  Debugging enabled.';
     422else
     423        echo '  Debugging disabled.';
    467424fi
    468425
    469426if [ "$strip" = "1" ]; then
    470         echo '  Binary stripping enabled.'
    471 else
    472         echo '  Binary stripping disabled.'
    473 fi
    474 
    475 echo '  Using event handler: '$events
    476 echo '  Using SSL library: '$ssl
    477 echo '  Building with these storage backends: '$STORAGES
     427        echo '  Binary stripping enabled.';
     428else
     429        echo '  Binary stripping disabled.';
     430fi
     431
     432echo '  Using event handler: '$events;
     433echo '  Using SSL library: '$ssl;
     434
     435#if [ "$flood" = "0" ]; then
     436#       echo '  Flood protection disabled.';
     437#else
     438#       echo '  Flood protection enabled.';
     439#fi
    478440
    479441if [ -n "$protocols" ]; then
    480         echo '  Building with these protocols:' $protocols
    481 else
    482         echo '  Building without IM-protocol support. We wish you a lot of fun...'
    483 fi
     442        echo '  Building with these protocols:' $protocols;
     443else
     444        echo '  Building without IM-protocol support. We wish you a lot of fun...';
     445fi
  • irc.c

    rfef6116 r3f9440d  
    3333GSList *irc_connection_list = NULL;
    3434
    35 static char *passchange( irc_t *irc, void *set, char *value )
    36 {
    37         irc_setpass( irc, value );
    38         irc_usermsg( irc, "Password successfully changed" );
    39         return NULL;
     35static char *passchange (irc_t *irc, void *set, char *value)
     36{
     37        irc_setpass (irc, value);
     38        return (NULL);
    4039}
    4140
     
    121120        irc_connection_list = g_slist_append( irc_connection_list, irc );
    122121       
    123         set_add( &irc->set, "away_devoice", "true",  set_eval_away_devoice, irc );
    124         set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
    125         set_add( &irc->set, "auto_reconnect", "false", set_eval_bool, irc );
    126         set_add( &irc->set, "auto_reconnect_delay", "300", set_eval_int, irc );
    127         set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
    128         set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
    129         set_add( &irc->set, "charset", "iso8859-1", set_eval_charset, irc );
    130         set_add( &irc->set, "debug", "false", set_eval_bool, irc );
    131         set_add( &irc->set, "default_target", "root", NULL, irc );
    132         set_add( &irc->set, "display_namechanges", "false", set_eval_bool, irc );
    133         set_add( &irc->set, "handle_unknown", "root", NULL, irc );
    134         set_add( &irc->set, "lcnicks", "true", set_eval_bool, irc );
    135         set_add( &irc->set, "ops", "both", set_eval_ops, irc );
    136         set_add( &irc->set, "password", NULL, passchange, irc );
    137         set_add( &irc->set, "private", "true", set_eval_bool, irc );
    138         set_add( &irc->set, "query_order", "lifo", NULL, irc );
    139         set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
    140         set_add( &irc->set, "strip_html", "true", NULL, irc );
    141         set_add( &irc->set, "to_char", ": ", set_eval_to_char, irc );
    142         set_add( &irc->set, "typing_notice", "false", set_eval_bool, irc );
     122        set_add( irc, "away_devoice", "true",  set_eval_away_devoice );
     123        set_add( irc, "auto_connect", "true", set_eval_bool );
     124        set_add( irc, "auto_reconnect", "false", set_eval_bool );
     125        set_add( irc, "auto_reconnect_delay", "300", set_eval_int );
     126        set_add( irc, "buddy_sendbuffer", "false", set_eval_bool );
     127        set_add( irc, "buddy_sendbuffer_delay", "200", set_eval_int );
     128        set_add( irc, "charset", "iso8859-1", set_eval_charset );
     129        set_add( irc, "debug", "false", set_eval_bool );
     130        set_add( irc, "default_target", "root", NULL );
     131        set_add( irc, "display_namechanges", "false", set_eval_bool );
     132        set_add( irc, "handle_unknown", "root", NULL );
     133        set_add( irc, "lcnicks", "true", set_eval_bool );
     134        set_add( irc, "ops", "both", set_eval_ops );
     135        set_add( irc, "private", "true", set_eval_bool );
     136        set_add( irc, "query_order", "lifo", NULL );
     137        set_add( irc, "save_on_quit", "true", set_eval_bool );
     138        set_add( irc, "strip_html", "true", NULL );
     139        set_add( irc, "to_char", ": ", set_eval_to_char );
     140        set_add( irc, "typing_notice", "false", set_eval_bool );
     141        set_add( irc, "password", NULL, passchange);
    143142       
    144143        conf_loaddefaults( irc );
     
    212211        log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
    213212       
    214         if( irc->status & USTATUS_IDENTIFIED && set_getint( &irc->set, "save_on_quit" ) )
     213        if( irc->status & USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) )
    215214                if( storage_save( irc, TRUE ) != STORAGE_OK )
    216215                        irc_usermsg( irc, "Error while saving settings!" );
     
    330329void irc_setpass (irc_t *irc, const char *pass)
    331330{
    332         g_free (irc->password);
     331        if (irc->password) g_free (irc->password);
    333332       
    334333        if (pass) {
    335334                irc->password = g_strdup (pass);
     335                irc_usermsg (irc, "Password successfully changed");
    336336        } else {
    337337                irc->password = NULL;
     
    364364                        }
    365365                       
    366                         if( ( cs = set_getstr( &irc->set, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     366                        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
    367367                        {
    368368                                conv[IRC_MAX_LINE] = 0;
     
    584584       
    585585        strip_newlines( line );
    586         if( ( cs = set_getstr( &irc->set, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     586        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
    587587        {
    588588                char conv[IRC_MAX_LINE+1];
     
    666666                        }
    667667                       
    668                         if( u->gc && !u->away && set_getbool( &irc->set, "away_devoice" ) )
     668                        if( u->gc && !u->away && set_getint( irc, "away_devoice" ) )
    669669                                strcat( namelist, "+" );
    670670                       
     
    676676        {
    677677                GList *l;
    678                 char *ops = set_getstr( &irc->set, "ops" );
     678                char *ops = set_getstr( irc, "ops" );
    679679               
    680680                /* root and the user aren't in the channel userlist but should
     
    924924{
    925925        char *nick, *s;
    926         char reason[128];
     926        char reason[64];
    927927       
    928928        if( u->gc && u->gc->flags & OPT_LOGGING_OUT )
    929929        {
    930                 if( u->gc->acc->server )
     930                if( u->gc->user->proto_opt[0][0] )
    931931                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
    932                                     u->gc->acc->server );
     932                                    u->gc->user->proto_opt[0] );
    933933                else if( ( s = strchr( u->gc->username, '@' ) ) )
    934934                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
     
    936936                else
    937937                        g_snprintf( reason, sizeof( reason ), "%s %s.%s", irc->myhost,
    938                                     u->gc->acc->prpl->name, irc->myhost );
     938                                    u->gc->prpl->name, irc->myhost );
    939939               
    940940                /* proto_opt might contain garbage after the : */
     
    10121012                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
    10131013                {
    1014                         if( u && u->gc && u->gc->acc->prpl->send_typing && strlen( s ) >= 10 )
     1014                        if( u && u->gc && u->gc->prpl->send_typing && strlen( s ) >= 10 )
    10151015                        {
    10161016                                time_t current_typing_notice = time( NULL );
     
    10181018                                if( current_typing_notice - u->last_typing_notice >= 5 )
    10191019                                {
    1020                                         u->gc->acc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
     1020                                        u->gc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
    10211021                                        u->last_typing_notice = current_typing_notice;
    10221022                                }
     
    10511051                }
    10521052        }
    1053         else if( c && c->gc && c->gc->acc && c->gc->acc->prpl )
     1053        else if( c && c->gc && c->gc->prpl )
    10541054        {
    10551055                return( bim_chat_msg( c->gc, c->id, s ) );
     
    10831083        if( !u || !u->gc ) return;
    10841084       
    1085         if( set_getint( &irc->set, "buddy_sendbuffer" ) && set_getint( &irc->set, "buddy_sendbuffer_delay" ) > 0 )
     1085        if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "buddy_sendbuffer_delay" ) > 0 )
    10861086        {
    10871087                int delay;
     
    11101110                strcat( u->sendbuf, "\n" );
    11111111               
    1112                 delay = set_getint( &irc->set, "buddy_sendbuffer_delay" );
     1112                delay = set_getint( irc, "buddy_sendbuffer_delay" );
    11131113                if( delay <= 5 )
    11141114                        delay *= 1000;
     
    11751175                int len = strlen( irc->nick) + 3;
    11761176                prefix = g_new (char, len );
    1177                 g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( &irc->set, "to_char" ) );
     1177                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( irc, "to_char" ) );
    11781178                prefix[len-1] = 0;
    11791179        }
  • irc_commands.c

    rfef6116 r3f9440d  
    150150                irc_part( irc, u, c->channel );
    151151               
    152                 if( c->gc )
     152                if( c->gc && c->gc->prpl )
    153153                {
    154154                        c->joined = 0;
    155                         c->gc->acc->prpl->chat_leave( c->gc, c->id );
     155                        c->gc->prpl->chat_leave( c->gc, c->id );
    156156                }
    157157        }
     
    173173                        user_t *u = user_find( irc, cmd[1] + 1 );
    174174                       
    175                         if( u && u->gc && u->gc->acc->prpl->chat_open )
     175                        if( u && u->gc && u->gc->prpl && u->gc->prpl->chat_open )
    176176                        {
    177177                                irc_reply( irc, 403, "%s :Initializing groupchat in a different channel", cmd[1] );
    178178                               
    179                                 if( !u->gc->acc->prpl->chat_open( u->gc, u->handle ) )
     179                                if( !u->gc->prpl->chat_open( u->gc, u->handle ) )
    180180                                {
    181181                                        irc_usermsg( irc, "Could not open a groupchat with %s.", u->nick );
     
    205205       
    206206        if( u && c && ( u->gc == c->gc ) )
    207                 if( c->gc && c->gc->acc->prpl->chat_invite )
    208                 {
    209                         c->gc->acc->prpl->chat_invite( c->gc, c->id, "", u->handle );
     207                if( c->gc && c->gc->prpl && c->gc->prpl->chat_invite )
     208                {
     209                        c->gc->prpl->chat_invite( c->gc, c->id, "", u->handle );
    210210                        irc_reply( irc, 341, "%s %s", nick, channel );
    211211                        return;
     
    230230                {
    231231                        unsigned int i;
    232                         char *t = set_getstr( &irc->set, "default_target" );
     232                        char *t = set_getstr( irc, "default_target" );
    233233                       
    234234                        if( g_strcasecmp( t, "last" ) == 0 && irc->last_target )
     
    477477               
    478478                if( u->gc )
    479                         irc_reply( irc, 312, "%s %s.%s :%s network", u->nick, u->gc->acc->user,
    480                                    *u->gc->acc->server ? u->gc->acc->server : "", u->gc->acc->prpl->name );
     479                        irc_reply( irc, 312, "%s %s.%s :%s network", u->nick, u->gc->user->username,
     480                                   *u->gc->user->proto_opt[0] ? u->gc->user->proto_opt[0] : "", u->gc->prpl->name );
    481481                else
    482482                        irc_reply( irc, 312, "%s %s :%s", u->nick, irc->myhost, IRCD_INFO );
  • nick.c

    rfef6116 r3f9440d  
    8686               
    8787                nick_strip( nick );
    88                 if( set_getint( &irc->set, "lcnicks" ) )
     88                if (set_getint(irc, "lcnicks"))
    8989                        nick_lc( nick );
    9090        }
  • protocols/Makefile

    rfef6116 r3f9440d  
    1010
    1111# [SH] Program variables
    12 objects = nogaim.o
     12objects = $(EVENT_HANDLER) http_client.o md5.o nogaim.o proxy.o sha.o $(SSL_CLIENT)
    1313
    1414# [SH] The next two lines should contain the directory name (in $(subdirs))
  • protocols/jabber/jabber.c

    rfef6116 r3f9440d  
    561561static void gjab_start(gjconn gjc)
    562562{
    563         account_t *acc;
     563        struct aim_user *user;
    564564        int port = -1, ssl = 0;
    565565        char *server = NULL, *s;
     
    568568                return;
    569569
    570         acc = GJ_GC(gjc)->acc;
    571         if (acc->server) {
     570        user = GJ_GC(gjc)->user;
     571        if (*user->proto_opt[0]) {
    572572                /* If there's a dot, assume there's a hostname in the beginning */
    573                 if (strchr(acc->server, '.')) {
    574                         server = g_strdup(acc->server);
     573                if (strchr(user->proto_opt[0], '.')) {
     574                        server = g_strdup(user->proto_opt[0]);
    575575                        if ((s = strchr(server, ':')))
    576576                                *s = 0;
     
    578578               
    579579                /* After the hostname, there can be a port number */
    580                 s = strchr(acc->server, ':');
     580                s = strchr(user->proto_opt[0], ':');
    581581                if (s && isdigit(s[1]))
    582582                        sscanf(s + 1, "%d", &port);
    583583               
    584584                /* And if there's the string ssl, the user wants an SSL-connection */
    585                 if (strstr(acc->server, ":ssl") || g_strcasecmp(acc->server, "ssl") == 0)
     585                if (strstr(user->proto_opt[0], ":ssl") || g_strcasecmp(user->proto_opt[0], "ssl") == 0)
    586586                        ssl = 1;
    587587        }
     
    616616        g_free(server);
    617617       
    618         if (!acc->gc || (gjc->fd < 0)) {
     618        if (!user->gc || (gjc->fd < 0)) {
    619619                STATE_EVT(JCONN_STATE_OFF)
    620620                return;
     
    15161516}
    15171517
    1518 static void jabber_login(account_t *acc)
    1519 {
    1520         struct gaim_connection *gc = new_gaim_conn(acc);
     1518static void jabber_login(struct aim_user *user)
     1519{
     1520        struct gaim_connection *gc = new_gaim_conn(user);
    15211521        struct jabber_data *jd = gc->proto_data = g_new0(struct jabber_data, 1);
    1522         char *loginname = create_valid_jid(acc->user, DEFAULT_SERVER, "BitlBee");
     1522        char *loginname = create_valid_jid(user->username, DEFAULT_SERVER, "BitlBee");
    15231523
    15241524        jd->hash = g_hash_table_new(g_str_hash, g_str_equal);
     
    15271527        set_login_progress(gc, 1, _("Connecting"));
    15281528
    1529         if (!(jd->gjc = gjab_new(loginname, acc->pass, gc))) {
     1529        if (!(jd->gjc = gjab_new(loginname, user->password, gc))) {
    15301530                g_free(loginname);
    15311531                hide_login_progress(gc, _("Unable to connect"));
  • protocols/msn/msn.c

    rfef6116 r3f9440d  
    2727#include "msn.h"
    2828
    29 static void msn_login( account_t *acc )
    30 {
    31         struct gaim_connection *gc = new_gaim_conn( acc );
     29static void msn_login( struct aim_user *acct )
     30{
     31        struct gaim_connection *gc = new_gaim_conn( acct );
    3232        struct msn_data *md = g_new0( struct msn_data, 1 );
    3333       
     
    3737        md->fd = -1;
    3838       
    39         if( strchr( acc->user, '@' ) == NULL )
     39        if( strchr( acct->username, '@' ) == NULL )
    4040        {
    4141                hide_login_progress( gc, "Invalid account name" );
  • protocols/nogaim.c

    rfef6116 r3f9440d  
    145145/* multi.c */
    146146
    147 struct gaim_connection *new_gaim_conn( account_t *acc )
     147struct gaim_connection *new_gaim_conn( struct aim_user *user )
    148148{
    149149        struct gaim_connection *gc;
     150        account_t *a;
    150151       
    151152        gc = g_new0( struct gaim_connection, 1 );
    152153       
    153         /* Maybe we should get rid of this memory waste later. ;-) */
    154         g_snprintf( gc->username, sizeof( gc->username ), "%s", acc->user );
    155         g_snprintf( gc->password, sizeof( gc->password ), "%s", acc->pass );
    156        
    157         gc->irc = acc->irc;
    158         gc->acc = acc;
    159         acc->gc = gc;
     154        gc->prpl = user->prpl;
     155        g_snprintf( gc->username, sizeof( gc->username ), "%s", user->username );
     156        g_snprintf( gc->password, sizeof( gc->password ), "%s", user->password );
     157        /* [MD] BUGFIX: don't set gc->irc to the global IRC, but use the one from the struct aim_user.
     158         * This fixes daemon mode breakage where IRC doesn't point to the currently active connection.
     159         */
     160        gc->irc = user->irc;
    160161       
    161162        connections = g_slist_append( connections, gc );
     163       
     164        user->gc = gc;
     165        gc->user = user;
     166       
     167        // Find the account_t so we can set its gc pointer
     168        for( a = gc->irc->accounts; a; a = a->next )
     169                if( ( struct aim_user * ) a->gc == user )
     170                {
     171                        a->gc = gc;
     172                        break;
     173                }
    162174       
    163175        return( gc );
     
    177189       
    178190        connections = g_slist_remove( connections, gc );
     191        g_free( gc->user );
    179192        g_free( gc );
    180193}
     
    207220        va_end( params );
    208221
    209         if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
    210             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( &gc->irc->set, "strip_html" ) ) )
     222        if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
     223            ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
    211224                strip_html( text );
    212225       
    213226        /* Try to find a different connection on the same protocol. */
    214227        for( a = gc->irc->accounts; a; a = a->next )
    215                 if( a->prpl == gc->acc->prpl && a->gc != gc )
     228                if( a->prpl == gc->prpl && a->gc != gc )
    216229                        break;
    217230       
    218231        /* If we found one, include the screenname in the message. */
    219232        if( a )
    220                 irc_usermsg( gc->irc, "%s(%s) - %s", gc->acc->prpl->name, gc->username, text );
     233                irc_usermsg( gc->irc, "%s(%s) - %s", gc->prpl->name, gc->username, text );
    221234        else
    222                 irc_usermsg( gc->irc, "%s - %s", gc->acc->prpl->name, text );
     235                irc_usermsg( gc->irc, "%s - %s", gc->prpl->name, text );
    223236       
    224237        g_free( text );
     
    229242        struct gaim_connection *gc = d;
    230243       
    231         if( gc->acc->prpl->keepalive )
    232                 gc->acc->prpl->keepalive( gc );
     244        if( gc->prpl && gc->prpl->keepalive )
     245                gc->prpl->keepalive( gc );
    233246       
    234247        return TRUE;
     
    284297        b_event_remove( gc->keepalive );
    285298        gc->flags |= OPT_LOGGING_OUT;
    286        
    287299        gc->keepalive = 0;
    288         gc->acc->prpl->close( gc );
     300        gc->prpl->close( gc );
    289301        b_event_remove( gc->inpa );
    290302       
     
    311323                /* Uhm... This is very sick. */
    312324        }
    313         else if( !gc->wants_to_die && set_getint( &irc->set, "auto_reconnect" ) )
    314         {
    315                 int delay = set_getint( &irc->set, "auto_reconnect_delay" );
     325        else if( !gc->wants_to_die && set_getint( irc, "auto_reconnect" ) )
     326        {
     327                int delay = set_getint( irc, "auto_reconnect_delay" );
    316328               
    317329                serv_got_crap( gc, "Reconnecting in %d seconds..", delay );
     
    352364        irc_t *irc = gc->irc;
    353365       
    354         if( set_getint( &irc->set, "debug" ) && 0 ) /* This message is too useless */
     366        if( set_getint( irc, "debug" ) && 0 ) /* This message is too useless */
    355367                serv_got_crap( gc, "Receiving user add from handle: %s", handle );
    356368       
    357369        if( user_findhandle( gc, handle ) )
    358370        {
    359                 if( set_getint( &irc->set, "debug" ) )
     371                if( set_getint( irc, "debug" ) )
    360372                        serv_got_crap( gc, "User already exists, ignoring add request: %s", handle );
    361373               
     
    366378       
    367379        memset( nick, 0, MAX_NICK_LENGTH + 1 );
    368         strcpy( nick, nick_get( gc->irc, handle, gc->acc->prpl, realname ) );
     380        strcpy( nick, nick_get( gc->irc, handle, gc->prpl, realname ) );
    369381       
    370382        u = user_add( gc->irc, nick );
     
    378390                u->user = g_strndup( handle, s - handle );
    379391        }
    380         else if( *gc->acc->server )
     392        else if( gc->user->proto_opt[0] && *gc->user->proto_opt[0] )
    381393        {
    382394                char *colon;
    383395               
    384                 if( ( colon = strchr( gc->acc->server, ':' ) ) )
    385                         u->host = g_strndup( gc->acc->server,
    386                                              colon - gc->acc->server );
     396                if( ( colon = strchr( gc->user->proto_opt[0], ':' ) ) )
     397                        u->host = g_strndup( gc->user->proto_opt[0],
     398                                             colon - gc->user->proto_opt[0] );
    387399                else
    388                         u->host = g_strdup( gc->acc->server );
     400                        u->host = g_strdup( gc->user->proto_opt[0] );
    389401               
    390402                u->user = g_strdup( handle );
     
    397409        else
    398410        {
    399                 u->host = g_strdup( gc->acc->prpl->name );
     411                u->host = g_strdup( gc->user->prpl->name );
    400412                u->user = g_strdup( handle );
    401413        }
     
    445457                u->realname = g_strdup( realname );
    446458               
    447                 if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( &gc->irc->set, "display_namechanges" ) )
     459                if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( gc->irc, "display_namechanges" ) )
    448460                        serv_got_crap( gc, "User `%s' changed name to `%s'", u->nick, u->realname );
    449461        }
     
    467479void show_got_added_yes( gpointer w, struct show_got_added_data *data )
    468480{
    469         data->gc->acc->prpl->add_buddy( data->gc, data->handle );
     481        data->gc->prpl->add_buddy( data->gc, data->handle );
    470482        add_buddy( data->gc, NULL, data->handle, data->handle );
    471483       
     
    501513        if( !u )
    502514        {
    503                 if( g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "add" ) == 0 )
     515                if( g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "add" ) == 0 )
    504516                {
    505517                        add_buddy( gc, NULL, handle, NULL );
     
    508520                else
    509521                {
    510                         if( set_getint( &gc->irc->set, "debug" ) || g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "ignore" ) != 0 )
     522                        if( set_getint( gc->irc, "debug" ) || g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "ignore" ) != 0 )
    511523                        {
    512524                                serv_got_crap( gc, "serv_got_update() for handle %s:", handle );
     
    546558        }
    547559       
    548         if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "oscar" ) == 0 || strcmp( gc->acc->prpl->name, "icq" ) == 0 ) )
     560        if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "oscar") || !strcmp(gc->prpl->name, "icq")) )
    549561        {
    550562                u->away = g_strdup( "Away" );
    551563        }
    552         else if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "jabber" ) == 0 ) )
     564        else if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "jabber") ) )
    553565        {
    554566                if( type & UC_DND )
     
    559571                        u->away = g_strdup( "Away" );
    560572        }
    561         else if( ( type & UC_UNAVAILABLE ) && gc->acc->prpl->get_status_string )
    562         {
    563                 u->away = g_strdup( gc->acc->prpl->get_status_string( gc, type ) );
     573        else if( ( type & UC_UNAVAILABLE ) && gc->prpl->get_status_string )
     574        {
     575                u->away = g_strdup( gc->prpl->get_status_string( gc, type ) );
    564576        }
    565577        else
     
    567579       
    568580        /* LISPy... */
    569         if( ( set_getint( &gc->irc->set, "away_devoice" ) ) &&          /* Don't do a thing when user doesn't want it */
     581        if( ( set_getint( gc->irc, "away_devoice" ) ) &&                /* Don't do a thing when user doesn't want it */
    570582            ( u->online ) &&                                            /* Don't touch offline people */
    571583            ( ( ( u->online != oo ) && !u->away ) ||                    /* Voice joining people */
     
    586598        if( !u )
    587599        {
    588                 char *h = set_getstr( &irc->set, "handle_unknown" );
     600                char *h = set_getstr( irc, "handle_unknown" );
    589601               
    590602                if( g_strcasecmp( h, "ignore" ) == 0 )
    591603                {
    592                         if( set_getint( &irc->set, "debug" ) )
     604                        if( set_getint( irc, "debug" ) )
    593605                                serv_got_crap( gc, "Ignoring message from unknown handle %s", handle );
    594606                       
     
    597609                else if( g_strncasecmp( h, "add", 3 ) == 0 )
    598610                {
    599                         int private = set_getint( &irc->set, "private" );
     611                        int private = set_getint( irc, "private" );
    600612                       
    601613                        if( h[3] )
     
    618630        }
    619631       
    620         if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
    621             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( &gc->irc->set, "strip_html" ) ) )
     632        if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
     633            ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
    622634                strip_html( msg );
    623635
     
    659671        user_t *u;
    660672       
    661         if( !set_getint( &gc->irc->set, "typing_notice" ) )
     673        if( !set_getint( gc->irc, "typing_notice" ) )
    662674                return;
    663675       
     
    681693        GList *ir;
    682694       
    683         if( set_getint( &gc->irc->set, "debug" ) )
     695        if( set_getint( gc->irc, "debug" ) )
    684696                serv_got_crap( gc, "You were removed from conversation %d", (int) id );
    685697       
     
    720732       
    721733        /* Gaim sends own messages through this too. IRC doesn't want this, so kill them */
    722         if( g_strcasecmp( who, gc->username ) == 0 )
     734        if( g_strcasecmp( who, gc->user->username ) == 0 )
    723735                return;
    724736       
     
    726738        for( c = gc->conversations; c && c->id != id; c = c->next );
    727739       
    728         if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
    729             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( &gc->irc->set, "strip_html" ) ) )
     740        if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
     741            ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
    730742                strip_html( msg );
    731743       
     
    760772        g_free( s );
    761773       
    762         if( set_getint( &gc->irc->set, "debug" ) )
     774        if( set_getint( gc->irc, "debug" ) )
    763775                serv_got_crap( gc, "Creating new conversation: (id=%d,handle=%s)", id, handle );
    764776       
     
    774786        int me = 0;
    775787       
    776         if( set_getint( &b->gc->irc->set, "debug" ) )
     788        if( set_getint( b->gc->irc, "debug" ) )
    777789                serv_got_crap( b->gc, "User %s added to conversation %d", handle, b->id );
    778790       
    779791        /* It might be yourself! */
    780         if( b->gc->acc->prpl->cmp_buddynames( handle, b->gc->username ) == 0 )
     792        if( b->gc->prpl->cmp_buddynames( handle, b->gc->user->username ) == 0 )
    781793        {
    782794                u = user_find( b->gc->irc, b->gc->irc->nick );
     
    808820        int me = 0;
    809821       
    810         if( set_getint( &b->gc->irc->set, "debug" ) )
     822        if( set_getint( b->gc->irc, "debug" ) )
    811823                serv_got_crap( b->gc, "User %s removed from conversation %d (%s)", handle, b->id, reason ? reason : "" );
    812824       
    813825        /* It might be yourself! */
    814         if( g_strcasecmp( handle, b->gc->username ) == 0 )
     826        if( g_strcasecmp( handle, b->gc->user->username ) == 0 )
    815827        {
    816828                u = user_find( b->gc->irc, b->gc->irc->nick );
     
    870882}
    871883
    872 char *set_eval_away_devoice( set_t *set, char *value )
    873 {
    874         irc_t *irc = set->data;
     884char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value )
     885{
    875886        int st;
    876887       
     
    886897        /* Horror.... */
    887898       
    888         if( st != set_getint( &irc->set, "away_devoice" ) )
     899        if( st != set_getint( irc, "away_devoice" ) )
    889900        {
    890901                char list[80] = "";
     
    926937        }
    927938       
    928         return( set_eval_bool( set, value ) );
     939        return( set_eval_bool( irc, set, value ) );
    929940}
    930941
     
    946957        }
    947958       
    948         st = gc->acc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
     959        st = gc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
    949960        g_free( buf );
    950961       
     
    963974        }
    964975       
    965         st = gc->acc->prpl->chat_send( gc, id, msg );
     976        st = gc->prpl->chat_send( gc, id, msg );
    966977        g_free( buf );
    967978       
     
    977988       
    978989        if( !away ) away = "";
    979         ms = m = gc->acc->prpl->away_states( gc );
     990        ms = m = gc->prpl->away_states( gc );
    980991       
    981992        while( m )
     
    9981009        if( m )
    9991010        {
    1000                 gc->acc->prpl->set_away( gc, m->data, *away ? away : NULL );
     1011                gc->prpl->set_away( gc, m->data, *away ? away : NULL );
    10011012        }
    10021013        else
     
    10051016                if( s )
    10061017                {
    1007                         gc->acc->prpl->set_away( gc, s, away );
    1008                         if( set_getint( &gc->irc->set, "debug" ) )
     1018                        gc->prpl->set_away( gc, s, away );
     1019                        if( set_getint( gc->irc, "debug" ) )
    10091020                                serv_got_crap( gc, "Setting away state to %s", s );
    10101021                }
    10111022                else
    1012                         gc->acc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
     1023                        gc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
    10131024        }
    10141025       
     
    10621073void bim_add_allow( struct gaim_connection *gc, char *handle )
    10631074{
    1064         if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->cmp_buddynames ) == NULL )
     1075        if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
    10651076        {
    10661077                gc->permit = g_slist_prepend( gc->permit, g_strdup( handle ) );
    10671078        }
    10681079       
    1069         gc->acc->prpl->add_permit( gc, handle );
     1080        gc->prpl->add_permit( gc, handle );
    10701081}
    10711082
     
    10741085        GSList *l;
    10751086       
    1076         if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->cmp_buddynames ) ) )
     1087        if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
    10771088        {
    10781089                g_free( l->data );
     
    10801091        }
    10811092       
    1082         gc->acc->prpl->rem_permit( gc, handle );
     1093        gc->prpl->rem_permit( gc, handle );
    10831094}
    10841095
    10851096void bim_add_block( struct gaim_connection *gc, char *handle )
    10861097{
    1087         if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->cmp_buddynames ) == NULL )
     1098        if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
    10881099        {
    10891100                gc->deny = g_slist_prepend( gc->deny, g_strdup( handle ) );
    10901101        }
    10911102       
    1092         gc->acc->prpl->add_deny( gc, handle );
     1103        gc->prpl->add_deny( gc, handle );
    10931104}
    10941105
     
    10971108        GSList *l;
    10981109       
    1099         if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->cmp_buddynames ) ) )
     1110        if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
    11001111        {
    11011112                g_free( l->data );
     
    11031114        }
    11041115       
    1105         gc->acc->prpl->rem_deny( gc, handle );
    1106 }
     1116        gc->prpl->rem_deny( gc, handle );
     1117}
  • protocols/nogaim.h

    rfef6116 r3f9440d  
    3939
    4040#include "bitlbee.h"
    41 #include "account.h"
    4241#include "proxy.h"
    4342#include "md5.h"
     
    6463struct gaim_connection
    6564{
    66         account_t *acc;
     65        struct prpl *prpl;
    6766        guint32 flags;
    6867       
     
    7978        GSList *deny;
    8079        int permdeny;
     80       
     81        struct aim_user *user;
    8182       
    8283        char username[64];
     
    125126};
    126127
     128struct aim_user {
     129        char username[64];
     130        char alias[SELF_ALIAS_LEN];
     131        char password[32];
     132        char user_info[2048];
     133        int options;
     134        struct prpl *prpl;
     135        /* prpls can use this to save information about the user,
     136         * like which server to connect to, etc */
     137        char proto_opt[7][256];
     138
     139        struct gaim_connection *gc;
     140        irc_t *irc;
     141};
     142
    127143struct prpl {
    128144        int options;
    129145        const char *name;
    130146
    131         void (* login)          (account_t *);
     147        void (* login)          (struct aim_user *);
    132148        void (* keepalive)      (struct gaim_connection *);
    133149        void (* close)          (struct gaim_connection *);
     
    190206
    191207void nogaim_init();
    192 char *set_eval_away_devoice( set_t *set, char *value );
     208char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value );
    193209
    194210gboolean auto_reconnect( gpointer data, gint fd, b_input_condition cond );
     
    196212
    197213/* multi.c */
    198 G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( account_t *acc );
     214G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( struct aim_user *user );
    199215G_MODULE_EXPORT void destroy_gaim_conn( struct gaim_connection *gc );
    200216G_MODULE_EXPORT void set_login_progress( struct gaim_connection *gc, int step, char *msg );
  • protocols/oscar/oscar.c

    rfef6116 r3f9440d  
    356356}
    357357
    358 static void oscar_login(account_t *acc) {
     358static void oscar_login(struct aim_user *user) {
    359359        aim_session_t *sess;
    360360        aim_conn_t *conn;
    361361        char buf[256];
    362         struct gaim_connection *gc = new_gaim_conn(acc);
     362        struct gaim_connection *gc = new_gaim_conn(user);
    363363        struct oscar_data *odata = gc->proto_data = g_new0(struct oscar_data, 1);
    364364
    365         if (isdigit(acc->user[0])) {
     365        if (isdigit(*user->username)) {
    366366                odata->icq = TRUE;
    367367                /* This is odd but it's necessary for a proper do_import and do_export.
    368368                   We don't do those anymore, but let's stick with it, just in case
    369                    it accidentally fixes something else too... </bitlbee> */
     369                   it accidentally fixes something else too... */
    370370                gc->password[8] = 0;
    371371        } else {
     
    390390        }
    391391       
    392         if (g_strcasecmp(acc->server, "login.icq.com") != 0 &&
    393             g_strcasecmp(acc->server, "login.oscar.aol.com") != 0) {
    394                 serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",acc->server);
     392        if (g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.icq.com") != 0 &&
     393            g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.oscar.aol.com") != 0) {
     394                serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",user->proto_opt[USEROPT_AUTH]);
    395395        }
    396396       
     
    402402
    403403        conn->status |= AIM_CONN_STATUS_INPROGRESS;
    404         conn->fd = proxy_connect(acc->server, AIM_LOGIN_PORT, oscar_login_connect, gc);
     404        conn->fd = proxy_connect(user->proto_opt[USEROPT_AUTH][0] ?
     405                                        user->proto_opt[USEROPT_AUTH] : AIM_DEFAULT_LOGIN_SERVER,
     406                                 user->proto_opt[USEROPT_AUTHPORT][0] ?
     407                                        atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
     408                                 oscar_login_connect, gc);
    405409        if (conn->fd < 0) {
    406410                hide_login_progress(gc, _("Couldn't connect to host"));
     
    481485        struct aim_authresp_info *info;
    482486        int i; char *host; int port;
     487        struct aim_user *user;
    483488        aim_conn_t *bosconn;
    484489
    485490        struct gaim_connection *gc = sess->aux_data;
    486491        struct oscar_data *od = gc->proto_data;
    487         port = AIM_LOGIN_PORT;
     492        user = gc->user;
     493        port = user->proto_opt[USEROPT_AUTHPORT][0] ?
     494                atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
    488495
    489496        va_start(ap, fr);
     
    864871        struct aim_redirect_data *redir;
    865872        struct gaim_connection *gc = sess->aux_data;
     873        struct aim_user *user = gc->user;
    866874        aim_conn_t *tstconn;
    867875        int i;
     
    869877        int port;
    870878
     879        port = user->proto_opt[USEROPT_AUTHPORT][0] ?
     880                atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
     881
    871882        va_start(ap, fr);
    872883        redir = va_arg(ap, struct aim_redirect_data *);
    873884        va_end(ap);
    874885
    875         port = AIM_LOGIN_PORT;
    876886        for (i = 0; i < (int)strlen(redir->ip); i++) {
    877887                if (redir->ip[i] == ':') {
     
    17131723        odata->rights.maxsiglen = odata->rights.maxawaymsglen = (guint)maxsiglen;
    17141724
    1715         /* FIXME: It seems we're not really using this, and it broke now that
    1716            struct aim_user is dead.
    17171725        aim_bos_setprofile(sess, fr->conn, gc->user->user_info, NULL, gaim_caps);
    1718         */
    1719        
     1726
    17201727        return 1;
    17211728}
  • protocols/yahoo/libyahoo2.c

    rfef6116 r3f9440d  
    8989#define vsnprintf _vsnprintf
    9090#endif
    91 
    92 #include "base64.h"
    9391
    9492#ifdef USE_STRUCT_CALLBACKS
     
    697695}
    698696
     697static char base64digits[] =    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     698                                "abcdefghijklmnopqrstuvwxyz"
     699                                "0123456789._";
     700static void to_y64(unsigned char *out, const unsigned char *in, int inlen)
    699701/* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
    700 static void to_y64(unsigned char *out, const unsigned char *in, int inlen)
    701 {
    702         base64_encode_real(in, inlen, out, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
     702{
     703        for (; inlen >= 3; inlen -= 3)
     704                {
     705                        *out++ = base64digits[in[0] >> 2];
     706                        *out++ = base64digits[((in[0]<<4) & 0x30) | (in[1]>>4)];
     707                        *out++ = base64digits[((in[1]<<2) & 0x3c) | (in[2]>>6)];
     708                        *out++ = base64digits[in[2] & 0x3f];
     709                        in += 3;
     710                }
     711        if (inlen > 0)
     712                {
     713                        unsigned char fragment;
     714
     715                        *out++ = base64digits[in[0] >> 2];
     716                        fragment = (in[0] << 4) & 0x30;
     717                        if (inlen > 1)
     718                                fragment |= in[1] >> 4;
     719                        *out++ = base64digits[fragment];
     720                        *out++ = (inlen < 2) ? '-'
     721                                        : base64digits[(in[1] << 2) & 0x3c];
     722                        *out++ = '-';
     723                }
     724        *out = '\0';
    703725}
    704726
  • protocols/yahoo/yahoo.c

    rfef6116 r3f9440d  
    121121}
    122122
    123 static void byahoo_login( account_t *acc )
    124 {
    125         struct gaim_connection *gc = new_gaim_conn( acc );
     123static void byahoo_login( struct aim_user *user )
     124{
     125        struct gaim_connection *gc = new_gaim_conn( user );
    126126        struct byahoo_data *yd = gc->proto_data = g_new0( struct byahoo_data, 1 );
    127127       
     
    130130       
    131131        set_login_progress( gc, 1, "Connecting" );
    132         yd->y2_id = yahoo_init( acc->user, acc->pass );
     132        yd->y2_id = yahoo_init( user->username, user->password );
    133133        yahoo_login( yd->y2_id, yd->current_status );
    134134}
     
    425425                yd = gc->proto_data;
    426426               
    427                 if( strcmp( gc->acc->prpl->name, "yahoo" ) == 0 && yd->y2_id == id )
     427                if( !strcmp(gc->prpl->name, "yahoo") && yd->y2_id == id )
    428428                        return( gc );
    429429        }
  • query.c

    rfef6116 r3f9440d  
    6363        }
    6464       
    65         if( g_strcasecmp( set_getstr( &irc->set, "query_order" ), "lifo" ) == 0 || irc->queries == q )
     65        if( g_strcasecmp( set_getstr( irc, "query_order" ), "lifo" ) == 0 || irc->queries == q )
    6666                query_display( irc, q );
    6767       
     
    172172        query_t *q;
    173173       
    174         if( g_strcasecmp( set_getstr( &irc->set, "query_order" ), "fifo" ) == 0 )
     174        if( g_strcasecmp( set_getstr( irc, "query_order" ), "fifo" ) == 0 )
    175175                q = irc->queries;
    176176        else
  • root_commands.c

    rfef6116 r3f9440d  
    127127}
    128128
    129 static void cmd_account( irc_t *irc, char **cmd );
    130 
    131129static void cmd_identify( irc_t *irc, char **cmd )
    132130{
    133131        storage_status_t status = storage_load( irc->nick, cmd[1], irc );
    134         char *account_on[] = { "account", "on", NULL };
    135132       
    136133        switch (status) {
     
    142139                break;
    143140        case STORAGE_OK:
    144                 irc_usermsg( irc, "Password accepted, settings and accounts loaded" );
     141                irc_usermsg( irc, "Password accepted" );
    145142                irc_umode_set( irc, "+R", 1 );
    146                 if( set_getint( &irc->set, "auto_connect" ) )
    147                         cmd_account( irc, account_on );
    148143                break;
    149         case STORAGE_OTHER_ERROR:
    150144        default:
    151                 irc_usermsg( irc, "Unknown error while loading configuration" );
     145                irc_usermsg( irc, "Something very weird happened" );
    152146                break;
    153147        }
     
    232226
    233227                a = account_add( irc, prpl, cmd[3], cmd[4] );
     228               
    234229                if( cmd[5] )
    235                         set_setstr( &a->set, "server", cmd[5] );
     230                        a->server = g_strdup( cmd[5] );
    236231               
    237232                irc_usermsg( irc, "Account successfully added" );
     
    311306                       
    312307                                for( a = irc->accounts; a; a = a->next )
    313                                         if( !a->gc && a->auto_connect )
     308                                        if( !a->gc )
    314309                                                account_on( irc, a );
    315310                        }
     
    357352                }
    358353        }
    359         else if( g_strcasecmp( cmd[1], "set" ) == 0 )
    360         {
    361                 char *acc_handle, *set_name = NULL, *tmp;
    362                
    363                 if( !cmd[2] )
    364                 {
    365                         irc_usermsg( irc, "Not enough parameters given (need %d)", 2 );
    366                         return;
    367                 }
    368                
    369                 acc_handle = g_strdup( cmd[2] );
    370                 if( ( tmp = strchr( acc_handle, '/' ) ) )
    371                 {
    372                         *tmp = 0;
    373                         set_name = tmp + 1;
    374                 }
    375                 a = account_get( irc, acc_handle );
    376                
    377                 if( a == NULL )
    378                 {
    379                         irc_usermsg( irc, "Invalid account" );
    380                         return;
    381                 }
    382                
    383                 if( cmd[3] )
    384                 {
    385                         set_t *s = set_find( &a->set, set_name );
    386                        
    387                         if( a->gc && s && s->flags & ACC_SET_OFFLINE_ONLY )
    388                         {
    389                                 irc_usermsg( irc, "This setting can only be changed when the account is off-line" );
    390                                 return;
    391                         }
    392                        
    393                         set_setstr( &a->set, set_name, cmd[3] );
    394                        
    395                         if( ( strcmp( cmd[3], "=" ) ) == 0 && cmd[4] )
    396                                 irc_usermsg( irc, "Warning: Correct syntax: \002account set <variable> <value>\002 (without =)" );
    397                 }
    398                 if( set_name ) /* else 'forgotten' on purpose.. Must show new value after changing */
    399                 {
    400                         char *s = set_getstr( &a->set, set_name );
    401                         if( s )
    402                                 irc_usermsg( irc, "%s = `%s'", set_name, s );
    403                         else
    404                                 irc_usermsg( irc, "%s is empty", set_name );
    405                 }
    406                 else
    407                 {
    408                         set_t *s = a->set;
    409                         while( s )
    410                         {
    411                                 if( s->value || s->def )
    412                                         irc_usermsg( irc, "%s = `%s'", s->key, s->value?s->value:s->def );
    413                                 else
    414                                         irc_usermsg( irc, "%s is empty", s->key );
    415                                 s = s->next;
    416                         }
    417                 }
    418                
    419                 g_free( acc_handle );
    420         }
    421354        else
    422355        {
     
    461394                else
    462395                {
    463                         nick_set( irc, cmd[2], a->gc->acc->prpl, cmd[3] );
     396                        nick_set( irc, cmd[2], a->gc->prpl, cmd[3] );
    464397                }
    465398        }
     
    468401           add them to your *real* (server-side) contact list. */
    469402        if( add_for_real )
    470                 a->gc->acc->prpl->add_buddy( a->gc, cmd[2] );
     403                a->gc->prpl->add_buddy( a->gc, cmd[2] );
    471404               
    472405        add_buddy( a->gc, NULL, cmd[2], cmd[2] );
     
    502435        }
    503436       
    504         if( !gc->acc->prpl->get_info )
     437        if( !gc->prpl->get_info )
    505438        {
    506439                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
     
    508441        else
    509442        {
    510                 gc->acc->prpl->get_info( gc, cmd[2] );
     443                gc->prpl->get_info( gc, cmd[2] );
    511444        }
    512445}
     
    543476                else if( u->send_handler == buddy_send_handler )
    544477                {
    545                         nick_set( irc, u->handle, u->gc->acc->prpl, cmd[2] );
     478                        nick_set( irc, u->handle, u->gc->prpl, cmd[2] );
    546479                }
    547480               
     
    562495        s = g_strdup( u->handle );
    563496       
    564         u->gc->acc->prpl->remove_buddy( u->gc, u->handle, NULL );
     497        u->gc->prpl->remove_buddy( u->gc, u->handle, NULL );
    565498        user_del( irc, cmd[1] );
    566499        nick_del( irc, cmd[1] );
     
    619552        }
    620553       
    621         if( !gc->acc->prpl->add_deny || !gc->acc->prpl->rem_permit )
     554        if( !gc->prpl->add_deny || !gc->prpl->rem_permit )
    622555        {
    623556                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
     
    678611        }
    679612       
    680         if( !gc->acc->prpl->rem_deny || !gc->acc->prpl->add_permit )
     613        if( !gc->prpl->rem_deny || !gc->prpl->add_permit )
    681614        {
    682615                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
     
    733666        if( cmd[1] && cmd[2] )
    734667        {
    735                 set_setstr( &irc->set, cmd[1], cmd[2] );
     668                set_setstr( irc, cmd[1], cmd[2] );
    736669               
    737670                if( ( strcmp( cmd[2], "=" ) ) == 0 && cmd[3] )
     
    740673        if( cmd[1] ) /* else 'forgotten' on purpose.. Must show new value after changing */
    741674        {
    742                 char *s = set_getstr( &irc->set, cmd[1] );
     675                char *s = set_getstr( irc, cmd[1] );
    743676                if( s )
    744677                        irc_usermsg( irc, "%s = `%s'", cmd[1], s );
    745                 else
    746                         irc_usermsg( irc, "%s is empty", cmd[1] );
    747678        }
    748679        else
     
    753684                        if( s->value || s->def )
    754685                                irc_usermsg( irc, "%s = `%s'", s->key, s->value?s->value:s->def );
    755                         else
    756                                 irc_usermsg( irc, "%s is empty", s->key );
    757686                        s = s->next;
    758687                }
     
    798727                if( online == 1 )
    799728                {
    800                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
     729                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    801730                        irc_usermsg( irc, format, u->nick, s, "Online" );
    802731                }
     
    809738                if( away == 1 )
    810739                {
    811                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
     740                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    812741                        irc_usermsg( irc, format, u->nick, s, u->away );
    813742                }
     
    819748                if( offline == 1 )
    820749                {
    821                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
     750                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    822751                        irc_usermsg( irc, format, u->nick, s, "Offline" );
    823752                }
     
    844773                irc_usermsg( irc, "Your name is `%s'" , a->gc->displayname ? a->gc->displayname : "NULL" );
    845774        }
    846         else if ( !a->prpl->set_info )
     775        else if ( !a->gc->prpl->set_info )
    847776        {
    848777                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
     
    852781                irc_usermsg( irc, "Setting your name to `%s'", cmd[2] );
    853782               
    854                 a->prpl->set_info( a->gc, cmd[2] );
     783                a->gc->prpl->set_info( a->gc, cmd[2] );
    855784        }
    856785}
     
    871800        for( num = 0; q; q = q->next, num ++ )
    872801                if( q->gc ) /* Not necessary yet, but it might come later */
    873                         irc_usermsg( irc, "%d, %s(%s): %s", num, q->gc->acc->prpl->name, q->gc->username, q->question );
     802                        irc_usermsg( irc, "%d, %s(%s): %s", num, q->gc->prpl->name, q->gc->username, q->question );
    874803                else
    875804                        irc_usermsg( irc, "%d, BitlBee: %s", num, q->question );
     
    899828                        user_t *u;
    900829                       
    901                         /* FIXME: Hmmm, this is actually pretty dangerous code... REMOVEME? :-) */
    902830                        for( u = irc->users; u; u = u->next )
    903831                                if( u->gc == gc )
    904832                                {
    905                                         u->gc->acc->prpl->remove_buddy( u->gc, u->handle, NULL );
     833                                        u->gc->prpl->remove_buddy( u->gc, u->handle, NULL );
    906834                                        user_del( irc, u->nick );
    907835                                }
     
    918846        for( n = gc->irc->nicks; n; n = n->next )
    919847        {
    920                 if( n->proto == gc->acc->prpl && !user_findhandle( gc, n->handle ) )
    921                 {
    922                         gc->acc->prpl->add_buddy( gc, n->handle );
     848                if( n->proto == gc->prpl && !user_findhandle( gc, n->handle ) )
     849                {
     850                        gc->prpl->add_buddy( gc, n->handle );
    923851                        add_buddy( gc, NULL, n->handle, NULL );
    924852                }
  • set.c

    rfef6116 r3f9440d  
    2626#include "bitlbee.h"
    2727
    28 set_t *set_add( set_t **head, char *key, char *def, void *eval, void *data )
    29 {
    30         set_t *s = set_find( head, key );
    31        
    32         /* Possibly the setting already exists. If it doesn't exist yet,
    33            we create it. If it does, we'll just change the default. */
     28set_t *set_add( irc_t *irc, char *key, char *def, void *eval )
     29{
     30        set_t *s = set_find( irc, key );
     31       
    3432        if( !s )
    3533        {
    36                 if( ( s = *head ) )
     34                if( ( s = irc->set ) )
    3735                {
    3836                        while( s->next ) s = s->next;
    39                         s->next = g_new0( set_t, 1 );
     37                        s->next = g_new ( set_t, 1 );
    4038                        s = s->next;
    4139                }
    4240                else
    4341                {
    44                         s = *head = g_new0( set_t, 1 );
     42                        s = irc->set = g_new( set_t, 1 );
    4543                }
     44                memset( s, 0, sizeof( set_t ) );
    4645                s->key = g_strdup( key );
    4746        }
     
    5453        if( def ) s->def = g_strdup( def );
    5554       
    56         s->eval = eval;
    57         s->data = data;
    58        
    59         return s;
    60 }
    61 
    62 set_t *set_find( set_t **head, char *key )
    63 {
    64         set_t *s = *head;
     55        if( s->eval )
     56        {
     57                g_free( s->eval );
     58                s->eval = NULL;
     59        }
     60        if( eval ) s->eval = eval;
     61       
     62        return( s );
     63}
     64
     65set_t *set_find( irc_t *irc, char *key )
     66{
     67        set_t *s = irc->set;
    6568       
    6669        while( s )
     
    7174        }
    7275       
    73         return s;
    74 }
    75 
    76 char *set_getstr( set_t **head, char *key )
    77 {
    78         set_t *s = set_find( head, key );
     76        return( s );
     77}
     78
     79char *set_getstr( irc_t *irc, char *key )
     80{
     81        set_t *s = set_find( irc, key );
    7982       
    8083        if( !s || ( !s->value && !s->def ) )
    81                 return NULL;
    82        
    83         return s->value ? s->value : s->def;
    84 }
    85 
    86 int set_getint( set_t **head, char *key )
    87 {
    88         char *s = set_getstr( head, key );
     84                return( NULL );
     85       
     86        return( s->value?s->value:s->def );
     87}
     88
     89int set_getint( irc_t *irc, char *key )
     90{
     91        char *s = set_getstr( irc, key );
    8992        int i = 0;
    9093       
    9194        if( !s )
    92                 return 0;
     95                return( 0 );
    9396       
    9497        if( ( g_strcasecmp( s, "true" ) == 0 ) || ( g_strcasecmp( s, "yes" ) == 0 ) || ( g_strcasecmp( s, "on" ) == 0 ) )
    95                 return 1;
     98                return( 1 );
    9699       
    97100        if( sscanf( s, "%d", &i ) != 1 )
    98                 return 0;
    99        
    100         return i;
    101 }
    102 
    103 int set_getbool( set_t **head, char *key )
    104 {
    105         char *s = set_getstr( head, key );
     101                return( 0 );
     102       
     103        return( i );
     104}
     105
     106int set_setstr( irc_t *irc, char *key, char *value )
     107{
     108        set_t *s = set_find( irc, key );
     109        char *nv = value;
    106110       
    107111        if( !s )
    108                 return 0;
    109        
    110         return bool2int( s );
    111 }
    112 
    113 int set_setstr( set_t **head, char *key, char *value )
    114 {
    115         set_t *s = set_find( head, key );
    116         char *nv = value;
    117        
    118         if( !s )
    119                 s = set_add( head, key, NULL, NULL, NULL );
    120        
    121         if( s->eval && !( nv = s->eval( s, value ) ) )
    122                 return 0;
     112                s = set_add( irc, key, NULL, NULL );
     113       
     114        if( s->eval && !( nv = s->eval( irc, s, value ) ) )
     115                return( 0 );
    123116       
    124117        if( s->value )
     
    128121        }
    129122       
    130         /* If there's a default setting and it's equal to what we're trying to
    131            set, stick with s->value = NULL. Otherwise, remember the setting. */
    132123        if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
    133124                s->value = g_strdup( nv );
     
    136127                g_free( nv );
    137128       
    138         return 1;
    139 }
    140 
    141 int set_setint( set_t **head, char *key, int value )
     129        return( 1 );
     130}
     131
     132int set_setint( irc_t *irc, char *key, int value )
    142133{
    143134        char s[24];     /* Not quite 128-bit clean eh? ;-) */
    144135       
    145         g_snprintf( s, sizeof( s ), "%d", value );
    146         return set_setstr( head, key, s );
    147 }
    148 
    149 void set_del( set_t **head, char *key )
    150 {
    151         set_t *s = *head, *t = NULL;
     136        sprintf( s, "%d", value );
     137        return( set_setstr( irc, key, s ) );
     138}
     139
     140void set_del( irc_t *irc, char *key )
     141{
     142        set_t *s = irc->set, *t = NULL;
    152143       
    153144        while( s )
     
    162153                        t->next = s->next;
    163154                else
    164                         *head = s->next;
     155                        irc->set = s->next;
    165156               
    166157                g_free( s->key );
     
    171162}
    172163
    173 char *set_eval_int( set_t *set, char *value )
    174 {
    175         char *s;
    176        
    177         for( s = value; *s; s ++ )
    178                 if( !isdigit( *s ) )
    179                         return NULL;
    180        
    181         return value;
    182 }
    183 
    184 char *set_eval_bool( set_t *set, char *value )
    185 {
    186         return is_bool( value ) ? value : NULL;
    187 }
    188 
    189 char *set_eval_to_char( set_t *set, char *value )
     164char *set_eval_int( irc_t *irc, set_t *set, char *value )
     165{
     166        char *s = value;
     167       
     168        for( ; *s; s ++ )
     169                if( *s < '0' || *s > '9' )
     170                        return( NULL );
     171       
     172        return( value );
     173}
     174
     175char *set_eval_bool( irc_t *irc, set_t *set, char *value )
     176{
     177        if( ( g_strcasecmp( value, "true" ) == 0 ) || ( g_strcasecmp( value, "yes" ) == 0 ) || ( g_strcasecmp( value, "on" ) == 0 ) )
     178                return( value );
     179        if( ( g_strcasecmp( value, "false" ) == 0 ) || ( g_strcasecmp( value, "no" ) == 0 ) || ( g_strcasecmp( value, "off" ) == 0 ) )
     180                return( value );
     181        return( set_eval_int( irc, set, value ) );
     182}
     183
     184char *set_eval_to_char( irc_t *irc, set_t *set, char *value )
    190185{
    191186        char *s = g_new( char, 3 );
     
    196191                sprintf( s, "%c ", *value );
    197192       
    198         return s;
    199 }
    200 
    201 char *set_eval_ops( set_t *set, char *value )
    202 {
    203         irc_t *irc = set->data;
    204        
     193        return( s );
     194}
     195
     196char *set_eval_ops( irc_t *irc, set_t *set, char *value )
     197{
    205198        if( g_strcasecmp( value, "user" ) == 0 )
     199        {
    206200                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    207201                                                              irc->channel, "+o-o", irc->nick, irc->mynick );
     202                return( value );
     203        }
    208204        else if( g_strcasecmp( value, "root" ) == 0 )
     205        {
    209206                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    210207                                                              irc->channel, "-o+o", irc->nick, irc->mynick );
     208                return( value );
     209        }
    211210        else if( g_strcasecmp( value, "both" ) == 0 )
     211        {
    212212                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    213213                                                              irc->channel, "+oo", irc->nick, irc->mynick );
     214                return( value );
     215        }
    214216        else if( g_strcasecmp( value, "none" ) == 0 )
     217        {
    215218                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    216219                                                              irc->channel, "-oo", irc->nick, irc->mynick );
    217         else
    218                 return NULL;
    219        
    220         return value;
    221 }
    222 
    223 char *set_eval_charset( set_t *set, char *value )
    224 {
    225         GIConv cd;
    226 
    227         if ( g_strncasecmp( value, "none", 4 ) == 0 )
    228                 return value;
    229 
    230         cd = g_iconv_open( "UTF-8", value );
    231         if( cd == (GIConv) -1 )
    232                 return NULL;
    233 
    234         g_iconv_close( cd );
    235         return value;
    236 }
     220                return( value );
     221        }
     222       
     223        return( NULL );
     224}
     225
  • set.h

    rfef6116 r3f9440d  
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
    4   * Copyright 2002-2006 Wilmer van der Gaast and others                *
     4  * Copyright 2002-2004 Wilmer van der Gaast and others                *
    55  \********************************************************************/
    66
     
    2626typedef struct set
    2727{
    28         void *data;
    29        
    3028        char *key;
    3129        char *value;
    3230        char *def;      /* Default */
    3331       
    34         int flags;
    35        
    36         /* Eval: Returns NULL if the value is incorrect or exactly the
    37            passed value variable. When returning a corrected value,
    38            set_setstr() should be able to free() the returned string! */
    39         char *(*eval) ( struct set *set, char *value );
     32        /* Eval: Returns NULL if the value is incorrect. Can return a
     33           corrected value. set_setstr() should be able to free() the
     34           returned string! */
     35        char *(*eval) ( irc_t *irc, struct set *set, char *value );
    4036        struct set *next;
    4137} set_t;
    4238
    43 set_t *set_add( set_t **head, char *key, char *def, void *eval, void *data );
    44 set_t *set_find( set_t **head, char *key );
    45 G_MODULE_EXPORT char *set_getstr( set_t **head, char *key );
    46 G_MODULE_EXPORT int set_getint( set_t **head, char *key );
    47 G_MODULE_EXPORT int set_getbool( set_t **head, char *key );
    48 int set_setstr( set_t **head, char *key, char *value );
    49 int set_setint( set_t **head, char *key, int value );
    50 void set_del( set_t **head, char *key );
     39set_t *set_add( irc_t *irc, char *key, char *def, void *eval );
     40G_MODULE_EXPORT set_t *set_find( irc_t *irc, char *key );
     41G_MODULE_EXPORT char *set_getstr( irc_t *irc, char *key );
     42G_MODULE_EXPORT int set_getint( irc_t *irc, char *key );
     43int set_setstr( irc_t *irc, char *key, char *value );
     44int set_setint( irc_t *irc, char *key, int value );
     45void set_del( irc_t *irc, char *key );
    5146
    52 char *set_eval_int( set_t *set, char *value );
    53 char *set_eval_bool( set_t *set, char *value );
     47char *set_eval_int( irc_t *irc, set_t *set, char *value );
     48char *set_eval_bool( irc_t *irc, set_t *set, char *value );
     49char *set_eval_to_char( irc_t *irc, set_t *set, char *value );
     50char *set_eval_ops( irc_t *irc, set_t *set, char *value );
    5451
    55 char *set_eval_to_char( set_t *set, char *value );
    56 char *set_eval_ops( set_t *set, char *value );
    57 char *set_eval_charset( set_t *set, char *value );
     52
  • storage.c

    rfef6116 r3f9440d  
    66
    77/* Support for multiple storage backends */
    8 
    9 /* Copyright (C) 2005 Jelmer Vernooij <jelmer@samba.org> */
    108
    119/*
     
    3129
    3230extern storage_t storage_text;
    33 extern storage_t storage_xml;
    3431
    35 static GList *storage_backends = NULL;
     32static GList text_entry = { &storage_text, NULL, NULL };
     33static GList *storage_backends = &text_entry;
    3634
    3735void register_storage_backend(storage_t *backend)
     
    4341{
    4442        GList *gl;
    45         storage_t *st = NULL;
     43        storage_t *st;
    4644
    4745        for (gl = storage_backends; gl; gl = gl->next) {
     
    6563        int i;
    6664        storage_t *storage;
    67        
    68         register_storage_backend(&storage_text);
    69         register_storage_backend(&storage_xml);
    70        
     65
    7166        storage = storage_init_single(primary);
    7267        if (storage == NULL)
  • storage.h

    rfef6116 r3f9440d  
    3333        STORAGE_ALREADY_EXISTS,
    3434        STORAGE_OTHER_ERROR /* Error that isn't caused by user input, such as
    35                                a database that is unreachable. log() will be
    36                                used for the exact error message */
     35                                                   a database that is unreachable. log() will be
     36                                                   used for the exact error message */
    3737} storage_status_t;
    3838
  • storage_text.c

    rfef6116 r3f9440d  
    116116        }
    117117        fclose( fp );
     118       
     119        if( set_getint( irc, "auto_connect" ) )
     120        {
     121                strcpy( s, "account on" );      /* Can't do this directly because r_c_s alters the string */
     122                root_command_string( irc, ru, s, 0 );
     123        }
    118124       
    119125        return STORAGE_OK;
  • unix.c

    rfef6116 r3f9440d  
    4848       
    4949        b_main_init();
     50       
    5051        log_init();
     52
    5153        nogaim_init();
    52        
    53         srand( time( NULL ) ^ getpid() );
    54        
     54
    5555        CONF_FILE = g_strdup( CONF_FILE_DEF );
     56       
    5657        global.helpfile = g_strdup( HELP_FILE );
    57        
     58
    5859        global.conf = conf_load( argc, argv );
    5960        if( global.conf == NULL )
    6061                return( 1 );
    61        
     62
     63
    6264        if( global.conf->runmode == RUNMODE_INETD )
    6365        {
     
    8789        if( i != 0 )
    8890                return( i );
    89        
     91
    9092        global.storage = storage_init( global.conf->primary_storage, global.conf->migrate_storage );
    9193        if ( global.storage == NULL) {
  • user.c

    rfef6116 r3f9440d  
    6767       
    6868        u->user = u->realname = u->host = u->nick = g_strdup( nick );
    69         u->is_private = set_getint( &irc->set, "private" );
     69        u->is_private = set_getint( irc, "private" );
    7070       
    7171        key = g_strdup( nick );
     
    147147        while( u )
    148148        {
    149                 if( u->gc == gc && u->handle && gc->acc->prpl->cmp_buddynames ( u->handle, handle ) == 0 )
     149                if( u->gc == gc && u->handle && gc->prpl->cmp_buddynames ( u->handle, handle ) == 0 )
    150150                        break;
    151151                u = u->next;
Note: See TracChangeset for help on using the changeset viewer.