Changes in / [d301872:934dddf3]


Ignore:
Files:
3 added
27 edited

Legend:

Unmodified
Added
Removed
  • .bzrignore

    rd301872 r934dddf3  
    1919coverage
    2020bitlbee.info
     21bitlbee.exe
  • Makefile

    rd301872 r934dddf3  
    1010
    1111# Program variables
    12 objects = account.o bitlbee.o conf.o crypting.o help.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) unix.o user.o
     12objects = account.o bitlbee.o crypting.o help.o ipc.o irc.o irc_commands.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) user.o
    1313headers = account.h bitlbee.h commands.h conf.h config.h crypting.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h user.h lib/events.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha1.h lib/ssl_client.h lib/url.h protocols/nogaim.h
    1414subdirs = lib protocols
     15
     16ifeq ($(TARGET),i586-mingw32msvc)
     17objects += win32.o
     18LFLAGS+=-lws2_32
     19EFLAGS+=-lsecur32
     20OUTFILE=bitlbee.exe
     21else
     22objects += unix.o conf.o log.o
     23OUTFILE=bitlbee
     24endif
    1525
    1626# Expansion of variables
  • account.c

    rd301872 r934dddf3  
    7979                return NULL;
    8080       
    81         if( strcmp( set->key, "username" ) == 0 )
     81        if( strcmp( set->key, "server" ) == 0 )
     82        {
     83                g_free( acc->server );
     84                if( value && *value )
     85                {
     86                        acc->server = g_strdup( value );
     87                        return value;
     88                }
     89                else
     90                {
     91                        acc->server = NULL;
     92                        return g_strdup( set->def );
     93                }
     94        }
     95        else if( value == NULL )
     96        {
     97                /* Noop, the other three can't be NULL. */
     98        }
     99        else if( strcmp( set->key, "username" ) == 0 )
    82100        {
    83101                g_free( acc->user );
     
    90108                acc->pass = g_strdup( value );
    91109                return NULL;    /* password shouldn't be visible in plaintext! */
    92         }
    93         else if( strcmp( set->key, "server" ) == 0 )
    94         {
    95                 g_free( acc->server );
    96                 if( *value )
    97                 {
    98                         acc->server = g_strdup( value );
    99                         return value;
    100                 }
    101                 else
    102                 {
    103                         acc->server = NULL;
    104                         return g_strdup( set->def );
    105                 }
    106110        }
    107111        else if( strcmp( set->key, "auto_connect" ) == 0 )
     
    234238        }
    235239}
     240
     241struct account_reconnect_delay
     242{
     243        int start;
     244        char op;
     245        int step;
     246        int max;
     247};
     248
     249int account_reconnect_delay_parse( char *value, struct account_reconnect_delay *p )
     250{
     251        memset( p, 0, sizeof( *p ) );
     252        /* A whole day seems like a sane "maximum maximum". */
     253        p->max = 86400;
     254       
     255        /* Format: /[0-9]+([*+][0-9]+(<[0-9+]))/ */
     256        while( *value && isdigit( *value ) )
     257                p->start = p->start * 10 + *value++ - '0';
     258       
     259        /* Sure, call me evil for implementing my own fscanf here, but it's
     260           dead simple and I'm immediately at the next part to parse. */
     261       
     262        if( *value == 0 )
     263                /* If the string ends now, the delay is constant. */
     264                return 1;
     265        else if( *value != '+' && *value != '*' )
     266                /* Otherwise allow either a + or a * */
     267                return 0;
     268       
     269        p->op = *value++;
     270       
     271        /* + or * the delay by this number every time. */
     272        while( *value && isdigit( *value ) )
     273                p->step = p->step * 10 + *value++ - '0';
     274       
     275        if( *value == 0 )
     276                /* Use the default maximum (one day). */
     277                return 1;
     278        else if( *value != '<' )
     279                return 0;
     280       
     281        p->max = 0;
     282        value ++;
     283        while( *value && isdigit( *value ) )
     284                p->max = p->max * 10 + *value++ - '0';
     285       
     286        return p->max > 0;
     287}
     288
     289char *set_eval_account_reconnect_delay( set_t *set, char *value )
     290{
     291        struct account_reconnect_delay p;
     292       
     293        return account_reconnect_delay_parse( value, &p ) ? value : NULL;
     294}
     295
     296int account_reconnect_delay( account_t *a )
     297{
     298        char *setting = set_getstr( &a->irc->set, "auto_reconnect_delay" );
     299        struct account_reconnect_delay p;
     300       
     301        if( account_reconnect_delay_parse( setting, &p ) )
     302        {
     303                if( a->auto_reconnect_delay == 0 )
     304                        a->auto_reconnect_delay = p.start;
     305                else if( p.op == '+' )
     306                        a->auto_reconnect_delay += p.step;
     307                else if( p.op == '*' )
     308                        a->auto_reconnect_delay *= p.step;
     309               
     310                if( a->auto_reconnect_delay > p.max )
     311                        a->auto_reconnect_delay = p.max;
     312        }
     313        else
     314        {
     315                a->auto_reconnect_delay = 0;
     316        }
     317       
     318        return a->auto_reconnect_delay;
     319}
  • account.h

    rd301872 r934dddf3  
    3535       
    3636        int auto_connect;
     37        int auto_reconnect_delay;
    3738        int reconnect;
    3839       
     
    5253
    5354char *set_eval_account( set_t *set, char *value );
     55char *set_eval_account_reconnect_delay( set_t *set, char *value );
     56int account_reconnect_delay( account_t *a );
    5457
    5558#define ACC_SET_NOSAVE          1
  • bitlbee.c

    rd301872 r934dddf3  
    118118       
    119119        if( global.conf->runmode == RUNMODE_FORKDAEMON )
    120                 ipc_master_load_state();
     120                ipc_master_load_state( getenv( "_BITLBEE_RESTART_STATE" ) );
    121121
    122122        if( global.conf->runmode == RUNMODE_DAEMON || global.conf->runmode == RUNMODE_FORKDAEMON )
    123123                ipc_master_listen_socket();
    124124       
     125#ifndef _WIN32
    125126        if( ( fp = fopen( global.conf->pidfile, "w" ) ) )
    126127        {
     
    132133                log_message( LOGLVL_WARNING, "Warning: Couldn't write PID to `%s'", global.conf->pidfile );
    133134        }
     135#endif
    134136       
    135137        return( 0 );
     
    140142        if( !irc_new( 0 ) )
    141143                return( 1 );
    142        
    143         log_link( LOGLVL_ERROR, LOGOUTPUT_IRC );
    144         log_link( LOGLVL_WARNING, LOGOUTPUT_IRC );
    145144       
    146145        return( 0 );
     
    254253        struct sockaddr_in conn_info;
    255254        int new_socket = accept( global.listen_socket, (struct sockaddr *) &conn_info, &size );
    256         pid_t client_pid = 0;
    257255       
    258256        if( new_socket == -1 )
     
    262260        }
    263261       
     262#ifndef _WIN32
    264263        if( global.conf->runmode == RUNMODE_FORKDAEMON )
    265264        {
     265                pid_t client_pid = 0;
    266266                int fds[2];
    267267               
     
    320320        }
    321321        else
     322#endif
    322323        {
    323324                log_message( LOGLVL_INFO, "Creating new connection with fd %d.", new_socket );
  • bitlbee.h

    rd301872 r934dddf3  
    2929#define _GNU_SOURCE /* Stupid GNU :-P */
    3030
     31/* Depend on Windows 2000 for now since we need getaddrinfo() */
     32#define _WIN32_WINNT 0x0501
     33
    3134#define PACKAGE "BitlBee"
    3235#define BITLBEE_VERSION "1.2.1"
     
    4851#include <stdio.h>
    4952#include <ctype.h>
     53#include <errno.h>
     54
    5055#ifndef _WIN32
    5156#include <syslog.h>
    52 #include <errno.h>
    5357#endif
    5458
  • conf.c

    rd301872 r934dddf3  
    148148                else if( opt == 'R' )
    149149                {
    150                         /* We can't load the statefile yet (and should make very sure we do this
    151                            only once), so set the filename here and load the state information
    152                            when initializing ForkDaemon. (This option only makes sense in that
    153                            mode anyway!) */
    154                         ipc_master_set_statefile( optarg );
     150                        /* Backward compatibility; older BitlBees passed this
     151                           info using a command-line flag. Allow people to
     152                           upgrade from such a version for now. */
     153                        setenv( "_BITLBEE_RESTART_STATE", optarg, 0 );
    155154                }
    156155                else if( opt == 'u' )
  • configure

    rd301872 r934dddf3  
    2020ipcsocket='/var/run/bitlbee.sock'
    2121pcdir='$prefix/lib/pkgconfig'
     22systemlibdirs="/lib /usr/lib /usr/local/lib"
    2223
    2324msn=1
     
    109110PCDIR=$pcdir
    110111
     112TARGET=$target
    111113ARCH=$arch
    112114CPU=$cpu
    113 OUTFILE=bitlbee
    114115
    115116DESTDIR=
     
    134135EOF
    135136
     137
     138
    136139if [ -n "$target" ]; then
    137         PKG_CONFIG_PATH=/usr/$target/lib/pkgconfig
     140        PKG_CONFIG_LIBDIR=/usr/$target/lib/pkgconfig
     141        export PKG_CONFIG_LIBDIR
    138142        PATH=/usr/$target/bin:$PATH
    139143        CC=$target-cc
    140144        LD=$target-ld
    141 fi
     145        systemlibdirs="/usr/$target/lib"
     146fi
     147
    142148
    143149if [ "$debug" = "1" ]; then
     
    285291elif [ "$ssl" = "nss" ]; then
    286292        detect_nss
     293elif [ "$ssl" = "sspi" ]; then
     294        echo
    287295elif [ "$ssl" = "openssl" ]; then
    288296        echo
     
    341349echo 'SSL_CLIENT=ssl_'$ssl'.o' >> Makefile.settings
    342350
    343 for i in /lib /usr/lib /usr/local/lib; do
     351for i in $systemlibdirs; do
    344352        if [ -f $i/libresolv.a ]; then
    345353                echo '#define HAVE_RESOLV_A' >> config.h
     
    501509        echo 'Cygwin is not officially supported.'
    502510;;
     511Windows )
     512;;
    503513* )
    504514        echo 'We haven'\''t tested BitlBee on many platforms yet, yours is untested. YMMV.'
  • doc/user-guide/commands.xml

    rd301872 r934dddf3  
    321321        </bitlbee-setting>
    322322
    323         <bitlbee-setting name="auto_reconnect_delay" type="integer" scope="global">
    324                 <default>300</default>
    325 
    326                 <description>
    327                         <para>
    328                                 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.
     323        <bitlbee-setting name="auto_reconnect_delay" type="string" scope="global">
     324                <default>5*3&lt;900</default>
     325
     326                <description>
     327                        <para>
     328                                Tell BitlBee after how many seconds it should attempt to bring a broken IM-connection back up.
     329                        </para>
     330
     331                        <para>
     332                                This can be one integer, for a constant delay. One can also set it to something like &quot;10*10&quot;, which means wait for ten seconds on the first reconnect, multiply it by ten on every failure. Once successfully connected, this delay is re-set to the initial value. With &lt; you can give a maximum delay.
    329333                        </para>
    330334
  • ipc.c

    rd301872 r934dddf3  
    3333
    3434GSList *child_list = NULL;
    35 static char *statefile = NULL;
    3635
    3736static void ipc_master_cmd_client( irc_t *data, char **cmd )
     
    6362}
    6463
     64static void ipc_master_cmd_deaf( irc_t *data, char **cmd )
     65{
     66        if( global.conf->runmode == RUNMODE_DAEMON )
     67        {
     68                b_event_remove( global.listen_watch_source_id );
     69                close( global.listen_socket );
     70               
     71                global.listen_socket = global.listen_watch_source_id = -1;
     72       
     73                ipc_to_children_str( "OPERMSG :Closed listening socket, waiting "
     74                                     "for all users to disconnect." );
     75        }
     76        else
     77        {
     78                ipc_to_children_str( "OPERMSG :The DEAF command only works in "
     79                                     "normal daemon mode. Try DIE instead." );
     80        }
     81}
     82
    6583void ipc_master_cmd_rehash( irc_t *data, char **cmd )
    6684{
     
    98116        { "hello",      0, ipc_master_cmd_client,     0 },
    99117        { "die",        0, ipc_master_cmd_die,        0 },
     118        { "deaf",       0, ipc_master_cmd_deaf,       0 },
    100119        { "wallops",    1, NULL,                      IPC_CMD_TO_CHILDREN },
    101120        { "wall",       1, NULL,                      IPC_CMD_TO_CHILDREN },
     
    441460}
    442461
     462#ifndef _WIN32
    443463char *ipc_master_save_state()
    444464{
     
    481501}
    482502
    483 void ipc_master_set_statefile( char *fn )
    484 {
    485         statefile = g_strdup( fn );
    486 }
    487 
    488503
    489504static gboolean new_ipc_client( gpointer data, gint serversock, b_input_condition cond )
     
    506521}
    507522
    508 #ifndef _WIN32
    509523int ipc_master_listen_socket()
    510524{
     
    543557}
    544558#else
     559int ipc_master_listen_socket()
     560{
    545561        /* FIXME: Open named pipe \\.\BITLBEE */
     562        return 0;
     563}
    546564#endif
    547565
    548 int ipc_master_load_state()
     566int ipc_master_load_state( char *statefile )
    549567{
    550568        struct bitlbee_child *child;
     
    554572        if( statefile == NULL )
    555573                return 0;
     574       
    556575        fp = fopen( statefile, "r" );
    557576        unlink( statefile );    /* Why do it later? :-) */
  • ipc.h

    rd301872 r934dddf3  
    5858
    5959char *ipc_master_save_state();
    60 void ipc_master_set_statefile( char *fn );
    61 int ipc_master_load_state();
     60int ipc_master_load_state( char *statefile );
    6261int ipc_master_listen_socket();
    6362
  • irc.c

    rd301872 r934dddf3  
    2626#define BITLBEE_CORE
    2727#include "bitlbee.h"
     28#include "sock.h"
    2829#include "crypting.h"
    2930#include "ipc.h"
     
    138139        set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
    139140        set_add( &irc->set, "auto_reconnect", "false", set_eval_bool, irc );
    140         set_add( &irc->set, "auto_reconnect_delay", "300", set_eval_int, irc );
     141        set_add( &irc->set, "auto_reconnect_delay", "5*3<900", set_eval_account_reconnect_delay, irc );
    141142        set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
    142143        set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
     
    314315        g_free( irc );
    315316       
    316         if( global.conf->runmode == RUNMODE_INETD || global.conf->runmode == RUNMODE_FORKDAEMON )
     317        if( global.conf->runmode == RUNMODE_INETD ||
     318            global.conf->runmode == RUNMODE_FORKDAEMON ||
     319            ( global.conf->runmode == RUNMODE_DAEMON &&
     320              global.listen_socket == -1 &&
     321              irc_connection_list == NULL ) )
    317322                b_main_quit();
    318323}
  • irc_commands.c

    rd301872 r934dddf3  
    626626        { "completions", 0, irc_cmd_completions, IRC_CMD_LOGGED_IN },
    627627        { "die",         0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
     628        { "deaf",        0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
    628629        { "wallops",     1, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
    629630        { "wall",        1, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
  • lib/misc.c

    rd301872 r934dddf3  
    373373void random_bytes( unsigned char *buf, int count )
    374374{
     375#ifndef _WIN32
    375376        static int use_dev = -1;
    376377       
     
    422423       
    423424        if( !use_dev )
     425#endif
    424426        {
    425427                int i;
     
    582584        md5_byte_t pass_md5[16];
    583585        md5_state_t md5_state;
    584         int ret, i;
    585        
    586         if( base64_decode( hash, &pass_dec ) != 21 )
    587         {
    588                 ret = -1;
    589         }
    590         else
     586        int ret = -1, i;
     587       
     588        if( base64_decode( hash, &pass_dec ) == 21 )
    591589        {
    592590                md5_init( &md5_state );
  • lib/ssl_bogus.c

    rd301872 r934dddf3  
    6161        return GAIM_INPUT_READ;
    6262}
     63
     64int ssl_pending( void *conn )
     65{
     66        return 0;
     67}
  • protocols/msn/msn.c

    rd301872 r934dddf3  
    113113{
    114114        struct msn_switchboard *sb;
    115         struct msn_data *md = ic->proto_data;
    116115       
    117116        if( ( sb = msn_sb_by_handle( ic, who ) ) )
     
    122121        {
    123122                struct msn_message *m;
    124                 char buf[1024];
    125123               
    126124                /* Create a message. We have to arrange a usable switchboard, and send the message later. */
     
    129127                m->text = g_strdup( message );
    130128               
    131                 /* FIXME: *CHECK* the reliability of using spare sb's! */
    132                 if( ( sb = msn_sb_spare( ic ) ) )
    133                 {
    134                         debug( "Trying to use a spare switchboard to message %s", who );
    135                        
    136                         sb->who = g_strdup( who );
    137                         g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, who );
    138                         if( msn_sb_write( sb, buf, strlen( buf ) ) )
    139                         {
    140                                 /* He/She should join the switchboard soon, let's queue the message. */
    141                                 sb->msgq = g_slist_append( sb->msgq, m );
    142                                 return( 1 );
    143                         }
    144                 }
    145                
    146                 debug( "Creating a new switchboard to message %s", who );
    147                
    148                 /* If we reach this line, there was no spare switchboard, so let's make one. */
    149                 g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
    150                 if( !msn_write( ic, buf, strlen( buf ) ) )
    151                 {
    152                         g_free( m->who );
    153                         g_free( m->text );
    154                         g_free( m );
    155                        
    156                         return( 0 );
    157                 }
    158                
    159                 /* And queue the message to md. We'll pick it up when the switchboard comes up. */
    160                 md->msgq = g_slist_append( md->msgq, m );
    161                
    162                 /* FIXME: If the switchboard creation fails, the message will not be sent. */
    163                
    164                 return( 1 );
     129                return msn_sb_write_msg( ic, m );
    165130        }
    166131       
     
    252217{
    253218        struct msn_switchboard *sb;
    254         struct msn_data *md = ic->proto_data;
    255         char buf[1024];
    256219       
    257220        if( ( sb = msn_sb_by_handle( ic, who ) ) )
     
    263226        {
    264227                struct msn_message *m;
    265                
    266                 if( ( sb = msn_sb_spare( ic ) ) )
    267                 {
    268                         debug( "Trying to reuse an existing switchboard as a groupchat with %s", who );
    269                         g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, who );
    270                         if( msn_sb_write( sb, buf, strlen( buf ) ) )
    271                                 return msn_sb_to_chat( sb );
    272                 }
    273                
    274                 /* If the stuff above failed for some reason: */
    275                 debug( "Creating a new switchboard to groupchat with %s", who );
    276                
    277                 /* Request a new switchboard. */
    278                 g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
    279                 if( !msn_write( ic, buf, strlen( buf ) ) )
    280                         return( 0 );
    281228               
    282229                /* Create a magic message. This is quite hackish, but who cares? :-P */
     
    285232                m->text = g_strdup( GROUPCHAT_SWITCHBOARD_MESSAGE );
    286233               
    287                 /* Queue the magic message and cross your fingers. */
    288                 md->msgq = g_slist_append( md->msgq, m );
    289                
    290                 /* FIXME: Can I try to return something here already? */
     234                msn_sb_write_msg( ic, m );
     235
    291236                return NULL;
    292237        }
  • protocols/msn/msn.h

    rd301872 r934dddf3  
    2323  Suite 330, Boston, MA  02111-1307  USA
    2424*/
     25
     26#ifndef _MSN_H
     27#define _MSN_H
    2528
    2629/* Some hackish magicstrings to make special-purpose messages/switchboards.
     
    176179void msn_sb_destroy( struct msn_switchboard *sb );
    177180gboolean msn_sb_connected( gpointer data, gint source, b_input_condition cond );
     181int msn_sb_write_msg( struct im_connection *ic, struct msn_message *m );
     182
     183#endif //_MSN_H
  • protocols/msn/ns.c

    rd301872 r934dddf3  
    278278                if( num_parts == 5 )
    279279                {
     280                        int i, groupcount;
     281                       
     282                        groupcount = atoi( cmd[4] );
     283                        if( groupcount > 0 )
     284                        {
     285                                /* valgrind says this is leaking memory, I'm guessing
     286                                   that this happens during server redirects. */
     287                                if( md->grouplist )
     288                                {
     289                                        for( i = 0; i < md->groupcount; i ++ )
     290                                                g_free( md->grouplist[i] );
     291                                        g_free( md->grouplist );
     292                                }
     293                               
     294                                md->groupcount = groupcount;
     295                                md->grouplist = g_new0( char *, md->groupcount );
     296                        }
     297                       
    280298                        md->buddycount = atoi( cmd[3] );
    281                         md->groupcount = atoi( cmd[4] );
    282                         if( md->groupcount > 0 )
    283                                 md->grouplist = g_new0( char *, md->groupcount );
    284                        
    285299                        if( !*cmd[3] || md->buddycount == 0 )
    286300                                msn_logged_in( ic );
     
    665679                                        imcb_log( ic, "INBOX contains %s new messages, plus %s messages in other folders.", inbox, folders );
    666680                                }
     681                               
     682                                g_free( inbox );
     683                                g_free( folders );
    667684                        }
    668685                        else if( g_strncasecmp( ct, "text/x-msmsgsemailnotification", 30 ) == 0 )
  • protocols/msn/sb.c

    rd301872 r934dddf3  
    4444                return( 0 );
    4545        }
     46       
     47        return( 1 );
     48}
     49
     50int msn_sb_write_msg( struct im_connection *ic, struct msn_message *m )
     51{
     52        struct msn_data *md = ic->proto_data;
     53        struct msn_switchboard *sb;
     54        char buf[1024];
     55
     56        /* FIXME: *CHECK* the reliability of using spare sb's! */
     57        if( ( sb = msn_sb_spare( ic ) ) )
     58        {
     59                debug( "Trying to use a spare switchboard to message %s", m->who );
     60               
     61                sb->who = g_strdup( m->who );
     62                g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, m->who );
     63                if( msn_sb_write( sb, buf, strlen( buf ) ) )
     64                {
     65                        /* He/She should join the switchboard soon, let's queue the message. */
     66                        sb->msgq = g_slist_append( sb->msgq, m );
     67                        return( 1 );
     68                }
     69        }
     70       
     71        debug( "Creating a new switchboard to message %s", m->who );
     72       
     73        /* If we reach this line, there was no spare switchboard, so let's make one. */
     74        g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
     75        if( !msn_write( ic, buf, strlen( buf ) ) )
     76        {
     77                g_free( m->who );
     78                g_free( m->text );
     79                g_free( m );
     80               
     81                return( 0 );
     82        }
     83       
     84        /* And queue the message to md. We'll pick it up when the switchboard comes up. */
     85        md->msgq = g_slist_append( md->msgq, m );
     86       
     87        /* FIXME: If the switchboard creation fails, the message will not be sent. */
    4688       
    4789        return( 1 );
  • protocols/nogaim.c

    rd301872 r934dddf3  
    267267           protocols. */
    268268        imc_set_away( ic, u->away );
     269       
     270        /* Apparently we're connected successfully, so reset the
     271           exponential backoff timer. */
     272        ic->acc->auto_reconnect_delay = 0;
    269273}
    270274
     
    290294        user_t *t, *u;
    291295        account_t *a;
     296        int delay;
    292297       
    293298        /* Nested calls might happen sometimes, this is probably the best
     
    329334        }
    330335        else if( allow_reconnect && set_getbool( &irc->set, "auto_reconnect" ) &&
    331                  set_getbool( &a->set, "auto_reconnect" ) )
    332         {
    333                 int delay = set_getint( &irc->set, "auto_reconnect_delay" );
    334                
     336                 set_getbool( &a->set, "auto_reconnect" ) &&
     337                 ( delay = account_reconnect_delay( a ) ) > 0 )
     338        {
    335339                imcb_log( ic, "Reconnecting in %d seconds..", delay );
    336340                a->reconnect = b_timeout_add( delay * 1000, auto_reconnect, a );
  • protocols/yahoo/libyahoo2.c

    rd301872 r934dddf3  
    6969#ifdef __MINGW32__
    7070# include <winsock2.h>
    71 # define write(a,b,c) send(a,b,c,0)
    72 # define read(a,b,c)  recv(a,b,c,0)
    7371#endif
    7472
  • protocols/yahoo/yahoo.c

    rd301872 r934dddf3  
    665665       
    666666        imcb_error( ic, "%s", err );
    667        
    668         if( fatal )
    669                 imc_logout( ic, TRUE );
    670667}
    671668
  • protocols/yahoo/yahoo_httplib.c

    rd301872 r934dddf3  
    5151#ifdef __MINGW32__
    5252# include <winsock2.h>
    53 # define write(a,b,c) send(a,b,c,0)
    54 # define read(a,b,c)  recv(a,b,c,0)
    5553# define snprintf _snprintf
    5654#endif
  • sock.h

    rd301872 r934dddf3  
    1616#else
    1717# include <winsock2.h>
    18 # ifndef _MSC_VER
    19 #  include <ws2tcpip.h>
    20 # endif
     18# include <ws2tcpip.h>
    2119# if !defined(BITLBEE_CORE) && defined(_MSC_VER)
    2220#   pragma comment(lib,"bitlbee.lib")
    2321# endif
    2422# include <io.h>
    25 # define read(a,b,c) recv(a,b,c,0)
    26 # define write(a,b,c) send(a,b,c,0)
    27 # define umask _umask
    28 # define mode_t int
    2923# define sock_make_nonblocking(fd) { int non_block = 1; ioctlsocket(fd, FIONBIO, &non_block); }
    3024# define sock_make_blocking(fd) { int non_block = 0; ioctlsocket(fd, FIONBIO, &non_block); }
  • storage_text.c

    rd301872 r934dddf3  
    2727#include "bitlbee.h"
    2828#include "crypting.h"
     29#ifdef _WIN32
     30# define umask _umask
     31# define mode_t int
     32#endif
     33
     34#ifndef F_OK
     35#define F_OK 0
     36#endif
    2937
    3038static void text_init (void)
  • storage_xml.c

    rd301872 r934dddf3  
    3030#include "md5.h"
    3131#include <glib/gstdio.h>
     32
     33#if GLIB_CHECK_VERSION(2,8,0)
     34#include <glib/gstdio.h>
     35#else
     36/* GLib < 2.8.0 doesn't have g_access, so just use the system access(). */
     37#include <unistd.h>
     38#define g_access access
     39#endif
    3240
    3341typedef enum
     
    244252static void xml_init( void )
    245253{
    246         if( ! g_file_test( global.conf->configdir, G_FILE_TEST_EXISTS ) )
     254        if( g_access( global.conf->configdir, F_OK ) != 0 )
    247255                log_message( LOGLVL_WARNING, "The configuration directory `%s' does not exist. Configuration won't be saved.", global.conf->configdir );
    248         else if( ! g_file_test( global.conf->configdir, G_FILE_TEST_EXISTS ) || g_access( global.conf->configdir, W_OK ) != 0 )
     256        else if( g_access( global.conf->configdir, F_OK ) != 0 ||
     257                 g_access( global.conf->configdir, W_OK ) != 0 )
    249258                log_message( LOGLVL_WARNING, "Permission problem: Can't read/write from/to `%s'.", global.conf->configdir );
    250259}
     
    373382        g_free( path2 );
    374383       
    375         if( !overwrite && g_file_test( path, G_FILE_TEST_EXISTS ) )
     384        if( !overwrite && g_access( path, F_OK ) == 0 )
    376385                return STORAGE_ALREADY_EXISTS;
    377386       
     
    481490static storage_status_t xml_remove( const char *nick, const char *password )
    482491{
    483         char s[512];
     492        char s[512], *lc;
    484493        storage_status_t status;
    485494
     
    488497                return status;
    489498
    490         g_snprintf( s, 511, "%s%s%s", global.conf->configdir, nick, ".xml" );
     499        lc = g_strdup( nick );
     500        nick_lc( lc );
     501        g_snprintf( s, 511, "%s%s%s", global.conf->configdir, lc, ".xml" );
     502        g_free( lc );
     503       
    491504        if( unlink( s ) == -1 )
    492505                return STORAGE_OTHER_ERROR;
  • unix.c

    rd301872 r934dddf3  
    4040static void sighandler( int signal );
    4141
    42 int main( int argc, char *argv[], char **envp )
     42int main( int argc, char *argv[] )
    4343{
    4444        int i = 0;
     
    6060        if( global.conf->runmode == RUNMODE_INETD )
    6161        {
     62                log_link( LOGLVL_ERROR, LOGOUTPUT_IRC );
     63                log_link( LOGLVL_WARNING, LOGOUTPUT_IRC );
     64       
    6265                i = bitlbee_inetd_init();
    6366                log_message( LOGLVL_INFO, "Bitlbee %s starting in inetd mode.", BITLBEE_VERSION );
     
    6669        else if( global.conf->runmode == RUNMODE_DAEMON )
    6770        {
     71                log_link( LOGLVL_ERROR, LOGOUTPUT_SYSLOG );
     72                log_link( LOGLVL_WARNING, LOGOUTPUT_SYSLOG );
     73
    6874                i = bitlbee_daemon_init();
    6975                log_message( LOGLVL_INFO, "Bitlbee %s starting in daemon mode.", BITLBEE_VERSION );
     
    135141        {
    136142                char *fn = ipc_master_save_state();
    137                 char **args;
    138                 int n, i;
    139143               
    140144                chdir( old_cwd );
    141145               
    142                 n = 0;
    143                 args = g_new0( char *, argc + 3 );
    144                 args[n++] = argv[0];
    145                 if( fn )
    146                 {
    147                         args[n++] = "-R";
    148                         args[n++] = fn;
    149                 }
    150                 for( i = 1; argv[i] && i < argc; i ++ )
    151                 {
    152                         if( strcmp( argv[i], "-R" ) == 0 )
    153                                 i += 2;
    154                        
    155                         args[n++] = argv[i];
    156                 }
     146                setenv( "_BITLBEE_RESTART_STATE", fn, 1 );
     147                g_free( fn );
    157148               
    158149                close( global.listen_socket );
    159150               
    160                 execve( args[0], args, envp );
     151                if( execv( argv[0], argv ) == -1 )
     152                        /* Apparently the execve() failed, so let's just
     153                           jump back into our own/current main(). */
     154                        /* Need more cleanup code to make this work. */
     155                        return 1; /* main( argc, argv ); */
    161156        }
    162157       
     
    219214        return( (double) time->tv_sec + (double) time->tv_usec / 1000000 );
    220215}
     216
     217
Note: See TracChangeset for help on using the changeset viewer.