Estou tentando montar uma função que recebe um caminho de arquivo, identifica o que é, define os cabeçalhos apropriados e serve-o como faria o Apache.

Estou fazendo isso porque preciso usar o PHP para processar algumas informações sobre a solicitação antes de servir o arquivo.

Velocidade é crítica

virtual () não é uma opção

Deve trabalhar em um ambiente de hospedagem compartilhada onde o usuário não tem controle do servidor web (Apache / nginx, etc)

Aqui está o que tenho até agora:

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], '.');
    }
}
}
?>

Minha resposta anterior foi parcial e não bem documentada, aqui está uma atualização com um resumo das soluções dela e de outros na discussão.

As soluções são ordenadas da melhor solução para a pior, mas também da solução que precisa de mais controle sobre o servidor web para a que precisa de menos. Não parece haver uma maneira fácil de ter uma solução que seja rápida e funcione em qualquer lugar.

Usando o cabeçalho X-SendFile

Conforme documentado por outros, é realmente a melhor maneira. A base é que você faz o controle de acesso em php e, em vez de enviar o arquivo você mesmo, diz ao servidor da web para fazê-lo.

O código php básico é:

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

Onde $file_nameestá o caminho completo no sistema de arquivos.

O principal problema desta solução é que ela precisa ser permitida pelo servidor web e não está instalada por padrão (apache), não está ativa por padrão (lighttpd) ou precisa de uma configuração específica (nginx).

Apache

No apache, se você usar mod_php, você precisa instalar um módulo chamado mod_xsendfile e então configurá-lo (na configuração do apache ou .htaccess se você permitir)

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

Com este módulo, o caminho do arquivo pode ser absoluto ou relativo ao especificado XSendFilePath.

Lighttpd

O mod_fastcgi suporta isso quando configurado com

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

A documentação para o recurso está no wiki lighttpd eles documentam o X-LIGHTTPD-send-filecabeçalho, mas o X-Sendfilenome também funciona

Nginx

No Nginx você não pode usar o X-Sendfilecabeçalho, você deve usar o seu próprio cabeçalho nomeado X-Accel-Redirect. Ele é habilitado por padrão e a única diferença real é que seu argumento deve ser um URI, não um sistema de arquivos. A conseqüência é que você deve definir um local marcado como interno em sua configuração para evitar que os clientes encontrem a url do arquivo real e acessem diretamente a ela, o wiki contém uma boa explicação disso.

Links simbólicos e cabeçalho de localização

Você pode usar links simbólicos e redirecionar para eles, basta criar links simbólicos para seu arquivo com nomes aleatórios quando um usuário estiver autorizado a acessar um arquivo e redirecionar o usuário para ele usando:

header("Location: " . $url_of_symlink);

Obviamente, você precisará de uma maneira de podá-los quando o script para criá-los for chamado ou via cron (na máquina se você tiver acesso ou via algum serviço webcron caso contrário)

No apache, você precisa ser capaz de habilitar FollowSymLinksem um .htaccessou na configuração do apache.

Controle de acesso por IP e cabeçalho de localização

Outro hack é gerar arquivos de acesso apache a partir do php, permitindo o IP explícito do usuário. No apache, significa usar comandos mod_authz_host( mod_access) Allow from.

O problema é que bloquear o acesso ao arquivo (já que vários usuários podem querer fazer isso ao mesmo tempo) não é trivial e pode fazer com que alguns usuários esperem muito. E você ainda precisa remover o arquivo de qualquer maneira.

Obviamente, outro problema seria que várias pessoas por trás do mesmo IP poderiam acessar o arquivo.

Quando tudo mais falhar

Se você realmente não tem como obter ajuda do seu servidor web, a única solução restante é readfile, que está disponível em todas as versões de php atualmente em uso e funciona muito bem (mas não é realmente eficiente).

Combinando soluções

Em suma, a melhor maneira de enviar um arquivo realmente rápido se você quiser que seu código php possa ser usado em qualquer lugar é ter uma opção configurável em algum lugar, com instruções sobre como ativá-lo dependendo do servidor web e talvez uma detecção automática em sua instalação roteiro.

É muito semelhante ao que é feito em muitos softwares para

• Limpar urls ( mod_rewriteno apache)
• Funções criptográficas ( mcryptmódulo php)
• Suporte a strings multibyte ( mbstringmódulo php)

A maneira mais rápida: não faça isso. Olhe no cabeçalho x-sendfile para nginx , há coisas semelhantes para outros servidores da web também. Isso significa que você ainda pode fazer o controle de acesso etc em php, mas delegar o envio real do arquivo a um servidor web projetado para isso.

PS: Eu fico arrepiado só de pensar em como é mais eficiente usar isso com o nginx, em comparação com ler e enviar o arquivo em php. Basta pensar se 100 pessoas estão baixando um arquivo: Com php + apache, sendo generoso, isso é provavelmente 100 * 15mb = 1,5 GB (aprox, atire em mim), de RAM bem ali. O Nginx apenas transfere o envio do arquivo para o kernel e, em seguida, é carregado diretamente do disco para os buffers de rede. Veloz!

PPS: E, com este método, você ainda pode fazer todo o controle de acesso, coisas de banco de dados que quiser.

Aqui vai uma solução PHP pura. Eu adaptei a seguinte função da minha estrutura pessoal :

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;
}

O código é tão eficiente quanto pode ser, ele fecha o manipulador de sessão para que outros scripts PHP possam ser executados simultaneamente para o mesmo usuário / sessão. Ele também oferece suporte a downloads em intervalos (que também é o que o Apache faz por padrão, eu suspeito), para que as pessoas possam pausar / retomar downloads e também se beneficiar de velocidades de download mais altas com aceleradores de download. Ele também permite que você especifique a velocidade máxima (em Kbps) na qual o download (parte) deve ser servido por meio do $speedargumento.

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

Deixe o Apache fazer o trabalho por você.

Uma melhor implementação, com suporte de cache, cabeçalhos http personalizados.

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;
    }
}

se você tem a possibilidade de adicionar extensões PECL ao seu php, você pode simplesmente usar as funções do pacote Fileinfo para determinar o tipo de conteúdo e então enviar os cabeçalhos apropriados ...

A Downloadfunção PHP mencionada aqui estava causando algum atraso antes de o arquivo realmente começar a ser baixado. Não sei se isso foi causado pelo uso de cache de verniz ou o quê, mas para mim ajudou a remover sleep(1);completamente e definir $speedcomo 1024. Agora funciona sem problemas e é rápido como o inferno. Talvez você possa modificar essa função também, pois vi que ela é usada em toda a internet.

Codifiquei uma função muito simples para servir arquivos com PHP e detecção automática de tipo 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);
}

Uso

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