The PHP Function Fread

The php function fread is used to read the content of an open file. It works with another function called fopen() which is used to open the file to be read. It is also possible to read the contents of a file without opening it via a different function called file_get_contents().

Basically, fread takes two parameters: the file handle to read from (which is the return value of fopen()) and the number of bytes to read. When it reads data from the file, PHP advances the array cursor by one byte for every byte that is read in. It stops reading when either the end of the file is reached or the number of bytes specified in parameter two is exceeded - whichever occurs first.

PHP will return the fread() result as a string, so it is easy to use in your scripts. It is a very fast way to get a lot of text into memory at once. This can be helpful if you need to send some data to the browser for download.

Be careful to limit the number of bytes that are fetched at any time. fread is "greedy" and will try to read as much data at once as it can. This can cause problems when working over a latent network. It is generally best to transfer blocks of data that are as small as possible at a time and use ob_flush() after each block to clear the Apache server's memory.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

fread example


        $downstream = fopen('php://output', 'wb');
        if (!\is_resource($downstream)) {
            throw new RuntimeException('Could not create temp stream');
        }

        if (!$this->unitTestMode) {
            ob_end_clean();
        }

        while (!feof($upstream)) {
            $read = fread($upstream, 4096);
            if (!\is_string($read)) {
                continue;
            }
            fwrite($downstream, $read);
            flush();
        }
    }

    private function canServedLocal(FilesystemInterface $filesystem, int $downloadStrategy): bool
    {
        return $filesystem instanceof Filesystem && $filesystem->getAdapter() instanceof Local && \in_array($downloadStrategy, [0, 2, 3], true);
    }
namespace Symfony\Component\Mime\Encoder;

/** * @author Fabien Potencier <fabien@symfony.com> */
final class EightBitContentEncoder implements ContentEncoderInterface
{
    public function encodeByteStream($stream, int $maxLineLength = 0): iterable
    {
        while (!feof($stream)) {
            yield fread($stream, 16372);
        }
    }

    public function getName(): string
    {
        return '8bit';
    }

    public function encodeString(string $string, ?string $charset = 'utf-8', int $firstLineOffset = 0, int $maxLineLength = 0): string
    {
        return $string;
    }
$thisfile_video            = &$info['video'];
        $thisfile_audio_dataformat = &$thisfile_audio['dataformat'];
        $thisfile_riff_audio       = &$thisfile_riff['audio'];
        $thisfile_riff_video       = &$thisfile_riff['video'];
        $thisfile_riff_WAVE        = array();

        $Original                 = array();
        $Original['avdataoffset'] = $info['avdataoffset'];
        $Original['avdataend']    = $info['avdataend'];

        $this->fseek($info['avdataoffset']);
        $RIFFheader = $this->fread(12);
        $offset = $this->ftell();
        $RIFFtype    = substr($RIFFheader, 0, 4);
        $RIFFsize    = substr($RIFFheader, 4, 4);
        $RIFFsubtype = substr($RIFFheader, 8, 4);

        switch ($RIFFtype) {

            case 'FORM':  // AIFF, AIFC                 //$info['fileformat'] = 'aiff';                 $this->container = 'aiff';
                $thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
                
 catch (ExceptionInterface $e) {
                    trigger_error($e->getMessage(), \E_USER_WARNING);

                    return false;
                }
            }

            if (0 !== fseek($this->content, $this->offset ?? 0)) {
                return false;
            }

