Return to random.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src

Annotation of embedaddon/php/ext/sqlite/libsqlite/src/random.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** 2001 September 15
                      3: **
                      4: ** The author disclaims copyright to this source code.  In place of
                      5: ** a legal notice, here is a blessing:
                      6: **
                      7: **    May you do good and not evil.
                      8: **    May you find forgiveness for yourself and forgive others.
                      9: **    May you share freely, never taking more than you give.
                     10: **
                     11: *************************************************************************
                     12: ** This file contains code to implement a pseudo-random number
                     13: ** generator (PRNG) for SQLite.
                     14: **
                     15: ** Random numbers are used by some of the database backends in order
                     16: ** to generate random integer keys for tables or random filenames.
                     17: **
                     18: ** $Id: random.c 195361 2005-09-07 15:11:33Z iliaa $
                     19: */
                     20: #include "sqliteInt.h"
                     21: #include "os.h"
                     22: 
                     23: 
                     24: /*
                     25: ** Get a single 8-bit random value from the RC4 PRNG.  The Mutex
                     26: ** must be held while executing this routine.
                     27: **
                     28: ** Why not just use a library random generator like lrand48() for this?
                     29: ** Because the OP_NewRecno opcode in the VDBE depends on having a very
                     30: ** good source of random numbers.  The lrand48() library function may
                     31: ** well be good enough.  But maybe not.  Or maybe lrand48() has some
                     32: ** subtle problems on some systems that could cause problems.  It is hard
                     33: ** to know.  To minimize the risk of problems due to bad lrand48()
                     34: ** implementations, SQLite uses this random number generator based
                     35: ** on RC4, which we know works very well.
                     36: */
                     37: static int randomByte(){
                     38:   unsigned char t;
                     39: 
                     40:   /* All threads share a single random number generator.
                     41:   ** This structure is the current state of the generator.
                     42:   */
                     43:   static struct {
                     44:     unsigned char isInit;          /* True if initialized */
                     45:     unsigned char i, j;            /* State variables */
                     46:     unsigned char s[256];          /* State variables */
                     47:   } prng;
                     48: 
                     49:   /* Initialize the state of the random number generator once,
                     50:   ** the first time this routine is called.  The seed value does
                     51:   ** not need to contain a lot of randomness since we are not
                     52:   ** trying to do secure encryption or anything like that...
                     53:   **
                     54:   ** Nothing in this file or anywhere else in SQLite does any kind of
                     55:   ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
                     56:   ** number generator) not as an encryption device.
                     57:   */
                     58:   if( !prng.isInit ){
                     59:     int i;
                     60:     char k[256];
                     61:     prng.j = 0;
                     62:     prng.i = 0;
                     63:     sqliteOsRandomSeed(k);
                     64:     for(i=0; i<256; i++){
                     65:       prng.s[i] = i;
                     66:     }
                     67:     for(i=0; i<256; i++){
                     68:       prng.j += prng.s[i] + k[i];
                     69:       t = prng.s[prng.j];
                     70:       prng.s[prng.j] = prng.s[i];
                     71:       prng.s[i] = t;
                     72:     }
                     73:     prng.isInit = 1;
                     74:   }
                     75: 
                     76:   /* Generate and return single random byte
                     77:   */
                     78:   prng.i++;
                     79:   t = prng.s[prng.i];
                     80:   prng.j += t;
                     81:   prng.s[prng.i] = prng.s[prng.j];
                     82:   prng.s[prng.j] = t;
                     83:   t += prng.s[prng.i];
                     84:   return prng.s[t];
                     85: }
                     86: 
                     87: /*
                     88: ** Return N random bytes.
                     89: */
                     90: void sqliteRandomness(int N, void *pBuf){
                     91:   unsigned char *zBuf = pBuf;
                     92:   sqliteOsEnterMutex();
                     93:   while( N-- ){
                     94:     *(zBuf++) = randomByte();
                     95:   }
                     96:   sqliteOsLeaveMutex();
                     97: }