Próbuję stworzyć funkcję, która odbiera ścieżkę do pliku, identyfikuje, co to jest, ustawia odpowiednie nagłówki i obsługuje ją tak, jak zrobiłby to Apache.

Powodem, dla którego to robię, jest to, że muszę użyć PHP do przetworzenia niektórych informacji o żądaniu przed udostępnieniem pliku.

Szybkość jest krytyczna

virtual () nie wchodzi w grę

Musi pracować we współdzielonym środowisku hostingowym, w którym użytkownik nie ma kontroli nad serwerem internetowym (Apache / nginx itp.)

Oto, co mam do tej pory:

File::output($path);

<?php
class File {
static function output($path) {
    // Check if the file exists
    if(!File::exists($path)) {
        header('HTTP/1.0 404 Not Found');
        exit();
    }

    // Set the content-type header
    header('Content-Type: '.File::mimeType($path));

    // Handle caching
    $fileModificationTime = gmdate('D, d M Y H:i:s', File::modificationTime($path)).' GMT';
    $headers = getallheaders();
    if(isset($headers['If-Modified-Since']) && $headers['If-Modified-Since'] == $fileModificationTime) {
        header('HTTP/1.1 304 Not Modified');
        exit();
    }
    header('Last-Modified: '.$fileModificationTime);

    // Read the file
    readfile($path);

    exit();
}

static function mimeType($path) {
    preg_match("|\.([a-z0-9]{2,4})$|i", $path, $fileSuffix);

    switch(strtolower($fileSuffix[1])) {
        case 'js' :
            return 'application/x-javascript';
        case 'json' :
            return 'application/json';
        case 'jpg' :
        case 'jpeg' :
        case 'jpe' :
            return 'image/jpg';
        case 'png' :
        case 'gif' :
        case 'bmp' :
        case 'tiff' :
            return 'image/'.strtolower($fileSuffix[1]);
        case 'css' :
            return 'text/css';
        case 'xml' :
            return 'application/xml';
        case 'doc' :
        case 'docx' :
            return 'application/msword';
        case 'xls' :
        case 'xlt' :
        case 'xlm' :
        case 'xld' :
        case 'xla' :
        case 'xlc' :
        case 'xlw' :
        case 'xll' :
            return 'application/vnd.ms-excel';
        case 'ppt' :
        case 'pps' :
            return 'application/vnd.ms-powerpoint';
        case 'rtf' :
            return 'application/rtf';
        case 'pdf' :
            return 'application/pdf';
        case 'html' :
        case 'htm' :
        case 'php' :
            return 'text/html';
        case 'txt' :
            return 'text/plain';
        case 'mpeg' :
        case 'mpg' :
        case 'mpe' :
            return 'video/mpeg';
        case 'mp3' :
            return 'audio/mpeg3';
        case 'wav' :
            return 'audio/wav';
        case 'aiff' :
        case 'aif' :
            return 'audio/aiff';
        case 'avi' :
            return 'video/msvideo';
        case 'wmv' :
            return 'video/x-ms-wmv';
        case 'mov' :
            return 'video/quicktime';
        case 'zip' :
            return 'application/zip';
        case 'tar' :
            return 'application/x-tar';
        case 'swf' :
            return 'application/x-shockwave-flash';
        default :
            if(function_exists('mime_content_type')) {
                $fileSuffix = mime_content_type($path);
            }
            return 'unknown/' . trim($fileSuffix[0], '.');
    }
}
}
?>

Moja poprzednia odpowiedź była częściowa i niezbyt dobrze udokumentowana, oto aktualizacja z podsumowaniem rozwiązań z niej i od innych w dyskusji.

Rozwiązania są uporządkowane od najlepszego do najgorszego, ale także od rozwiązania wymagającego największej kontroli nad serwerem WWW do tego, które potrzebuje mniej. Wydaje się, że nie ma łatwego sposobu na znalezienie jednego rozwiązania, które jest zarówno szybkie, jak i działa wszędzie.

Korzystanie z nagłówka X-SendFile

Jak udokumentowali inni, to właściwie najlepszy sposób. Podstawą jest to, że wykonujesz kontrolę dostępu w php, a następnie zamiast samodzielnie wysyłać plik, każesz to zrobić serwerowi WWW.

Podstawowy kod php to:

