Changes in / [6ff51ff:dd34575]


Ignore:
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.h

    r6ff51ff rdd34575  
    9595#define g_main_quit             __PLEASE_USE_B_MAIN_QUIT__
    9696
     97#ifndef F_OK
     98#define F_OK 0
     99#endif
     100
    97101#ifndef G_GNUC_MALLOC
    98102/* Doesn't exist in GLib <=2.4 while everything else in BitlBee should
  • configure

    r6ff51ff rdd34575  
    7474--ssl=...       SSL library to use (gnutls, nss, openssl, bogus, auto)
    7575                                                        $ssl
    76 
    77 --target=...    Cross compilation target                same as host
    7876EOF
    7977                exit;
     
    134132EOF
    135133
    136 if [ -n "$target" ]; then
    137         PKG_CONFIG_PATH=/usr/$target/lib/pkgconfig
    138         PATH=/usr/$target/bin:$PATH
    139         CC=$target-cc
    140         LD=$target-ld
    141 fi
    142 
    143134if [ "$debug" = "1" ]; then
    144135        [ -z "$CFLAGS" ] && CFLAGS=-g
     
    167158echo "CC=$CC" >> Makefile.settings;
    168159
    169 if [ -z "$LD" ]; then
    170         if type ld > /dev/null 2> /dev/null; then
    171                 LD=ld
    172         else
    173                 echo 'Cannot find ld, aborting.'
    174                 exit 1;
    175         fi
    176 fi
    177 
    178 echo "LD=$LD" >> Makefile.settings
     160if [ -n "$LD" ]; then
     161        echo "LD=$LD" >> Makefile.settings;
     162elif type ld > /dev/null 2> /dev/null; then
     163        echo "LD=ld" >> Makefile.settings;
     164else
     165        echo 'Cannot find ld, aborting.'
     166        exit 1;
     167fi
    179168
    180169if [ -z "$PKG_CONFIG" ]; then
     
    224213detect_gnutls()
    225214{
    226         if $PKG_CONFIG --exists gnutls; then
    227                 cat <<EOF>>Makefile.settings
    228 EFLAGS+=`$PKG_CONFIG --libs gnutls`
    229 CFLAGS+=`$PKG_CONFIG --cflags gnutls`
    230 EOF
    231                 ssl=gnutls
    232                 ret=1
    233         elif libgnutls-config --version > /dev/null 2> /dev/null; then
     215        if libgnutls-config --version > /dev/null 2> /dev/null; then
    234216                cat <<EOF>>Makefile.settings
    235217EFLAGS+=`libgnutls-config --libs`
     
    507489esac
    508490
    509 if [ -n "$target" ]; then
    510         echo "Cross-compiling for: $target"
    511 fi
    512 
    513491echo
    514492echo 'Configuration done:'
  • lib/misc.c

    r6ff51ff rdd34575  
    392392}
    393393
     394/* A pretty reliable random number generator. Tries to use the /dev/random
     395   devices first, and falls back to the random number generator from libc
     396   when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
     397   lack of entropy won't halt BitlBee. */
     398void random_bytes( unsigned char *buf, int count )
     399{
     400        static int use_dev = -1;
     401       
     402        /* Actually this probing code isn't really necessary, is it? */
     403        if( use_dev == -1 )
     404        {
     405                if( access( "/dev/random", R_OK ) == 0 || access( "/dev/urandom", R_OK ) == 0 )
     406                        use_dev = 1;
     407                else
     408                {
     409                        use_dev = 0;
     410                        srand( ( getpid() << 16 ) ^ time( NULL ) );
     411                }
     412        }
     413       
     414        if( use_dev )
     415        {
     416                int fd;
     417               
     418                /* At least on Linux, /dev/random can block if there's not
     419                   enough entropy. We really don't want that, so if it can't
     420                   give anything, use /dev/urandom instead. */
     421                if( ( fd = open( "/dev/random", O_RDONLY | O_NONBLOCK ) ) >= 0 )
     422                        if( read( fd, buf, count ) == count )
     423                        {
     424                                close( fd );
     425                                return;
     426                        }
     427                close( fd );
     428               
     429                /* urandom isn't supposed to block at all, but just to be
     430                   sure. If it blocks, we'll disable use_dev and use the libc
     431                   randomizer instead. */
     432                if( ( fd = open( "/dev/urandom", O_RDONLY | O_NONBLOCK ) ) >= 0 )
     433                        if( read( fd, buf, count ) == count )
     434                        {
     435                                close( fd );
     436                                return;
     437                        }
     438                close( fd );
     439               
     440                /* If /dev/random blocks once, we'll still try to use it
     441                   again next time. If /dev/urandom also fails for some
     442                   reason, stick with libc during this session. */
     443               
     444                use_dev = 0;
     445                srand( ( getpid() << 16 ) ^ time( NULL ) );
     446        }
     447       
     448        if( !use_dev )
     449        {
     450                int i;
     451               
     452                /* Possibly the LSB of rand() isn't very random on some
     453                   platforms. Seems okay on at least Linux and OSX though. */
     454                for( i = 0; i < count; i ++ )
     455                        buf[i] = rand() & 0xff;
     456        }
     457}
     458
    394459int is_bool( char *value )
    395460{
  • storage_xml.c

    r6ff51ff rdd34575  
    2929#include "arc.h"
    3030#include "md5.h"
    31 #include <glib/gstdio.h>
    3231
    3332typedef enum
     
    244243static void xml_init( void )
    245244{
    246         if( ! g_file_test( global.conf->configdir, G_FILE_TEST_EXISTS ) )
     245        if( access( global.conf->configdir, F_OK ) != 0 )
    247246                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 )
     247        else if( access( global.conf->configdir, R_OK ) != 0 || access( global.conf->configdir, W_OK ) != 0 )
    249248                log_message( LOGLVL_WARNING, "Permission problem: Can't read/write from/to `%s'.", global.conf->configdir );
    250249}
     
    373372        g_free( path2 );
    374373       
    375         if( !overwrite && g_file_test( path, G_FILE_TEST_EXISTS ) )
     374        if( !overwrite && access( path, F_OK ) != -1 )
    376375                return STORAGE_ALREADY_EXISTS;
    377376       
  • unix.c

    r6ff51ff rdd34575  
    219219        return( (double) time->tv_sec + (double) time->tv_usec / 1000000 );
    220220}
    221 
    222 /* A pretty reliable random number generator. Tries to use the /dev/random
    223    devices first, and falls back to the random number generator from libc
    224    when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
    225    lack of entropy won't halt BitlBee. */
    226 void random_bytes( unsigned char *buf, int count )
    227 {
    228         static int use_dev = -1;
    229        
    230         /* Actually this probing code isn't really necessary, is it? */
    231         if( use_dev == -1 )
    232         {
    233                 if( access( "/dev/random", R_OK ) == 0 || access( "/dev/urandom", R_OK ) == 0 )
    234                         use_dev = 1;
    235                 else
    236                 {
    237                         use_dev = 0;
    238                         srand( ( getpid() << 16 ) ^ time( NULL ) );
    239                 }
    240         }
    241        
    242         if( use_dev )
    243         {
    244                 int fd;
    245                
    246                 /* At least on Linux, /dev/random can block if there's not
    247                    enough entropy. We really don't want that, so if it can't
    248                    give anything, use /dev/urandom instead. */
    249                 if( ( fd = open( "/dev/random", O_RDONLY | O_NONBLOCK ) ) >= 0 )
    250                         if( read( fd, buf, count ) == count )
    251                         {
    252                                 close( fd );
    253                                 return;
    254                         }
    255                 close( fd );
    256                
    257                 /* urandom isn't supposed to block at all, but just to be
    258                    sure. If it blocks, we'll disable use_dev and use the libc
    259                    randomizer instead. */
    260                 if( ( fd = open( "/dev/urandom", O_RDONLY | O_NONBLOCK ) ) >= 0 )
    261                         if( read( fd, buf, count ) == count )
    262                         {
    263                                 close( fd );
    264                                 return;
    265                         }
    266                 close( fd );
    267                
    268                 /* If /dev/random blocks once, we'll still try to use it
    269                    again next time. If /dev/urandom also fails for some
    270                    reason, stick with libc during this session. */
    271                
    272                 use_dev = 0;
    273                 srand( ( getpid() << 16 ) ^ time( NULL ) );
    274         }
    275        
    276         if( !use_dev )
    277         {
    278                 int i;
    279                
    280                 /* Possibly the LSB of rand() isn't very random on some
    281                    platforms. Seems okay on at least Linux and OSX though. */
    282                 for( i = 0; i < count; i ++ )
    283                         buf[i] = rand() & 0xff;
    284         }
    285 }
    286 
    287 
Note: See TracChangeset for help on using the changeset viewer.