            if ('' !== $data = fread($this->content, $count)) {
                fseek($this->content, 0, \SEEK_END);
                $this->offset += \strlen($data);

                return $data;
            }
        }

        if (\is_string($this->content)) {
            if (\strlen($this->content) <= $count) {
                $data = $this->content;
                $this->content = null;
            }
if (0 < $contentLength) {
                $normalizedHeaders['content-length'] = ['Content-Length: '.($contentLength += \strlen($body[$i][1]))];
            }

            $body = static function D$size) use ($body) {
                foreach ($body as $i => [$k, $part, $h]) {
                    unset($body[$i]);

                    yield $part;

                    while (null !== $h && !feof($h)) {
                        if (false === $part = fread($h, $size)) {
                            throw new TransportException(sprintf('Error while reading uploaded stream for body part "%s".', $k));
                        }

                        yield $part;
                    }
                }
                $h = null;
            };
        }

        if (\is_string($body)) {
            
while (true) {
            $chunkSize = min($position, 1024);
            $position -= $chunkSize;
            fseek($file, $position);

            if (0 === $chunkSize) {
                // bof reached                 break;
            }

            $buffer = fread($file, $chunkSize);

            if (false === ($upTo = strrpos($buffer, "\n"))) {
                $line = $buffer.$line;
                continue;
            }

            $position += $upTo;
            $line = substr($buffer, $upTo + 1).$line;
            fseek($file, max(0, $position), \SEEK_SET);

            if ('' !== $line) {
                

    protected function loadResource(string $resource): array
    {
        $stream = fopen($resource, 'r');

        $stat = fstat($stream);

        if ($stat['size'] < self::MO_HEADER_SIZE) {
            throw new InvalidResourceException('MO stream content has an invalid format.');
        }
        $magic = unpack('V1', fread($stream, 4));
        $magic = hexdec(substr(dechex(current($magic)), -8));

        if (self::MO_LITTLE_ENDIAN_MAGIC == $magic) {
            $isBigEndian = false;
        } elseif (self::MO_BIG_ENDIAN_MAGIC == $magic) {
            $isBigEndian = true;
        } else {
            throw new InvalidResourceException('MO stream content has an invalid format.');
        }

        // formatRevision
do {
                        $current_pos = ftell($this->socket);
                        if ($current_pos >= $read_to) break;

                        if($this->out_stream) {
                            if(stream_copy_to_stream($this->socket, $this->out_stream, $read_to - $current_pos) == 0) {
                              $this->_checkSocketReadTimeout();
                              break;
                             }
                        } else {
                            $line = @fread($this->socket, $read_to - $current_pos);
                            if ($line === false || strlen($line) === 0) {
                                $this->_checkSocketReadTimeout();
                                break;
                            }
                                    $chunk .= $line;
                        }
                    } while (! feof($this->socket));

                    $chunk .= @fgets($this->socket);
                    $this->_checkSocketReadTimeout();

                    
public $max_frames = 100000;

    /** * @return bool */
    public function Analyze() {
        $info = &$this->getid3->info;

        $this->fseek($info['avdataoffset']);

        $FLVdataLength = $info['avdataend'] - $info['avdataoffset'];
        $FLVheader = $this->fread(5);

        $info['fileformat'] = 'flv';
        $info['flv']['header']['signature'] =                           substr($FLVheader, 0, 3);
        $info['flv']['header']['version']   = getid3_lib::BigEndian2Int(substr($FLVheader, 3, 1));
        $TypeFlags                          = getid3_lib::BigEndian2Int(substr($FLVheader, 4, 1));

        if ($info['flv']['header']['signature'] != self::magic) {
            $this->error('Expecting "'.getid3_lib::PrintHexBytes(self::magic).'" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($info['flv']['header']['signature']).'"');
            unset($info['flv'], $info['fileformat']);
            return false;
        }

        
$error = error_get_last();
                throw new Exception($error['message'], 'fopen');
            }
        }

        while (!feof($socket)) {
            $this->info = stream_get_meta_data($socket);
            if ($this->info['timed_out']) {
                throw new Exception('fsocket timed out', 'timeout');
            }

            $block = fread($socket, Requests::BUFFER_SIZE);
            if (!$doingbody) {
                $response .= $block;
                if (strpos($response, "\r\n\r\n")) {
                    list($headers, $block) = explode("\r\n\r\n", $response, 2);
                    $doingbody             = true;
                }
            }

            // Are we in body mode now?             if ($doingbody) {
                $options['hooks']->dispatch('request.progress', [$block, $size, $this->max_bytes]);
                
if (!is_resource($ifp)) {
            throw new SodiumException('Could not open input file for reading');
        }

        /** @var resource $ofp */
        $ofp = fopen($outputFile, 'wb');
        if (!is_resource($ofp)) {
            fclose($ifp);
            throw new SodiumException('Could not open output file for writing');
        }

        $ephemeralPK = fread($ifp, ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES);
        if (!is_string($ephemeralPK)) {
            throw new SodiumException('Could not read input file');
        }
        if (self::strlen($ephemeralPK) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
            fclose($ifp);
            fclose($ofp);
            throw new SodiumException('Could not read public key from sealed file');
        }

        $nonce = ParagonIE_Sodium_Compat::crypto_generichash(
            $ephemeralPK . $publicKey,
            
$this->fseek($info['avdataoffset']);

        $offset      = 0;
        $atomcounter = 0;
        $atom_data_read_buffer_size = $info['php_memory_limit'] ? round($info['php_memory_limit'] / 4) : $this->getid3->option_fread_buffer_size * 1024; // set read buffer to 25% of PHP memory limit (if one is specified), otherwise use option_fread_buffer_size [default: 32MB]         while ($offset < $info['avdataend']) {
            if (!getid3_lib::intValueSupported($offset)) {
                $this->error('Unable to parse atom at offset '.$offset.' because beyond '.round(PHP_INT_MAX / 1073741824).'GB limit of PHP filesystem functions');
                break;
            }
            $this->fseek($offset);
            $AtomHeader = $this->fread(8);

            // https://github.com/JamesHeinrich/getID3/issues/382             // Atom sizes are stored as 32-bit number in most cases, but sometimes (notably for "mdat")             // a 64-bit value is required, in which case the normal 32-bit size field is set to 0x00000001             // and the 64-bit "real" size value is the next 8 bytes.             $atom_size_extended_bytes = 0;
            $atomsize = getid3_lib::BigEndian2Int(substr($AtomHeader, 0, 4));
            $atomname = substr($AtomHeader, 4, 4);
            if ($atomsize == 1) {
                $atom_size_extended_bytes = 8;
                $atomsize = getid3_lib::BigEndian2Int($this->fread($atom_size_extended_bytes));
            }
if ( ! ftp_fget( $this->link, $temphandle, $file, FTP_BINARY ) ) {
            fclose( $temphandle );
            unlink( $tempfile );
            return false;
        }

        fseek( $temphandle, 0 ); // Skip back to the start of the file being written to.         $contents = '';

        while ( ! feof( $temphandle ) ) {
            $contents .= fread( $temphandle, 8 * KB_IN_BYTES );
        }

        fclose( $temphandle );
        unlink( $tempfile );

        return $contents;
    }

    /** * Reads entire file into an array. * * @since 2.5.0 * * @param string $file Path to the file. * @return array|false File contents in an array on success, false on failure. */
$this->info['avdataoffset'] = max($this->info['avdataoffset'], $this->info['id3v2']['tag_offset_end']);
            }
            foreach (array('id3v1'=>'id3v1', 'apetag'=>'ape', 'lyrics3'=>'lyrics3') as $tag_name => $tag_key) {
                if (isset($this->info[$tag_key]['tag_offset_start'])) {
                    $this->info['avdataend'] = min($this->info['avdataend'], $this->info[$tag_key]['tag_offset_start']);
                }
            }

            // ID3v2 detection (NOT parsing), even if ($this->option_tag_id3v2 == false) done to make fileformat easier             if (!$this->option_tag_id3v2) {
                fseek($this->fp, 0);
                $header = fread($this->fp, 10);
                if ((substr($header, 0, 3) == 'ID3') && (strlen($header) == 10)) {
                    $this->info['id3v2']['header']        = true;
                    $this->info['id3v2']['majorversion']  = ord($header[3]);
                    $this->info['id3v2']['minorversion']  = ord($header[4]);
                    $this->info['avdataoffset']          += getid3_lib::BigEndian2Int(substr($header, 6, 4), 1) + 10; // length of ID3v2 tag in 10-byte header doesn't include 10-byte header length                 }
            }

            // read 32 kb file data             fseek($this->fp, $this->info['avdataoffset']);
            $formattest = fread($this->fp, 32774);

            
return '';
            }
        } else {
            rewind($this->fileHandle);
        }

        $data   = '';
        $buffer = 0;
        clearstatcache(); // Address https://github.com/codeigniter4/CodeIgniter4/issues/2056
        for ($read = 0, $length = filesize($this->filePath . $id); $read < $length; $read += strlen($buffer)) {
            if (($buffer = fread($this->fileHandle, $length - $read)) === false) {
                break;
            }

            $data .= $buffer;
        }

        $this->fingerprint = md5($data);

        return $data;
    }

    
Home | Imprint | This part of the site doesn't use cookies.