header("X-Sendfile: $file_name");
header("Content-type: application/octet-stream");
header('Content-Disposition: attachment; filename="' . basename($file_name) . '"');

Gdzie $file_namejest pełna ścieżka w systemie plików.

Głównym problemem związanym z tym rozwiązaniem jest to, że musi być dozwolone przez serwer sieciowy i albo nie jest instalowane domyślnie (apache), nie jest domyślnie aktywne (lighttpd) lub wymaga określonej konfiguracji (nginx).

Apache

Pod Apache, jeśli używasz mod_php, musisz zainstalować moduł o nazwie mod_xsendfile, a następnie skonfigurować go (w konfiguracji apache lub .htaccess, jeśli na to pozwolisz)

XSendFile on
XSendFilePath /home/www/example.com/htdocs/files/

W tym module ścieżka pliku może być bezwzględna lub względna w stosunku do określonego XSendFilePath.

Lighttpd

Mod_fastcgi obsługuje to, gdy jest skonfigurowany z

"allow-x-send-file" => "enable" 

Dokumentacja funkcji znajduje się na lighttpd wiki, gdzie dokumentuje X-LIGHTTPD-send-filenagłówek, ale X-Sendfilenazwa również działa

Nginx

Na Nginx nie możesz użyć X-Sendfilenagłówka, musisz użyć własnego nagłówka o nazwie X-Accel-Redirect. Jest domyślnie włączony, a jedyną prawdziwą różnicą jest to, że jego argumentem powinien być identyfikator URI, a nie system plików. Konsekwencją jest to, że musisz zdefiniować lokalizację oznaczoną jako wewnętrzną w twojej konfiguracji, aby uniknąć znalezienia przez klientów prawdziwego adresu URL pliku i bezpośredniego przejścia do niego, ich wiki zawiera dobre wyjaśnienie tego.

Nagłówek łącza symboliczne i lokalizacja

Możesz użyć linków symbolicznych i przekierować do nich, po prostu utwórz dowiązania symboliczne do swojego pliku z losowymi nazwami, gdy użytkownik jest upoważniony do dostępu do pliku i przekieruj użytkownika do niego za pomocą:

header("Location: " . $url_of_symlink);

Oczywiście będziesz potrzebować sposobu, aby je przyciąć, gdy zostanie wywołany skrypt do ich utworzenia lub przez cron (na komputerze, jeśli masz dostęp lub za pośrednictwem usługi webcron w przeciwnym razie)

W Apache musisz mieć możliwość włączenia FollowSymLinksw .htaccesskonfiguracji Apache lub w konfiguracji Apache.

Kontrola dostępu według adresu IP i nagłówka lokalizacji

Innym hackem jest generowanie plików dostępu Apache z php, umożliwiając jawne IP użytkownika. W apache oznacza to użycie poleceń mod_authz_host( mod_access) Allow from.

Problem polega na tym, że blokowanie dostępu do pliku (ponieważ wielu użytkowników może chcieć to zrobić w tym samym czasie) jest nietrywialne i może prowadzić do długiego oczekiwania niektórych użytkowników. I tak nadal musisz przyciąć plik.

Oczywiście innym problemem byłoby to, że wiele osób korzystających z tego samego adresu IP mogłoby potencjalnie uzyskać dostęp do pliku.

Kiedy wszystko inne zawodzi

Jeśli naprawdę nie masz możliwości, aby Twój serwer WWW Ci pomógł, jedynym rozwiązaniem pozostaje readfile, który jest dostępny we wszystkich aktualnie używanych wersjach php i działa całkiem dobrze (ale nie jest zbyt wydajny).

Łączenie rozwiązań

W porządku, najlepszym sposobem na naprawdę szybkie wysłanie pliku, jeśli chcesz, aby kod php był użyteczny wszędzie, jest gdzieś konfigurowalna opcja, z instrukcjami, jak ją aktywować w zależności od serwera internetowego i być może automatycznego wykrywania podczas instalacji scenariusz.

Jest to bardzo podobne do tego, co robi się w wielu programach

• Czyste adresy URL ( mod_rewritena Apache)
• Funkcje kryptograficzne ( mcryptmoduł PHP)
• Obsługa ciągów wielobajtowych ( mbstringmoduł PHP)

