Resumable downloads when using PHP to send the file?

Question

We are using a PHP scripting for tunnelling file downloads, since we don't want to expose the absolute path of downloadable file:

header("Content-Type: $ctype");
header("Content-Length: " . filesize($file));
header("Content-Disposition: attachment; filename=\"$fileName\"");
readfile($file);

Unfortunately we noticed that downloads passed through this script can't be resumed by the end user.

Is there any way to support resumable downloads with such a PHP-based solution?

Theo · Answer 1 · 2009-07-16T08:05:35.580

111

The first thing you need to do is to send the Accept-Ranges: bytes header in all responses, to tell the client that you support partial content. Then, if request with a Range: bytes=x-y header is received (with x and y being numbers) you parse the range the client is requesting, open the file as usual, seek x bytes ahead and send the next y - x bytes. Also set the response to HTTP/1.0 206 Partial Content.

Without having tested anything, this could work, more or less:

$filesize = filesize($file);

$offset = 0;
$length = $filesize;

if ( isset($_SERVER['HTTP_RANGE']) ) {
    // if the HTTP_RANGE header is set we're dealing with partial content

    $partialContent = true;

    // find the requested range
    // this might be too simplistic, apparently the client can request
    // multiple ranges, which can become pretty complex, so ignore it for now
    preg_match('/bytes=(\d+)-(\d+)?/', $_SERVER['HTTP_RANGE'], $matches);

    $offset = intval($matches[1]);
    $length = intval($matches[2]) - $offset;
} else {
    $partialContent = false;
}

$file = fopen($file, 'r');

// seek to the requested offset, this is 0 if it's not a partial content request
fseek($file, $offset);

$data = fread($file, $length);

fclose($file);

if ( $partialContent ) {
    // output the right headers for partial content

    header('HTTP/1.1 206 Partial Content');

    header('Content-Range: bytes ' . $offset . '-' . ($offset + $length) . '/' . $filesize);
}

// output the regular HTTP headers
header('Content-Type: ' . $ctype);
header('Content-Length: ' . $filesize);
header('Content-Disposition: attachment; filename="' . $fileName . '"');
header('Accept-Ranges: bytes');

// don't forget to send the data too
print($data);

I may have missed something obvious, and I have most definitely ignored some potential sources of errors, but it should be a start.

There's a description of partial content here and I found some info on partial content on the documentation page for fread.

edited Jul 16 '09 at 08:05

answered Oct 01 '08 at 12:56

Theo

131,503
21
160
205

3

Small bug, your regular expression should be: preg_match('/bytes=(\d+)-(\d+)?/', $_SERVER['HTTP_RANGE'], $matches) – deepwell Jul 13 '09 at 22:46
1

You're right and I've changed it. However, I it's too simplistic anyway, according to the specs you can do "bytes=x-y", "bytes=-x", "bytes=x-", "bytes=x-y,a-b", etc. so the bug in the previous version was the missing end slash, not the lack of a question mark. – Theo Jul 16 '09 at 08:09
@Theo: Are you sure `$length` is `intval($matches[2]) - $offset` and not `$length - 1`? – Alix Axel Feb 17 '11 at 02:46
It's been a while since I wrote that code, but it looks right to me, `$matches[1]` is the requested start index and `$matches[2]` is the end, so the the difference should be the length of the requested range. `$length - 1` would be the last index in the file, and that's not necessarily what's being requested. That said, to support ranges you have to do a little more work since multiple ranges can be requested, and whatnot. – Theo Feb 17 '11 at 16:54
8

