Changes in / [6398094:eda0270]


Ignore:
Files:
30 added
22 deleted
32 edited

Legend:

Unmodified
Added
Removed

  • Makefile

    r6398094 reda0270  
    1010
    1111# Program variables
    12 objects = 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
     12objects = 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
    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
     14subdirs = protocols lib
    1515
    1616# Expansion of variables
    … …  
    4242
    4343distclean: clean $(subdirs)
    44         rm -f Makefile.settings config.h
     44        rm -f Makefile.settings config.h bitlbee.pc
    4545        find . -name 'DEADJOE' -o -name '*.orig' -o -name '*.rej' -o -name '*~' -exec rm -f {} \;
    4646

  • account.c

    r6398094 reda0270  
    3131{
    3232        account_t *a;
     33        set_t *s;
    3334       
    3435        if( irc->accounts )
    3536        {
    3637                for( a = irc->accounts; a->next; a = a->next );
    37                 a = a->next = g_new0 ( account_t, 1 );
     38                a = a->next = g_new0( account_t, 1 );
    3839        }
    3940        else
    … …  
    4546        a->user = g_strdup( user );
    4647        a->pass = g_strdup( pass );
     48        a->auto_connect = 1;
    4749        a->irc = irc;
    4850       
     51        s = set_add( &a->set, "auto_connect", "true", set_eval_account, a );
     52        s->flags |= ACC_SET_NOSAVE;
     53       
     54        s = set_add( &a->set, "password", NULL, set_eval_account, a );
     55        s->flags |= ACC_SET_NOSAVE;
     56       
     57        s = set_add( &a->set, "username", NULL, set_eval_account, a );
     58        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
     59        set_setstr( &a->set, "username", user );
     60       
     61        a->nicks = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free );
     62       
     63        /* This function adds some more settings (and might want to do more
     64           things that have to be done now, although I can't think of anything. */
     65        if( prpl->acc_init )
     66                prpl->acc_init( a );
     67       
    4968        return( a );
     69}
     70
     71char *set_eval_account( set_t *set, char *value )
     72{
     73        account_t *acc = set->data;
     74       
     75        /* Double-check: We refuse to edit on-line accounts. */
     76        if( set->flags & ACC_SET_OFFLINE_ONLY && acc->gc )
     77                return NULL;
     78       
     79        if( strcmp( set->key, "username" ) == 0 )
     80        {
     81                g_free( acc->user );
     82                acc->user = g_strdup( value );
     83                return value;
     84        }
     85        else if( strcmp( set->key, "password" ) == 0 )
     86        {
     87                g_free( acc->pass );
     88                acc->pass = g_strdup( value );
     89                return NULL;    /* password shouldn't be visible in plaintext! */
     90        }
     91        else if( strcmp( set->key, "server" ) == 0 )
     92        {
     93                g_free( acc->server );
     94                if( *value )
     95                        acc->server = g_strdup( value );
     96                else
     97                        acc->server = NULL;
     98                return value;
     99        }
     100        else if( strcmp( set->key, "auto_connect" ) == 0 )
     101        {
     102                if( !is_bool( value ) )
     103                        return NULL;
     104               
     105                acc->auto_connect = bool2int( value );
     106                return value;
     107        }
     108       
     109        return NULL;
    50110}
    51111
    … …  
    68128                        for( a = irc->accounts; a; a = a->next )
    69129                                if( a->prpl == proto &&
    70                                     a->prpl->cmp_buddynames( handle, a->user ) == 0 )
     130                                    a->prpl->handle_cmp( handle, a->user ) == 0 )
    71131                                        ret = a;
    72132                }
    … …  
    129189                        }
    130190                       
     191                        while( a->set )
     192                                set_del( &a->set, a->set->key );
     193                       
     194                        g_hash_table_destroy( a->nicks );
     195                       
    131196                        g_free( a->user );
    132197                        g_free( a->pass );
    … …  
    142207void account_on( irc_t *irc, account_t *a )
    143208{
    144         struct aim_user *u;
    145        
    146209        if( a->gc )
    147210        {
    … …  
    152215        cancel_auto_reconnect( a );
    153216       
    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 :-/ */
    162217        a->reconnect = 0;
    163        
    164         a->prpl->login( u );
     218        a->prpl->login( a );
    165219}
    166220

  • account.h

    r6398094 reda0270  
    3434        char *server;
    3535       
     36        int auto_connect;
    3637        int reconnect;
     38       
     39        set_t *set;
     40        GHashTable *nicks;
    3741       
    3842        struct irc *irc;
    … …  
    4751void account_off( irc_t *irc, account_t *a );
    4852
     53char *set_eval_account( set_t *set, char *value );
     54
     55#define ACC_SET_NOSAVE          1
     56#define ACC_SET_OFFLINE_ONLY    2
     57#define ACC_SET_ONLINE_ONLY     4
     58
    4959#endif

  • bitlbee.c

    r6398094 reda0270  
    310310                        irc_t *irc;
    311311                       
     312                        /* Since we're fork()ing here, let's make sure we won't
     313                           get the same random numbers as the parent/siblings. */
     314                        srand( time( NULL ) ^ getpid() );
     315                       
    312316                        /* Close the listening socket, we're a client. */
    313317                        close( global.listen_socket );

  • bitlbee.h

    r6398094 reda0270  
    124124#include "commands.h"
    125125#include "account.h"
     126#include "nick.h"
    126127#include "conf.h"
    127128#include "log.h"
    … …  
    130131#include "query.h"
    131132#include "sock.h"
    132 #include "util.h"
     133#include "misc.h"
    133134#include "proxy.h"
    134135

  • conf.c

    r6398094 reda0270  
    3434#include "ipc.h"
    3535
    36 #include "protocols/proxy.h"
     36#include "proxy.h"
    3737
    3838char *CONF_FILE;
    … …  
    5555        conf->nofork = 0;
    5656        conf->verbose = 0;
    57         conf->primary_storage = "text";
     57        conf->primary_storage = "xml";
     58        conf->migrate_storage = g_strsplit( "text", ",", -1 );
    5859        conf->runmode = RUNMODE_INETD;
    5960        conf->authmode = AUTHMODE_OPEN;
    … …  
    322323                if( g_strcasecmp( ini->section, "defaults" ) == 0 )
    323324                {
    324                         set_t *s = set_find( irc, ini->key );
     325                        set_t *s = set_find( &irc->set, ini->key );
    325326                       
    326327                        if( s )

  • configure

    r6398094 reda0270  
    3131
    3232events=glib
     33ldap=auto
    3334ssl=auto
    3435
    … …  
    6667
    6768--ipv6=0/1      IPv6 socket support                     $ipv6
     69
     70--ldap=0/1/auto LDAP support                            $ldap
    6871
    6972--events=...    Event handler (glib, libevent)          $events
    … …  
    141144fi
    142145
    143 echo CFLAGS+=-I`pwd` -I`pwd`/protocols -I. >> Makefile.settings
     146echo CFLAGS+=-I`pwd` -I`pwd`/lib -I`pwd`/protocols -I. >> Makefile.settings
    144147
    145148echo CFLAGS+=-DHAVE_CONFIG_H >> Makefile.settings
    146149
    147150if [ -n "$CC" ]; then
    148         echo "CC=$CC" >> Makefile.settings;
     151        CC=$CC
    149152elif type gcc > /dev/null 2> /dev/null; then
    150         echo "CC=gcc" >> Makefile.settings;
     153        CC=gcc
    151154elif type cc > /dev/null 2> /dev/null; then
    152         echo "CC=cc" >> Makefile.settings;
     155        CC=cc
    153156else
    154157        echo 'Cannot find a C compiler, aborting.'
    155158        exit 1;
    156159fi
     160
     161echo "CC=$CC" >> Makefile.settings;
    157162
    158163if [ -n "$LD" ]; then
    … …  
    232237}
    233238
    234 if [ "$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
     239detect_ldap()
     240{
     241        TMPFILE=`mktemp`
     242        if $CC -o $TMPFILE -shared -lldap 2>/dev/null >/dev/null; then
     243                cat<<EOF>>Makefile.settings
     244EFLAGS+=-lldap
     245CFLAGS+=
     246EOF
     247                ldap=1
     248                rm -f $TMPFILE
     249                ret=1
     250        else
     251                ldap=0
     252                ret=0
     253        fi
     254}
     255
     256if [ "$ssl" = "auto" ]; then
     257        detect_gnutls
     258        if [ "$ret" = "0" ]; then
     259                detect_nss
     260        fi
     261elif [ "$ssl" = "gnutls" ]; then
     262        detect_gnutls
     263elif [ "$ssl" = "nss" ]; then
     264        detect_nss
     265elif [ "$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
     290elif [ "$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
    245296                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;
    275         else
    276                 echo
    277                 echo 'ERROR: Unknown SSL library specified.'
    278                 exit 1;
    279         fi
    280        
    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;
    290        
    291         echo 'SSL_CLIENT=ssl_'$ssl'.o' >> Makefile.settings
    292 fi
     297                echo 'Real SSL support is necessary for MSN authentication, will build without'
     298                echo 'MSN protocol support.'
     299                msn=0
     300        fi
     301       
     302        ret=1
     303else
     304        echo
     305        echo 'ERROR: Unknown SSL library specified.'
     306        exit 1
     307fi
     308
     309if [ "$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)'
     315       
     316        exit 1
     317fi;
     318
     319echo 'SSL_CLIENT=ssl_'$ssl'.o' >> Makefile.settings
     320
     321STORAGES="text xml"
     322
     323if [ "$ldap" = "auto" ]; then
     324        detect_ldap
     325fi
     326
     327if [ "$ldap" = 0 ]; then
     328        echo "#undef WITH_LDAP" >> config.h
     329elif [ "$ldap" = 1 ]; then
     330        echo "#define WITH_LDAP 1" >> config.h
     331        STORAGES="$STORAGES ldap"
     332fi
     333
     334for i in $STORAGES; do
     335        STORAGE_OBJS="$STORAGE_OBJS storage_$i.o"
     336done
     337echo "STORAGE_OBJS="$STORAGE_OBJS >> Makefile.settings
    293338
    294339if [ "$strip" = 0 ]; then
    … …  
    304349        elif type strip > /dev/null 2> /dev/null; then
    305350                echo "STRIP=strip" >> Makefile.settings;
    306         elif /bin/test -x /usr/ccs/bin/strip; then
    307                 echo "STRIP=/usr/ccs/bin/strip" >> Makefile.settings;
    308351        else
    309352                echo
    … …  
    384427if [ "$protocols" = "PROTOCOLS = " ]; then
    385428        echo "WARNING: You haven't selected any communication protocol to compile!"
    386         echo "         Bitlbee will run, but you will be unable to connect to IM servers!"
     429        echo "         BitlBee will run, but you will be unable to connect to IM servers!"
    387430fi
    388431
    … …  
    419462
    420463if [ "$debug" = "1" ]; then
    421         echo '  Debugging enabled.';
    422 else
    423         echo '  Debugging disabled.';
     464        echo '  Debugging enabled.'
     465else
     466        echo '  Debugging disabled.'
    424467fi
    425468
    426469if [ "$strip" = "1" ]; then
    427         echo '  Binary stripping enabled.';
    428 else
    429         echo '  Binary stripping disabled.';
    430 fi
    431 
    432 echo '  Using event handler: '$events;
    433 echo '  Using SSL library: '$ssl;
    434 
    435 #if [ "$flood" = "0" ]; then
    436 #       echo '  Flood protection disabled.';
    437 #else
    438 #       echo '  Flood protection enabled.';
    439 #fi
     470        echo '  Binary stripping enabled.'
     471else
     472        echo '  Binary stripping disabled.'
     473fi
     474
     475echo '  Using event handler: '$events
     476echo '  Using SSL library: '$ssl
     477echo '  Building with these storage backends: '$STORAGES
    440478
    441479if [ -n "$protocols" ]; then
    442         echo '  Building with these protocols:' $protocols;
    443 else
    444         echo '  Building without IM-protocol support. We wish you a lot of fun...';
    445 fi
     480        echo '  Building with these protocols:' $protocols
     481else
     482        echo '  Building without IM-protocol support. We wish you a lot of fun...'
     483fi

  • doc/user-guide/commands.xml

    r6398094 reda0270  
    1111
    1212                        <para>
    13                                 Available actions: add, del, list, on, off. See <emphasis>help account &lt;action&gt;</emphasis> for more information.
     13                                Available actions: add, del, list, on, off and set. See <emphasis>help account &lt;action&gt;</emphasis> for more information.
    1414                        </para>
    1515
    … …  
    2626                       
    2727                        <bitlbee-command name="jabber">
    28                                 <syntax>account add jabber &lt;handle&gt; &lt;password&gt; [&lt;servertag&gt;]</syntax>
     28                                <syntax>account add jabber &lt;handle@server.tld&gt; &lt;password&gt; [&lt;servertag&gt;]</syntax>
    2929
    3030                                <description>
    3131                                        <para>
    32                                                 Note that the servertag argument is optional. You only have to use it if the part after the @ in your handle isn't the hostname of your Jabber server, or if you want to use SSL/connect to a non-standard port number. The format is simple: [&lt;servername&gt;[:&lt;portnumber&gt;][:ssl]]. For example, this is how you can connect to Google Talk:
     32                                                Note that the servertag argument is optional. You only have to use it if the part after the @ in your handle isn't the hostname of your Jabber server, or if you want to use SSL/connect to a non-standard port number. The format is simple: [&lt;servername&gt;[:&lt;portnumber&gt;][:ssl]].
     33                                        </para>
     34                                </description>
     35
     36                                <description>
     37                                        <para>
     38                                                Google Talk uses the Jabber protocol. Please note that Google talk is SSL-only, but officially reachable over both port 5222 and 5223. Usually BitlBee users have to connect via port 5223, for example like this:
    3339                                        </para>
    3440                                </description>
    … …  
    3844                                        <ircline nick="root">Account successfully added</ircline>
    3945                                </ircexample>
    40 
    41                                 <description>
    42                                         <para>
    43                                                 Note that Google talk is SSL-only, but officially reachable over both port 5222 and 5223. However, for some people only port 5222 works, for some people only 5223. This is something you'll have to try out.
    44                                         </para>
    45                                 </description>
    4646                        </bitlbee-command>
    4747
    4848                        <bitlbee-command name="msn">
    49                                 <syntax>account add msn &lt;handle&gt; &lt;password&gt;</syntax>
     49                                <syntax>account add msn &lt;handle@server.tld&gt; &lt;password&gt;</syntax>
    5050
    5151                                <description>
    … …  
    103103                        <description>
    104104                                <para>
    105                                         This command will try to log into the specified account. If no account is specified, BitlBee will log into all the accounts. (Including accounts awaiting a reconnection)
     105                                        This command will try to log into the specified account. If no account is specified, BitlBee will log into all the accounts that have the auto_connect flag set.
    106106                                </para>
    107107
    … …  
    118118                        <description>
    119119                                <para>
    120                                         This command disconnects the connection for the specified account. If no account is specified, BitlBee will deactivate all active accounts. (Including accounts awaiting a reconnection)
     120                                        This command disconnects the connection for the specified account. If no account is specified, BitlBee will deactivate all active accounts and cancel all pending reconnects.
    121121                                </para>
    122122
    … …  
    133133                                <para>
    134134                                        This command gives you a list of all the accounts known by BitlBee, including the numbers you'll need for most account commands.
     135                                </para>
     136                        </description>
     137                </bitlbee-command>
     138
     139                <bitlbee-command name="set">
     140                        <syntax>account set &lt;account id&gt;</syntax>
     141                        <syntax>account set &lt;account id&gt;/&lt;setting&gt;</syntax>
     142                        <syntax>account set &lt;account id&gt;/&lt;setting&gt; &lt;value&gt;</syntax>
     143
     144                        <description>
     145                                <para>
     146                                        This account can be used to change various settings for IM accounts. For all protocols, this command can be used to change the handle or the password BitlBee uses to log in and if it should be logged in automatically. Some protocols have additional settings. You can see the settings available for a connection by typing <emphasis>account set &lt;account id&gt;</emphasis>.
     147                                </para>
     148                               
     149                                <para>
     150                                        For more infomation about a setting, see <emphasis>help set &lt;setting&gt;</emphasis>.
     151                                </para>
     152                               
     153                                <para>
     154                                        The account ID can be a number (see <emphasis>account list</emphasis>), the protocol name or (part of) the screenname, as long as it matches only one connection.
    135155                                </para>
    136156                        </description>
    … …  
    276296        </bitlbee-command>
    277297
     298        <bitlbee-setting name="auto_connect" type="boolean">
     299                <default>True</default>
     300
     301                <description>
     302                        <para>
     303                                With this option enabled, when you identify BitlBee will automatically connect to your accounts, with this disabled it will not do this.
     304                        </para>
     305                       
     306                        <para>
     307                                This setting can also be changed for specific accounts using the <emphasis>account set</emphasis> command. (However, these values will be ignored if the global <emphasis>auto_connect</emphasis> setting is disabled!)
     308                        </para>
     309                </description>
     310        </bitlbee-setting>
     311
     312        <bitlbee-setting name="auto_reconnect" type="boolean">
     313                <default>False</default>
     314
     315                <description>
     316                        <para>
     317                                If an IM-connections breaks, you're supposed to bring it back up yourself. Having BitlBee do this automatically might not always be a good idea, for several reasons. If you want the connections to be restored automatically, you can enable this setting.
     318                        </para>
     319
     320                        <para>
     321                                See also the <emphasis>auto_reconnect_delay</emphasis> setting.
     322                        </para>
     323                </description>
     324
     325        </bitlbee-setting>
     326
     327        <bitlbee-setting name="auto_reconnect_delay" type="integer">
     328                <default>300</default>
     329
     330                <description>
     331                        <para>
     332                                Tell BitlBee after how many seconds it should attempt to bring an IM-connection back up after a crash. It's not a good idea to set this value very low, it will cause too much useless traffic when an IM-server is down for a few hours.
     333                        </para>
     334
     335                        <para>
     336                                See also the <emphasis>auto_reconnect</emphasis> setting.
     337                        </para>
     338                </description>
     339        </bitlbee-setting>
     340
     341        <bitlbee-setting name="away_devoice" type="boolean">
     342                <default>True</default>
     343
     344                <description>
     345                        <para>
     346                                With this option enabled, the root user devoices people when they go away (just away, not offline) and gives the voice back when they come back. You might dislike the voice-floods you'll get if your contact list is huge, so this option can be disabled.
     347                        </para>
     348                </description>
     349        </bitlbee-setting>
     350
     351        <bitlbee-setting name="buddy_sendbuffer" type="boolean">
     352                <default>False</default>
     353
     354                <description>
     355                        <para>
     356                                By default, when you send a message to someone, BitlBee forwards this message to the user immediately. When you paste a large number of lines, the lines will be sent in separate messages, which might not be very nice to read. If you enable this setting, BitlBee will buffer your messages and wait for more data.
     357                        </para>
     358
     359                        <para>
     360                                Using the <emphasis>buddy_sendbuffer_delay</emphasis> setting you can specify the number of seconds BitlBee should wait for more data before the complete message is sent.
     361                        </para>
     362
     363                        <para>
     364                                Please note that if you remove a buddy from your list (or if the connection to that user drops) and there's still data in the buffer, this data will be lost. BitlBee will not try to send the message to the user in those cases.
     365                        </para>
     366                </description>
     367        </bitlbee-setting>
     368
     369        <bitlbee-setting name="buddy_sendbuffer_delay" type="integer">
     370                <default>200</default>
     371
     372                <description>
     373
     374                        <para>
     375                                Tell BitlBee after how many (mili)seconds a buffered message should be sent. Values greater than 5 will be interpreted as miliseconds, 5 and lower as seconds.
     376                        </para>
     377
     378                        <para>
     379                                See also the <emphasis>buddy_sendbuffer</emphasis> setting.
     380                        </para>
     381                </description>
     382        </bitlbee-setting>
     383
    278384        <bitlbee-setting name="charset" type="string">
    279385                <default>iso8859-1</default>
    … …  
    292398        </bitlbee-setting>
    293399
    294         <bitlbee-setting name="private" type="boolean">
    295                 <default>True</default>
    296 
    297                 <description>
    298 
    299                         <para>
    300                                 If value is true, messages from users will appear in separate query windows. If false, messages from users will appear in the control channel.
    301                         </para>
    302 
    303                         <para>
    304                                 This setting is remembered (during one session) per-user, this setting only changes the default state. This option takes effect as soon as you reconnect.
    305                         </para>
    306                 </description>
    307         </bitlbee-setting>
    308 
    309         <bitlbee-setting name="save_on_quit" type="boolean">
    310                 <default>True</default>
    311 
    312                 <description>
    313                         <para>
    314                                 If enabled causes BitlBee to save all current settings and account details when user disconnects. This is enabled by default, and these days there's not really a reason to have it disabled anymore.
    315                         </para>
    316                 </description>
    317         </bitlbee-setting>
    318 
    319         <bitlbee-setting name="strip_html" type="boolean">
    320                 <default>True</default>
    321 
    322                 <description>
    323                         <para>
    324                                 Determines what BitlBee should do with HTML in messages. Normally this is turned on and HTML will be stripped from messages, if BitlBee thinks there is HTML.
    325                         </para>
    326                         <para>
    327                                 If BitlBee fails to detect this sometimes (most likely in AIM messages over an ICQ connection), you can set this setting to <emphasis>always</emphasis>, but this might sometimes accidentally strip non-HTML things too.
    328                         </para>
    329                 </description>
    330         </bitlbee-setting>
    331 
    332400        <bitlbee-setting name="debug" type="boolean">
    333401                <default>False</default>
    … …  
    340408        </bitlbee-setting>
    341409
    342         <bitlbee-setting name="to_char" type="string">
    343                 <default>": "</default>
    344 
    345                 <description>
    346 
    347                         <para>
    348                                 It's customary that messages meant for one specific person on an IRC channel are prepended by his/her alias followed by a colon ':'. BitlBee does this by default. If you prefer a different character, you can set it using <emphasis>set to_char</emphasis>.
    349                         </para>
    350 
    351                         <para>
    352                                 Please note that this setting is only used for incoming messages. For outgoing messages you can use ':' (colon) or ',' to separate the destination nick from the message, and this is not configurable.
    353                         </para>
    354                 </description>
    355         </bitlbee-setting>
    356 
    357         <bitlbee-setting name="typing_notice" type="boolean">
     410        <bitlbee-setting name="default_target" type="string">
     411                <default>root</default>
     412                <possible-values>root, last</possible-values>
     413
     414                <description>
     415                        <para>
     416                                With this value set to <emphasis>root</emphasis>, lines written in the control channel without any nickname in front of them will be interpreted as commands. If you want BitlBee to send those lines to the last person you addressed in the control channel, set this to <emphasis>last</emphasis>.
     417                        </para>
     418                </description>
     419        </bitlbee-setting>
     420
     421        <bitlbee-setting name="display_name" type="string">
     422                <description>
     423                        <para>
     424                                Currently only available for MSN connections. This setting allows you to read and change your "friendly name" for this connection. Since this is a server-side setting, it can't be changed when the account is off-line.
     425                        </para>
     426                </description>
     427        </bitlbee-setting>
     428
     429        <bitlbee-setting name="display_namechanges" type="boolean">
    358430                <default>False</default>
    359431
    360                 <description>
    361                         <para>
    362                                 Sends you a /notice when a user starts typing a message (if the protocol supports it, MSN for example). This is a bug, not a feature. (But please don't report it.. ;-) You don't want to use it. Really. In fact the typing-notification is just one of the least useful 'innovations' ever. It's just there because some guy will probably ask me about it anyway. ;-)
    363                         </para>
    364                 </description>
    365         </bitlbee-setting>
    366 
    367         <bitlbee-setting name="ops" type="string">
    368                 <default>both</default>
    369                 <possible-values>both, root, user, none</possible-values>
    370 
    371                 <description>
    372                         <para>
    373                                 Some people prefer themself and root to have operator status in &amp;bitlbee, other people don't. You can change these states using this setting.
    374                         </para>
    375 
    376                         <para>
    377                                 The value "both" means both user and root get ops. "root" means, well, just root. "user" means just the user. "none" means nobody will get operator status.
    378                         </para>
    379                 </description>
    380         </bitlbee-setting>
    381 
    382         <bitlbee-setting name="away_devoice" type="boolean">
    383                 <default>True</default>
    384 
    385                 <description>
    386                         <para>
    387                                 With this option enabled, the root user devoices people when they go away (just away, not offline) and gives the voice back when they come back. You might dislike the voice-floods you'll get if your contact list is huge, so this option can be disabled.
    388                         </para>
    389                 </description>
     432                <para>
     433                        With this option enabled, root will inform you when someone in your buddy list changes his/her "friendly name".
     434                </para>
    390435        </bitlbee-setting>
    391436
    … …  
    417462        </bitlbee-setting>
    418463
    419         <bitlbee-setting name="auto_connect" type="boolean">
     464        <bitlbee-setting name="lcnicks" type="boolean">
    420465                <default>True</default>
    421466
    422467                <description>
    423468                        <para>
    424                                 With this option enabled, when you identify BitlBee will automatically connect to your accounts, with this disabled it will not do this.
    425                         </para>
    426                 </description>
    427         </bitlbee-setting>
    428 
    429         <bitlbee-setting name="auto_reconnect" type="boolean">
    430                 <default>False</default>
    431 
    432                 <description>
    433                         <para>
    434                                 If an IM-connections breaks, you're supposed to bring it back up yourself. Having BitlBee do this automatically might not always be a good idea, for several reasons. If you want the connections to be restored automatically, you can enable this setting.
    435                         </para>
    436 
    437                         <para>
    438                                 See also the <emphasis>auto_reconnect_delay</emphasis> setting.
    439                         </para>
    440                 </description>
    441 
    442         </bitlbee-setting>
    443 
    444         <bitlbee-setting name="auto_reconnect_delay" type="integer">
    445                 <default>300</default>
    446 
    447                 <description>
    448 
    449                         <para>
    450                                 Tell BitlBee after how many seconds it should attempt to bring an IM-connection back up after a crash. It's not a good idea to set this value very low, it will cause too much useless traffic when an IM-server is down for a few hours.
    451                         </para>
    452 
    453                         <para>
    454                                 See also the <emphasis>auto_reconnect</emphasis> setting.
    455                         </para>
    456                 </description>
    457         </bitlbee-setting>
    458 
    459         <bitlbee-setting name="buddy_sendbuffer" type="boolean">
    460                 <default>False</default>
    461 
    462                 <description>
    463 
    464                         <para>
    465                                 By default, when you send a message to someone, BitlBee forwards this message to the user immediately. When you paste a large number of lines, the lines will be sent in separate messages, which might not be very nice to read. If you enable this setting, BitlBee will buffer your messages and wait for more data.
    466                         </para>
    467 
    468                         <para>
    469                                 Using the <emphasis>buddy_sendbuffer_delay</emphasis> setting you can specify the number of seconds BitlBee should wait for more data before the complete message is sent.
    470                         </para>
    471 
    472                         <para>
    473                                 Please note that if you remove a buddy from your list (or if the connection to that user drops) and there's still data in the buffer, this data will be lost. BitlBee will not try to send the message to the user in those cases.
    474                         </para>
    475                 </description>
    476 
    477         </bitlbee-setting>
    478 
    479         <bitlbee-setting name="buddy_sendbuffer_delay" type="integer">
    480                 <default>200</default>
    481 
    482                 <description>
    483 
    484                         <para>
    485                                 Tell BitlBee after how many (mili)seconds a buffered message should be sent. Values greater than 5 will be interpreted as miliseconds, 5 and lower as seconds.
    486                         </para>
    487 
    488                         <para>
    489                                 See also the <emphasis>buddy_sendbuffer</emphasis> setting.
    490                         </para>
    491                 </description>
    492 
    493         </bitlbee-setting>
    494 
    495         <bitlbee-setting name="default_target" type="string">
    496                 <default>root</default>
    497                 <possible-values>root, last</possible-values>
    498 
    499                 <description>
    500                         <para>
    501                                 With this value set to <emphasis>root</emphasis>, lines written in the control channel without any nickname in front of them will be interpreted as commands. If you want BitlBee to send those lines to the last person you addressed in the control channel, set this to <emphasis>last</emphasis>.
    502                         </para>
    503                 </description>
    504 
    505         </bitlbee-setting>
    506 
    507         <bitlbee-setting name="display_namechanges" type="boolean">
    508                 <default>False</default>
    509 
    510                 <para>
    511                         With this option enabled, root will inform you when someone in your buddy list changes his/her "friendly name".
    512                 </para>
     469                                Hereby you can change whether you want all lower case nick names or leave the case as it intended by your peer.
     470                        </para>
     471                </description>
     472
     473        </bitlbee-setting>
     474
     475        <bitlbee-setting name="ops" type="string">
     476                <default>both</default>
     477                <possible-values>both, root, user, none</possible-values>
     478
     479                <description>
     480                        <para>
     481                                Some people prefer themself and root to have operator status in &amp;bitlbee, other people don't. You can change these states using this setting.
     482                        </para>
     483
     484                        <para>
     485                                The value "both" means both user and root get ops. "root" means, well, just root. "user" means just the user. "none" means nobody will get operator status.
     486                        </para>
     487                </description>
    513488        </bitlbee-setting>
    514489
    … …  
    516491                <description>
    517492                        <para>
    518                                 Use this setting to change your "NickServ" password.
     493                                Use this global setting to change your "NickServ" password.
     494                        </para>
     495                       
     496                        <para>
     497                                This setting is also available for all IM accounts to change the password BitlBee uses to connect to the service.
     498                        </para>
     499                       
     500                        <para>
     501                                Note that BitlBee will always say this setting is empty. This doesn't mean there is no password, it just means that, for security reasons, BitlBee stores passwords somewhere else so they can't just be retrieved in plain text.
     502                        </para>
     503                </description>
     504        </bitlbee-setting>
     505       
     506        <bitlbee-setting name="port" type="integer">
     507                <description>
     508                        <para>
     509                                Currently only available for Jabber connections. Specifies the port number to connect to. Usually this should be set to 5222, or 5223 for SSL-connections.
     510                        </para>
     511                </description>
     512        </bitlbee-setting>
     513
     514        <bitlbee-setting name="private" type="boolean">
     515                <default>True</default>
     516
     517                <description>
     518                        <para>
     519                                If value is true, messages from users will appear in separate query windows. If false, messages from users will appear in the control channel.
     520                        </para>
     521
     522                        <para>
     523                                This setting is remembered (during one session) per-user, this setting only changes the default state. This option takes effect as soon as you reconnect.
    519524                        </para>
    520525                </description>
    … …  
    536541        </bitlbee-setting>
    537542
    538         <bitlbee-setting name="lcnicks" type="boolean">
     543        <bitlbee-setting name="resource" type="string">
     544                <default>BitlBee</default>
     545
     546                <description>
     547                        <para>
     548                                Can be set for Jabber connections. You can use this to connect to your Jabber account from multiple clients at once, with every client using a different resource string.
     549                        </para>
     550                </description>
     551        </bitlbee-setting>
     552
     553        <bitlbee-setting name="save_on_quit" type="boolean">
    539554                <default>True</default>
    540555
    541556                <description>
    542557                        <para>
    543                                 Hereby you can change whether you want all lower case nick names or leave the case as it intended by your peer.
    544                         </para>
    545                 </description>
    546 
     558                                If enabled causes BitlBee to save all current settings and account details when user disconnects. This is enabled by default, and these days there's not really a reason to have it disabled anymore.
     559                        </para>
     560                </description>
     561        </bitlbee-setting>
     562
     563        <bitlbee-setting name="server" type="string">
     564                <description>
     565                        <para>
     566                                Can be set for Jabber- and OSCAR-connections. For OSCAR, this must be set to <emphasis>login.icq.com</emphasis> if it's an ICQ connection, or <emphasis>login.oscar.aol.com</emphasis> if it's an AIM connection. For Jabber, you have to set this if the servername isn't equal to the part after the @ in the Jabber handle.
     567                        </para>
     568                </description>
     569        </bitlbee-setting>
     570
     571        <bitlbee-setting name="ssl" type="boolean">
     572                <default>False</default>
     573
     574                <description>
     575                        <para>
     576                                Currently only available for Jabber connections. Set this to true if the server accepts SSL connections.
     577                        </para>
     578                </description>
     579        </bitlbee-setting>
     580
     581        <bitlbee-setting name="strip_html" type="boolean">
     582                <default>True</default>
     583
     584                <description>
     585                        <para>
     586                                Determines what BitlBee should do with HTML in messages. Normally this is turned on and HTML will be stripped from messages, if BitlBee thinks there is HTML.
     587                        </para>
     588                        <para>
     589                                If BitlBee fails to detect this sometimes (most likely in AIM messages over an ICQ connection), you can set this setting to <emphasis>always</emphasis>, but this might sometimes accidentally strip non-HTML things too.
     590                        </para>
     591                </description>
     592        </bitlbee-setting>
     593
     594        <bitlbee-setting name="to_char" type="string">
     595                <default>": "</default>
     596
     597                <description>
     598                        <para>
     599                                It's customary that messages meant for one specific person on an IRC channel are prepended by his/her alias followed by a colon ':'. BitlBee does this by default. If you prefer a different character, you can set it using <emphasis>set to_char</emphasis>.
     600                        </para>
     601
     602                        <para>
     603                                Please note that this setting is only used for incoming messages. For outgoing messages you can use ':' (colon) or ',' to separate the destination nick from the message, and this is not configurable.
     604                        </para>
     605                </description>
     606        </bitlbee-setting>
     607
     608        <bitlbee-setting name="typing_notice" type="boolean">
     609                <default>False</default>
     610
     611                <description>
     612                        <para>
     613                                Sends you a /notice when a user starts typing a message (if the protocol supports it, MSN for example). This is a bug, not a feature. (But please don't report it.. ;-) You don't want to use it. Really. In fact the typing-notification is just one of the least useful 'innovations' ever. It's just there because some guy will probably ask me about it anyway. ;-)
     614                        </para>
     615                </description>
    547616        </bitlbee-setting>
    548617

  • doc/user-guide/help.xsl

    r6398094 reda0270  
    77        version="1.1">
    88
    9         <xsl:output method="text" encoding="iso-8859-1" standalone="yes"/>
     9        <xsl:output method="text" encoding="utf-8" standalone="yes"/>
    1010        <xsl:strip-space elements="*"/>
    1111

  • irc.c

    r6398094 reda0270  
    3333GSList *irc_connection_list = NULL;
    3434
    35 static char *passchange (irc_t *irc, void *set, char *value)
    36 {
    37         irc_setpass (irc, value);
    38         return (NULL);
     35static 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;
    3940}
    4041
    … …  
    123124        irc_connection_list = g_slist_append( irc_connection_list, irc );
    124125       
    125         set_add( irc, "away_devoice", "true",  set_eval_away_devoice );
    126         set_add( irc, "auto_connect", "true", set_eval_bool );
    127         set_add( irc, "auto_reconnect", "false", set_eval_bool );
    128         set_add( irc, "auto_reconnect_delay", "300", set_eval_int );
    129         set_add( irc, "buddy_sendbuffer", "false", set_eval_bool );
    130         set_add( irc, "buddy_sendbuffer_delay", "200", set_eval_int );
    131         set_add( irc, "charset", "iso8859-1", set_eval_charset );
    132         set_add( irc, "debug", "false", set_eval_bool );
    133         set_add( irc, "default_target", "root", NULL );
    134         set_add( irc, "display_namechanges", "false", set_eval_bool );
    135         set_add( irc, "handle_unknown", "root", NULL );
    136         set_add( irc, "lcnicks", "true", set_eval_bool );
    137         set_add( irc, "ops", "both", set_eval_ops );
    138         set_add( irc, "private", "true", set_eval_bool );
    139         set_add( irc, "query_order", "lifo", NULL );
    140         set_add( irc, "save_on_quit", "true", set_eval_bool );
    141         set_add( irc, "strip_html", "true", NULL );
    142         set_add( irc, "to_char", ": ", set_eval_to_char );
    143         set_add( irc, "typing_notice", "false", set_eval_bool );
    144         set_add( irc, "password", NULL, passchange);
     126        set_add( &irc->set, "away_devoice", "true",  set_eval_away_devoice, irc );
     127        set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
     128        set_add( &irc->set, "auto_reconnect", "false", set_eval_bool, irc );
     129        set_add( &irc->set, "auto_reconnect_delay", "300", set_eval_int, irc );
     130        set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
     131        set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
     132        set_add( &irc->set, "charset", "iso8859-1", set_eval_charset, irc );
     133        set_add( &irc->set, "debug", "false", set_eval_bool, irc );
     134        set_add( &irc->set, "default_target", "root", NULL, irc );
     135        set_add( &irc->set, "display_namechanges", "false", set_eval_bool, irc );
     136        set_add( &irc->set, "handle_unknown", "root", NULL, irc );
     137        set_add( &irc->set, "lcnicks", "true", set_eval_bool, irc );
     138        set_add( &irc->set, "ops", "both", set_eval_ops, irc );
     139        set_add( &irc->set, "password", NULL, passchange, irc );
     140        set_add( &irc->set, "private", "true", set_eval_bool, irc );
     141        set_add( &irc->set, "query_order", "lifo", NULL, irc );
     142        set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
     143        set_add( &irc->set, "strip_html", "true", NULL, irc );
     144        set_add( &irc->set, "to_char", ": ", set_eval_to_char, irc );
     145        set_add( &irc->set, "typing_notice", "false", set_eval_bool, irc );
    145146       
    146147        conf_loaddefaults( irc );
    … …  
    206207void irc_free(irc_t * irc)
    207208{
    208         account_t *account, *accounttmp;
     209        account_t *account;
    209210        user_t *user, *usertmp;
    210         nick_t *nick, *nicktmp;
    211211        help_t *helpnode, *helpnodetmp;
    212         set_t *setnode, *setnodetmp;
    213212       
    214213        log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
    215214       
    216         if( irc->status & USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) )
     215        if( irc->status & USTATUS_IDENTIFIED && set_getint( &irc->set, "save_on_quit" ) )
    217216                if( storage_save( irc, TRUE ) != STORAGE_OK )
    218217                        irc_usermsg( irc, "Error while saving settings!" );
    … …  
    254253                query_del(irc, irc->queries);
    255254       
    256         if (irc->accounts != NULL) {
    257                 account = irc->accounts;
    258                 while (account != NULL) {
    259                         g_free(account->user);
    260                         g_free(account->pass);
    261                         g_free(account->server);
    262                         accounttmp = account;
    263                         account = account->next;
    264                         g_free(accounttmp);
    265                 }
    266         }
     255        while (irc->accounts)
     256                account_del(irc, irc->accounts);
     257       
     258        while (irc->set)
     259                set_del(&irc->set, irc->set->key);
    267260       
    268261        if (irc->users != NULL) {
    … …  
    289282        g_hash_table_destroy(irc->watches);
    290283       
    291         if (irc->nicks != NULL) {
    292                 nick = irc->nicks;
    293                 while (nick != NULL) {
    294                         g_free(nick->nick);
    295                         g_free(nick->handle);
    296                                        
    297                         nicktmp = nick;
    298                         nick = nick->next;
    299                         g_free(nicktmp);
    300                 }
    301         }
    302284        if (irc->help != NULL) {
    303285                helpnode = irc->help;
    … …  
    310292                }
    311293        }
    312         if (irc->set != NULL) {
    313                 setnode = irc->set;
    314                 while (setnode != NULL) {
    315                         g_free(setnode->key);
    316                         g_free(setnode->def);
    317                         g_free(setnode->value);
    318                        
    319                         setnodetmp = setnode;
    320                         setnode = setnode->next;
    321                         g_free(setnodetmp);
    322                 }
    323         }
    324294        g_free(irc);
    325295       
    … …  
    332302void irc_setpass (irc_t *irc, const char *pass)
    333303{
    334         if (irc->password) g_free (irc->password);
     304        g_free (irc->password);
    335305       
    336306        if (pass) {
    337307                irc->password = g_strdup (pass);
    338                 irc_usermsg (irc, "Password successfully changed");
    339308        } else {
    340309                irc->password = NULL;
    … …  
    367336                        }
    368337                       
    369                         if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     338                        if( ( cs = set_getstr( &irc->set, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
    370339                        {
    371340                                conv[IRC_MAX_LINE] = 0;
    … …  
    587556       
    588557        strip_newlines( line );
    589         if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     558        if( ( cs = set_getstr( &irc->set, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
    590559        {
    591560                char conv[IRC_MAX_LINE+1];
    … …  
    670639                        }
    671640                       
    672                         if( u->gc && !u->away && set_getint( irc, "away_devoice" ) )
     641                        if( u->gc && !u->away && set_getbool( &irc->set, "away_devoice" ) )
    673642                                strcat( namelist, "+" );
    674643                        else if( ( strcmp( u->nick, irc->mynick ) == 0 && ( strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) == 0 ) ) ||
    … …  
    683652        {
    684653                GList *l;
     654                char *ops = set_getstr( &irc->set, "ops" );
    685655               
    686656                /* root and the user aren't in the channel userlist but should
    … …  
    930900{
    931901        char *nick, *s;
    932         char reason[64];
     902        char reason[128];
    933903       
    934904        if( u->gc && u->gc->flags & OPT_LOGGING_OUT )
    935905        {
    936                 if( u->gc->user->proto_opt[0][0] )
     906                if( u->gc->acc->server )
    937907                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
    938                                     u->gc->user->proto_opt[0] );
     908                                    u->gc->acc->server );
    939909                else if( ( s = strchr( u->gc->username, '@' ) ) )
    940910                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
    … …  
    942912                else
    943913                        g_snprintf( reason, sizeof( reason ), "%s %s.%s", irc->myhost,
    944                                     u->gc->prpl->name, irc->myhost );
     914                                    u->gc->acc->prpl->name, irc->myhost );
    945915               
    946916                /* proto_opt might contain garbage after the : */
    … …  
    1018988                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
    1019989                {
    1020                         if( u && u->gc && u->gc->prpl->send_typing && strlen( s ) >= 10 )
     990                        if( u && u->gc && u->gc->acc->prpl->send_typing && strlen( s ) >= 10 )
    1021991                        {
    1022992                                time_t current_typing_notice = time( NULL );
    … …  
    1024994                                if( current_typing_notice - u->last_typing_notice >= 5 )
    1025995                                {
    1026                                         u->gc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
     996                                        u->gc->acc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
    1027997                                        u->last_typing_notice = current_typing_notice;
    1028998                                }
    … …  
    10571027                }
    10581028        }
    1059         else if( c && c->gc && c->gc->prpl )
     1029        else if( c && c->gc && c->gc->acc && c->gc->acc->prpl )
    10601030        {
    10611031                return( bim_chat_msg( c->gc, c->id, s ) );
    … …  
    10891059        if( !u || !u->gc ) return;
    10901060       
    1091         if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "buddy_sendbuffer_delay" ) > 0 )
     1061        if( set_getint( &irc->set, "buddy_sendbuffer" ) && set_getint( &irc->set, "buddy_sendbuffer_delay" ) > 0 )
    10921062        {
    10931063                int delay;
    … …  
    11161086                strcat( u->sendbuf, "\n" );
    11171087               
    1118                 delay = set_getint( irc, "buddy_sendbuffer_delay" );
     1088                delay = set_getint( &irc->set, "buddy_sendbuffer_delay" );
    11191089                if( delay <= 5 )
    11201090                        delay *= 1000;
    … …  
    11811151                int len = strlen( irc->nick) + 3;
    11821152                prefix = g_new (char, len );
    1183                 g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( irc, "to_char" ) );
     1153                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( &irc->set, "to_char" ) );
    11841154                prefix[len-1] = 0;
    11851155        }

  • irc.h

    r6398094 reda0270  
    9898
    9999#include "user.h"
    100 #include "nick.h"
     100// #include "nick.h"
    101101
    102102extern GSList *irc_connection_list;

  • irc_commands.c

    r6398094 reda0270  
    150150                irc_part( irc, u, c->channel );
    151151               
    152                 if( c->gc && c->gc->prpl )
     152                if( c->gc )
    153153                {
    154154                        c->joined = 0;
    155                         c->gc->prpl->chat_leave( c->gc, c->id );
     155                        c->gc->acc->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->prpl && u->gc->prpl->chat_open )
     175                        if( u && u->gc && u->gc->acc->prpl->chat_open )
    176176                        {
    177177                                irc_reply( irc, 403, "%s :Initializing groupchat in a different channel", cmd[1] );
    178178                               
    179                                 if( !u->gc->prpl->chat_open( u->gc, u->handle ) )
     179                                if( !u->gc->acc->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->prpl && c->gc->prpl->chat_invite )
    208                 {
    209                         c->gc->prpl->chat_invite( c->gc, c->id, "", u->handle );
     207                if( c->gc && c->gc->acc->prpl->chat_invite )
     208                {
     209                        c->gc->acc->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, "default_target" );
     232                        char *t = set_getstr( &irc->set, "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->user->username,
    480                                    *u->gc->user->proto_opt[0] ? u->gc->user->proto_opt[0] : "", u->gc->prpl->name );
     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->server : "",
     481                                   u->gc->acc->prpl->name );
    481482                else
    482483                        irc_reply( irc, 312, "%s %s :%s", u->nick, irc->myhost, IRCD_INFO );

  • nick.c

    r6398094 reda0270  
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
    4   * Copyright 2002-2004 Wilmer van der Gaast and others                *
     4  * Copyright 2002-2006 Wilmer van der Gaast and others                *
    55  \********************************************************************/
    66
    … …  
    2727#include "bitlbee.h"
    2828
    29 void nick_set( irc_t *irc, const char *handle, struct prpl *proto, const char *nick )
    30 {
    31         nick_t *m = NULL, *n = irc->nicks;
    32        
    33         while( n )
    34         {
    35                 if( ( g_strcasecmp( n->handle, handle ) == 0 ) && n->proto == proto )
    36                 {
    37                         g_free( n->nick );
    38                         n->nick = nick_dup( nick );
    39                         nick_strip( n->nick );
    40                        
    41                         return;
    42                 }
    43                 n = ( m = n )->next;    // :-P
    44         }
    45        
    46         if( m )
    47                 n = m->next = g_new0( nick_t, 1 );
     29/* Store handles in lower case and strip spaces, because AIM is braindead. */
     30static char *clean_handle( const char *orig )
     31{
     32        char *new = g_malloc( strlen( orig ) + 1 );
     33        int i = 0;
     34       
     35        do {
     36                if (*orig != ' ')
     37                        new[i++] = tolower( *orig );
     38        }
     39        while (*(orig++));
     40       
     41        return new;
     42}
     43
     44void nick_set( account_t *acc, const char *handle, const char *nick )
     45{
     46        char *store_handle, *store_nick = g_malloc( MAX_NICK_LENGTH + 1 );
     47       
     48        store_handle = clean_handle( handle );
     49        strncpy( store_nick, nick, MAX_NICK_LENGTH );
     50        nick_strip( store_nick );
     51       
     52        g_hash_table_replace( acc->nicks, store_handle, store_nick );
     53}
     54
     55char *nick_get( account_t *acc, const char *handle, const char *realname )
     56{
     57        static char nick[MAX_NICK_LENGTH+1];
     58        char *store_handle, *found_nick;
     59        int inf_protection = 256;
     60       
     61        memset( nick, 0, MAX_NICK_LENGTH + 1 );
     62       
     63        store_handle = clean_handle( handle );
     64        /* Find out if we stored a nick for this person already. If not, try
     65           to generate a sane nick automatically. */
     66        if( ( found_nick = g_hash_table_lookup( acc->nicks, store_handle ) ) )
     67        {
     68                strncpy( nick, found_nick, MAX_NICK_LENGTH );
     69        }
    4870        else
    49                 n = irc->nicks = g_new0( nick_t, 1 );
    50        
    51         n->handle = g_strdup( handle );
    52         n->proto = proto;
    53         n->nick = nick_dup( nick );
    54        
    55         nick_strip( n->nick );
    56 }
    57 
    58 char *nick_get( irc_t *irc, const char *handle, struct prpl *proto, const char *realname )
    59 {
    60         static char nick[MAX_NICK_LENGTH+1];
    61         nick_t *n = irc->nicks;
    62         int inf_protection = 256;
    63        
    64         memset( nick, 0, MAX_NICK_LENGTH + 1 );
    65        
    66         while( n && !*nick )
    67                 if( ( n->proto == proto ) && ( g_strcasecmp( n->handle, handle ) == 0 ) )
    68                         strcpy( nick, n->nick );
    69                 else
    70                         n = n->next;
    71        
    72         if( !n )
    7371        {
    7472                char *s;
    … …  
    8684               
    8785                nick_strip( nick );
    88                 if (set_getint(irc, "lcnicks"))
     86                if( set_getbool( &acc->irc->set, "lcnicks" ) )
    8987                        nick_lc( nick );
    9088        }
    91        
    92         while( !nick_ok( nick ) || user_find( irc, nick ) )
     89        g_free( store_handle );
     90       
     91        /* Now, find out if the nick is already in use at the moment, and make
     92           subtle changes to make it unique. */
     93        while( !nick_ok( nick ) || user_find( acc->irc, nick ) )
    9394        {
    9495                if( strlen( nick ) < ( MAX_NICK_LENGTH - 1 ) )
    … …  
    106107                        int i;
    107108                       
    108                         irc_usermsg( irc, "WARNING: Almost had an infinite loop in nick_get()! "
    109                                           "This used to be a fatal BitlBee bug, but we tried to fix it. "
    110                                           "This message should *never* appear anymore. "
    111                                           "If it does, please *do* send us a bug report! "
    112                                           "Please send all the following lines in your report:" );
    113                        
    114                         irc_usermsg( irc, "Trying to get a sane nick for handle %s", handle );
     109                        irc_usermsg( acc->irc, "WARNING: Almost had an infinite loop in nick_get()! "
     110                                               "This used to be a fatal BitlBee bug, but we tried to fix it. "
     111                                               "This message should *never* appear anymore. "
     112                                               "If it does, please *do* send us a bug report! "
     113                                               "Please send all the following lines in your report:" );
     114                       
     115                        irc_usermsg( acc->irc, "Trying to get a sane nick for handle %s", handle );
    115116                        for( i = 0; i < MAX_NICK_LENGTH; i ++ )
    116                                 irc_usermsg( irc, "Char %d: %c/%d", i, nick[i], nick[i] );
    117                        
    118                         irc_usermsg( irc, "FAILED. Returning an insane nick now. Things might break. "
    119                                           "Good luck, and please don't forget to paste the lines up here "
    120                                           "in #bitlbee on OFTC or in a mail to wilmer@gaast.net" );
     117                                irc_usermsg( acc->irc, "Char %d: %c/%d", i, nick[i], nick[i] );
     118                       
     119                        irc_usermsg( acc->irc, "FAILED. Returning an insane nick now. Things might break. "
     120                                               "Good luck, and please don't forget to paste the lines up here "
     121                                               "in #bitlbee on OFTC or in a mail to wilmer@gaast.net" );
    121122                       
    122123                        g_snprintf( nick, MAX_NICK_LENGTH + 1, "xx%x", rand() );
    … …  
    126127        }
    127128       
    128         return( nick );
    129 }
    130 
    131 void nick_del( irc_t *irc, const char *nick )
    132 {
    133         nick_t *l = NULL, *n = irc->nicks;
    134        
    135         while( n )
    136         {
    137                 if( g_strcasecmp( n->nick, nick ) == 0 )
    138                 {
    139                         if( l )
    140                                 l->next = n->next;
    141                         else
    142                                 irc->nicks = n->next;
    143                        
    144                         g_free( n->handle );
    145                         g_free( n->nick );
    146                         g_free( n );
    147                        
    148                         break;
    149                 }
    150                 n = (l=n)->next;
    151         }
     129        return nick;
     130}
     131
     132void nick_del( account_t *acc, const char *handle )
     133{
     134        g_hash_table_remove( acc->nicks, handle );
    152135}
    153136

  • nick.h

    r6398094 reda0270  
    2424*/
    2525
    26 typedef struct __NICK
    27 {
    28         char *handle;
    29         struct prpl *proto;
    30         char *nick;
    31         struct __NICK *next;
    32 } nick_t;
    33 
    34 void nick_set( irc_t *irc, const char *handle, struct prpl *proto, const char *nick );
    35 char *nick_get( irc_t *irc, const char *handle, struct prpl *proto, const char *realname );
    36 void nick_del( irc_t *irc, const char *nick );
     26void nick_set( account_t *acc, const char *handle, const char *nick );
     27char *nick_get( account_t *acc, const char *handle, const char *realname );
     28void nick_del( account_t *acc, const char *handle );
    3729void nick_strip( char *nick );
    3830

  • protocols/Makefile

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

  • protocols/jabber/jabber.c

    r6398094 reda0270  
    561561static void gjab_start(gjconn gjc)
    562562{
    563         struct aim_user *user;
     563        account_t *acc;
    564564        int port = -1, ssl = 0;
    565         char *server = NULL, *s;
     565        char *server = NULL;
    566566
    567567        if (!gjc || gjc->state != JCONN_STATE_OFF)
    568568                return;
    569569
    570         user = GJ_GC(gjc)->user;
    571         if (*user->proto_opt[0]) {
    572                 /* If there's a dot, assume there's a hostname in the beginning */
    573                 if (strchr(user->proto_opt[0], '.')) {
    574                         server = g_strdup(user->proto_opt[0]);
    575                         if ((s = strchr(server, ':')))
    576                                 *s = 0;
    577                 }
    578                
    579                 /* After the hostname, there can be a port number */
    580                 s = strchr(user->proto_opt[0], ':');
    581                 if (s && isdigit(s[1]))
    582                         sscanf(s + 1, "%d", &port);
    583                
    584                 /* And if there's the string ssl, the user wants an SSL-connection */
    585                 if (strstr(user->proto_opt[0], ":ssl") || g_strcasecmp(user->proto_opt[0], "ssl") == 0)
    586                         ssl = 1;
    587         }
    588        
    589         if (port == -1 && !ssl)
    590                 port = DEFAULT_PORT;
    591         else if (port == -1 && ssl)
    592                 port = DEFAULT_PORT_SSL;
    593         else if (port < JABBER_PORT_MIN || port > JABBER_PORT_MAX) {
     570        acc = GJ_GC(gjc)->acc;
     571        server = acc->server;
     572        port = set_getint(&acc->set, "port");
     573        ssl = set_getbool(&acc->set, "ssl");
     574       
     575        if (port < JABBER_PORT_MIN || port > JABBER_PORT_MAX) {
    594576                serv_got_crap(GJ_GC(gjc), "For security reasons, the Jabber port number must be in the %d-%d range.", JABBER_PORT_MIN, JABBER_PORT_MAX);
    595577                STATE_EVT(JCONN_STATE_OFF)
    … …  
    614596        }
    615597       
    616         g_free(server);
    617        
    618         if (!user->gc || (gjc->fd < 0)) {
     598        if (!acc->gc || (gjc->fd < 0)) {
    619599                STATE_EVT(JCONN_STATE_OFF)
    620600                return;
    … …  
    15161496}
    15171497
    1518 static void jabber_login(struct aim_user *user)
    1519 {
    1520         struct gaim_connection *gc = new_gaim_conn(user);
    1521         struct jabber_data *jd = gc->proto_data = g_new0(struct jabber_data, 1);
    1522         char *loginname = create_valid_jid(user->username, DEFAULT_SERVER, "BitlBee");
    1523 
     1498static void jabber_acc_init(account_t *acc)
     1499{
     1500        set_t *s;
     1501       
     1502        s = set_add( &acc->set, "port", "5222", set_eval_int, acc );
     1503        s->flags |= ACC_SET_OFFLINE_ONLY;
     1504       
     1505        s = set_add( &acc->set, "resource", "BitlBee", NULL, acc );
     1506        s->flags |= ACC_SET_OFFLINE_ONLY;
     1507       
     1508        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
     1509        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
     1510       
     1511        s = set_add( &acc->set, "ssl", "false", set_eval_bool, acc );
     1512        s->flags |= ACC_SET_OFFLINE_ONLY;
     1513}
     1514
     1515static void jabber_login(account_t *acc)
     1516{
     1517        struct gaim_connection *gc;
     1518        struct jabber_data *jd;
     1519        char *resource, *loginname;
     1520       
     1521        /* Time to move some data/things from the old syntax to the new one: */
     1522        if (acc->server) {
     1523                char *s, *tmp_server;
     1524                int port;
     1525               
     1526                if (g_strcasecmp(acc->server, "ssl") == 0) {
     1527                        set_setstr(&acc->set, "server", "");
     1528                        set_setint(&acc->set, "port", DEFAULT_PORT_SSL);
     1529                        set_setstr(&acc->set, "ssl", "true");
     1530                       
     1531                        g_free(acc->server);
     1532                        acc->server = NULL;
     1533                } else if ((s = strchr(acc->server, ':'))) {
     1534                        if (strstr(acc->server, ":ssl")) {
     1535                                set_setint(&acc->set, "port", DEFAULT_PORT_SSL);
     1536                                set_setstr(&acc->set, "ssl", "true");
     1537                        }
     1538                        if (isdigit(s[1])) {
     1539                                if (sscanf(s + 1, "%d", &port) == 1)
     1540                                        set_setint(&acc->set, "port", port);
     1541                        }
     1542                        tmp_server = g_strndup(acc->server, s - acc->server);
     1543                        set_setstr(&acc->set, "server", tmp_server);
     1544                        g_free(tmp_server);
     1545                }
     1546        }
     1547       
     1548        gc = new_gaim_conn(acc);
     1549        jd = gc->proto_data = g_new0(struct jabber_data, 1);
     1550       
     1551        if( strchr( acc->user, '@' ) == NULL )
     1552        {
     1553                hide_login_progress( gc, "Invalid account name" );
     1554                signoff( gc );
     1555                return;
     1556        }
     1557       
     1558        resource = set_getstr(&acc->set, "resource");
     1559        loginname = create_valid_jid(acc->user, DEFAULT_SERVER, resource);
     1560       
    15241561        jd->hash = g_hash_table_new(g_str_hash, g_str_equal);
    15251562        jd->chats = NULL;       /* we have no chats yet */
    … …  
    15271564        set_login_progress(gc, 1, _("Connecting"));
    15281565
    1529         if (!(jd->gjc = gjab_new(loginname, user->password, gc))) {
     1566        if (!(jd->gjc = gjab_new(loginname, acc->pass, gc))) {
    15301567                g_free(loginname);
    15311568                hide_login_progress(gc, _("Unable to connect"));
    … …  
    23372374        ret->name = "jabber";
    23382375        ret->away_states = jabber_away_states;
     2376        ret->acc_init = jabber_acc_init;
    23392377        ret->login = jabber_login;
    23402378        ret->close = jabber_close;
    … …  
    23492387        ret->alias_buddy = jabber_roster_update;
    23502388        ret->group_buddy = jabber_group_change;
    2351         ret->cmp_buddynames = g_strcasecmp;
     2389        ret->handle_cmp = g_strcasecmp;
    23522390
    23532391        register_protocol (ret);

  • protocols/msn/msn.c

    r6398094 reda0270  
    2727#include "msn.h"
    2828
    29 static void msn_login( struct aim_user *acct )
    30 {
    31         struct gaim_connection *gc = new_gaim_conn( acct );
     29static char *msn_set_display_name( set_t *set, char *value );
     30
     31static void msn_acc_init( account_t *acc )
     32{
     33        set_t *s;
     34       
     35        s = set_add( &acc->set, "display_name", NULL, msn_set_display_name, acc );
     36        s->flags |= ACC_SET_NOSAVE | ACC_SET_ONLINE_ONLY;
     37}
     38
     39static void msn_login( account_t *acc )
     40{
     41        struct gaim_connection *gc = new_gaim_conn( acc );
    3242        struct msn_data *md = g_new0( struct msn_data, 1 );
    3343       
    … …  
    3747        md->fd = -1;
    3848       
    39         if( strchr( acct->username, '@' ) == NULL )
     49        if( strchr( acc->user, '@' ) == NULL )
    4050        {
    4151                hide_login_progress( gc, "Invalid account name" );
    … …  
    212222static void msn_set_info( struct gaim_connection *gc, char *info )
    213223{
    214         int i;
    215         char buf[1024], *fn, *s;
    216         struct msn_data *md = gc->proto_data;
    217        
    218         if( strlen( info ) > 129 )
    219         {
    220                 do_error_dialog( gc, "Maximum name length exceeded", "MSN" );
    221                 return;
    222         }
    223        
    224         /* Of course we could use http_encode() here, but when we encode
    225            every character, the server is less likely to complain about the
    226            chosen name. However, the MSN server doesn't seem to like escaped
    227            non-ASCII chars, so we keep those unescaped. */
    228         s = fn = g_new0( char, strlen( info ) * 3 + 1 );
    229         for( i = 0; info[i]; i ++ )
    230                 if( info[i] & 128 )
    231                 {
    232                         *s = info[i];
    233                         s ++;
    234                 }
    235                 else
    236                 {
    237                         g_snprintf( s, 4, "%%%02X", info[i] );
    238                         s += 3;
    239                 }
    240        
    241         g_snprintf( buf, sizeof( buf ), "REA %d %s %s\r\n", ++md->trId, gc->username, fn );
    242         msn_write( gc, buf, strlen( buf ) );
    243         g_free( fn );
     224        msn_set_display_name( set_find( &gc->acc->set, "display_name" ), info );
    244225}
    245226
    … …  
    380361}
    381362
     363static char *msn_set_display_name( set_t *set, char *value )
     364{
     365        account_t *acc = set->data;
     366        struct gaim_connection *gc = acc->gc;
     367        struct msn_data *md;
     368        char buf[1024], *fn, *s;
     369        int i;
     370       
     371        /* Double-check. */
     372        if( gc == NULL )
     373                return NULL;
     374       
     375        md = gc->proto_data;
     376       
     377        if( strlen( value ) > 129 )
     378        {
     379                serv_got_crap( gc, "Maximum name length exceeded" );
     380                return NULL;
     381        }
     382       
     383        /* Of course we could use http_encode() here, but when we encode
     384           every character, the server is less likely to complain about the
     385           chosen name. However, the MSN server doesn't seem to like escaped
     386           non-ASCII chars, so we keep those unescaped. */
     387        s = fn = g_new0( char, strlen( value ) * 3 + 1 );
     388        for( i = 0; value[i]; i ++ )
     389                if( value[i] & 128 )
     390                {
     391                        *s = value[i];
     392                        s ++;
     393                }
     394                else
     395                {
     396                        g_snprintf( s, 4, "%%%02X", value[i] );
     397                        s += 3;
     398                }
     399       
     400        g_snprintf( buf, sizeof( buf ), "REA %d %s %s\r\n", ++md->trId, gc->username, fn );
     401        msn_write( gc, buf, strlen( buf ) );
     402        g_free( fn );
     403       
     404        /* Returning NULL would be better, because the server still has to
     405           confirm the name change. However, it looks a bit confusing to the
     406           user. */
     407        return value;
     408}
     409
    382410void msn_init()
    383411{
    384412        struct prpl *ret = g_new0(struct prpl, 1);
     413       
    385414        ret->name = "msn";
    386415        ret->login = msn_login;
     416        ret->acc_init = msn_acc_init;
    387417        ret->close = msn_close;
    388418        ret->send_im = msn_send_im;
    … …  
    404434        ret->rem_deny = msn_rem_deny;
    405435        ret->send_typing = msn_send_typing;
    406         ret->cmp_buddynames = g_strcasecmp;
     436        ret->handle_cmp = g_strcasecmp;
    407437
    408438        register_protocol(ret);

  • protocols/msn/ns.c

    r6398094 reda0270  
    223223                else if( num_parts == 7 && strcmp( cmd[2], "OK" ) == 0 )
    224224                {
     225                        set_t *s;
     226                       
    225227                        http_decode( cmd[4] );
    226228                       
    227229                        strncpy( gc->displayname, cmd[4], sizeof( gc->displayname ) );
    228230                        gc->displayname[sizeof(gc->displayname)-1] = 0;
     231                       
     232                        if( ( s = set_find( &gc->acc->set, "display_name" ) ) )
     233                        {
     234                                g_free( s->value );
     235                                s->value = g_strdup( cmd[4] );
     236                        }
    229237                       
    230238                        set_login_progress( gc, 1, "Authenticated, getting buddy list" );
    … …  
    517525                if( g_strcasecmp( cmd[3], gc->username ) == 0 )
    518526                {
     527                        set_t *s;
     528                       
    519529                        http_decode( cmd[4] );
    520530                        strncpy( gc->displayname, cmd[4], sizeof( gc->displayname ) );
    521531                        gc->displayname[sizeof(gc->displayname)-1] = 0;
     532                       
     533                        if( ( s = set_find( &gc->acc->set, "display_name" ) ) )
     534                        {
     535                                g_free( s->value );
     536                                s->value = g_strdup( cmd[4] );
     537                        }
    522538                }
    523539                else

  • protocols/nogaim.c

    r6398094 reda0270  
    145145/* multi.c */
    146146
    147 struct gaim_connection *new_gaim_conn( struct aim_user *user )
     147struct gaim_connection *new_gaim_conn( account_t *acc )
    148148{
    149149        struct gaim_connection *gc;
    150         account_t *a;
    151150       
    152151        gc = g_new0( struct gaim_connection, 1 );
    153152       
    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;
     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;
    161160       
    162161        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                 }
    174162       
    175163        return( gc );
    … …  
    189177       
    190178        connections = g_slist_remove( connections, gc );
    191         g_free( gc->user );
    192179        g_free( gc );
    193180}
    … …  
    220207        va_end( params );
    221208
    222         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    223             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     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" ) ) )
    224211                strip_html( text );
    225212       
    226213        /* Try to find a different connection on the same protocol. */
    227214        for( a = gc->irc->accounts; a; a = a->next )
    228                 if( a->prpl == gc->prpl && a->gc != gc )
     215                if( a->prpl == gc->acc->prpl && a->gc != gc )
    229216                        break;
    230217       
    231218        /* If we found one, include the screenname in the message. */
    232219        if( a )
    233                 irc_usermsg( gc->irc, "%s(%s) - %s", gc->prpl->name, gc->username, text );
     220                irc_usermsg( gc->irc, "%s(%s) - %s", gc->acc->prpl->name, gc->username, text );
    234221        else
    235                 irc_usermsg( gc->irc, "%s - %s", gc->prpl->name, text );
     222                irc_usermsg( gc->irc, "%s - %s", gc->acc->prpl->name, text );
    236223       
    237224        g_free( text );
    … …  
    242229        struct gaim_connection *gc = d;
    243230       
    244         if( gc->prpl && gc->prpl->keepalive )
    245                 gc->prpl->keepalive( gc );
     231        if( gc->acc->prpl->keepalive )
     232                gc->acc->prpl->keepalive( gc );
    246233       
    247234        return TRUE;
    … …  
    297284        b_event_remove( gc->keepalive );
    298285        gc->flags |= OPT_LOGGING_OUT;
     286       
    299287        gc->keepalive = 0;
    300         gc->prpl->close( gc );
     288        gc->acc->prpl->close( gc );
    301289        b_event_remove( gc->inpa );
    302290       
    … …  
    323311                /* Uhm... This is very sick. */
    324312        }
    325         else if( !gc->wants_to_die && set_getint( irc, "auto_reconnect" ) )
    326         {
    327                 int delay = set_getint( irc, "auto_reconnect_delay" );
     313        else if( !gc->wants_to_die && set_getint( &irc->set, "auto_reconnect" ) )
     314        {
     315                int delay = set_getint( &irc->set, "auto_reconnect_delay" );
    328316               
    329317                serv_got_crap( gc, "Reconnecting in %d seconds..", delay );
    … …  
    364352        irc_t *irc = gc->irc;
    365353       
    366         if( set_getint( irc, "debug" ) && 0 ) /* This message is too useless */
     354        if( set_getint( &irc->set, "debug" ) && 0 ) /* This message is too useless */
    367355                serv_got_crap( gc, "Receiving user add from handle: %s", handle );
    368356       
    369357        if( user_findhandle( gc, handle ) )
    370358        {
    371                 if( set_getint( irc, "debug" ) )
     359                if( set_getint( &irc->set, "debug" ) )
    372360                        serv_got_crap( gc, "User already exists, ignoring add request: %s", handle );
    373361               
    … …  
    378366       
    379367        memset( nick, 0, MAX_NICK_LENGTH + 1 );
    380         strcpy( nick, nick_get( gc->irc, handle, gc->prpl, realname ) );
     368        strcpy( nick, nick_get( gc->acc, handle, realname ) );
    381369       
    382370        u = user_add( gc->irc, nick );
    … …  
    390378                u->user = g_strndup( handle, s - handle );
    391379        }
    392         else if( gc->user->proto_opt[0] && *gc->user->proto_opt[0] )
     380        else if( gc->acc->server )
    393381        {
    394382                char *colon;
    395383               
    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] );
     384                if( ( colon = strchr( gc->acc->server, ':' ) ) )
     385                        u->host = g_strndup( gc->acc->server,
     386                                             colon - gc->acc->server );
    399387                else
    400                         u->host = g_strdup( gc->user->proto_opt[0] );
     388                        u->host = g_strdup( gc->acc->server );
    401389               
    402390                u->user = g_strdup( handle );
    … …  
    409397        else
    410398        {
    411                 u->host = g_strdup( gc->user->prpl->name );
     399                u->host = g_strdup( gc->acc->prpl->name );
    412400                u->user = g_strdup( handle );
    413401        }
    … …  
    457445                u->realname = g_strdup( realname );
    458446               
    459                 if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( gc->irc, "display_namechanges" ) )
     447                if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( &gc->irc->set, "display_namechanges" ) )
    460448                        serv_got_crap( gc, "User `%s' changed name to `%s'", u->nick, u->realname );
    461449        }
    … …  
    479467void show_got_added_yes( gpointer w, struct show_got_added_data *data )
    480468{
    481         data->gc->prpl->add_buddy( data->gc, data->handle );
     469        data->gc->acc->prpl->add_buddy( data->gc, data->handle );
    482470        add_buddy( data->gc, NULL, data->handle, data->handle );
    483471       
    … …  
    513501        if( !u )
    514502        {
    515                 if( g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "add" ) == 0 )
     503                if( g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "add" ) == 0 )
    516504                {
    517505                        add_buddy( gc, NULL, handle, NULL );
    … …  
    520508                else
    521509                {
    522                         if( set_getint( gc->irc, "debug" ) || g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "ignore" ) != 0 )
     510                        if( set_getint( &gc->irc->set, "debug" ) || g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "ignore" ) != 0 )
    523511                        {
    524512                                serv_got_crap( gc, "serv_got_update() for handle %s:", handle );
    … …  
    558546        }
    559547       
    560         if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "oscar") || !strcmp(gc->prpl->name, "icq")) )
     548        if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "oscar" ) == 0 || strcmp( gc->acc->prpl->name, "icq" ) == 0 ) )
    561549        {
    562550                u->away = g_strdup( "Away" );
    563551        }
    564         else if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "jabber") ) )
     552        else if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "jabber" ) == 0 ) )
    565553        {
    566554                if( type & UC_DND )
    … …  
    571559                        u->away = g_strdup( "Away" );
    572560        }
    573         else if( ( type & UC_UNAVAILABLE ) && gc->prpl->get_status_string )
    574         {
    575                 u->away = g_strdup( gc->prpl->get_status_string( gc, type ) );
     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 ) );
    576564        }
    577565        else
    … …  
    579567       
    580568        /* LISPy... */
    581         if( ( set_getint( gc->irc, "away_devoice" ) ) &&                /* Don't do a thing when user doesn't want it */
     569        if( ( set_getint( &gc->irc->set, "away_devoice" ) ) &&          /* Don't do a thing when user doesn't want it */
    582570            ( u->online ) &&                                            /* Don't touch offline people */
    583571            ( ( ( u->online != oo ) && !u->away ) ||                    /* Voice joining people */
    … …  
    598586        if( !u )
    599587        {
    600                 char *h = set_getstr( irc, "handle_unknown" );
     588                char *h = set_getstr( &irc->set, "handle_unknown" );
    601589               
    602590                if( g_strcasecmp( h, "ignore" ) == 0 )
    603591                {
    604                         if( set_getint( irc, "debug" ) )
     592                        if( set_getint( &irc->set, "debug" ) )
    605593                                serv_got_crap( gc, "Ignoring message from unknown handle %s", handle );
    606594                       
    … …  
    609597                else if( g_strncasecmp( h, "add", 3 ) == 0 )
    610598                {
    611                         int private = set_getint( irc, "private" );
     599                        int private = set_getint( &irc->set, "private" );
    612600                       
    613601                        if( h[3] )
    … …  
    630618        }
    631619       
    632         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    633             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     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" ) ) )
    634622                strip_html( msg );
    635623
    … …  
    671659        user_t *u;
    672660       
    673         if( !set_getint( gc->irc, "typing_notice" ) )
     661        if( !set_getint( &gc->irc->set, "typing_notice" ) )
    674662                return;
    675663       
    … …  
    693681        GList *ir;
    694682       
    695         if( set_getint( gc->irc, "debug" ) )
     683        if( set_getint( &gc->irc->set, "debug" ) )
    696684                serv_got_crap( gc, "You were removed from conversation %d", (int) id );
    697685       
    … …  
    732720       
    733721        /* Gaim sends own messages through this too. IRC doesn't want this, so kill them */
    734         if( g_strcasecmp( who, gc->user->username ) == 0 )
     722        if( g_strcasecmp( who, gc->username ) == 0 )
    735723                return;
    736724       
    … …  
    738726        for( c = gc->conversations; c && c->id != id; c = c->next );
    739727       
    740         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    741             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     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" ) ) )
    742730                strip_html( msg );
    743731       
    … …  
    772760        g_free( s );
    773761       
    774         if( set_getint( gc->irc, "debug" ) )
     762        if( set_getint( &gc->irc->set, "debug" ) )
    775763                serv_got_crap( gc, "Creating new conversation: (id=%d,handle=%s)", id, handle );
    776764       
    … …  
    786774        int me = 0;
    787775       
    788         if( set_getint( b->gc->irc, "debug" ) )
     776        if( set_getint( &b->gc->irc->set, "debug" ) )
    789777                serv_got_crap( b->gc, "User %s added to conversation %d", handle, b->id );
    790778       
    791779        /* It might be yourself! */
    792         if( b->gc->prpl->cmp_buddynames( handle, b->gc->user->username ) == 0 )
     780        if( b->gc->acc->prpl->handle_cmp( handle, b->gc->username ) == 0 )
    793781        {
    794782                u = user_find( b->gc->irc, b->gc->irc->nick );
    … …  
    820808        int me = 0;
    821809       
    822         if( set_getint( b->gc->irc, "debug" ) )
     810        if( set_getint( &b->gc->irc->set, "debug" ) )
    823811                serv_got_crap( b->gc, "User %s removed from conversation %d (%s)", handle, b->id, reason ? reason : "" );
    824812       
    825813        /* It might be yourself! */
    826         if( g_strcasecmp( handle, b->gc->user->username ) == 0 )
     814        if( g_strcasecmp( handle, b->gc->username ) == 0 )
    827815        {
    828816                u = user_find( b->gc->irc, b->gc->irc->nick );
    … …  
    882870}
    883871
    884 char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value )
    885 {
     872char *set_eval_away_devoice( set_t *set, char *value )
     873{
     874        irc_t *irc = set->data;
    886875        int st;
    887876       
    … …  
    897886        /* Horror.... */
    898887       
    899         if( st != set_getint( irc, "away_devoice" ) )
     888        if( st != set_getint( &irc->set, "away_devoice" ) )
    900889        {
    901890                char list[80] = "";
    … …  
    937926        }
    938927       
    939         return( set_eval_bool( irc, set, value ) );
     928        return( set_eval_bool( set, value ) );
    940929}
    941930
    … …  
    957946        }
    958947       
    959         st = gc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
     948        st = gc->acc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
    960949        g_free( buf );
    961950       
    … …  
    974963        }
    975964       
    976         st = gc->prpl->chat_send( gc, id, msg );
     965        st = gc->acc->prpl->chat_send( gc, id, msg );
    977966        g_free( buf );
    978967       
    … …  
    988977       
    989978        if( !away ) away = "";
    990         ms = m = gc->prpl->away_states( gc );
     979        ms = m = gc->acc->prpl->away_states( gc );
    991980       
    992981        while( m )
    … …  
    1009998        if( m )
    1010999        {
    1011                 gc->prpl->set_away( gc, m->data, *away ? away : NULL );
     1000                gc->acc->prpl->set_away( gc, m->data, *away ? away : NULL );
    10121001        }
    10131002        else
    … …  
    10161005                if( s )
    10171006                {
    1018                         gc->prpl->set_away( gc, s, away );
    1019                         if( set_getint( gc->irc, "debug" ) )
     1007                        gc->acc->prpl->set_away( gc, s, away );
     1008                        if( set_getint( &gc->irc->set, "debug" ) )
    10201009                                serv_got_crap( gc, "Setting away state to %s", s );
    10211010                }
    10221011                else
    1023                         gc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
     1012                        gc->acc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
    10241013        }
    10251014       
    … …  
    10731062void bim_add_allow( struct gaim_connection *gc, char *handle )
    10741063{
    1075         if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1064        if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) == NULL )
    10761065        {
    10771066                gc->permit = g_slist_prepend( gc->permit, g_strdup( handle ) );
    10781067        }
    10791068       
    1080         gc->prpl->add_permit( gc, handle );
     1069        gc->acc->prpl->add_permit( gc, handle );
    10811070}
    10821071
    … …  
    10851074        GSList *l;
    10861075       
    1087         if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1076        if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) ) )
    10881077        {
    10891078                g_free( l->data );
    … …  
    10911080        }
    10921081       
    1093         gc->prpl->rem_permit( gc, handle );
     1082        gc->acc->prpl->rem_permit( gc, handle );
    10941083}
    10951084
    10961085void bim_add_block( struct gaim_connection *gc, char *handle )
    10971086{
    1098         if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1087        if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) == NULL )
    10991088        {
    11001089                gc->deny = g_slist_prepend( gc->deny, g_strdup( handle ) );
    11011090        }
    11021091       
    1103         gc->prpl->add_deny( gc, handle );
     1092        gc->acc->prpl->add_deny( gc, handle );
    11041093}
    11051094
    … …  
    11081097        GSList *l;
    11091098       
    1110         if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1099        if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) ) )
    11111100        {
    11121101                g_free( l->data );
    … …  
    11141103        }
    11151104       
    1116         gc->prpl->rem_deny( gc, handle );
    1117 }
     1105        gc->acc->prpl->rem_deny( gc, handle );
     1106}

  • protocols/nogaim.h

    r6398094 reda0270  
    3939
    4040#include "bitlbee.h"
     41#include "account.h"
    4142#include "proxy.h"
    4243#include "md5.h"
    … …  
    6364struct gaim_connection
    6465{
    65         struct prpl *prpl;
     66        account_t *acc;
    6667        guint32 flags;
    6768       
    … …  
    7879        GSList *deny;
    7980        int permdeny;
    80        
    81         struct aim_user *user;
    8281       
    8382        char username[64];
    … …  
    126125};
    127126
    128 struct 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 
    143127struct prpl {
    144128        int options;
    145129        const char *name;
    146130
    147         void (* login)          (struct aim_user *);
     131        void (* acc_init)       (account_t *);
     132        void (* login)          (account_t *);
    148133        void (* keepalive)      (struct gaim_connection *);
    149134        void (* close)          (struct gaim_connection *);
    … …  
    180165       
    181166        /* Mainly for AOL, since they think "Bung hole" == "Bu ngho le". *sigh* */
    182         int (* cmp_buddynames) (const char *who1, const char *who2);
     167        int (* handle_cmp) (const char *who1, const char *who2);
    183168};
    184169
    … …  
    206191
    207192void nogaim_init();
    208 char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value );
     193char *set_eval_away_devoice( set_t *set, char *value );
    209194
    210195gboolean auto_reconnect( gpointer data, gint fd, b_input_condition cond );
    … …  
    212197
    213198/* multi.c */
    214 G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( struct aim_user *user );
     199G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( account_t *acc );
    215200G_MODULE_EXPORT void destroy_gaim_conn( struct gaim_connection *gc );
    216201G_MODULE_EXPORT void set_login_progress( struct gaim_connection *gc, int step, char *msg );

  • protocols/oscar/oscar.c

    r6398094 reda0270  
    356356}
    357357
    358 static void oscar_login(struct aim_user *user) {
     358static void oscar_acc_init(account_t *acc)
     359{
     360        set_t *s;
     361       
     362        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
     363        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
     364}
     365
     366static void oscar_login(account_t *acc) {
    359367        aim_session_t *sess;
    360368        aim_conn_t *conn;
    361369        char buf[256];
    362         struct gaim_connection *gc = new_gaim_conn(user);
     370        struct gaim_connection *gc = new_gaim_conn(acc);
    363371        struct oscar_data *odata = gc->proto_data = g_new0(struct oscar_data, 1);
    364372
    365         if (isdigit(*user->username)) {
     373        if (isdigit(acc->user[0])) {
    366374                odata->icq = TRUE;
    367375                /* This is odd but it's necessary for a proper do_import and do_export.
    368376                   We don't do those anymore, but let's stick with it, just in case
    369                    it accidentally fixes something else too... */
     377                   it accidentally fixes something else too... </bitlbee> */
    370378                gc->password[8] = 0;
    371379        } else {
    … …  
    390398        }
    391399       
    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]);
     400        if (acc->server == NULL) {
     401                hide_login_progress(gc, "No servername specified");
     402                signoff(gc);
     403                return;
     404        }
     405       
     406        if (g_strcasecmp(acc->server, "login.icq.com") != 0 &&
     407            g_strcasecmp(acc->server, "login.oscar.aol.com") != 0) {
     408                serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",acc->server);
    395409        }
    396410       
    … …  
    402416
    403417        conn->status |= AIM_CONN_STATUS_INPROGRESS;
    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);
     418        conn->fd = proxy_connect(acc->server, AIM_LOGIN_PORT, oscar_login_connect, gc);
    409419        if (conn->fd < 0) {
    410420                hide_login_progress(gc, _("Couldn't connect to host"));
    … …  
    485495        struct aim_authresp_info *info;
    486496        int i; char *host; int port;
    487         struct aim_user *user;
    488497        aim_conn_t *bosconn;
    489498
    490499        struct gaim_connection *gc = sess->aux_data;
    491500        struct oscar_data *od = gc->proto_data;
    492         user = gc->user;
    493         port = user->proto_opt[USEROPT_AUTHPORT][0] ?
    494                 atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
     501        port = AIM_LOGIN_PORT;
    495502
    496503        va_start(ap, fr);
    … …  
    871878        struct aim_redirect_data *redir;
    872879        struct gaim_connection *gc = sess->aux_data;
    873         struct aim_user *user = gc->user;
    874880        aim_conn_t *tstconn;
    875881        int i;
    … …  
    877883        int port;
    878884
    879         port = user->proto_opt[USEROPT_AUTHPORT][0] ?
    880                 atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
    881 
    882885        va_start(ap, fr);
    883886        redir = va_arg(ap, struct aim_redirect_data *);
    884887        va_end(ap);
    885888
     889        port = AIM_LOGIN_PORT;
    886890        for (i = 0; i < (int)strlen(redir->ip); i++) {
    887891                if (redir->ip[i] == ':') {
    … …  
    17231727        odata->rights.maxsiglen = odata->rights.maxawaymsglen = (guint)maxsiglen;
    17241728
     1729        /* FIXME: It seems we're not really using this, and it broke now that
     1730           struct aim_user is dead.
    17251731        aim_bos_setprofile(sess, fr->conn, gc->user->user_info, NULL, gaim_caps);
    1726 
     1732        */
     1733       
    17271734        return 1;
    17281735}
    … …  
    26562663        ret->away_states = oscar_away_states;
    26572664        ret->login = oscar_login;
     2665        ret->acc_init = oscar_acc_init;
    26582666        ret->close = oscar_close;
    26592667        ret->send_im = oscar_send_im;
    … …  
    26732681        ret->set_permit_deny = oscar_set_permit_deny;
    26742682        ret->keepalive = oscar_keepalive;
    2675         ret->cmp_buddynames = aim_sncmp;
    26762683        ret->get_status_string = oscar_get_status_string;
    26772684        ret->send_typing = oscar_send_typing;
     2685       
     2686        ret->handle_cmp = aim_sncmp;
    26782687
    26792688        register_protocol(ret);

  • protocols/yahoo/libyahoo2.c

    r6398094 reda0270  
    8989#define vsnprintf _vsnprintf
    9090#endif
     91
     92#include "base64.h"
    9193
    9294#ifdef USE_STRUCT_CALLBACKS
    … …  
    695697}
    696698
    697 static char base64digits[] =    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    698                                 "abcdefghijklmnopqrstuvwxyz"
    699                                 "0123456789._";
     699/* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
    700700static void to_y64(unsigned char *out, const unsigned char *in, int inlen)
    701 /* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
    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';
     701{
     702        base64_encode_real(in, inlen, out, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
    725703}
    726704

  • protocols/yahoo/yahoo.c

    r6398094 reda0270  
    121121}
    122122
    123 static void byahoo_login( struct aim_user *user )
    124 {
    125         struct gaim_connection *gc = new_gaim_conn( user );
     123static void byahoo_login( account_t *acc )
     124{
     125        struct gaim_connection *gc = new_gaim_conn( acc );
    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( user->username, user->password );
     132        yd->y2_id = yahoo_init( acc->user, acc->pass );
    133133        yahoo_login( yd->y2_id, yd->current_status );
    134134}
    … …  
    409409        ret->chat_leave = byahoo_chat_leave;
    410410        ret->chat_open = byahoo_chat_open;
    411         ret->cmp_buddynames = g_strcasecmp;
     411
     412        ret->handle_cmp = g_strcasecmp;
    412413       
    413414        register_protocol(ret);
    … …  
    425426                yd = gc->proto_data;
    426427               
    427                 if( !strcmp(gc->prpl->name, "yahoo") && yd->y2_id == id )
     428                if( strcmp( gc->acc->prpl->name, "yahoo" ) == 0 && yd->y2_id == id )
    428429                        return( gc );
    429430        }

  • query.c

    r6398094 reda0270  
    6363        }
    6464       
    65         if( g_strcasecmp( set_getstr( irc, "query_order" ), "lifo" ) == 0 || irc->queries == q )
     65        if( g_strcasecmp( set_getstr( &irc->set, "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, "query_order" ), "fifo" ) == 0 )
     174        if( g_strcasecmp( set_getstr( &irc->set, "query_order" ), "fifo" ) == 0 )
    175175                q = irc->queries;
    176176        else

  • root_commands.c

    r6398094 reda0270  
    127127}
    128128
     129static void cmd_account( irc_t *irc, char **cmd );
     130
    129131static void cmd_identify( irc_t *irc, char **cmd )
    130132{
    131133        storage_status_t status = storage_load( irc->nick, cmd[1], irc );
     134        char *account_on[] = { "account", "on", NULL };
    132135       
    133136        switch (status) {
    … …  
    139142                break;
    140143        case STORAGE_OK:
    141                 irc_usermsg( irc, "Password accepted" );
     144                irc_usermsg( irc, "Password accepted, settings and accounts loaded" );
    142145                irc_umode_set( irc, "+R", 1 );
     146                if( set_getint( &irc->set, "auto_connect" ) )
     147                        cmd_account( irc, account_on );
    143148                break;
     149        case STORAGE_OTHER_ERROR:
    144150        default:
    145                 irc_usermsg( irc, "Something very weird happened" );
     151                irc_usermsg( irc, "Unknown error while loading configuration" );
    146152                break;
    147153        }
    … …  
    226232
    227233                a = account_add( irc, prpl, cmd[3], cmd[4] );
    228                
    229234                if( cmd[5] )
    230                         a->server = g_strdup( cmd[5] );
     235                        set_setstr( &a->set, "server", cmd[5] );
    231236               
    232237                irc_usermsg( irc, "Account successfully added" );
    … …  
    306311                       
    307312                                for( a = irc->accounts; a; a = a->next )
    308                                         if( !a->gc )
     313                                        if( !a->gc && a->auto_connect )
    309314                                                account_on( irc, a );
    310315                        }
    … …  
    352357                }
    353358        }
     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                        g_free( acc_handle );
     380                        irc_usermsg( irc, "Invalid account" );
     381                        return;
     382                }
     383               
     384                if( cmd[3] )
     385                {
     386                        set_t *s = set_find( &a->set, set_name );
     387                       
     388                        if( a->gc && s && s->flags & ACC_SET_OFFLINE_ONLY )
     389                        {
     390                                g_free( acc_handle );
     391                                irc_usermsg( irc, "This setting can only be changed when the account is %s-line", "off" );
     392                                return;
     393                        }
     394                        else if( !a->gc && s && s->flags & ACC_SET_ONLINE_ONLY )
     395                        {
     396                                g_free( acc_handle );
     397                                irc_usermsg( irc, "This setting can only be changed when the account is %s-line", "on" );
     398                                return;
     399                        }
     400                       
     401                        set_setstr( &a->set, set_name, cmd[3] );
     402                       
     403                        if( ( strcmp( cmd[3], "=" ) ) == 0 && cmd[4] )
     404                                irc_usermsg( irc, "Warning: Correct syntax: \002account set <variable> <value>\002 (without =)" );
     405                }
     406                if( set_name ) /* else 'forgotten' on purpose.. Must show new value after changing */
     407                {
     408                        char *s = set_getstr( &a->set, set_name );
     409                        if( s )
     410                                irc_usermsg( irc, "%s = `%s'", set_name, s );
     411                        else
     412                                irc_usermsg( irc, "%s is empty", set_name );
     413                }
     414                else
     415                {
     416                        set_t *s = a->set;
     417                        while( s )
     418                        {
     419                                if( s->value || s->def )
     420                                        irc_usermsg( irc, "%s = `%s'", s->key, s->value?s->value:s->def );
     421                                else
     422                                        irc_usermsg( irc, "%s is empty", s->key );
     423                                s = s->next;
     424                        }
     425                }
     426               
     427                g_free( acc_handle );
     428        }
    354429        else
    355430        {
    … …  
    394469                else
    395470                {
    396                         nick_set( irc, cmd[2], a->gc->prpl, cmd[3] );
     471                        nick_set( a, cmd[2], cmd[3] );
    397472                }
    398473        }
    … …  
    401476           add them to your *real* (server-side) contact list. */
    402477        if( add_for_real )
    403                 a->gc->prpl->add_buddy( a->gc, cmd[2] );
     478                a->gc->acc->prpl->add_buddy( a->gc, cmd[2] );
    404479               
    405480        add_buddy( a->gc, NULL, cmd[2], cmd[2] );
    … …  
    435510        }
    436511       
    437         if( !gc->prpl->get_info )
     512        if( !gc->acc->prpl->get_info )
    438513        {
    439514                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
    … …  
    441516        else
    442517        {
    443                 gc->prpl->get_info( gc, cmd[2] );
     518                gc->acc->prpl->get_info( gc, cmd[2] );
    444519        }
    445520}
    … …  
    476551                else if( u->send_handler == buddy_send_handler )
    477552                {
    478                         nick_set( irc, u->handle, u->gc->prpl, cmd[2] );
     553                        nick_set( u->gc->acc, u->handle, cmd[2] );
    479554                }
    480555               
    … …  
    495570        s = g_strdup( u->handle );
    496571       
    497         u->gc->prpl->remove_buddy( u->gc, u->handle, NULL );
     572        u->gc->acc->prpl->remove_buddy( u->gc, u->handle, NULL );
    498573        user_del( irc, cmd[1] );
    499         nick_del( irc, cmd[1] );
     574        nick_del( u->gc->acc, u->handle );
    500575       
    501576        irc_usermsg( irc, "Buddy `%s' (nick %s) removed from contact list", s, cmd[1] );
    … …  
    552627        }
    553628       
    554         if( !gc->prpl->add_deny || !gc->prpl->rem_permit )
     629        if( !gc->acc->prpl->add_deny || !gc->acc->prpl->rem_permit )
    555630        {
    556631                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
    … …  
    611686        }
    612687       
    613         if( !gc->prpl->rem_deny || !gc->prpl->add_permit )
     688        if( !gc->acc->prpl->rem_deny || !gc->acc->prpl->add_permit )
    614689        {
    615690                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
    … …  
    666741        if( cmd[1] && cmd[2] )
    667742        {
    668                 set_setstr( irc, cmd[1], cmd[2] );
     743                set_setstr( &irc->set, cmd[1], cmd[2] );
    669744               
    670745                if( ( strcmp( cmd[2], "=" ) ) == 0 && cmd[3] )
    … …  
    673748        if( cmd[1] ) /* else 'forgotten' on purpose.. Must show new value after changing */
    674749        {
    675                 char *s = set_getstr( irc, cmd[1] );
     750                char *s = set_getstr( &irc->set, cmd[1] );
    676751                if( s )
    677752                        irc_usermsg( irc, "%s = `%s'", cmd[1], s );
     753                else
     754                        irc_usermsg( irc, "%s is empty", cmd[1] );
    678755        }
    679756        else
    … …  
    684761                        if( s->value || s->def )
    685762                                irc_usermsg( irc, "%s = `%s'", s->key, s->value?s->value:s->def );
     763                        else
     764                                irc_usermsg( irc, "%s is empty", s->key );
    686765                        s = s->next;
    687766                }
    … …  
    727806                if( online == 1 )
    728807                {
    729                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     808                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
    730809                        irc_usermsg( irc, format, u->nick, s, "Online" );
    731810                }
    … …  
    738817                if( away == 1 )
    739818                {
    740                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     819                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
    741820                        irc_usermsg( irc, format, u->nick, s, u->away );
    742821                }
    … …  
    748827                if( offline == 1 )
    749828                {
    750                         g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     829                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->acc->prpl->name );
    751830                        irc_usermsg( irc, format, u->nick, s, "Offline" );
    752831                }
    … …  
    773852                irc_usermsg( irc, "Your name is `%s'" , a->gc->displayname ? a->gc->displayname : "NULL" );
    774853        }
    775         else if ( !a->gc->prpl->set_info )
     854        else if ( !a->prpl->set_info )
    776855        {
    777856                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
    … …  
    781860                irc_usermsg( irc, "Setting your name to `%s'", cmd[2] );
    782861               
    783                 a->gc->prpl->set_info( a->gc, cmd[2] );
     862                a->prpl->set_info( a->gc, cmd[2] );
    784863        }
    785864}
    … …  
    800879        for( num = 0; q; q = q->next, num ++ )
    801880                if( q->gc ) /* Not necessary yet, but it might come later */
    802                         irc_usermsg( irc, "%d, %s(%s): %s", num, q->gc->prpl->name, q->gc->username, q->question );
     881                        irc_usermsg( irc, "%d, %s(%s): %s", num, q->gc->acc->prpl->name, q->gc->username, q->question );
    803882                else
    804883                        irc_usermsg( irc, "%d, BitlBee: %s", num, q->question );
    805 }
    806 
    807 static void cmd_import_buddies( irc_t *irc, char **cmd )
    808 {
    809         struct gaim_connection *gc;
    810         account_t *a;
    811         nick_t *n;
    812        
    813         if( !( a = account_get( irc, cmd[1] ) ) )
    814         {
    815                 irc_usermsg( irc, "Invalid account" );
    816                 return;
    817         }
    818         else if( !( ( gc = a->gc ) && ( a->gc->flags & OPT_LOGGED_IN ) ) )
    819         {
    820                 irc_usermsg( irc, "That account is not on-line" );
    821                 return;
    822         }
    823        
    824         if( cmd[2] )
    825         {
    826                 if( g_strcasecmp( cmd[2], "clear" ) == 0 )
    827                 {
    828                         user_t *u;
    829                        
    830                         for( u = irc->users; u; u = u->next )
    831                                 if( u->gc == gc )
    832                                 {
    833                                         u->gc->prpl->remove_buddy( u->gc, u->handle, NULL );
    834                                         user_del( irc, u->nick );
    835                                 }
    836                        
    837                         irc_usermsg( irc, "Old buddy list cleared." );
    838                 }
    839                 else
    840                 {
    841                         irc_usermsg( irc, "Invalid argument: %s", cmd[2] );
    842                         return;
    843                 }
    844         }
    845        
    846         for( n = gc->irc->nicks; n; n = n->next )
    847         {
    848                 if( n->proto == gc->prpl && !user_findhandle( gc, n->handle ) )
    849                 {
    850                         gc->prpl->add_buddy( gc, n->handle );
    851                         add_buddy( gc, NULL, n->handle, NULL );
    852                 }
    853         }
    854        
    855         irc_usermsg( irc, "Sent all add requests. Please wait for a while, the server needs some time to handle all the adds." );
    856884}
    857885
    … …  
    874902        { "blist",          0, cmd_blist,          0 },
    875903        { "nick",           1, cmd_nick,           0 },
    876         { "import_buddies", 1, cmd_import_buddies, 0 },
    877904        { "qlist",          0, cmd_qlist,          0 },
    878905        { NULL }

  • set.c

    r6398094 reda0270  
    2626#include "bitlbee.h"
    2727
    28 set_t *set_add( irc_t *irc, char *key, char *def, void *eval )
    29 {
    30         set_t *s = set_find( irc, key );
    31        
    32         if( !s )
    33         {
    34                 if( ( s = irc->set ) )
     28set_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. */
     34        if( !s )
     35        {
     36                if( ( s = *head ) )
    3537                {
    3638                        while( s->next ) s = s->next;
    37                         s->next = g_new ( set_t, 1 );
     39                        s->next = g_new0( set_t, 1 );
    3840                        s = s->next;
    3941                }
    4042                else
    4143                {
    42                         s = irc->set = g_new( set_t, 1 );
     44                        s = *head = g_new0( set_t, 1 );
    4345                }
    44                 memset( s, 0, sizeof( set_t ) );
    4546                s->key = g_strdup( key );
    4647        }
    … …  
    5354        if( def ) s->def = g_strdup( def );
    5455       
    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 
    65 set_t *set_find( irc_t *irc, char *key )
    66 {
    67         set_t *s = irc->set;
     56        s->eval = eval;
     57        s->data = data;
     58       
     59        return s;
     60}
     61
     62set_t *set_find( set_t **head, char *key )
     63{
     64        set_t *s = *head;
    6865       
    6966        while( s )
    … …  
    7471        }
    7572       
    76         return( s );
    77 }
    78 
    79 char *set_getstr( irc_t *irc, char *key )
    80 {
    81         set_t *s = set_find( irc, key );
     73        return s;
     74}
     75
     76char *set_getstr( set_t **head, char *key )
     77{
     78        set_t *s = set_find( head, key );
    8279       
    8380        if( !s || ( !s->value && !s->def ) )
    84                 return( NULL );
    85        
    86         return( s->value?s->value:s->def );
    87 }
    88 
    89 int set_getint( irc_t *irc, char *key )
    90 {
    91         char *s = set_getstr( irc, key );
     81                return NULL;
     82       
     83        return s->value ? s->value : s->def;
     84}
     85
     86int set_getint( set_t **head, char *key )
     87{
     88        char *s = set_getstr( head, key );
    9289        int i = 0;
    9390       
    9491        if( !s )
    95                 return( 0 );
     92                return 0;
    9693       
    9794        if( ( g_strcasecmp( s, "true" ) == 0 ) || ( g_strcasecmp( s, "yes" ) == 0 ) || ( g_strcasecmp( s, "on" ) == 0 ) )
    98                 return( 1 );
     95                return 1;
    9996       
    10097        if( sscanf( s, "%d", &i ) != 1 )
    101                 return( 0 );
    102        
    103         return( i );
    104 }
    105 
    106 int set_setstr( irc_t *irc, char *key, char *value )
    107 {
    108         set_t *s = set_find( irc, key );
     98                return 0;
     99       
     100        return i;
     101}
     102
     103int set_getbool( set_t **head, char *key )
     104{
     105        char *s = set_getstr( head, key );
     106       
     107        if( !s )
     108                return 0;
     109       
     110        return bool2int( s );
     111}
     112
     113int set_setstr( set_t **head, char *key, char *value )
     114{
     115        set_t *s = set_find( head, key );
    109116        char *nv = value;
    110117       
    111118        if( !s )
    112                 s = set_add( irc, key, NULL, NULL );
    113        
    114         if( s->eval && !( nv = s->eval( irc, s, value ) ) )
    115                 return( 0 );
     119                s = set_add( head, key, NULL, NULL, NULL );
     120       
     121        if( s->eval && !( nv = s->eval( s, value ) ) )
     122                return 0;
    116123       
    117124        if( s->value )
    … …  
    121128        }
    122129       
     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. */
    123132        if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
    124133                s->value = g_strdup( nv );
    … …  
    127136                g_free( nv );
    128137       
    129         return( 1 );
    130 }
    131 
    132 int set_setint( irc_t *irc, char *key, int value )
     138        return 1;
     139}
     140
     141int set_setint( set_t **head, char *key, int value )
    133142{
    134143        char s[24];     /* Not quite 128-bit clean eh? ;-) */
    135144       
    136         sprintf( s, "%d", value );
    137         return( set_setstr( irc, key, s ) );
    138 }
    139 
    140 void set_del( irc_t *irc, char *key )
    141 {
    142         set_t *s = irc->set, *t = NULL;
     145        g_snprintf( s, sizeof( s ), "%d", value );
     146        return set_setstr( head, key, s );
     147}
     148
     149void set_del( set_t **head, char *key )
     150{
     151        set_t *s = *head, *t = NULL;
    143152       
    144153        while( s )
    … …  
    153162                        t->next = s->next;
    154163                else
    155                         irc->set = s->next;
     164                        *head = s->next;
    156165               
    157166                g_free( s->key );
    … …  
    162171}
    163172
    164 char *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 
    175 char *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 
    184 char *set_eval_to_char( irc_t *irc, set_t *set, char *value )
     173char *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
     184char *set_eval_bool( set_t *set, char *value )
     185{
     186        return is_bool( value ) ? value : NULL;
     187}
     188
     189char *set_eval_to_char( set_t *set, char *value )
    185190{
    186191        char *s = g_new( char, 3 );
    … …  
    191196                sprintf( s, "%c ", *value );
    192197       
    193         return( s );
    194 }
    195 
    196 char *set_eval_ops( irc_t *irc, set_t *set, char *value )
    197 {
     198        return s;
     199}
     200
     201char *set_eval_ops( set_t *set, char *value )
     202{
     203        irc_t *irc = set->data;
     204       
    198205        if( g_strcasecmp( value, "user" ) == 0 )
    199         {
    200206                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    201207                                                              irc->channel, "+o-o", irc->nick, irc->mynick );
    202                 return( value );
    203         }
    204208        else if( g_strcasecmp( value, "root" ) == 0 )
    205         {
    206209                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    207210                                                              irc->channel, "-o+o", irc->nick, irc->mynick );
    208                 return( value );
    209         }
    210211        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         }
    216214        else if( g_strcasecmp( value, "none" ) == 0 )
    217         {
    218215                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    219216                                                              irc->channel, "-oo", irc->nick, irc->mynick );
    220                 return( value );
    221         }
    222        
    223         return( NULL );
    224 }
    225 
     217        else
     218                return NULL;
     219       
     220        return value;
     221}
     222
     223char *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}

  • set.h

    r6398094 reda0270  
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
    4   * Copyright 2002-2004 Wilmer van der Gaast and others                *
     4  * Copyright 2002-2006 Wilmer van der Gaast and others                *
    55  \********************************************************************/
    66
    … …  
    2626typedef struct set
    2727{
     28        void *data;
     29       
    2830        char *key;
    2931        char *value;
    3032        char *def;      /* Default */
    3133       
    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 );
     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 );
    3640        struct set *next;
    3741} set_t;
    3842
    39 set_t *set_add( irc_t *irc, char *key, char *def, void *eval );
    40 G_MODULE_EXPORT set_t *set_find( irc_t *irc, char *key );
    41 G_MODULE_EXPORT char *set_getstr( irc_t *irc, char *key );
    42 G_MODULE_EXPORT int set_getint( irc_t *irc, char *key );
    43 int set_setstr( irc_t *irc, char *key, char *value );
    44 int set_setint( irc_t *irc, char *key, int value );
    45 void set_del( irc_t *irc, char *key );
     43set_t *set_add( set_t **head, char *key, char *def, void *eval, void *data );
     44set_t *set_find( set_t **head, char *key );
     45G_MODULE_EXPORT char *set_getstr( set_t **head, char *key );
     46G_MODULE_EXPORT int set_getint( set_t **head, char *key );
     47G_MODULE_EXPORT int set_getbool( set_t **head, char *key );
     48int set_setstr( set_t **head, char *key, char *value );
     49int set_setint( set_t **head, char *key, int value );
     50void set_del( set_t **head, char *key );
    4651
    47 char *set_eval_int( irc_t *irc, set_t *set, char *value );
    48 char *set_eval_bool( irc_t *irc, set_t *set, char *value );
    49 char *set_eval_to_char( irc_t *irc, set_t *set, char *value );
    50 char *set_eval_ops( irc_t *irc, set_t *set, char *value );
     52char *set_eval_int( set_t *set, char *value );
     53char *set_eval_bool( set_t *set, char *value );
    5154
    52 
     55char *set_eval_to_char( set_t *set, char *value );
     56char *set_eval_ops( set_t *set, char *value );
     57char *set_eval_charset( set_t *set, char *value );

  • storage.c

    r6398094 reda0270  
    66
    77/* Support for multiple storage backends */
     8
     9/* Copyright (C) 2005 Jelmer Vernooij <jelmer@samba.org> */
    810
    911/*
    … …  
    2931
    3032extern storage_t storage_text;
     33extern storage_t storage_xml;
    3134
    32 static GList text_entry = { &storage_text, NULL, NULL };
    33 static GList *storage_backends = &text_entry;
     35static GList *storage_backends = NULL;
    3436
    3537void register_storage_backend(storage_t *backend)
    … …  
    4143{
    4244        GList *gl;
    43         storage_t *st;
     45        storage_t *st = NULL;
    4446
    4547        for (gl = storage_backends; gl; gl = gl->next) {
    … …  
    6365        int i;
    6466        storage_t *storage;
    65 
     67       
     68        register_storage_backend(&storage_text);
     69        register_storage_backend(&storage_xml);
     70       
    6671        storage = storage_init_single(primary);
    67         if (storage == NULL)
     72        if (storage == NULL && storage->save == NULL)
    6873                return NULL;
    6974

  • storage.h

    r6398094 reda0270  
    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

    r6398094 reda0270  
    2828#include "crypting.h"
    2929
    30 /* DO NOT USE THIS FUNCTION IN NEW CODE. This
    31  * function is here merely because the save/load code still uses
    32  * ids rather than names */
    33 static struct prpl *find_protocol_by_id(int id)
    34 {
    35         switch (id) {
    36         case 0: case 1: case 3: return find_protocol("oscar");
    37         case 4: return find_protocol("msn");
    38         case 2: return find_protocol("yahoo");
    39         case 8: return find_protocol("jabber");
    40         default: break;
    41         }
    42         return NULL;
    43 }
    44 
    45 static int find_protocol_id(const char *name)
    46 {
    47         if (!strcmp(name, "oscar")) return 1;
    48         if (!strcmp(name, "msn")) return 4;
    49         if (!strcmp(name, "yahoo")) return 2;
    50         if (!strcmp(name, "jabber")) return 8;
    51 
    52         return -1;
    53 }
    54 
    55 
    5630static void text_init (void)
    5731{
    … …  
    7044        FILE *fp;
    7145        user_t *ru = user_find( irc, ROOT_NICK );
     46        account_t *acc, *acc_lookup[9];
    7247       
    7348        if( irc->status & USTATUS_IDENTIFIED )
    … …  
    8055        fscanf( fp, "%32[^\n]s", s );
    8156
    82         if (checkpass (password, s) != 0)
     57        if( checkpass( password, s ) != 0 )
    8358        {
    8459                fclose( fp );
    … …  
    10075        fclose( fp );
    10176       
     77        /* Build a list with the first listed account of every protocol
     78           number. So if the user had nicks defined for a second account on
     79           the same IM network, those nicks will be added to the wrong
     80           account, and the user should rename those buddies again. But at
     81           least from now on things will be saved properly. */
     82        memset( acc_lookup, 0, sizeof( acc_lookup ) );
     83        for( acc = irc->accounts; acc; acc = acc->next )
     84        {
     85                if( acc_lookup[0] == NULL && strcmp( acc->prpl->name, "oscar" ) == 0 )
     86                        acc_lookup[0] = acc_lookup[1] = acc_lookup[3] = acc;
     87                else if( acc_lookup[2] == NULL && strcmp( acc->prpl->name, "yahoo" ) == 0 )
     88                        acc_lookup[2] = acc;
     89                else if( acc_lookup[4] == NULL && strcmp( acc->prpl->name, "msn" ) == 0 )
     90                        acc_lookup[4] = acc;
     91                else if( acc_lookup[8] == NULL && strcmp( acc->prpl->name, "jabber" ) == 0 )
     92                        acc_lookup[8] = acc;
     93        }
     94       
    10295        g_snprintf( s, 511, "%s%s%s", global.conf->configdir, my_nick, ".nicks" );
    10396        fp = fopen( s, "r" );
    … …  
    10598        while( fscanf( fp, "%s %d %s", s, &proto, nick ) > 0 )
    10699        {
    107                 struct prpl *prpl;
    108 
    109                 prpl = find_protocol_by_id(proto);
    110 
    111                 if (!prpl)
     100                if( ( acc = acc_lookup[proto] ) == NULL )
    112101                        continue;
    113 
     102               
    114103                http_decode( s );
    115                 nick_set( irc, s, prpl, nick );
     104                nick_set( acc, s, nick );
    116105        }
    117106        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         }
    124        
    125         return STORAGE_OK;
    126 }
    127 
    128 static storage_status_t text_save( irc_t *irc, int overwrite )
    129 {
    130         char s[512];
    131         char path[512], new_path[512];
    132         char *line;
    133         nick_t *n;
    134         set_t *set;
    135         mode_t ou = umask( 0077 );
    136         account_t *a;
    137         FILE *fp;
    138         char *hash;
    139 
    140         if (!overwrite) {
    141                 g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    142                 if (access( path, F_OK ) != -1)
    143                         return STORAGE_ALREADY_EXISTS;
    144        
    145                 g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    146                 if (access( path, F_OK ) != -1)
    147                         return STORAGE_ALREADY_EXISTS;
    148         }
    149        
    150         /*\
    151          *  [SH] Nothing should be saved if no password is set, because the
    152          *  password is not set if it was wrong, or if one is not identified
    153          *  yet. This means that a malicious user could easily overwrite
    154          *  files owned by someone else:
    155          *  a Bad Thing, methinks
    156         \*/
    157 
    158         /* [WVG] No? Really? */
    159 
    160         /*\
    161          *  [SH] Okay, okay, it wasn't really Wilmer who said that, it was
    162          *  me. I just thought it was funny.
    163         \*/
    164        
    165         hash = hashpass( irc->password );
    166         if( hash == NULL )
    167         {
    168                 irc_usermsg( irc, "Please register yourself if you want to save your settings." );
    169                 return STORAGE_OTHER_ERROR;
    170         }
    171        
    172         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".nicks~" );
    173         fp = fopen( path, "w" );
    174         if( !fp ) return STORAGE_OTHER_ERROR;
    175         for( n = irc->nicks; n; n = n->next )
    176         {
    177                 strcpy( s, n->handle );
    178                 s[169] = 0; /* Prevent any overflow (169 ~ 512 / 3) */
    179                 http_encode( s );
    180                 g_snprintf( s + strlen( s ), 510 - strlen( s ), " %d %s", find_protocol_id(n->proto->name), n->nick );
    181                 if( fprintf( fp, "%s\n", s ) != strlen( s ) + 1 )
    182                 {
    183                         irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    184                         fclose( fp );
    185                         return STORAGE_OTHER_ERROR;
    186                 }
    187         }
    188         if( fclose( fp ) != 0 )
    189         {
    190                 irc_usermsg( irc, "fclose() reported an error. Disk full?" );
    191                 return STORAGE_OTHER_ERROR;
    192         }
    193  
    194         g_snprintf( new_path, 512, "%s%s%s", global.conf->configdir, irc->nick, ".nicks" );
    195         if( unlink( new_path ) != 0 )
    196         {
    197                 if( errno != ENOENT )
    198                 {
    199                         irc_usermsg( irc, "Error while removing old .nicks file" );
    200                         return STORAGE_OTHER_ERROR;
    201                 }
    202         }
    203         if( rename( path, new_path ) != 0 )
    204         {
    205                 irc_usermsg( irc, "Error while renaming new .nicks file" );
    206                 return STORAGE_OTHER_ERROR;
    207         }
    208        
    209         g_snprintf( path, 511, "%s%s%s", global.conf->configdir, irc->nick, ".accounts~" );
    210         fp = fopen( path, "w" );
    211         if( !fp ) return STORAGE_OTHER_ERROR;
    212         if( fprintf( fp, "%s", hash ) != strlen( hash ) )
    213         {
    214                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    215                 fclose( fp );
    216                 return STORAGE_OTHER_ERROR;
    217         }
    218         g_free( hash );
    219 
    220         for( a = irc->accounts; a; a = a->next )
    221         {
    222                 if( !strcmp(a->prpl->name, "oscar") )
    223                         g_snprintf( s, sizeof( s ), "account add oscar \"%s\" \"%s\" %s", a->user, a->pass, a->server );
    224                 else
    225                         g_snprintf( s, sizeof( s ), "account add %s \"%s\" \"%s\" \"%s\"",
    226                                     a->prpl->name, a->user, a->pass, a->server ? a->server : "" );
    227                
    228                 line = obfucrypt( s, irc->password );
    229                 if( *line )
    230                 {
    231                         if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    232                         {
    233                                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    234                                 fclose( fp );
    235                                 return STORAGE_OTHER_ERROR;
    236                         }
    237                 }
    238                 g_free( line );
    239         }
    240        
    241         for( set = irc->set; set; set = set->next )
    242         {
    243                 if( set->value && set->def )
    244                 {
    245                         g_snprintf( s, sizeof( s ), "set %s \"%s\"", set->key, set->value );
    246                         line = obfucrypt( s, irc->password );
    247                         if( *line )
    248                         {
    249                                 if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    250                                 {
    251                                         irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    252                                         fclose( fp );
    253                                         return STORAGE_OTHER_ERROR;
    254                                 }
    255                         }
    256                         g_free( line );
    257                 }
    258         }
    259        
    260         if( strcmp( irc->mynick, ROOT_NICK ) != 0 )
    261         {
    262                 g_snprintf( s, sizeof( s ), "rename %s %s", ROOT_NICK, irc->mynick );
    263                 line = obfucrypt( s, irc->password );
    264                 if( *line )
    265                 {
    266                         if( fprintf( fp, "%s\n", line ) != strlen( line ) + 1 )
    267                         {
    268                                 irc_usermsg( irc, "fprintf() wrote too little. Disk full?" );
    269                                 fclose( fp );
    270                                 return STORAGE_OTHER_ERROR;
    271                         }
    272                 }
    273                 g_free( line );
    274         }
    275         if( fclose( fp ) != 0 )
    276         {
    277                 irc_usermsg( irc, "fclose() reported an error. Disk full?" );
    278                 return STORAGE_OTHER_ERROR;
    279         }
    280        
    281         g_snprintf( new_path, 512, "%s%s%s", global.conf->configdir, irc->nick, ".accounts" );
    282         if( unlink( new_path ) != 0 )
    283         {
    284                 if( errno != ENOENT )
    285                 {
    286                         irc_usermsg( irc, "Error while removing old .accounts file" );
    287                         return STORAGE_OTHER_ERROR;
    288                 }
    289         }
    290         if( rename( path, new_path ) != 0 )
    291         {
    292                 irc_usermsg( irc, "Error while renaming new .accounts file" );
    293                 return STORAGE_OTHER_ERROR;
    294         }
    295        
    296         umask( ou );
    297107       
    298108        return STORAGE_OK;
    … …  
    343153        .check_pass = text_check_pass,
    344154        .remove = text_remove,
    345         .load = text_load,
    346         .save = text_save
     155        .load = text_load
    347156};

  • unix.c

    r6398094 reda0270  
    4848       
    4949        b_main_init();
    50        
    5150        log_init();
    52 
    5351        nogaim_init();
    54 
     52       
     53        srand( time( NULL ) ^ getpid() );
     54       
    5555        CONF_FILE = g_strdup( CONF_FILE_DEF );
    56        
    5756        global.helpfile = g_strdup( HELP_FILE );
    58 
     57       
    5958        global.conf = conf_load( argc, argv );
    6059        if( global.conf == NULL )
    6160                return( 1 );
    62 
    63 
     61       
    6462        if( global.conf->runmode == RUNMODE_INETD )
    6563        {
    … …  
    8987        if( i != 0 )
    9088                return( i );
    91 
     89       
    9290        global.storage = storage_init( global.conf->primary_storage, global.conf->migrate_storage );
    9391        if ( global.storage == NULL) {

  • user.c

    r6398094 reda0270  
    6767       
    6868        u->user = u->realname = u->host = u->nick = g_strdup( nick );
    69         u->is_private = set_getint( irc, "private" );
     69        u->is_private = set_getint( &irc->set, "private" );
    7070       
    7171        key = g_strdup( nick );
    … …  
    143143user_t *user_findhandle( struct gaim_connection *gc, char *handle )
    144144{
    145         user_t *u = gc->irc->users;
    146        
    147         while( u )
    148         {
    149                 if( u->gc == gc && u->handle && gc->prpl->cmp_buddynames ( u->handle, handle ) == 0 )
    150                         break;
    151                 u = u->next;
    152         }
    153        
    154         return( u );
     145        user_t *u;
     146        char *nick;
     147       
     148        /* First, let's try a hash lookup. If it works, it's probably faster. */
     149        if( ( nick = g_hash_table_lookup( gc->acc->nicks, handle ) ) &&
     150            ( u = user_find( gc->irc, nick ) ) &&
     151            ( gc->acc->prpl->handle_cmp( handle, u->handle ) == 0 ) )
     152                return u;
     153       
     154        /* However, it doesn't always work, so in that case we'll have to dig
     155           through the whole userlist. :-( */
     156        for( u = gc->irc->users; u; u = u->next )
     157                if( u->gc == gc && u->handle && gc->acc->prpl->handle_cmp( u->handle, handle ) == 0 )
     158                        return u;
     159       
     160        return NULL;
    155161}
    156162
Note: See TracChangeset for help on using the changeset viewer.