protected function connectToAddress(string $address, float $timeout, bool $encrypt)
 {
     $url = \sprintf('%s://%s', $this->protocol, $address);
     $errno = null;
     $errstr = null;
     $context = \stream_context_create(\array_replace_recursive($this->options, ['socket' => ['connect' => $address]]));
     $socket = @\stream_socket_client($url, $errno, $errstr, $timeout ?: null, \STREAM_CLIENT_CONNECT | \STREAM_CLIENT_ASYNC_CONNECT, $context);
     if (!\is_resource($socket)) {
         throw new SocketException(\sprintf('Could not connect to "%s" (%s): [%s] %s', $url, $this->peer, $errno, \trim($errstr)));
     }
     try {
         \stream_set_blocking($socket, false);
         \stream_set_read_buffer($socket, 0);
         \stream_set_write_buffer($socket, 0);
         if ($this->tcpNoDelay) {
             Socket::setTcpNoDelay($socket, true);
         }
         if ($encrypt) {
             yield from $this->encryptSocketClient($socket, $timeout);
         } else {
             (yield new AwaitWrite($socket, $timeout));
         }
         return $socket;
     } catch (\Throwable $e) {
         Socket::shutdown($socket);
         throw $e;
     }
 }

 /**
  * Generates random bytes as a string of given length.
  *
  * <code>
  * echo Txp::get('\Textpattern\Password\Random')->generate(196);
  * </code>
  *
  * @param  int $length The length of the generated value
  * @return string The value
  */
 public function generate($length)
 {
     $bytes = (int) ceil($length / 2);
     if (function_exists('mcrypt_create_iv') && version_compare(PHP_VERSION, '5.3.0') >= 0) {
         $random = mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM);
         if ($random && strlen($random) === $bytes) {
             return substr(bin2hex($random), 0, $length);
         }
     }
     if (IS_WIN === false && file_exists('/dev/urandom') && is_readable('/dev/urandom') && ($fp = fopen('/dev/urandom', 'rb')) !== false) {
         if (function_exists('stream_set_read_buffer')) {
             stream_set_read_buffer($fp, 0);
         }
         $random = fread($fp, $bytes);
         fclose($fp);
         if ($random && strlen($random) === $bytes) {
             return substr(bin2hex($random), 0, $length);
         }
     }
     if (IS_WIN === false && function_exists('openssl_random_pseudo_bytes') && version_compare(PHP_VERSION, '5.3.4') >= 0) {
         $random = openssl_random_pseudo_bytes($bytes, $strong);
         if ($random && $strong === true && strlen($random) === $bytes) {
             return substr(bin2hex($random), 0, $length);
         }
     }
     return parent::generate($length);
 }