Very helpful, but I had to make two minor tweaks to make it work: 1. If the client does not send the endpoint in the range (since it's implicit), `$length` will be negative. `$length = (($matches[2]) ? intval($matches[2]) : $filesize) - $offset;` fixes that. 2. `Content-Range` treats the first byte as byte `0`, so the last byte is `$filesize - 1`. Therefore, it has to be `($offset + $length - 1)`. – Dennis Mar 07 '12 at 13:48
@Theo : would you be kind enough to review my answer for this question : http://stackoverflow.com/a/10517451/1093649 thanks – Justin T. May 11 '12 at 08:14
Your code has a fatal flaw: reading the data into a buffer. Why not just use `echo fread(...);` after sending the headers? – Cole Tobin Mar 28 '13 at 17:34
It is not support remote file downloading? :( – Siyamak Shahpasand Mar 30 '13 at 21:09
There is a nice discussion of this at http://www.richnetapps.com/php-download-script-with-resume-option/ – Joe Mabel Jan 14 '14 at 18:12
1

Above doesn't work for big downloads, you get a "PHP Fatal error: Allowed memory size of XXXX bytes exhausted (tried to allocate XXX bytes) in ". In my case 100MB was too big. You basically save all file in a variable and the spit it out. – sarah.ferguson Jan 29 '16 at 16:56
1

You can solve the large file issue by reading it out in chunks instead of all at once. – dynamichael Sep 23 '18 at 06:36
Note that in Apache you also need mod_headers enabled ("a2enmod headers") and "Header set Accept-Ranges" in your conf or .htaccess – below43 Feb 13 '20 at 08:59

DaveRandom · Answer 2 · 2018-01-28T03:15:49.403

EDIT 2017/01 - I wrote a library to do this in PHP >=7.0 https://github.com/DaveRandom/Resume

EDIT 2016/02 - Code completely rewritten to a set of modular tools an an example usage, rather than a monolithic function. Corrections mentioned in comments below have been incorporated.

A tested, working solution (based heavily on Theo's answer above) which deals with resumable downloads, in a set of a few standalone tools. This code requires PHP 5.4 or later.

This solution can still only cope with one range per request, but under any circumstance with a standard browser that I can think of, this should not cause a problem.

<?php

/**
 * Get the value of a header in the current request context
 *
 * @param string $name Name of the header
 * @return string|null Returns null when the header was not sent or cannot be retrieved
 */
function get_request_header($name)
{
    $name = strtoupper($name);

    // IIS/Some Apache versions and configurations
    if (isset($_SERVER['HTTP_' . $name])) {
        return trim($_SERVER['HTTP_' . $name]);
    }

    // Various other SAPIs
    foreach (apache_request_headers() as $header_name => $value) {
        if (strtoupper($header_name) === $name) {
            return trim($value);
        }
    }

    return null;
}

class NonExistentFileException extends \RuntimeException {}
class UnreadableFileException extends \RuntimeException {}
class UnsatisfiableRangeException extends \RuntimeException {}
class InvalidRangeHeaderException extends \RuntimeException {}

class RangeHeader
{
    /**
     * The first byte in the file to send (0-indexed), a null value indicates the last
     * $end bytes
     *
     * @var int|null
     */
    private $firstByte;

    /**
     * The last byte in the file to send (0-indexed), a null value indicates $start to
     * EOF
     *
     * @var int|null
     */
    private $lastByte;

    /**
     * Create a new instance from a Range header string
     *
     * @param string $header
     * @return RangeHeader
     */
    public static function createFromHeaderString($header)
    {
        if ($header === null) {
            return null;
        }

        if (!preg_match('/^\s*(\S+)\s*(\d*)\s*-\s*(\d*)\s*(?:,|$)/', $header, $info)) {
            throw new InvalidRangeHeaderException('Invalid header format');
        } else if (strtolower($info[1]) !== 'bytes') {
            throw new InvalidRangeHeaderException('Unknown range unit: ' . $info[1]);
        }

        return new self(
            $info[2] === '' ? null : $info[2],
            $info[3] === '' ? null : $info[3]
        );
    }

    /**
     * @param int|null $firstByte
     * @param int|null $lastByte
     * @throws InvalidRangeHeaderException
     */
    public function __construct($firstByte, $lastByte)
    {
        $this->firstByte = $firstByte === null ? $firstByte : (int)$firstByte;
        $this->lastByte = $lastByte === null ? $lastByte : (int)$lastByte;

        if ($this->firstByte === null && $this->lastByte === null) {
            throw new InvalidRangeHeaderException(
                'Both start and end position specifiers empty'
            );
        } else if ($this->firstByte < 0 || $this->lastByte < 0) {
            throw new InvalidRangeHeaderException(
                'Position specifiers cannot be negative'
            );
        } else if ($this->lastByte !== null && $this->lastByte < $this->firstByte) {
            throw new InvalidRangeHeaderException(
                'Last byte cannot be less than first byte'
            );
        }
    }

    /**
     * Get the start position when this range is applied to a file of the specified size
     *
     * @param int $fileSize
     * @return int
     * @throws UnsatisfiableRangeException
     */
    public function getStartPosition($fileSize)
    {
        $size = (int)$fileSize;

        if ($this->firstByte === null) {
            return ($size - 1) - $this->lastByte;
        }

        if ($size <= $this->firstByte) {
            throw new UnsatisfiableRangeException(
                'Start position is after the end of the file'
            );
        }

        return $this->firstByte;
    }

    /**
     * Get the end position when this range is applied to a file of the specified size
     *
     * @param int $fileSize
     * @return int
     * @throws UnsatisfiableRangeException
     */
    public function getEndPosition($fileSize)
    {
        $size = (int)$fileSize;

        if ($this->lastByte === null) {
            return $size - 1;
        }

        if ($size <= $this->lastByte) {
            throw new UnsatisfiableRangeException(
                'End position is after the end of the file'
            );
        }

        return $this->lastByte;
    }

    /**
     * Get the length when this range is applied to a file of the specified size
     *
     * @param int $fileSize
     * @return int
     * @throws UnsatisfiableRangeException
     */
    public function getLength($fileSize)
    {
        $size = (int)$fileSize;

        return $this->getEndPosition($size) - $this->getStartPosition($size) + 1;
    }

    /**
     * Get a Content-Range header corresponding to this Range and the specified file
     * size
     *
     * @param int $fileSize
     * @return string
     */
    public function getContentRangeHeader($fileSize)
    {
        return 'bytes ' . $this->getStartPosition($fileSize) . '-'
             . $this->getEndPosition($fileSize) . '/' . $fileSize;
    }
}

class PartialFileServlet
{
    /**
     * The range header on which the data transmission will be based
     *
     * @var RangeHeader|null
     */
    private $range;

    /**
     * @param RangeHeader $range Range header on which the transmission will be based
     */
    public function __construct(RangeHeader $range = null)
    {
        $this->range = $range;
    }

    /**
     * Send part of the data in a seekable stream resource to the output buffer
     *
     * @param resource $fp Stream resource to read data from
     * @param int $start Position in the stream to start reading
     * @param int $length Number of bytes to read
     * @param int $chunkSize Maximum bytes to read from the file in a single operation
     */
    private function sendDataRange($fp, $start, $length, $chunkSize = 8192)
    {
        if ($start > 0) {
            fseek($fp, $start, SEEK_SET);
        }

        while ($length) {
            $read = ($length > $chunkSize) ? $chunkSize : $length;
            $length -= $read;
            echo fread($fp, $read);
        }
    }

    /**
     * Send the headers that are included regardless of whether a range was requested
     *
     * @param string $fileName
     * @param int $contentLength
     * @param string $contentType
     */
    private function sendDownloadHeaders($fileName, $contentLength, $contentType)
    {
        header('Content-Type: ' . $contentType);
        header('Content-Length: ' . $contentLength);
        header('Content-Disposition: attachment; filename="' . $fileName . '"');
        header('Accept-Ranges: bytes');
    }

    /**
     * Send data from a file based on the current Range header
     *
     * @param string $path Local file system path to serve
     * @param string $contentType MIME type of the data stream
     */
    public function sendFile($path, $contentType = 'application/octet-stream')
    {
        // Make sure the file exists and is a file, otherwise we are wasting our time
        $localPath = realpath($path);
        if ($localPath === false || !is_file($localPath)) {
            throw new NonExistentFileException(
                $path . ' does not exist or is not a file'
            );
        }

        // Make sure we can open the file for reading
        if (!$fp = fopen($localPath, 'r')) {
            throw new UnreadableFileException(
                'Failed to open ' . $localPath . ' for reading'
            );
        }

        $fileSize = filesize($localPath);

        if ($this->range == null) {
            // No range requested, just send the whole file
            header('HTTP/1.1 200 OK');
            $this->sendDownloadHeaders(basename($localPath), $fileSize, $contentType);

            fpassthru($fp);
        } else {
            // Send the request range
            header('HTTP/1.1 206 Partial Content');
            header('Content-Range: ' . $this->range->getContentRangeHeader($fileSize));
            $this->sendDownloadHeaders(
                basename($localPath),
                $this->range->getLength($fileSize),
                $contentType
            );

            $this->sendDataRange(
                $fp,
                $this->range->getStartPosition($fileSize),
                $this->range->getLength($fileSize)
            );
        }

        fclose($fp);
    }
}

Example usage:

<?php

$path = '/local/path/to/file.ext';
$contentType = 'application/octet-stream';

// Avoid sending unexpected errors to the client - we should be serving a file,
// we don't want to corrupt the data we send
ini_set('display_errors', '0');

try {
    $rangeHeader = RangeHeader::createFromHeaderString(get_request_header('Range'));
    (new PartialFileServlet($rangeHeader))->sendFile($path, $contentType);
} catch (InvalidRangeHeaderException $e) {
    header("HTTP/1.1 400 Bad Request");
} catch (UnsatisfiableRangeException $e) {
    header("HTTP/1.1 416 Range Not Satisfiable");
} catch (NonExistentFileException $e) {
    header("HTTP/1.1 404 Not Found");
} catch (UnreadableFileException $e) {
    header("HTTP/1.1 500 Internal Server Error");
}

// It's usually a good idea to explicitly exit after sending a file to avoid sending any
// extra data on the end that might corrupt the file
exit;

Pretty nice code here. I did find a bug on the line where $length is set. Should be: $length = $end - $start + 1; — bobwienholt, May 11 '12 at 01:59
Dave - thanks for this! I'm looking at using this for resumable downloads from the vps to client using that code I sent you recently :) — Jimbo, Nov 04 '13 at 21:54
Should Content-Length be set to the actual file size, or just the number of partial bytes being sent? This page makes it look like it should be the partial bytes, but that's not what's done in the example code above. http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html — willus, Dec 21 '13 at 15:18
Another little typo: `$start = $end - intval($range[0]);` should be `range[1]` — BurninLeo, Mar 03 '14 at 14:29
@willus I take your advice into code, becouse streaming mp3 without that don't work for me. — Luke Duda, Jan 09 '15 at 08:41
@Luke Duda what did you put instead of $filesize for mp3 streaming? — sarah.ferguson, Jan 29 '16 at 17:08
@sarah.ferguson Code completely rewritten and updated, see above. — DaveRandom, Feb 01 '16 at 15:15
`fpassthru()` allocates the remainder of the file in PHP memory, so it needs to be sent/flushed in portions for huge files. Otherwise getting `PHP Fatal error: Allowed memory size of nnn bytes exhausted`, at least in PHP 5.4 — MattBianco, Jan 10 '17 at 07:26
replace `fpassthru($fp);` with `$this->sendDataRange($fp, 0, $fileSize);` to make it work with large files. — MattBianco, Jan 10 '17 at 07:33
adding a `set_time_limit(30);` and perhaps an `ob_flush(); flush()` inside the `while` loop of `sendDataRange()` also helps. — MattBianco, Jan 10 '17 at 07:45
@DaveRandom what license is this code under? Thinking of using it but don't want to step on your rights. — madscientist159, Sep 24 '17 at 20:05
@madscientist159 It is MIT licensed. See also: https://github.com/DaveRandom/Resume — DaveRandom, Sep 26 '17 at 17:34
@DaveRandom Just wanted to say thanks for your work on this. — Joel, Sep 15 '20 at 06:46

LifeInstructor · Answer 3 · 2016-01-12T20:56:15.290

This works 100% super check it I am using it and no problems any more.

        /* Function: download with resume/speed/stream options */


         /* List of File Types */
        function fileTypes($extension){
            $fileTypes['swf'] = 'application/x-shockwave-flash';
            $fileTypes['pdf'] = 'application/pdf';
            $fileTypes['exe'] = 'application/octet-stream';
            $fileTypes['zip'] = 'application/zip';
            $fileTypes['doc'] = 'application/msword';
            $fileTypes['xls'] = 'application/vnd.ms-excel';
            $fileTypes['ppt'] = 'application/vnd.ms-powerpoint';
            $fileTypes['gif'] = 'image/gif';
            $fileTypes['png'] = 'image/png';
            $fileTypes['jpeg'] = 'image/jpg';
            $fileTypes['jpg'] = 'image/jpg';
            $fileTypes['rar'] = 'application/rar';

            $fileTypes['ra'] = 'audio/x-pn-realaudio';
            $fileTypes['ram'] = 'audio/x-pn-realaudio';
            $fileTypes['ogg'] = 'audio/x-pn-realaudio';

            $fileTypes['wav'] = 'video/x-msvideo';
            $fileTypes['wmv'] = 'video/x-msvideo';
            $fileTypes['avi'] = 'video/x-msvideo';
            $fileTypes['asf'] = 'video/x-msvideo';
            $fileTypes['divx'] = 'video/x-msvideo';

            $fileTypes['mp3'] = 'audio/mpeg';
            $fileTypes['mp4'] = 'audio/mpeg';
            $fileTypes['mpeg'] = 'video/mpeg';
            $fileTypes['mpg'] = 'video/mpeg';
            $fileTypes['mpe'] = 'video/mpeg';
            $fileTypes['mov'] = 'video/quicktime';
            $fileTypes['swf'] = 'video/quicktime';
            $fileTypes['3gp'] = 'video/quicktime';
            $fileTypes['m4a'] = 'video/quicktime';
            $fileTypes['aac'] = 'video/quicktime';
            $fileTypes['m3u'] = 'video/quicktime';
            return $fileTypes[$extention];
        };

        /*
          Parameters: downloadFile(File Location, File Name,
          max speed, is streaming
          If streaming - videos will show as videos, images as images
          instead of download prompt
         */

        function downloadFile($fileLocation, $fileName, $maxSpeed = 100, $doStream = false) {
            if (connection_status() != 0)
                return(false);
        //    in some old versions this can be pereferable to get extention
        //    $extension = strtolower(end(explode('.', $fileName)));
            $extension = pathinfo($fileName, PATHINFO_EXTENSION);

            $contentType = fileTypes($extension);
            header("Cache-Control: public");
            header("Content-Transfer-Encoding: binary\n");
            header('Content-Type: $contentType');

            $contentDisposition = 'attachment';

            if ($doStream == true) {
                /* extensions to stream */
                $array_listen = array('mp3', 'm3u', 'm4a', 'mid', 'ogg', 'ra', 'ram', 'wm',
                    'wav', 'wma', 'aac', '3gp', 'avi', 'mov', 'mp4', 'mpeg', 'mpg', 'swf', 'wmv', 'divx', 'asf');
                if (in_array($extension, $array_listen)) {
                    $contentDisposition = 'inline';
                }
            }

            if (strstr($_SERVER['HTTP_USER_AGENT'], "MSIE")) {
                $fileName = preg_replace('/\./', '%2e', $fileName, substr_count($fileName, '.') - 1);
                header("Content-Disposition: $contentDisposition;
                    filename=\"$fileName\"");
            } else {
                header("Content-Disposition: $contentDisposition;
                    filename=\"$fileName\"");
            }

            header("Accept-Ranges: bytes");
            $range = 0;
            $size = filesize($fileLocation);

            if (isset($_SERVER['HTTP_RANGE'])) {
                list($a, $range) = explode("=", $_SERVER['HTTP_RANGE']);
                str_replace($range, "-", $range);
                $size2 = $size - 1;
                $new_length = $size - $range;
                header("HTTP/1.1 206 Partial Content");
                header("Content-Length: $new_length");
                header("Content-Range: bytes $range$size2/$size");
            } else {
                $size2 = $size - 1;
                header("Content-Range: bytes 0-$size2/$size");
                header("Content-Length: " . $size);
            }

            if ($size == 0) {
                die('Zero byte file! Aborting download');
            }
            set_magic_quotes_runtime(0);
            $fp = fopen("$fileLocation", "rb");

            fseek($fp, $range);

            while (!feof($fp) and ( connection_status() == 0)) {
                set_time_limit(0);
                print(fread($fp, 1024 * $maxSpeed));
                flush();
                ob_flush();
                sleep(1);
            }
            fclose($fp);

            return((connection_status() == 0) and ! connection_aborted());
        }

        /* Implementation */
        // downloadFile('path_to_file/1.mp3', '1.mp3', 1024, false);

I upvoted because the speed limit is really useful, however an MD5 check on a resumed file ( Firefox ) showed a mismatch. The str_replace for $range is wrong, should be another explode, the result made numeric, and a dash added to the Content-Range header. — WhoIsRich, Mar 14 '13 at 21:52
set_time_limit(0); is not really appropriate in my opinion. A more reasonable limit of 24 hours maybe? — twicejr, Apr 20 '15 at 11:05
This works 0% :( It can't send a simple `MP4` to the client, but it sends an `MP3` but unfortunately the Chrome, can't seek in this `MP3`. — HF_, Jan 30 '19 at 19:23
You have to add video also for this parameter $fileTypes['mp4'] = 'audio/mpeg'; — LifeInstructor, Feb 01 '19 at 09:21
Content-type can be easily set by using the **mime_content_type()** function, rather than keeping an endless list of content type strings. — andreszs, Jan 06 '21 at 14:36

Sietse · Answer 4 · 2008-10-01T12:42:39.263

16

Yes. Support byteranges. See RFC 2616 section 14.35 .

It basically means that you should read the Range header, and start serving the file from the specified offset.

This means that you can't use readfile(), since that serves the whole file. Instead, use fopen() first, then fseek() to the correct position, and then use fpassthru() to serve the file.

edited Oct 01 '08 at 12:42

answered Oct 01 '08 at 12:34

Sietse

7,884
12
51
65

4

fpassthru is not a good idea if the file is multiple megabytes, you might run out of memory. Just fread() and print() in chunks. – Willem Oct 12 '08 at 22:58
3

fpassthru works great here with hundreds of megabytes. ``echo file_get_contents(...)`` did not work (OOM). So I don't think that is an issue. PHP 5.3. – Janus Troelsen Sep 16 '11 at 12:52
1

@JanusTroelsen No, its not. It all depends on your server's configuration. If you have a strong server, with a lot of memory allocated to PHP, then maybe it works fine for you. On "weak" configurations (literally: shared hostings) using `fpassthru` will fail on even 50 MB files. You should definitely not use it, if you're serving large files on weak server configuration. As @Wimmer correctly points out, `fread` + `print` is all, that you need in this case. – trejder Feb 25 '14 at 08:04
2

@trejder: See the note [on readfile()](http://nl3.php.net/manual/en/function.readfile.php): *readfile() will not present any memory issues, even when sending large files, on its own. If you encounter an out of memory error ensure that output buffering is off with ob_get_level().* – Janus Troelsen Feb 25 '14 at 09:05
@JanusTroelsen Well, I have output buffering turned on, because I have to (my framework uses it). `readfile()` died on sending 200 MB files, even though max memory in `php.ini` was set to 1 GB, that is five times that. When I implemented simple solution with file chunking (using `fopen` and `fread`, but not `fpassthru`), all problems were gone and I managed to send file even up to 2 GB large, without any issues, even though `php.ini` configuration hasn't changed. So my previous comment is a little bit incorrect, as I hasn't tested this issue with output buffering turned off, as you suggest. – trejder Feb 25 '14 at 13:18
1

@trejder the problem is you didn't configure your output buffering right. It does the chunking automatically, if you tell it to: http://php.net/manual/en/outcontrol.configuration.php#ini.output-buffering e.g. output_buffering=4096 (and if your framework doesn't allow this, you framework sucks) – ZJR Oct 14 '15 at 17:00

score 12 · Answer 5 · answered Aug 22 '09 at 18:17

12

A really nice way to solve this without having to "roll your own" PHP code is to use the mod_xsendfile Apache module. Then in PHP, you just set the appropriate headers. Apache gets to do its thing.

header("X-Sendfile: /path/to/file");
header("Content-Type: application/octet-stream");
header("Content-Disposition: attachment; file=\"filename\"");

answered Aug 22 '09 at 18:17

Jonathan Hawkes

953
2
12
24

3

What if you want to unlink the file after sending? – Janus Troelsen Sep 16 '11 at 12:54
1

If you want to unlink the file after sending you need a special flag to indicate that, see `XSendFilePath [AllowFileDelete]` (https://tn123.org/mod_xsendfile/beta/). – Jens A. Koch Jul 26 '16 at 11:38

score 9 · Answer 6 · edited Mar 19 '15 at 09:50

9

If you're willing to install a new PECL module, the easiest way to support resumeable downloads with PHP is through http_send_file(), like this

<?php
http_send_content_disposition("document.pdf", true);
http_send_content_type("application/pdf");
http_throttle(0.1, 2048);
http_send_file("../report.pdf");
?>

source : http://www.php.net/manual/en/function.http-send-file.php

We use it to serve database-stored content and it works like a charm !

edited Mar 19 '15 at 09:50

Mikko Rantalainen

14,132
10
74
112

answered May 09 '12 at 13:47

Justin T.

3,643
1
22
43

3

Works like a charm. However take care you do not have output buffering (ob_start etc) turned on. Especially when sending large files, this will buffer the complete requested range. – Pieter van Ginkel Jan 07 '13 at 13:01
When was this added to PHP? Always been there? – thomthom Jan 08 '13 at 14:47
2

That's Pecl, not PHP. I don't have this function. – Geo Aug 15 '13 at 16:15
This function is deprecated. Not working anymore. – Benyamin Limanto Sep 25 '21 at 09:41

score 4 · Answer 7 · answered Oct 01 '08 at 12:42

Yes, you can use the Range header for that. You need to give 3 more headers to the client for a full download:

header ("Accept-Ranges: bytes");
header ("Content-Length: " . $fileSize);
header ("Content-Range: bytes 0-" . $fileSize - 1 . "/" . $fileSize . ";");

Than for an interrupted download you need to check the Range request header by:

$headers = getAllHeaders ();
$range = substr ($headers['Range'], '6');

And in this case don't forget to serve the content with 206 status code:

header ("HTTP/1.1 206 Partial content");
header ("Accept-Ranges: bytes");
header ("Content-Length: " . $remaining_length);
header ("Content-Range: bytes " . $start . "-" . $to . "/" . $fileSize . ";");

You'll get the $start and $to variables from the request header, and use fseek() to seek to the correct position in the file.

@ceejayoz: getallheaders() is a php function that you get if you are using apache http://uk2.php.net/getallheaders — Tom Haigh, Oct 25 '08 at 10:25

Mygod · Answer 8 · 2014-07-01T14:19:29.117

The top answer has various bugs.

The major bug: It doesn't handle Range header correctly. bytes a-b should mean [a, b] instead of [a, b), and bytes a- is not handled.
The minor bug: It doesn't use buffer to handle output. This may consume too much memory and cause low speed for large files.

Here's my modified code:

// TODO: configurations here
$fileName = "File Name";
$file = "File Path";
$bufferSize = 2097152;

$filesize = filesize($file);
$offset = 0;
$length = $filesize;
if (isset($_SERVER['HTTP_RANGE'])) {
    // if the HTTP_RANGE header is set we're dealing with partial content
    // find the requested range
    // this might be too simplistic, apparently the client can request
    // multiple ranges, which can become pretty complex, so ignore it for now
    preg_match('/bytes=(\d+)-(\d+)?/', $_SERVER['HTTP_RANGE'], $matches);
    $offset = intval($matches[1]);
    $end = $matches[2] || $matches[2] === '0' ? intval($matches[2]) : $filesize - 1;
    $length = $end + 1 - $offset;
    // output the right headers for partial content
    header('HTTP/1.1 206 Partial Content');
    header("Content-Range: bytes $offset-$end/$filesize");
}
// output the regular HTTP headers
header('Content-Type: ' . mime_content_type($file));
header("Content-Length: $filesize");
header("Content-Disposition: attachment; filename=\"$fileName\"");
header('Accept-Ranges: bytes');

$file = fopen($file, 'r');
// seek to the requested offset, this is 0 if it's not a partial content request
fseek($file, $offset);
// don't forget to send the data too
ini_set('memory_limit', '-1');
while ($length >= $bufferSize)
{
    print(fread($file, $bufferSize));
    $length -= $bufferSize;
}
if ($length) print(fread($file, $length));
fclose($file);

@MikkoRantalainen I forgot. You could try removing it and see what happens. — Mygod, Apr 04 '15 at 03:58
Unfortunately you will throw an error in the $end assignment in case $matches[2] is not set (e.g. with a "Range=0-" request). I used this instead: `if(!isset($matches[2])) { $end=$fs-1; } else { $end = intval($matches[2]); }` — Skynet, Dec 08 '16 at 09:56

score 3 · Answer 9 · answered Mar 14 '14 at 06:57

3

This worked very well for me: https://github.com/pomle/php-serveFilePartial

answered Mar 14 '14 at 06:57

user3418767

31
1

score 3 · Answer 10 · answered Mar 14 '15 at 11:27

3

Small composer enabled class which works the same way as pecl http_send_file. This means support for resumable downloads and throttle. https://github.com/diversen/http-send-file

answered Mar 14 '15 at 11:27

dennis

620
8
21

score 2 · Answer 11 · answered Oct 03 '17 at 13:31

You could use the below code for byte range request support across any browser

    <?php
$file = 'YouTube360p.mp4';
$fileLoc = $file;
$filesize = filesize($file);
$offset = 0;
$fileLength = $filesize;
$length = $filesize - 1;

if ( isset($_SERVER['HTTP_RANGE']) ) {
    // if the HTTP_RANGE header is set we're dealing with partial content

    $partialContent = true;
    preg_match('/bytes=(\d+)-(\d+)?/', $_SERVER['HTTP_RANGE'], $matches);

    $offset = intval($matches[1]);
    $tempLength = intval($matches[2]) - 0;
    if($tempLength != 0)
    {
        $length = $tempLength;
    }
    $fileLength = ($length - $offset) + 1;
} else {
    $partialContent = false;
    $offset = $length;
}

$file = fopen($file, 'r');

// seek to the requested offset, this is 0 if it's not a partial content request
fseek($file, $offset);

$data = fread($file, $length);

fclose($file);

if ( $partialContent ) {
    // output the right headers for partial content
    header('HTTP/1.1 206 Partial Content');
}

// output the regular HTTP headers
header('Content-Type: ' . mime_content_type($fileLoc));
header('Content-Length: ' . $fileLength);
header('Content-Disposition: inline; filename="' . $file . '"');
header('Accept-Ranges: bytes');
header('Content-Range: bytes ' . $offset . '-' . $length . '/' . $filesize);

// don't forget to send the data too
print($data);
?>

score 1 · Answer 12 · answered Oct 01 '08 at 12:35

Resuming downloads in HTTP is done through the Range header. If the request contains a Range header, and if other indicators (e.g. If-Match, If-Unmodified-Since) indicate that the content hasn't changed since the download was started, you give a 206 response code (rather than 200), indicate the range of bytes you're returning in the Content-Range header, then provide that range in the response body.

I don't know how to do that in PHP, though.

score 1 · Answer 13 · answered Mar 14 '11 at 17:30

Thanks Theo! your method did not directly work for streaming divx because i found the divx player was sending ranges like bytes=9932800-

but it showed me how to do it so thanks :D

if(isset($_SERVER['HTTP_RANGE']))
{
    file_put_contents('showrange.txt',$_SERVER['HTTP_RANGE']);

score 0 · Answer 14 · answered Sep 10 '21 at 12:33

I've created a library for serving files with support for conditional (don't download file again unless it has changed) and ranged (pause and resume download) requests. It even works with virtual file systems, such as Flysystem.

Check it out here: FileWaiter

Example usage:

use Stadly\FileWaiter\Adapter\Local;
use Stadly\FileWaiter\File;
use Stadly\FileWaiter\Waiter;

$streamFactory = new \GuzzleHttp\Psr7\HttpFactory();                // Any PSR-17 compatible stream factory.
$file = new File(new Local('filename.txt', $streamFactory));        // Or another file adapter. See below.
$responseFactory = new \GuzzleHttp\Psr7\HttpFactory();              // Any PSR-17 compatible response factory.

$waiter = new Waiter($file, $responseFactory);

$request = \GuzzleHttp\Psr7\ServerRequest::fromGlobals();           // Any PSR-7 compatible server request.

$response = $waiter->handle($request);                              // The response is created by the response factory.

$emitter = new \Laminas\HttpHandlerRunner\Emitter\SapiEmitter();    // Any way of emitting PSR-7 responses.
$emitter->emit($response);
die();

Resumable downloads when using PHP to send the file?

14 Answers14

Linked

Related