Changeset 5be87b2 for unix.c

Timestamp:

2008-04-02T15:03:02Z (17 years ago)

Author:

Jelmer Vernooij <jelmer@…>

Branches:

master

Children:

1a57b893, 69aaf14

Parents:

fa75134

Message:

Move unix-specific random_bytes() implementation to unix.c.

File:

• unix.c (modified) (1 diff)

unix.c

@@ -219 +219 @@
         return( (double) time->tv_sec + (double) time->tv_usec / 1000000 );
 }
+
+/* A pretty reliable random number generator. Tries to use the /dev/random
+   devices first, and falls back to the random number generator from libc
+   when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
+   lack of entropy won't halt BitlBee. */
+void random_bytes( unsigned char *buf, int count )
+{
+        static int use_dev = -1;
+        
+        /* Actually this probing code isn't really necessary, is it? */
+        if( use_dev == -1 )
+        {
+                if( access( "/dev/random", R_OK ) == 0 || access( "/dev/urandom", R_OK ) == 0 )
+                        use_dev = 1;
+                else
+                {
+                        use_dev = 0;
+                        srand( ( getpid() << 16 ) ^ time( NULL ) );
+                }
+        }
+        
+        if( use_dev )
+        {
+                int fd;
+                
+                /* At least on Linux, /dev/random can block if there's not
+                   enough entropy. We really don't want that, so if it can't
+                   give anything, use /dev/urandom instead. */
+                if( ( fd = open( "/dev/random", O_RDONLY | O_NONBLOCK ) ) >= 0 )
+                        if( read( fd, buf, count ) == count )
+                        {
+                                close( fd );
+                                return;
+                        }
+                close( fd );
+                
+                /* urandom isn't supposed to block at all, but just to be
+                   sure. If it blocks, we'll disable use_dev and use the libc
+                   randomizer instead. */
+                if( ( fd = open( "/dev/urandom", O_RDONLY | O_NONBLOCK ) ) >= 0 )
+                        if( read( fd, buf, count ) == count )
+                        {
+                                close( fd );
+                                return;
+                        }
+                close( fd );
+                
+                /* If /dev/random blocks once, we'll still try to use it
+                   again next time. If /dev/urandom also fails for some
+                   reason, stick with libc during this session. */
+                
+                use_dev = 0;
+                srand( ( getpid() << 16 ) ^ time( NULL ) );
+        }
+        
+        if( !use_dev )
+        {
+                int i;
+                
+                /* Possibly the LSB of rand() isn't very random on some
+                   platforms. Seems okay on at least Linux and OSX though. */
+                for( i = 0; i < count; i ++ )
+                        buf[i] = rand() & 0xff;
+        }
+}
+
+