# random_r

## NAME



           random_r, srandom_r, initstate_r, setstate_r - reentrant random
           number generator
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <stdlib.h>**
    
           **int random_r(struct random_data *restrict** _buf_**,**
                        **int32_t *restrict** _result_**);**
           **int srandom_r(unsigned int** _seed_**, struct random_data ***_buf_**);**
    
           **int initstate_r(unsigned int** _seed_**, char** _statebuf_**[restrict .**_statelen_**],**
                        **size_t** _statelen_**, struct random_data *restrict** _buf_**);**
           **int setstate_r(char *restrict** _statebuf_**,**
                        **struct random_data *restrict** _buf_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **random_r**(), **srandom_r**(), **initstate_r**(), **setstate_r**():
               /* glibc >= 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE
    


## DESCRIPTION



           These functions are the reentrant equivalents of the functions
           described in random(3).  They are suitable for use in
           multithreaded programs where each thread needs to obtain an
           independent, reproducible sequence of random numbers.
    
           The **random_r**() function is like random(3), except that instead of
           using state information maintained in a global variable, it uses
           the state information in the argument pointed to by _buf_ , which
           must have been previously initialized by **initstate_r**().  The
           generated random number is returned in the argument _result_.
    
           The **srandom_r**() function is like srandom(3), except that it
           initializes the seed for the random number generator whose state
           is maintained in the object pointed to by _buf_ , which must have
           been previously initialized by **initstate_r**(), instead of the seed
           associated with the global state variable.
    
           The **initstate_r**() function is like initstate(3) except that it
           initializes the state in the object pointed to by _buf_ , rather than
           initializing the global state variable.  Before calling this
           function, the _buf.state_ field must be initialized to NULL.  The
           **initstate_r**() function records a pointer to the _statebuf_ argument
           inside the structure pointed to by _buf_.  Thus, _statebuf_ should not
           be deallocated so long as _buf_ is still in use.  (So, _statebuf_
           should typically be allocated as a static variable, or allocated
           on the heap using malloc(3) or similar.)
    
           The **setstate_r**() function is like setstate(3) except that it
           modifies the state in the object pointed to by _buf_ , rather than
           modifying the global state variable.  _state_ must first have been
           initialized using **initstate_r**() or be the result of a previous
           call of **setstate_r**().
    


## RETURN VALUE



           All of these functions return 0 on success.  On error, -1 is
           returned, with _errno_ set to indicate the error.
    


## ERRORS



           **EINVAL** A state array of less than 8 bytes was specified to
                  **initstate_r**().
    
           **EINVAL** The _statebuf_ or _buf_ argument to **setstate_r**() was NULL.
    
           **EINVAL** The _buf_ or _result_ argument to **random_r**() was NULL.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌─────────────────────────────┬───────────────┬──────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├─────────────────────────────┼───────────────┼──────────────────┤
           │ **random_r**(), **srandom_r**(),    │ Thread safety │ MT-Safe race:buf │
           │ **initstate_r**(), **setstate_r**() │               │                  │
           └─────────────────────────────┴───────────────┴──────────────────┘
    


## STANDARDS



           GNU.
    


## BUGS



           The **initstate_r**() interface is confusing.  It appears that the
           _random_data_ type is intended to be opaque, but the implementation
           requires the user to either initialize the _buf.state_ field to NULL
           or zero out the entire structure before the call.
    


* * *