Najszybszy sposób: nie rób tego. Zajrzyj do nagłówka x-sendfile dla nginx , są też podobne rzeczy dla innych serwerów WWW. Oznacza to, że nadal możesz kontrolować dostęp itp. W php, ale delegować faktyczne wysyłanie pliku na serwer sieciowy przeznaczony do tego celu.

PS: Przeraża mnie myślenie o tym, o ile wydajniejsze jest używanie tego z nginx w porównaniu do czytania i wysyłania pliku w php. Pomyśl tylko, jeśli 100 osób pobiera plik: z php + apache, będąc hojnym, to prawdopodobnie 100 * 15 MB = 1,5 GB (w przybliżeniu, zastrzel mnie) pamięci RAM. Nginx po prostu przekaże plik do jądra, a następnie zostanie załadowany bezpośrednio z dysku do buforów sieciowych. Szybki!

PPS: Dzięki tej metodzie nadal możesz wykonywać całą kontrolę dostępu, operacje związane z bazą danych.

Oto czyste rozwiązanie PHP. Zaadaptowałem następującą funkcję z moich osobistych ram :

function Download($path, $speed = null, $multipart = true)
{
    while (ob_get_level() > 0)
    {
        ob_end_clean();
    }

    if (is_file($path = realpath($path)) === true)
    {
        $file = @fopen($path, 'rb');
        $size = sprintf('%u', filesize($path));
        $speed = (empty($speed) === true) ? 1024 : floatval($speed);

        if (is_resource($file) === true)
        {
            set_time_limit(0);

            if (strlen(session_id()) > 0)
            {
                session_write_close();
            }

            if ($multipart === true)
            {
                $range = array(0, $size - 1);

                if (array_key_exists('HTTP_RANGE', $_SERVER) === true)
                {
                    $range = array_map('intval', explode('-', preg_replace('~.*=([^,]*).*~', '$1', $_SERVER['HTTP_RANGE'])));

                    if (empty($range[1]) === true)
                    {
                        $range[1] = $size - 1;
                    }

                    foreach ($range as $key => $value)
                    {
                        $range[$key] = max(0, min($value, $size - 1));
                    }

                    if (($range[0] > 0) || ($range[1] < ($size - 1)))
                    {
                        header(sprintf('%s %03u %s', 'HTTP/1.1', 206, 'Partial Content'), true, 206);
                    }
                }

                header('Accept-Ranges: bytes');
                header('Content-Range: bytes ' . sprintf('%u-%u/%u', $range[0], $range[1], $size));
            }

            else
            {
                $range = array(0, $size - 1);
            }

            header('Pragma: public');
            header('Cache-Control: public, no-cache');
            header('Content-Type: application/octet-stream');
            header('Content-Length: ' . sprintf('%u', $range[1] - $range[0] + 1));
            header('Content-Disposition: attachment; filename="' . basename($path) . '"');
            header('Content-Transfer-Encoding: binary');

            if ($range[0] > 0)
            {
                fseek($file, $range[0]);
            }

            while ((feof($file) !== true) && (connection_status() === CONNECTION_NORMAL))
            {
                echo fread($file, round($speed * 1024)); flush(); sleep(1);
            }

            fclose($file);
        }

        exit();
    }

    else
    {
        header(sprintf('%s %03u %s', 'HTTP/1.1', 404, 'Not Found'), true, 404);
    }

    return false;
}

Kod jest tak wydajny, jak to tylko możliwe, zamyka procedurę obsługi sesji, aby inne skrypty PHP mogły działać jednocześnie dla tego samego użytkownika / sesji. Obsługuje również serwowanie pobrań w zakresach (co podejrzewam, że domyślnie robi to Apache), dzięki czemu ludzie mogą wstrzymywać / wznawiać pobieranie, a także korzystać z wyższych prędkości pobierania dzięki akceleratorom pobierania. Pozwala również określić maksymalną prędkość (w Kb / s), z jaką pobieranie (część) powinno być obsługiwane za pośrednictwem $speedargumentu.

header('Location: ' . $path);
exit(0);

Pozwól Apache wykonać pracę za Ciebie.

Lepsza implementacja z obsługą pamięci podręcznej i dostosowanymi nagłówkami HTTP.

serveStaticFile($fn, array(
        'headers'=>array(
            'Content-Type' => 'image/x-icon',
            'Cache-Control' =>  'public, max-age=604800',
            'Expires' => gmdate("D, d M Y H:i:s", time() + 30 * 86400) . " GMT",
        )
    ));