function dmx_connect()
{
    global $debug, $dmx, $read_buffer;
    $r = trim(`ls -1 /dev/serial/by-id 2>/dev/null |grep "DMX"`);
    if ($r == '') {
        logformat("No USB DMX Interface appears to be connected!\n");
        exit(1);
    }
    $t = explode("-", $r);
    if (isset($t[1])) {
        logformat(sprintf("Found a %s\n", $t[1]));
    }
    $interface = "/dev/serial/by-id/" . $r;
    `stty -F {$interface} 230400 raw -echo`;
    if ($dmx = fopen($interface, 'w+')) {
        stream_set_blocking($dmx, 0);
        stream_set_read_buffer($dmx, 2048);
        $data = '';
        dmx_set_levels($data);
        dmx_set_dmx_receive_mode(SEND_ON_CHANGE_ONLY);
        sleep(1);
        while ($b = fread($dmx, 2048)) {
        }
        //empty the buffer
        $data = "Hello World!";
        dmx_set_parameters(27, 4, 40, $data);
        if (!($c = dmx_request_parameters($read_buffer))) {
            dmx_close();
            return 0;
        }
        return $c;
    }
    return 0;
}

 public function __construct($stream, LoopInterface $loop)
 {
     $this->stream = $stream;
     if (!is_resource($this->stream) || get_resource_type($this->stream) !== "stream") {
         throw new InvalidArgumentException('First parameter must be a valid stream resource');
     }
     stream_set_blocking($this->stream, 0);
     // Use unbuffered read operations on the underlying stream resource.
     // Reading chunks from the stream may otherwise leave unread bytes in
     // PHP's stream buffers which some event loop implementations do not
     // trigger events on (edge triggered).
     // This does not affect the default event loop implementation (level
     // triggered), so we can ignore platforms not supporting this (HHVM).
     if (function_exists('stream_set_read_buffer')) {
         stream_set_read_buffer($this->stream, 0);
     }
     $this->loop = $loop;
     $this->buffer = new Buffer($this->stream, $this->loop);
     $that = $this;
     $this->buffer->on('error', function ($error) use($that) {
         $that->emit('error', array($error, $that));
         $that->close();
     });
     $this->buffer->on('drain', function () use($that) {
         $that->emit('drain', array($that));
     });
     $this->resume();
 }

 function get_random_bytes($count)
 {
     $output = '';
     if (@is_readable('/dev/urandom') && ($fh = @fopen('/dev/urandom', 'rb'))) {
         if (function_exists('stream_set_read_buffer')) {
             stream_set_read_buffer($fh, 0);
         }
         $output = fread($fh, $count);
         fclose($fh);
     } elseif (function_exists('openssl_random_pseudo_bytes')) {
         $output = openssl_random_pseudo_bytes($count, $orpb_secure);
         if ($orpb_secure != true) {
             $output = '';
         }
     } elseif (defined('MCRYPT_DEV_URANDOM')) {
         $output = mcrypt_create_iv($count, MCRYPT_DEV_URANDOM);
     }
     if (strlen($output) < $count) {
         $output = '';
         for ($i = 0; $i < $count; $i += 16) {
             $this->random_state = md5(microtime() . $this->random_state);
             $output .= pack('H*', md5($this->random_state));
         }
         $output = substr($output, 0, $count);
     }
     return $output;
 }

 /**
  * Generate a random string by using openssl, dev/urandom or random
  * @param int $length optional length of the string
  * @return string random string
  * @author Benjamin BALET <[email protected]>
  */
 private function generateRandomString($length = 10)
 {
     if (function_exists('openssl_random_pseudo_bytes')) {
         $rnd = openssl_random_pseudo_bytes($length, $strong);
         if ($strong === TRUE) {
             return base64_encode($rnd);
         }
     }
     $sha = '';
     $rnd = '';
     if (file_exists('/dev/urandom')) {
         $fp = fopen('/dev/urandom', 'rb');
         if ($fp) {
             if (function_exists('stream_set_read_buffer')) {
                 stream_set_read_buffer($fp, 0);
             }
             $sha = fread($fp, $length);
             fclose($fp);
         }
     }
     for ($i = 0; $i < $length; $i++) {
         $sha = hash('sha256', $sha . mt_rand());
         $char = mt_rand(0, 62);
         $rnd .= chr(hexdec($sha[$char] . $sha[$char + 1]));
     }
     return base64_encode($rnd);
 }

 /**
  * Use /dev/arandom or /dev/urandom for random numbers
  * 
  * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
  * 
  * @param int $bytes
  * @return string
  */
 function random_bytes($bytes)
 {
     static $fp = null;
     if ($fp === null) {
         if (is_readable('/dev/arandom')) {
             $fp = fopen('/dev/arandom', 'rb');
         } else {
             $fp = fopen('/dev/urandom', 'rb');
         }
     }
     if ($fp !== false) {
         $streamset = stream_set_read_buffer($fp, 0);
         if ($streamset === 0) {
             $remaining = $bytes;
             do {
                 $read = fread($fp, $remaining);
                 if ($read === false) {
                     // We cannot safely read from urandom.
                     $buf = false;
                     break;
                 }
                 // Decrease the number of bytes returned from remaining
                 $remaining -= RandomCompat_strlen($read);
                 $buf .= $read;
             } while ($remaining > 0);
             if ($buf !== false) {
                 if (RandomCompat_strlen($buf) === $bytes) {
                     return $buf;
                 }
             }
         }
     }
     throw new Exception('PHP failed to generate random data.');
 }

 /**
  * @param resource $resource
  * @param bool $autoClose
  * @throws InvalidArgumentException
  */
 public function __construct($resource, $autoClose = true)
 {
     parent::__construct($resource, $autoClose);
     $this->readable = true;
     $this->bufferSize = 4096;
     if (function_exists('stream_set_read_buffer')) {
         stream_set_read_buffer($this->resource, 0);
     }
 }

 private function readFromStatus()
 {
     stream_set_blocking($this->pipeHandles[3], 0);
     stream_set_read_buffer($this->pipeHandles[3], 0);
     $status = '';
     while (!feof($this->pipeHandles[3])) {
         $status .= fread($this->pipeHandles[3], 1);
     }
     return $status;
 }

 /**
  * Wrapper around the stream.
  * Provides async and non async write access required for threads
  * @param ForkableLoopInterface $loop
  * @param resource $connection
  */
 public function __construct(ForkableLoopInterface $loop, $connection)
 {
     $this->loop = $loop;
     $this->connection = $connection;
     $this->buffer = new BinaryBuffer();
     $this->ThrowOnConnectionInvalid();
     if (function_exists('stream_set_read_buffer')) {
         stream_set_read_buffer($this->connection, 0);
     }
     $this->attachReadStream();
 }

 /**
  * @param resource $resource
  * @param LoopInterface $loop
  * @param bool $autoClose
  * @throws InvalidArgumentException
  */
 public function __construct($resource, LoopInterface $loop, $autoClose = true)
 {
     parent::__construct($resource, $autoClose);
     if (function_exists('stream_set_read_buffer')) {
         stream_set_read_buffer($this->resource, 0);
     }
     $this->loop = $loop;
     $this->listening = false;
     $this->paused = true;
     $this->resume();
 }

 /**
  * @param resource $resource Stream resource.
  * @param bool $autoClose True to close the resource on destruct, false to leave it open.
  */
 public function __construct($resource, bool $autoClose = true)
 {
     parent::__construct($resource, $autoClose);
     stream_set_read_buffer($resource, 0);
     stream_set_chunk_size($resource, self::CHUNK_SIZE);
     $this->queue = new \SplQueue();
     $this->poll = $this->createPoll($resource, $this->queue);
     $this->onCancelled = function () {
         $this->poll->cancel();
         $this->queue->shift();
     };
 }

 /**
  * Returns the pointer to the random source.
  * @return resource The pointer to the random source.
  */
 private function getPointer()
 {
     if (!isset($this->pointer)) {
         $this->pointer = fopen($this->source, 'r');
         // File read buffering is not supported on HHVM
         if (!defined('HHVM_VERSION')) {
             stream_set_chunk_size($this->pointer, 32);
             stream_set_read_buffer($this->pointer, 32);
         }
     }
     return $this->pointer;
 }

 /**
  * Connect to Kafka via socket
  * 
  * @return void
  */
 public function connect()
 {
     if (!is_resource($this->conn)) {
         $this->conn = stream_socket_client('tcp://' . $this->host . ':' . $this->port, $errno, $errstr);
         if (!$this->conn) {
             throw new RuntimeException($errstr, $errno);
         }
         stream_set_timeout($this->conn, $this->socketTimeout);
         stream_set_read_buffer($this->conn, $this->socketBufferSize);
         stream_set_write_buffer($this->conn, $this->socketBufferSize);
         //echo "\nConnected to ".$this->host.":".$this->port."\n";
     }
 }

 private function init()
 {
     $connection = @stream_socket_client('tcp://' . $this->host . ':' . $this->port);
     stream_set_write_buffer($connection, 0);
     stream_set_read_buffer($connection, 0);
     if (!$connection) {
         throw new \Exception('No SyncDaemon available.');
     }
     $data = trim(fgets($connection));
     if ($data != self::ACCEPT) {
         throw new \Exception('Connection faild. Wrong answer: ' . $data);
     }
     $this->connection = $connection;
 }

 /** Returns a random binary string
  *
  */
 function bytes($n)
 {
     if (!is_int($n) || $n < 0) {
         throw new InvalidArgumentException("Argument must be non-negative integer: got {$n}");
     }
     if ($this->fp === null) {
         if (defined('MCRYPT_DEV_URANDOM')) {
             $bytes = mcrypt_create_iv($n, MCRYPT_DEV_URANDOM);
             if ($bytes === FALSE || strlen($bytes) != $n) {
                 throw new RuntimeException("mcrypt_create_iv failed!");
             }
             return $bytes;
         }
         $this->fp = fopen('/dev/urandom', 'rb');
         if ($this->fp === FALSE) {
             $this->fp = null;
             throw new RuntimeException("fopen of /dev/urandom failed");
         }
         // by default PHP reads 4096 of bytes
         // http://stackoverflow.com/questions/4296932/does-phps-fread-always-read-at-least-4096-bytes
         // With php >= 5.3.3, we might be able to speed this up:
         // http://php.net/manual/en/function.stream-set-read-buffer.php
         if (function_exists('stream_set_read_buffer')) {
             stream_set_read_buffer($this->fp, 0);
         }
     }
     $bits = '';
     $count = 0;
     $itermax = 10;
     // possible some weird IO problem is preventing reading of bytes
     // make sure infinite loop doesn't happen.  Not sure how PHP
     // handles E_AGAIN signal under load.
     while ($count < $itermax) {
         $len = strlen($bits);
         if ($len === $n) {
             break;
         }
         $count++;
         $tmp = fread($this->fp, $n - $len);
         if ($tmp === FALSE) {
             continue;
         }
         $bits .= $tmp;
     }
     if ($count === $itermax) {
         throw new RuntimeException("After {$itermax} iterations, only got {$len} bytes, requested {$n}");
     }
     return $bits;
 }

 public function __construct()
 {
     if (self::$eio === null) {
         \eio_init();
         $eio = @\eio_get_event_stream();
         \stream_set_blocking($eio, false);
         \stream_set_read_buffer($eio, 0);
         self::$eio = $eio;
         self::$callback = function () {
             while (\eio_npending()) {
                 \eio_poll();
             }
         };
     }
 }

 /**
  * {@inheritdoc}
  */
 public function connect()
 {
     if ($this->sock) {
         return;
     }
     $this->sock = stream_socket_client($this->uri, $errno, $errstr, $this->timeout);
     if (!$this->sock) {
         throw new \RuntimeException("Can't connect to the server at '{$this->uri}' ({$errno}: {$errstr})");
     }
     stream_set_timeout($this->sock, $this->timeout);
     stream_set_blocking($this->sock, $this->blocking);
     stream_set_read_buffer($this->sock, 0);
     // 64k
     stream_set_write_buffer($this->sock, 0);
 }

 /**
  * Transport constructor.
  * @param $socket
  * @param LoopInterface $loop
  */
 public function __construct($socket, LoopInterface $loop)
 {
     $this->socket = $socket;
     $this->loop = $loop;
     stream_set_blocking($this->socket, 0);
     // Use unbuffered read operations on the underlying stream resource.
     // Reading chunks from the stream may otherwise leave unread bytes in
     // PHP's stream buffers which some event loop implementations do not
     // trigger events on (edge triggered).
     // This does not affect the default event loop implementation (level
     // triggered), so we can ignore platforms not supporting this (HHVM).
     if (function_exists('stream_set_read_buffer')) {
         stream_set_read_buffer($this->socket, 0);
     }
 }

 public function __construct($host, $port, $connection_timeout, $read_write_timeout = null, $context = null, $blocking = false)
 {
     $errstr = $errno = null;
     $this->sock = null;
     if ($context) {
         $remote = sprintf('tls://%s:%s', $host, $port);
         $this->sock = @stream_socket_client($remote, $errno, $errstr, $connection_timeout, STREAM_CLIENT_CONNECT, $context);
     } else {
         $remote = sprintf('tcp://%s:%s', $host, $port);
         $this->sock = @stream_socket_client($remote, $errno, $errstr, $connection_timeout, STREAM_CLIENT_CONNECT);
     }
     if (!$this->sock) {
         throw new RuntimeException("Error Connecting to server({$errno}): {$errstr} ");
     }
     if (null !== $read_write_timeout) {
         if (!stream_set_timeout($this->sock, $read_write_timeout)) {
             throw new \Exception("Timeout (stream_set_timeout) could not be set");
         }
     }
     /**
      * Manually set blocking & write buffer settings and make sure they are successfuly set
      * Use non-blocking as we dont want to stuck waiting for socket data while fread() w/o timeout
      */
     if (!stream_set_blocking($this->sock, $blocking)) {
         throw new \Exception("Blocking could not be set");
     }
     $rbuff = stream_set_read_buffer($this->sock, 0);
     if (!(0 === $rbuff)) {
         throw new \Exception("Read buffer could not be set");
     }
     /**
      * ! this is not reliably returns success (0)
      * ! but default buffer is pretty high (few Kb), so will not affect sending single small pushes
      *
      * Output using fwrite() is normally buffered at 8K.
      * This means that if there are two processes wanting to write to the same output stream (a file),
      * each is paused after 8K of data to allow the other to write.
      *
      * Ensures that all writes with fwrite() are completed
      * before other processes are allowed to write to that output stream
      */
     stream_set_write_buffer($this->sock, 0);
     /**
      * Set small chunk size (default=4096/8192)
      * Setting this to small values (100bytes) still does NOT help detecting feof()
      */
     stream_set_chunk_size($this->sock, 1024);
 }