function serveStaticFile($path, $options = array()) {
    $path = realpath($path);
    if (is_file($path)) {
        if(session_id())
            session_write_close();

        header_remove();
        set_time_limit(0);
        $size = filesize($path);
        $lastModifiedTime = filemtime($path);
        $fp = @fopen($path, 'rb');
        $range = array(0, $size - 1);

        header('Last-Modified: ' . gmdate("D, d M Y H:i:s", $lastModifiedTime)." GMT");
        if (( ! empty($_SERVER['HTTP_IF_MODIFIED_SINCE']) && strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']) == $lastModifiedTime ) ) {
            header("HTTP/1.1 304 Not Modified", true, 304);
            return true;
        }

        if (isset($_SERVER['HTTP_RANGE'])) {
            //$valid = preg_match('^bytes=\d*-\d*(,\d*-\d*)*$', $_SERVER['HTTP_RANGE']);
            if(substr($_SERVER['HTTP_RANGE'], 0, 6) != 'bytes=') {
                header('HTTP/1.1 416 Requested Range Not Satisfiable', true, 416);
                header('Content-Range: bytes */' . $size); // Required in 416.
                return false;
            }

            $ranges = explode(',', substr($_SERVER['HTTP_RANGE'], 6));
            $range = explode('-', $ranges[0]); // to do: only support the first range now.

            if ($range[0] === '') $range[0] = 0;
            if ($range[1] === '') $range[1] = $size - 1;

            if (($range[0] >= 0) && ($range[1] <= $size - 1) && ($range[0] <= $range[1])) {
                header('HTTP/1.1 206 Partial Content', true, 206);
                header('Content-Range: bytes ' . sprintf('%u-%u/%u', $range[0], $range[1], $size));
            }
            else {
                header('HTTP/1.1 416 Requested Range Not Satisfiable', true, 416);
                header('Content-Range: bytes */' . $size);
                return false;
            }
        }

        $contentLength = $range[1] - $range[0] + 1;

        //header('Content-Disposition: attachment; filename="xxxxx"');
        $headers = array(
            'Accept-Ranges' => 'bytes',
            'Content-Length' => $contentLength,
            'Content-Type' => 'application/octet-stream',
        );

        if(!empty($options['headers'])) {
            $headers = array_merge($headers, $options['headers']);
        }
        foreach($headers as $k=>$v) {
            header("$k: $v", true);
        }

        if ($range[0] > 0) {
            fseek($fp, $range[0]);
        }
        $sentSize = 0;
        while (!feof($fp) && (connection_status() === CONNECTION_NORMAL)) {
            $readingSize = $contentLength - $sentSize;
            $readingSize = min($readingSize, 512 * 1024);
            if($readingSize <= 0) break;

            $data = fread($fp, $readingSize);
            if(!$data) break;
            $sentSize += strlen($data);
            echo $data;
            flush();
        }

        fclose($fp);
        return true;
    }
    else {
        header('HTTP/1.1 404 Not Found', true, 404);
        return false;
    }
}

jeśli masz możliwość dodania rozszerzeń PECL do swojego php, możesz po prostu użyć funkcji z pakietu Fileinfo, aby określić typ zawartości, a następnie wysłać odpowiednie nagłówki ...

DownloadWspomniana tutaj funkcja PHP powodowała pewne opóźnienie przed faktycznym rozpoczęciem pobierania pliku. Nie wiem, czy było to spowodowane użyciem cache lakieru czy co, ale u mnie pomogło to sleep(1);całkowicie usunąć i ustawić $speedna 1024. Teraz działa bez problemu i jest szybki jak diabli. Może mógłbyś zmodyfikować tę funkcję, ponieważ widziałem ją w całym internecie.

Zakodowałem bardzo prostą funkcję do obsługi plików z PHP i automatycznym wykrywaniem typu MIME:

function serve_file($filepath, $new_filename=null) {
    $filename = basename($filepath);
    if (!$new_filename) {
        $new_filename = $filename;
    }
    $mime_type = mime_content_type($filepath);
    header('Content-type: '.$mime_type);
    header('Content-Disposition: attachment; filename="downloaded.pdf"');
    readfile($filepath);
}

Stosowanie

serve_file("/no_apache/invoice243.pdf");