WebSVN – Sites.obs-saisons.fr – Diff – /trunk/applications/jrest/lib/HTTP/Download.php


<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
/**
 * HTTP::Download
 * 
 * PHP versions 4 and 5
 *
 * @category   HTTP
 * @package    HTTP_Download
 * @author     Michael Wallner <mike@php.net>
 * @copyright  2003-2005 Michael Wallner
 * @license    BSD, revised
 * @version    CVS: $Id$
 * @link       http://pear.php.net/package/HTTP_Download
 */
 
// {{{ includes
/**
 * Requires PEAR
 */
require_once 'PEAR.php';
 
/**
 * Requires HTTP_Header
 */
require_once 'HTTP/Header.php';
// }}}
 
// {{{ constants
/**#@+ Use with HTTP_Download::setContentDisposition() **/
/**
 * Send data as attachment
 */
define('HTTP_DOWNLOAD_ATTACHMENT', 'attachment');
/**
 * Send data inline
 */
define('HTTP_DOWNLOAD_INLINE', 'inline');
/**#@-**/
 
/**#@+ Use with HTTP_Download::sendArchive() **/
/**
 * Send as uncompressed tar archive
 */
define('HTTP_DOWNLOAD_TAR', 'TAR');
/**
 * Send as gzipped tar archive
 */
define('HTTP_DOWNLOAD_TGZ', 'TGZ');
/**
 * Send as bzip2 compressed tar archive
 */
define('HTTP_DOWNLOAD_BZ2', 'BZ2');
/**
 * Send as zip archive
 */
define('HTTP_DOWNLOAD_ZIP', 'ZIP');
/**#@-**/
 
/**#@+
 * Error constants
 */
define('HTTP_DOWNLOAD_E_HEADERS_SENT',          -1);
define('HTTP_DOWNLOAD_E_NO_EXT_ZLIB',           -2);
define('HTTP_DOWNLOAD_E_NO_EXT_MMAGIC',         -3);
define('HTTP_DOWNLOAD_E_INVALID_FILE',          -4);
define('HTTP_DOWNLOAD_E_INVALID_PARAM',         -5);
define('HTTP_DOWNLOAD_E_INVALID_RESOURCE',      -6);
define('HTTP_DOWNLOAD_E_INVALID_REQUEST',       -7);
define('HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE',  -8);
define('HTTP_DOWNLOAD_E_INVALID_ARCHIVE_TYPE',  -9);
/**#@-**/
// }}}
 
/** 
 * Send HTTP Downloads/Responses.
 *
 * With this package you can handle (hidden) downloads.
 * It supports partial downloads, resuming and sending 
 * raw data ie. from database BLOBs.
 * 
 * <i>ATTENTION:</i>
 * You shouldn't use this package together with ob_gzhandler or 
 * zlib.output_compression enabled in your php.ini, especially 
 * if you want to send already gzipped data!
 * 
 * @access   public
 * @version  $Revision$
 */
class HTTP_Download
{
    // {{{ protected member variables
    /**
     * Path to file for download
     *
     * @see     HTTP_Download::setFile()
     * @access  protected
     * @var     string
     */
    var $file = '';
    
    /**
     * Data for download
     *
     * @see     HTTP_Download::setData()
     * @access  protected
     * @var     string
     */
    var $data = null;
    
    /**
     * Resource handle for download
     *
     * @see     HTTP_Download::setResource()
     * @access  protected
     * @var     int
     */
    var $handle = null;
    
    /**
     * Whether to gzip the download
     *
     * @access  protected
     * @var     bool
     */
    var $gzip = false;
    
    /**
     * Whether to allow caching of the download on the clients side
     * 
     * @access  protected
     * @var     bool
     */
    var $cache = true;
    
    /**
     * Size of download
     *
     * @access  protected
     * @var     int
     */
    var $size = 0;
    
    /**
     * Last modified
     *
     * @access  protected
     * @var     int
     */
    var $lastModified = 0;
    
    /**
     * HTTP headers
     *
     * @access  protected
     * @var     array
     */
    var $headers   = array(
        'Content-Type'  => 'application/x-octetstream',
        'Pragma'        => 'cache',
        'Cache-Control' => 'public, must-revalidate, max-age=0',
        'Accept-Ranges' => 'bytes',
        'X-Sent-By'     => 'PEAR::HTTP::Download'
    );
 
    /**
     * HTTP_Header
     * 
     * @access  protected
     * @var     object
     */
    var $HTTP = null;
    
    /**
     * ETag
     * 
     * @access  protected
     * @var     string
     */
    var $etag = '';
    
    /**
     * Buffer Size
     * 
     * @access  protected
     * @var     int
     */
    var $bufferSize = 2097152;
    
    /**
     * Throttle Delay
     * 
     * @access  protected
     * @var     float
     */
    var $throttleDelay = 0;
    
    /**
     * Sent Bytes
     * 
     * @access  public
     * @var     int
     */
    var $sentBytes = 0;
    // }}}
    
    // {{{ constructor
    /**
     * Constructor
     *
     * Set supplied parameters.
     * 
     * @access  public
     * @param   array   $params     associative array of parameters
     * 
     *          <b>one of:</b>
     *                  o 'file'                => path to file for download
     *                  o 'data'                => raw data for download
     *                  o 'resource'            => resource handle for download
     * <br/>
     *          <b>and any of:</b>
     *                  o 'cache'               => whether to allow cs caching
     *                  o 'gzip'                => whether to gzip the download
     *                  o 'lastmodified'        => unix timestamp
     *                  o 'contenttype'         => content type of download
     *                  o 'contentdisposition'  => content disposition
     *                  o 'buffersize'          => amount of bytes to buffer
     *                  o 'throttledelay'       => amount of secs to sleep
     *                  o 'cachecontrol'        => cache privacy and validity
     * 
     * <br />
     * 'Content-Disposition' is not HTTP compliant, but most browsers 
     * follow this header, so it was borrowed from MIME standard.
     * 
     * It looks like this: <br />
     * "Content-Disposition: attachment; filename=example.tgz".
     * 
     * @see HTTP_Download::setContentDisposition()
     */
    function HTTP_Download($params = array())
    {
        $this->HTTP = new HTTP_Header;
        $this->setParams($params);
    }
    // }}}
    
    // {{{ public methods
    /**
     * Set parameters
     * 
     * Set supplied parameters through its accessor methods.
     *
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   array   $params     associative array of parameters
     * 
     * @see     HTTP_Download::HTTP_Download()
     */
    function setParams($params)
    {
        foreach((array) $params as $param => $value){
            $method = 'set'. $param;
            
            if (!method_exists($this, $method)) {
                return PEAR::raiseError(
                    "Method '$method' doesn't exist.",
                    HTTP_DOWNLOAD_E_INVALID_PARAM
                );
            }
            
            $e = call_user_func_array(array(&$this, $method), (array) $value);
            
            if (PEAR::isError($e)) {
                return $e;
            }
        }
        return true;
    }
    
    /**
     * Set path to file for download
     *
     * The Last-Modified header will be set to files filemtime(), actually.
     * Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_FILE) if file doesn't exist.
     * Sends HTTP 404 status if $send_404 is set to true.
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   string  $file       path to file for download
     * @param   bool    $send_404   whether to send HTTP/404 if
     *                              the file wasn't found
     */
    function setFile($file, $send_404 = true)
    {
        $file = realpath($file);
        if (!is_file($file)) {
            if ($send_404) {
                $this->HTTP->sendStatusCode(404);
            }
            return PEAR::raiseError(
                "File '$file' not found.",
                HTTP_DOWNLOAD_E_INVALID_FILE
            );
        }
        $this->setLastModified(filemtime($file));
        $this->file = $file;
        $this->size = filesize($file);
        return true;
    }
    
    /**
     * Set data for download
     *
     * Set $data to null if you want to unset this.
     * 
     * @access  public
     * @return  void
     * @param   $data   raw data to send
     */
    function setData($data = null)
    {
        $this->data = $data;
        $this->size = strlen($data);
    }
    
    /**
     * Set resource for download
     *
     * The resource handle supplied will be closed after sending the download.
     * Returns a PEAR_Error (HTTP_DOWNLOAD_E_INVALID_RESOURCE) if $handle 
     * is no valid resource. Set $handle to null if you want to unset this.
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   int     $handle     resource handle
     */
    function setResource($handle = null)
    {
        if (!isset($handle)) {
            $this->handle = null;
            $this->size = 0;
            return true;
        }
        
        if (is_resource($handle)) {
            $this->handle = $handle;
            $filestats    = fstat($handle);
            $this->size   = $filestats['size'];
            return true;
        }
 
        return PEAR::raiseError(
            "Handle '$handle' is no valid resource.",
            HTTP_DOWNLOAD_E_INVALID_RESOURCE
        );
    }
    
    /**
     * Whether to gzip the download
     *
     * Returns a PEAR_Error (HTTP_DOWNLOAD_E_NO_EXT_ZLIB)
     * if ext/zlib is not available/loadable.
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   bool    $gzip   whether to gzip the download
     */
    function setGzip($gzip = false)
    {
        if ($gzip && !PEAR::loadExtension('zlib')){
            return PEAR::raiseError(
                'GZIP compression (ext/zlib) not available.',
                HTTP_DOWNLOAD_E_NO_EXT_ZLIB
            );
        }
        $this->gzip = (bool) $gzip;
        return true;
    }
 
    /**
     * Whether to allow caching
     * 
     * If set to true (default) we'll send some headers that are commonly
     * used for caching purposes like ETag, Cache-Control and Last-Modified.
     * 
     * If caching is disabled, we'll send the download no matter if it
     * would actually be cached at the client side.
     *
     * @access  public
     * @return  void
     * @param   bool    $cache  whether to allow caching
     */
    function setCache($cache = true)
    {
        $this->cache = (bool) $cache;
    }
    
    /**
     * Whether to allow proxies to cache
     * 
     * If set to 'private' proxies shouldn't cache the response.
     * This setting defaults to 'public' and affects only cached responses.
     * 
     * @access  public
     * @return  bool
     * @param   string  $cache  private or public
     * @param   int     $maxage maximum age of the client cache entry
     */
    function setCacheControl($cache = 'public', $maxage = 0)
    {
        switch ($cache = strToLower($cache))
        {
            case 'private':
            case 'public':
                $this->headers['Cache-Control'] = 
                    $cache .', must-revalidate, max-age='. abs($maxage);
                return true;
            break;
        }
        return false;
    }
    
    /**
     * Set ETag
     * 
     * Sets a user-defined ETag for cache-validation.  The ETag is usually
     * generated by HTTP_Download through its payload information.
     * 
     * @access  public
     * @return  void
     * @param   string  $etag Entity tag used for strong cache validation.
     */
    function setETag($etag = null)
    {
        $this->etag = (string) $etag;
    }
    
    /**
     * Set Size of Buffer
     * 
     * The amount of bytes specified as buffer size is the maximum amount
     * of data read at once from resources or files.  The default size is 2M
     * (2097152 bytes).  Be aware that if you enable gzip compression and
     * you set a very low buffer size that the actual file size may grow
     * due to added gzip headers for each sent chunk of the specified size.
     * 
     * Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_PARAM) if $size is not
     * greater than 0 bytes.
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   int     $bytes Amount of bytes to use as buffer.
     */
    function setBufferSize($bytes = 2097152)
    {
        if (0 >= $bytes) {
            return PEAR::raiseError(
                'Buffer size must be greater than 0 bytes ('. $bytes .' given)',
                HTTP_DOWNLOAD_E_INVALID_PARAM);
        }
        $this->bufferSize = abs($bytes);
        return true;
    }
    
    /**
     * Set Throttle Delay
     * 
     * Set the amount of seconds to sleep after each chunck that has been
     * sent.  One can implement some sort of throttle through adjusting the
     * buffer size and the throttle delay.  With the following settings
     * HTTP_Download will sleep a second after each 25 K of data sent.
     * 
     * <code>
     *  Array(
     *      'throttledelay' => 1,
     *      'buffersize'    => 1024 * 25,
     *  )
     * </code>
     * 
     * Just be aware that if gzipp'ing is enabled, decreasing the chunk size 
     * too much leads to proportionally increased network traffic due to added
     * gzip header and bottom bytes around each chunk.
     * 
     * @access  public
     * @return  void
     * @param   float   $seconds    Amount of seconds to sleep after each 
     *                              chunk that has been sent.
     */
    function setThrottleDelay($seconds = 0)
    {
        $this->throttleDelay = abs($seconds) * 1000;
    }
    
    /**
     * Set "Last-Modified"
     *
     * This is usually determined by filemtime() in HTTP_Download::setFile()
     * If you set raw data for download with HTTP_Download::setData() and you
     * want do send an appropiate "Last-Modified" header, you should call this
     * method.
     * 
     * @access  public
     * @return  void
     * @param   int     unix timestamp
     */
    function setLastModified($last_modified)
    {
        $this->lastModified = $this->headers['Last-Modified'] = (int) $last_modified;
    }
    
    /**
     * Set Content-Disposition header
     * 
     * @see HTTP_Download::HTTP_Download
     *
     * @access  public
     * @return  void
     * @param   string  $disposition    whether to send the download
     *                                  inline or as attachment
     * @param   string  $file_name      the filename to display in
     *                                  the browser's download window
     * 
     * <b>Example:</b>
     * <code>
     * $HTTP_Download->setContentDisposition(
     *   HTTP_DOWNLOAD_ATTACHMENT,
     *   'download.tgz'
     * );
     * </code>
     */
    function setContentDisposition( $disposition    = HTTP_DOWNLOAD_ATTACHMENT, 
                                    $file_name      = null)
    {
        $cd = $disposition;
        if (isset($file_name)) {
            $cd .= '; filename="' . $file_name . '"';
        } elseif ($this->file) {
            $cd .= '; filename="' . basename($this->file) . '"';
        }
        $this->headers['Content-Disposition'] = $cd;
    }
    
    /**
     * Set content type of the download
     *
     * Default content type of the download will be 'application/x-octetstream'.
     * Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE) if 
     * $content_type doesn't seem to be valid.
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   string  $content_type   content type of file for download
     */
    function setContentType($content_type = 'application/x-octetstream')
    {
        if (!preg_match('/^[a-z]+\w*\/[a-z]+[\w.;= -]*$/', $content_type)) {
            return PEAR::raiseError(
                "Invalid content type '$content_type' supplied.",
                HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE
            );
        }
        $this->headers['Content-Type'] = $content_type;
        return true;
    }
    
    /**
     * Guess content type of file
     * 
     * First we try to use PEAR::MIME_Type, if installed, to detect the content 
     * type, else we check if ext/mime_magic is loaded and properly configured.
     *
     * Returns PEAR_Error if:
     *      o if PEAR::MIME_Type failed to detect a proper content type
     *        (HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE)
     *      o ext/magic.mime is not installed, or not properly configured
     *        (HTTP_DOWNLOAD_E_NO_EXT_MMAGIC)
     *      o mime_content_type() couldn't guess content type or returned
     *        a content type considered to be bogus by setContentType()
     *        (HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE)
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     */
    function guessContentType()
    {
        if (class_exists('MIME_Type') || @include_once 'MIME/Type.php') {
            if (PEAR::isError($mime_type = MIME_Type::autoDetect($this->file))) {
                return PEAR::raiseError($mime_type->getMessage(),
                    HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE);
            }
            return $this->setContentType($mime_type);
        }
        if (!function_exists('mime_content_type')) {
            return PEAR::raiseError(
                'This feature requires ext/mime_magic!',
                HTTP_DOWNLOAD_E_NO_EXT_MMAGIC
            );
        }
        if (!is_file(ini_get('mime_magic.magicfile'))) {
            return PEAR::raiseError(
                'ext/mime_magic is loaded but not properly configured!',
                HTTP_DOWNLOAD_E_NO_EXT_MMAGIC
            );
        }
        if (!$content_type = @mime_content_type($this->file)) {
            return PEAR::raiseError(
                'Couldn\'t guess content type with mime_content_type().',
                HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE
            );
        }
        return $this->setContentType($content_type);
    }
 
    /**
     * Send
     *
     * Returns PEAR_Error if:
     *   o HTTP headers were already sent (HTTP_DOWNLOAD_E_HEADERS_SENT)
     *   o HTTP Range was invalid (HTTP_DOWNLOAD_E_INVALID_REQUEST)
     * 
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   bool    $autoSetContentDisposition Whether to set the
     *                  Content-Disposition header if it isn't already.
     */
    function send($autoSetContentDisposition = true)
    {
        if (headers_sent()) {
            return PEAR::raiseError(
                'Headers already sent.',
                HTTP_DOWNLOAD_E_HEADERS_SENT
            );
        }
        
        if (!ini_get('safe_mode')) {
            @set_time_limit(0);
        }
        
        if ($autoSetContentDisposition && 
            !isset($this->headers['Content-Disposition'])) {
            $this->setContentDisposition();
        }
        
        if ($this->cache) {
            $this->headers['ETag'] = $this->generateETag();
            if ($this->isCached()) {
                $this->HTTP->sendStatusCode(304);
                $this->sendHeaders();
                return true;
            }
        } else {
            unset($this->headers['Last-Modified']);
        }
        
        if (ob_get_level()) {
        	while (@ob_end_clean());
        }
        
        if ($this->gzip) {
            @ob_start('ob_gzhandler');
        } else {
            ob_start();
        }
        
        $this->sentBytes = 0;
        
        if ($this->isRangeRequest()) {
            $this->HTTP->sendStatusCode(206);
            $chunks = $this->getChunks();
        } else {
            $this->HTTP->sendStatusCode(200);
            $chunks = array(array(0, $this->size));
            if (!$this->gzip && count(ob_list_handlers()) < 2) {
                $this->headers['Content-Length'] = $this->size;
            }
        }
 
        if (PEAR::isError($e = $this->sendChunks($chunks))) {
            ob_end_clean();
            $this->HTTP->sendStatusCode(416);
            return $e;
        }
        
        ob_end_flush();
        flush();
        return true;
    }    
 
    /**
     * Static send
     *
     * @see     HTTP_Download::HTTP_Download()
     * @see     HTTP_Download::send()
     * 
     * @static
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   array   $params     associative array of parameters
     * @param   bool    $guess      whether HTTP_Download::guessContentType()
     *                               should be called
     */
    function staticSend($params, $guess = false)
    {
        $d = new HTTP_Download();
        $e = $d->setParams($params);
        if (PEAR::isError($e)) {
            return $e;
        }
        if ($guess) {
            $e = $d->guessContentType();
            if (PEAR::isError($e)) {
                return $e;
            }
        }
        return $d->send();
    }
    
    /**
     * Send a bunch of files or directories as an archive
     * 
     * Example:
     * <code>
     *  require_once 'HTTP/Download.php';
     *  HTTP_Download::sendArchive(
     *      'myArchive.tgz',
     *      '/var/ftp/pub/mike',
     *      HTTP_DOWNLOAD_TGZ,
     *      '',
     *      '/var/ftp/pub'
     *  );
     * </code>
     *
     * @see         Archive_Tar::createModify()
     * @deprecated  use HTTP_Download_Archive::send()
     * @static
     * @access  public
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   string  $name       name the sent archive should have
     * @param   mixed   $files      files/directories
     * @param   string  $type       archive type
     * @param   string  $add_path   path that should be prepended to the files
     * @param   string  $strip_path path that should be stripped from the files
     */
    function sendArchive(   $name, 
                            $files, 
                            $type       = HTTP_DOWNLOAD_TGZ, 
                            $add_path   = '', 
                            $strip_path = '')
    {
        require_once 'HTTP/Download/Archive.php';
        return HTTP_Download_Archive::send($name, $files, $type, 
            $add_path, $strip_path);
    }
    // }}}
    
    // {{{ protected methods
    /** 
     * Generate ETag
     * 
     * @access  protected
     * @return  string
     */
    function generateETag()
    {
        if (!$this->etag) {
            if ($this->data) {
                $md5 = md5($this->data);
            } else {
                $fst = is_resource($this->handle) ? 
                    fstat($this->handle) : stat($this->file);
                $md5 = md5($fst['mtime'] .'='. $fst['ino'] .'='. $fst['size']);
            }
            $this->etag = '"' . $md5 . '-' . crc32($md5) . '"';
        }
        return $this->etag;
    }
    
    /** 
     * Send multiple chunks
     * 
     * @access  protected
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   array   $chunks
     */
    function sendChunks($chunks)
    {
        if (count($chunks) == 1) {
            return $this->sendChunk(current($chunks));
        }
 
        $bound = uniqid('HTTP_DOWNLOAD-', true);
        $cType = $this->headers['Content-Type'];
        $this->headers['Content-Type'] =
            'multipart/byteranges; boundary=' . $bound;
        $this->sendHeaders();
        foreach ($chunks as $chunk){
            if (PEAR::isError($e = $this->sendChunk($chunk, $cType, $bound))) {
                return $e;
            }
        }
        #echo "\r\n--$bound--\r\n";
        return true;
    }
    
    /**
     * Send chunk of data
     * 
     * @access  protected
     * @return  mixed   Returns true on success or PEAR_Error on failure.
     * @param   array   $chunk  start and end offset of the chunk to send
     * @param   string  $cType  actual content type
     * @param   string  $bound  boundary for multipart/byteranges
     */
    function sendChunk($chunk, $cType = null, $bound = null)
    {
        list($offset, $lastbyte) = $chunk;
        $length = ($lastbyte - $offset) + 1;
        
        if ($length < 1) {
            return PEAR::raiseError(
                "Error processing range request: $offset-$lastbyte/$length",
                HTTP_DOWNLOAD_E_INVALID_REQUEST
            );
        }
        
        $range = $offset . '-' . $lastbyte . '/' . $this->size;
        
        if (isset($cType, $bound)) {
            echo    "\r\n--$bound\r\n",
                    "Content-Type: $cType\r\n",
                    "Content-Range: bytes $range\r\n\r\n";
        } else {
            if ($this->isRangeRequest()) {
                $this->headers['Content-Length'] = $length;
                $this->headers['Content-Range'] = 'bytes '. $range;
            }
            $this->sendHeaders();
        }
 
        if ($this->data) {
            while (($length -= $this->bufferSize) > 0) {
                $this->flush(substr($this->data, $offset, $this->bufferSize));
                $this->throttleDelay and $this->sleep();
                $offset += $this->bufferSize;
            }
            if ($length) {
                $this->flush(substr($this->data, $offset, $this->bufferSize + $length));
            }
        } else {
            if (!is_resource($this->handle)) {
                $this->handle = fopen($this->file, 'rb');
            }
            fseek($this->handle, $offset);
            while (($length -= $this->bufferSize) > 0) {
                $this->flush(fread($this->handle, $this->bufferSize));
                $this->throttleDelay and $this->sleep();
            }
            if ($length) {
                $this->flush(fread($this->handle, $this->bufferSize + $length));
            }
        }
        return true;
    }
    
    /** 
     * Get chunks to send
     * 
     * @access  protected
     * @return  array
     */
    function getChunks()
    {
        $parts = array();
        foreach (explode(',', $this->getRanges()) as $chunk){
            list($o, $e) = explode('-', $chunk);
            if ($e >= $this->size || (empty($e) && $e !== 0 && $e !== '0')) {
                $e = $this->size - 1;
            }
            if (empty($o) && $o !== 0 && $o !== '0') {
                $o = $this->size - $e;
                $e = $this->size - 1;
            }
            $parts[] = array($o, $e);
        }
        return $parts;
    }
    
    /** 
     * Check if range is requested
     * 
     * @access  protected
     * @return  bool
     */
    function isRangeRequest()
    {
        if (!isset($_SERVER['HTTP_RANGE'])) {
            return false;
        }
        return $this->isValidRange();
    }
    
    /** 
     * Get range request
     * 
     * @access  protected
     * @return  array
     */
    function getRanges()
    {
        return preg_match('/^bytes=((\d*-\d*,? ?)+)$/', 
            @$_SERVER['HTTP_RANGE'], $matches) ? $matches[1] : array();
    }
    
    /** 
     * Check if entity is cached
     * 
     * @access  protected
     * @return  bool
     */
    function isCached()
    {
        return (
            (isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) &&
            $this->lastModified == strtotime(current($a = explode(
                ';', $_SERVER['HTTP_IF_MODIFIED_SINCE'])))) ||
            (isset($_SERVER['HTTP_IF_NONE_MATCH']) &&
            $this->compareAsterisk('HTTP_IF_NONE_MATCH', $this->etag))
        );
    }
    
    /** 
     * Check if entity hasn't changed
     * 
     * @access  protected
     * @return  bool
     */
    function isValidRange()
    {
        if (isset($_SERVER['HTTP_IF_MATCH']) &&
            !$this->compareAsterisk('HTTP_IF_MATCH', $this->etag)) {
            return false;
        }
        if (isset($_SERVER['HTTP_IF_RANGE']) &&
                  $_SERVER['HTTP_IF_RANGE'] !== $this->etag &&
                  strtotime($_SERVER['HTTP_IF_RANGE']) !== $this->lastModified) {
            return false;
        }
        if (isset($_SERVER['HTTP_IF_UNMODIFIED_SINCE'])) {
            $lm = current($a = explode(';', $_SERVER['HTTP_IF_UNMODIFIED_SINCE']));
            if (strtotime($lm) !== $this->lastModified) {
                return false;
            }
        }
        if (isset($_SERVER['HTTP_UNLESS_MODIFIED_SINCE'])) {
            $lm = current($a = explode(';', $_SERVER['HTTP_UNLESS_MODIFIED_SINCE']));
            if (strtotime($lm) !== $this->lastModified) {
                return false;
            }
        }
        return true;
    }
    
    /** 
     * Compare against an asterisk or check for equality
     * 
     * @access  protected
     * @return  bool
     * @param   string  key for the $_SERVER array
     * @param   string  string to compare
     */
    function compareAsterisk($svar, $compare)
    {
        foreach (array_map('trim', explode(',', $_SERVER[$svar])) as $request) {
            if ($request === '*' || $request === $compare) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * Send HTTP headers
     *
     * @access  protected
     * @return  void
     */
    function sendHeaders()
    {
        foreach ($this->headers as $header => $value) {
            $this->HTTP->setHeader($header, $value);
        }
        $this->HTTP->sendHeaders();
        /* NSAPI won't output anything if we did this */
        if (strncasecmp(PHP_SAPI, 'nsapi', 5)) {
            ob_flush();
            flush();
        }
    }
    
    /**
     * Flush
     * 
     * @access  protected
     * @return  void
     * @param   string  $data
     */
    function flush($data = '')
    {
        if ($dlen = strlen($data)) {
            $this->sentBytes += $dlen;
            echo $data;
        }
        ob_flush();
        flush();
    }
    
    /**
     * Sleep
     * 
     * @access  protected
     * @return  void
     */
    function sleep()
    {
        if (OS_WINDOWS) {
            com_message_pump($this->throttleDelay);
        } else {
            usleep($this->throttleDelay * 1000);
        }
    }
    // }}}
}
?>

Rev 31	Rev 316
1	`<?php`	1	`<?php`
2	`/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */`	2	`/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */`
3		3
4	`/**`	4	`/**`
5	`* HTTP::Download`	5	`* HTTP::Download`
6	`*`	6	`*`
7	`* PHP versions 4 and 5`	7	`* PHP versions 4 and 5`
8	`*`	8	`*`
9	`* @category HTTP`	9	`* @category HTTP`
10	`* @package HTTP_Download`	10	`* @package HTTP_Download`
11	`* @author Michael Wallner <mike@php.net>`	11	`* @author Michael Wallner <mike@php.net>`
12	`* @copyright 2003-2005 Michael Wallner`	12	`* @copyright 2003-2005 Michael Wallner`
13	`* @license BSD, revised`	13	`* @license BSD, revised`
14	`* @version CVS: $Id$`	14	`* @version CVS: $Id$`
15	`* @link http://pear.php.net/package/HTTP_Download`	15	`* @link http://pear.php.net/package/HTTP_Download`
16	`*/`	16	`*/`
17		17
18	`// {{{ includes`	18	`// {{{ includes`
19	`/**`	19	`/**`
20	`* Requires PEAR`	20	`* Requires PEAR`
21	`*/`	21	`*/`
22	`require_once 'PEAR.php';`	22	`require_once 'PEAR.php';`
23		23
24	`/**`	24	`/**`
25	`* Requires HTTP_Header`	25	`* Requires HTTP_Header`
26	`*/`	26	`*/`
27	`require_once 'HTTP/Header.php';`	27	`require_once 'HTTP/Header.php';`
28	`// }}}`	28	`// }}}`
29		29
30	`// {{{ constants`	30	`// {{{ constants`
31	`/#@+ Use with HTTP_Download::setContentDisposition() /`	31	`/#@+ Use with HTTP_Download::setContentDisposition() /`
32	`/**`	32	`/**`
33	`* Send data as attachment`	33	`* Send data as attachment`
34	`*/`	34	`*/`
35	`define('HTTP_DOWNLOAD_ATTACHMENT', 'attachment');`	35	`define('HTTP_DOWNLOAD_ATTACHMENT', 'attachment');`
36	`/**`	36	`/**`
37	`* Send data inline`	37	`* Send data inline`
38	`*/`	38	`*/`
39	`define('HTTP_DOWNLOAD_INLINE', 'inline');`	39	`define('HTTP_DOWNLOAD_INLINE', 'inline');`
40	`/#@-/`	40	`/#@-/`
41		41
42	`/#@+ Use with HTTP_Download::sendArchive() /`	42	`/#@+ Use with HTTP_Download::sendArchive() /`
43	`/**`	43	`/**`
44	`* Send as uncompressed tar archive`	44	`* Send as uncompressed tar archive`
45	`*/`	45	`*/`
46	`define('HTTP_DOWNLOAD_TAR', 'TAR');`	46	`define('HTTP_DOWNLOAD_TAR', 'TAR');`
47	`/**`	47	`/**`
48	`* Send as gzipped tar archive`	48	`* Send as gzipped tar archive`
49	`*/`	49	`*/`
50	`define('HTTP_DOWNLOAD_TGZ', 'TGZ');`	50	`define('HTTP_DOWNLOAD_TGZ', 'TGZ');`
51	`/**`	51	`/**`
52	`* Send as bzip2 compressed tar archive`	52	`* Send as bzip2 compressed tar archive`
53	`*/`	53	`*/`
54	`define('HTTP_DOWNLOAD_BZ2', 'BZ2');`	54	`define('HTTP_DOWNLOAD_BZ2', 'BZ2');`
55	`/**`	55	`/**`
56	`* Send as zip archive`	56	`* Send as zip archive`
57	`*/`	57	`*/`
58	`define('HTTP_DOWNLOAD_ZIP', 'ZIP');`	58	`define('HTTP_DOWNLOAD_ZIP', 'ZIP');`
59	`/#@-/`	59	`/#@-/`
60		60
61	`/**#@+`	61	`/**#@+`
62	`* Error constants`	62	`* Error constants`
63	`*/`	63	`*/`
64	`define('HTTP_DOWNLOAD_E_HEADERS_SENT', -1);`	64	`define('HTTP_DOWNLOAD_E_HEADERS_SENT', -1);`
65	`define('HTTP_DOWNLOAD_E_NO_EXT_ZLIB', -2);`	65	`define('HTTP_DOWNLOAD_E_NO_EXT_ZLIB', -2);`
66	`define('HTTP_DOWNLOAD_E_NO_EXT_MMAGIC', -3);`	66	`define('HTTP_DOWNLOAD_E_NO_EXT_MMAGIC', -3);`
67	`define('HTTP_DOWNLOAD_E_INVALID_FILE', -4);`	67	`define('HTTP_DOWNLOAD_E_INVALID_FILE', -4);`
68	`define('HTTP_DOWNLOAD_E_INVALID_PARAM', -5);`	68	`define('HTTP_DOWNLOAD_E_INVALID_PARAM', -5);`
69	`define('HTTP_DOWNLOAD_E_INVALID_RESOURCE', -6);`	69	`define('HTTP_DOWNLOAD_E_INVALID_RESOURCE', -6);`
70	`define('HTTP_DOWNLOAD_E_INVALID_REQUEST', -7);`	70	`define('HTTP_DOWNLOAD_E_INVALID_REQUEST', -7);`
71	`define('HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE', -8);`	71	`define('HTTP_DOWNLOAD_E_INVALID_CONTENT_TYPE', -8);`
72	`define('HTTP_DOWNLOAD_E_INVALID_ARCHIVE_TYPE', -9);`	72	`define('HTTP_DOWNLOAD_E_INVALID_ARCHIVE_TYPE', -9);`
73	`/#@-/`	73	`/#@-/`
74	`// }}}`	74	`// }}}`
75		75
76	`/**`	76	`/**`
77	`* Send HTTP Downloads/Responses.`	77	`* Send HTTP Downloads/Responses.`
78	`*`	78	`*`
79	`* With this package you can handle (hidden) downloads.`	79	`* With this package you can handle (hidden) downloads.`
80	`* It supports partial downloads, resuming and sending`	80	`* It supports partial downloads, resuming and sending`
81	`* raw data ie. from database BLOBs.`	81	`* raw data ie. from database BLOBs.`
82	`*`	82	`*`
83	`* <i>ATTENTION:</i>`	83	`* <i>ATTENTION:</i>`
84	`* You shouldn't use this package together with ob_gzhandler or`	84	`* You shouldn't use this package together with ob_gzhandler or`
85	`* zlib.output_compression enabled in your php.ini, especially`	85	`* zlib.output_compression enabled in your php.ini, especially`
86	`* if you want to send already gzipped data!`	86	`* if you want to send already gzipped data!`
87	`*`	87	`*`
88	`* @access public`	88	`* @access public`
89	`* @version $Revision$`	89	`* @version $Revision$`
90	`*/`	90	`*/`
91	`class HTTP_Download`	91	`class HTTP_Download`
92	`{`	92	`{`
93	`// {{{ protected member variables`	93	`// {{{ protected member variables`
94	`/**`	94	`/**`
95	`* Path to file for download`	95	`* Path to file for download`
96	`*`	96	`*`
97	`* @see HTTP_Download::setFile()`	97	`* @see HTTP_Download::setFile()`
98	`* @access protected`	98	`* @access protected`
99	`* @var string`	99	`* @var string`
100	`*/`	100	`*/`
101	`var $file = '';`	101	`var $file = '';`
102		102
103	`/**`	103	`/**`
104	`* Data for download`	104	`* Data for download`
105	`*`	105	`*`
106	`* @see HTTP_Download::setData()`	106	`* @see HTTP_Download::setData()`
107	`* @access protected`	107	`* @access protected`
108	`* @var string`	108	`* @var string`
109	`*/`	109	`*/`
110	`var $data = null;`	110	`var $data = null;`
111		111
112	`/**`	112	`/**`
113	`* Resource handle for download`	113	`* Resource handle for download`
114	`*`	114	`*`
115	`* @see HTTP_Download::setResource()`	115	`* @see HTTP_Download::setResource()`
116	`* @access protected`	116	`* @access protected`
117	`* @var int`	117	`* @var int`
118	`*/`	118	`*/`
119	`var $handle = null;`	119	`var $handle = null;`
120		120
121	`/**`	121	`/**`
122	`* Whether to gzip the download`	122	`* Whether to gzip the download`
123	`*`	123	`*`
124	`* @access protected`	124	`* @access protected`
125	`* @var bool`	125	`* @var bool`
126	`*/`	126	`*/`
127	`var $gzip = false;`	127	`var $gzip = false;`
128		128
129	`/**`	129	`/**`
130	`* Whether to allow caching of the download on the clients side`	130	`* Whether to allow caching of the download on the clients side`
131	`*`	131	`*`
132	`* @access protected`	132	`* @access protected`
133	`* @var bool`	133	`* @var bool`
134	`*/`	134	`*/`
135	`var $cache = true;`	135	`var $cache = true;`
136		136
137	`/**`	137	`/**`
138	`* Size of download`	138	`* Size of download`
139	`*`	139	`*`
140	`* @access protected`	140	`* @access protected`
141	`* @var int`	141	`* @var int`
142	`*/`	142	`*/`
143	`var $size = 0;`	143	`var $size = 0;`
144		144
145	`/**`	145	`/**`
146	`* Last modified`	146	`* Last modified`
147	`*`	147	`*`
148	`* @access protected`	148	`* @access protected`
149	`* @var int`	149	`* @var int`
150	`*/`	150	`*/`
151	`var $lastModified = 0;`	151	`var $lastModified = 0;`
152		152
153	`/**`	153	`/**`
154	`* HTTP headers`	154	`* HTTP headers`
155	`*`	155	`*`
156	`* @access protected`	156	`* @access protected`
157	`* @var array`	157	`* @var array`
158	`*/`	158	`*/`
159	`var $headers = array(`	159	`var $headers = array(`
160	`'Content-Type' => 'application/x-octetstream',`	160	`'Content-Type' => 'application/x-octetstream',`
161	`'Pragma' => 'cache',`	161	`'Pragma' => 'cache',`
162	`'Cache-Control' => 'public, must-revalidate, max-age=0',`	162	`'Cache-Control' => 'public, must-revalidate, max-age=0',`
163	`'Accept-Ranges' => 'bytes',`	163	`'Accept-Ranges' => 'bytes',`
164	`'X-Sent-By' => 'PEAR::HTTP::Download'`	164	`'X-Sent-By' => 'PEAR::HTTP::Download'`
165	`);`	165	`);`
166		166
167	`/**`	167	`/**`
168	`* HTTP_Header`	168	`* HTTP_Header`
169	`*`	169	`*`
170	`* @access protected`	170	`* @access protected`
171	`* @var object`	171	`* @var object`
172	`*/`	172	`*/`
173	`var $HTTP = null;`	173	`var $HTTP = null;`
174		174
175	`/**`	175	`/**`
176	`* ETag`	176	`* ETag`
177	`*`	177	`*`
178	`* @access protected`	178	`* @access protected`
179	`* @var string`	179	`* @var string`
180	`*/`	180	`*/`
181	`var $etag = '';`	181	`var $etag = '';`
182		182
183	`/**`	183	`/**`
184	`* Buffer Size`	184	`* Buffer Size`
185	`*`	185	`*`
186	`* @access protected`	186	`* @access protected`
187	`* @var int`	187	`* @var int`
188	`*/`	188	`*/`
189	`var $bufferSize = 2097152;`	189	`var $bufferSize = 2097152;`
190		190
191	`/**`	191	`/**`
192	`* Throttle Delay`	192	`* Throttle Delay`
193	`*`	193	`*`
194	`* @access protected`	194	`* @access protected`
195	`* @var float`	195	`* @var float`
196	`*/`	196	`*/`
197	`var $throttleDelay = 0;`	197	`var $throttleDelay = 0;`
198		198
199	`/**`	199	`/**`
200	`* Sent Bytes`	200	`* Sent Bytes`
201	`*`	201	`*`
202	`* @access public`	202	`* @access public`
203	`* @var int`	203	`* @var int`
204	`*/`	204	`*/`
205	`var $sentBytes = 0;`	205	`var $sentBytes = 0;`
206	`// }}}`	206	`// }}}`
207		207
208	`// {{{ constructor`	208	`// {{{ constructor`
209	`/**`	209	`/**`
210	`* Constructor`	210	`* Constructor`
211	`*`	211	`*`
212	`* Set supplied parameters.`	212	`* Set supplied parameters.`
213	`*`	213	`*`
214	`* @access public`	214	`* @access public`
215	`* @param array $params associative array of parameters`	215	`* @param array $params associative array of parameters`
216	`*`	216	`*`
217	`* <b>one of:</b>`	217	`* <b>one of:</b>`
218	`* o 'file' => path to file for download`	218	`* o 'file' => path to file for download`
219	`* o 'data' => raw data for download`	219	`* o 'data' => raw data for download`
220	`* o 'resource' => resource handle for download`	220	`* o 'resource' => resource handle for download`
221	`* <br/>`	221	`* <br/>`
222	`* <b>and any of:</b>`	222	`* <b>and any of:</b>`
223	`* o 'cache' => whether to allow cs caching`	223	`* o 'cache' => whether to allow cs caching`
224	`* o 'gzip' => whether to gzip the download`	224	`* o 'gzip' => whether to gzip the download`
225	`* o 'lastmodified' => unix timestamp`	225	`* o 'lastmodified' => unix timestamp`
226	`* o 'contenttype' => content type of download`	226	`* o 'contenttype' => content type of download`
227	`* o 'contentdisposition' => content disposition`	227	`* o 'contentdisposition' => content disposition`
228	`* o 'buffersize' => amount of bytes to buffer`	228	`* o 'buffersize' => amount of bytes to buffer`
229	`* o 'throttledelay' => amount of secs to sleep`	229	`* o 'throttledelay' => amount of secs to sleep`
230	`* o 'cachecontrol' => cache privacy and validity`	230	`* o 'cachecontrol' => cache privacy and validity`
231	`*`	231	`*`
232	`* <br />`	232	`* <br />`
233	`* 'Content-Disposition' is not HTTP compliant, but most browsers`	233	`* 'Content-Disposition' is not HTTP compliant, but most browsers`
234	`* follow this header, so it was borrowed from MIME standard.`	234	`* follow this header, so it was borrowed from MIME standard.`
235	`*`	235	`*`
236	`* It looks like this: <br />`	236	`* It looks like this: <br />`
237	`* "Content-Disposition: attachment; filename=example.tgz".`	237	`* "Content-Disposition: attachment; filename=example.tgz".`
238	`*`	238	`*`
239	`* @see HTTP_Download::setContentDisposition()`	239	`* @see HTTP_Download::setContentDisposition()`
240	`*/`	240	`*/`
241	`function HTTP_Download($params = array())`	241	`function HTTP_Download($params = array())`
242	`{`	242	`{`
243	`$this->HTTP = &new HTTP_Header;`	243	`$this->HTTP = new HTTP_Header;`
244	`$this->setParams($params);`	244	`$this->setParams($params);`
245	`}`	245	`}`
246	`// }}}`	246	`// }}}`
247		247
248	`// {{{ public methods`	248	`// {{{ public methods`
249	`/**`	249	`/**`
250	`* Set parameters`	250	`* Set parameters`
251	`*`	251	`*`
252	`* Set supplied parameters through its accessor methods.`	252	`* Set supplied parameters through its accessor methods.`
253	`*`	253	`*`
254	`* @access public`	254	`* @access public`
255	`* @return mixed Returns true on success or PEAR_Error on failure.`	255	`* @return mixed Returns true on success or PEAR_Error on failure.`
256	`* @param array $params associative array of parameters`	256	`* @param array $params associative array of parameters`
257	`*`	257	`*`
258	`* @see HTTP_Download::HTTP_Download()`	258	`* @see HTTP_Download::HTTP_Download()`
259	`*/`	259	`*/`
260	`function setParams($params)`	260	`function setParams($params)`
261	`{`	261	`{`
262	`foreach((array) $params as $param => $value){`	262	`foreach((array) $params as $param => $value){`
263	`$method = 'set'. $param;`	263	`$method = 'set'. $param;`
264		264
265	`if (!method_exists($this, $method)) {`	265	`if (!method_exists($this, $method)) {`
266	`return PEAR::raiseError(`	266	`return PEAR::raiseError(`
267	`"Method '$method' doesn't exist.",`	267	`"Method '$method' doesn't exist.",`
268	`HTTP_DOWNLOAD_E_INVALID_PARAM`	268	`HTTP_DOWNLOAD_E_INVALID_PARAM`
269	`);`	269	`);`
270	`}`	270	`}`
271		271
272	`$e = call_user_func_array(array(&$this, $method), (array) $value);`	272	`$e = call_user_func_array(array(&$this, $method), (array) $value);`
273		273
274	`if (PEAR::isError($e)) {`	274	`if (PEAR::isError($e)) {`
275	`return $e;`	275	`return $e;`
276	`}`	276	`}`
277	`}`	277	`}`
278	`return true;`	278	`return true;`
279	`}`	279	`}`
280		280
281	`/**`	281	`/**`
282	`* Set path to file for download`	282	`* Set path to file for download`
283	`*`	283	`*`
284	`* The Last-Modified header will be set to files filemtime(), actually.`	284	`* The Last-Modified header will be set to files filemtime(), actually.`
285	`* Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_FILE) if file doesn't exist.`	285	`* Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_FILE) if file doesn't exist.`
286	`* Sends HTTP 404 status if $send_404 is set to true.`	286	`* Sends HTTP 404 status if $send_404 is set to true.`
287	`*`	287	`*`
288	`* @access public`	288	`* @access public`
289	`* @return mixed Returns true on success or PEAR_Error on failure.`	289	`* @return mixed Returns true on success or PEAR_Error on failure.`
290	`* @param string $file path to file for download`	290	`* @param string $file path to file for download`
291	`* @param bool $send_404 whether to send HTTP/404 if`	291	`* @param bool $send_404 whether to send HTTP/404 if`
292	`* the file wasn't found`	292	`* the file wasn't found`
293	`*/`	293	`*/`
294	`function setFile($file, $send_404 = true)`	294	`function setFile($file, $send_404 = true)`
295	`{`	295	`{`
296	`$file = realpath($file);`	296	`$file = realpath($file);`
297	`if (!is_file($file)) {`	297	`if (!is_file($file)) {`
298	`if ($send_404) {`	298	`if ($send_404) {`
299	`$this->HTTP->sendStatusCode(404);`	299	`$this->HTTP->sendStatusCode(404);`
300	`}`	300	`}`
301	`return PEAR::raiseError(`	301	`return PEAR::raiseError(`
302	`"File '$file' not found.",`	302	`"File '$file' not found.",`
303	`HTTP_DOWNLOAD_E_INVALID_FILE`	303	`HTTP_DOWNLOAD_E_INVALID_FILE`
304	`);`	304	`);`
305	`}`	305	`}`
306	`$this->setLastModified(filemtime($file));`	306	`$this->setLastModified(filemtime($file));`
307	`$this->file = $file;`	307	`$this->file = $file;`
308	`$this->size = filesize($file);`	308	`$this->size = filesize($file);`
309	`return true;`	309	`return true;`
310	`}`	310	`}`
311		311
312	`/**`	312	`/**`
313	`* Set data for download`	313	`* Set data for download`
314	`*`	314	`*`
315	`* Set $data to null if you want to unset this.`	315	`* Set $data to null if you want to unset this.`
316	`*`	316	`*`
317	`* @access public`	317	`* @access public`
318	`* @return void`	318	`* @return void`
319	`* @param $data raw data to send`	319	`* @param $data raw data to send`
320	`*/`	320	`*/`
321	`function setData($data = null)`	321	`function setData($data = null)`
322	`{`	322	`{`
323	`$this->data = $data;`	323	`$this->data = $data;`
324	`$this->size = strlen($data);`	324	`$this->size = strlen($data);`
325	`}`	325	`}`
326		326
327	`/**`	327	`/**`
328	`* Set resource for download`	328	`* Set resource for download`
329	`*`	329	`*`
330	`* The resource handle supplied will be closed after sending the download.`	330	`* The resource handle supplied will be closed after sending the download.`
331	`* Returns a PEAR_Error (HTTP_DOWNLOAD_E_INVALID_RESOURCE) if $handle`	331	`* Returns a PEAR_Error (HTTP_DOWNLOAD_E_INVALID_RESOURCE) if $handle`
332	`* is no valid resource. Set $handle to null if you want to unset this.`	332	`* is no valid resource. Set $handle to null if you want to unset this.`
333	`*`	333	`*`
334	`* @access public`	334	`* @access public`
335	`* @return mixed Returns true on success or PEAR_Error on failure.`	335	`* @return mixed Returns true on success or PEAR_Error on failure.`
336	`* @param int $handle resource handle`	336	`* @param int $handle resource handle`
337	`*/`	337	`*/`
338	`function setResource($handle = null)`	338	`function setResource($handle = null)`
339	`{`	339	`{`
340	`if (!isset($handle)) {`	340	`if (!isset($handle)) {`
341	`$this->handle = null;`	341	`$this->handle = null;`
342	`$this->size = 0;`	342	`$this->size = 0;`
343	`return true;`	343	`return true;`
344	`}`	344	`}`
345		345
346	`if (is_resource($handle)) {`	346	`if (is_resource($handle)) {`
347	`$this->handle = $handle;`	347	`$this->handle = $handle;`
348	`$filestats = fstat($handle);`	348	`$filestats = fstat($handle);`
349	`$this->size = $filestats['size'];`	349	`$this->size = $filestats['size'];`
350	`return true;`	350	`return true;`
351	`}`	351	`}`
352		352
353	`return PEAR::raiseError(`	353	`return PEAR::raiseError(`
354	`"Handle '$handle' is no valid resource.",`	354	`"Handle '$handle' is no valid resource.",`
355	`HTTP_DOWNLOAD_E_INVALID_RESOURCE`	355	`HTTP_DOWNLOAD_E_INVALID_RESOURCE`
356	`);`	356	`);`
357	`}`	357	`}`
358		358
359	`/**`	359	`/**`
360	`* Whether to gzip the download`	360	`* Whether to gzip the download`
361	`*`	361	`*`
362	`* Returns a PEAR_Error (HTTP_DOWNLOAD_E_NO_EXT_ZLIB)`	362	`* Returns a PEAR_Error (HTTP_DOWNLOAD_E_NO_EXT_ZLIB)`
363	`* if ext/zlib is not available/loadable.`	363	`* if ext/zlib is not available/loadable.`
364	`*`	364	`*`
365	`* @access public`	365	`* @access public`
366	`* @return mixed Returns true on success or PEAR_Error on failure.`	366	`* @return mixed Returns true on success or PEAR_Error on failure.`
367	`* @param bool $gzip whether to gzip the download`	367	`* @param bool $gzip whether to gzip the download`
368	`*/`	368	`*/`
369	`function setGzip($gzip = false)`	369	`function setGzip($gzip = false)`
370	`{`	370	`{`
371	`if ($gzip && !PEAR::loadExtension('zlib')){`	371	`if ($gzip && !PEAR::loadExtension('zlib')){`
372	`return PEAR::raiseError(`	372	`return PEAR::raiseError(`
373	`'GZIP compression (ext/zlib) not available.',`	373	`'GZIP compression (ext/zlib) not available.',`
374	`HTTP_DOWNLOAD_E_NO_EXT_ZLIB`	374	`HTTP_DOWNLOAD_E_NO_EXT_ZLIB`
375	`);`	375	`);`
376	`}`	376	`}`
377	`$this->gzip = (bool) $gzip;`	377	`$this->gzip = (bool) $gzip;`
378	`return true;`	378	`return true;`
379	`}`	379	`}`
380		380
381	`/**`	381	`/**`
382	`* Whether to allow caching`	382	`* Whether to allow caching`
383	`*`	383	`*`
384	`* If set to true (default) we'll send some headers that are commonly`	384	`* If set to true (default) we'll send some headers that are commonly`
385	`* used for caching purposes like ETag, Cache-Control and Last-Modified.`	385	`* used for caching purposes like ETag, Cache-Control and Last-Modified.`
386	`*`	386	`*`
387	`* If caching is disabled, we'll send the download no matter if it`	387	`* If caching is disabled, we'll send the download no matter if it`
388	`* would actually be cached at the client side.`	388	`* would actually be cached at the client side.`
389	`*`	389	`*`
390	`* @access public`	390	`* @access public`
391	`* @return void`	391	`* @return void`
392	`* @param bool $cache whether to allow caching`	392	`* @param bool $cache whether to allow caching`
393	`*/`	393	`*/`
394	`function setCache($cache = true)`	394	`function setCache($cache = true)`
395	`{`	395	`{`
396	`$this->cache = (bool) $cache;`	396	`$this->cache = (bool) $cache;`
397	`}`	397	`}`
398		398
399	`/**`	399	`/**`
400	`* Whether to allow proxies to cache`	400	`* Whether to allow proxies to cache`
401	`*`	401	`*`
402	`* If set to 'private' proxies shouldn't cache the response.`	402	`* If set to 'private' proxies shouldn't cache the response.`
403	`* This setting defaults to 'public' and affects only cached responses.`	403	`* This setting defaults to 'public' and affects only cached responses.`
404	`*`	404	`*`
405	`* @access public`	405	`* @access public`
406	`* @return bool`	406	`* @return bool`
407	`* @param string $cache private or public`	407	`* @param string $cache private or public`
408	`* @param int $maxage maximum age of the client cache entry`	408	`* @param int $maxage maximum age of the client cache entry`
409	`*/`	409	`*/`
410	`function setCacheControl($cache = 'public', $maxage = 0)`	410	`function setCacheControl($cache = 'public', $maxage = 0)`
411	`{`	411	`{`
412	`switch ($cache = strToLower($cache))`	412	`switch ($cache = strToLower($cache))`
413	`{`	413	`{`
414	`case 'private':`	414	`case 'private':`
415	`case 'public':`	415	`case 'public':`
416	`$this->headers['Cache-Control'] =`	416	`$this->headers['Cache-Control'] =`
417	`$cache .', must-revalidate, max-age='. abs($maxage);`	417	`$cache .', must-revalidate, max-age='. abs($maxage);`
418	`return true;`	418	`return true;`
419	`break;`	419	`break;`
420	`}`	420	`}`
421	`return false;`	421	`return false;`
422	`}`	422	`}`
423		423
424	`/**`	424	`/**`
425	`* Set ETag`	425	`* Set ETag`
426	`*`	426	`*`
427	`* Sets a user-defined ETag for cache-validation. The ETag is usually`	427	`* Sets a user-defined ETag for cache-validation. The ETag is usually`
428	`* generated by HTTP_Download through its payload information.`	428	`* generated by HTTP_Download through its payload information.`
429	`*`	429	`*`
430	`* @access public`	430	`* @access public`
431	`* @return void`	431	`* @return void`
432	`* @param string $etag Entity tag used for strong cache validation.`	432	`* @param string $etag Entity tag used for strong cache validation.`
433	`*/`	433	`*/`
434	`function setETag($etag = null)`	434	`function setETag($etag = null)`
435	`{`	435	`{`
436	`$this->etag = (string) $etag;`	436	`$this->etag = (string) $etag;`
437	`}`	437	`}`
438		438
439	`/**`	439	`/**`
440	`* Set Size of Buffer`	440	`* Set Size of Buffer`
441	`*`	441	`*`
442	`* The amount of bytes specified as buffer size is the maximum amount`	442	`* The amount of bytes specified as buffer size is the maximum amount`
443	`* of data read at once from resources or files. The default size is 2M`	443	`* of data read at once from resources or files. The default size is 2M`
444	`* (2097152 bytes). Be aware that if you enable gzip compression and`	444	`* (2097152 bytes). Be aware that if you enable gzip compression and`
445	`* you set a very low buffer size that the actual file size may grow`	445	`* you set a very low buffer size that the actual file size may grow`
446	`* due to added gzip headers for each sent chunk of the specified size.`	446	`* due to added gzip headers for each sent chunk of the specified size.`
447	`*`	447	`*`
448	`* Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_PARAM) if $size is not`	448	`* Returns PEAR_Error (HTTP_DOWNLOAD_E_INVALID_PARAM) if $size is not`
449	`* greater than 0 bytes.`	449	`* greater than 0 bytes.`
450	`*`	450	`*`
451	`* @access public`	451	`* @access public`
452	`* @return mixed Returns true on success or PEAR_Error on failure.`	452	`* @return mixed Returns true on success or PEAR_Error on failure.`
453	`* @param int $bytes Amount of bytes to use as buffer.`	453	`* @param int $bytes Amount of bytes to use as buffer.`
454	`*/`	454	`*/`
455	`function setBufferSize($bytes = 2097152)`	455	`function setBufferSize($bytes = 2097152)`
456	`{`	456	`{`
457	`if (0 >= $bytes) {`	457	`if (0 >= $bytes) {`
458	`return PEAR::raiseError(`	458	`return PEAR::raiseError(`
459	`'Buffer size must be greater than 0 bytes ('. $bytes .' given)',`	459	`'Buffer size must be greater than 0 bytes ('. $bytes .' given)',`
460	`HTTP_DOWNLOAD_E_INVALID_PARAM);`	460	`HTTP_DOWNLOAD_E_INVALID_PARAM);`
461	`}`	461	`}`
462	`$this->bufferSize = abs($bytes);`	462	`$this->bufferSize = abs($bytes);`
463	`return true;`	463	`return true;`
464	`}`	464	`}`
465		465
466	`/**`	466	`/**`
467	`* Set Throttle Delay`	467	`* Set Throttle Delay`
468	`*`	468	`*`
469	`* Set the amount of seconds to sleep after each chunck that has been`	469	`* Set the amount of seconds to sleep after each chunck that has been`
470	`* sent. One can implement some sort of throttle through adjusting the`	470	`* sent. One can implement some sort of throttle through adjusting the`
471	`* buffer size and the throttle delay. With the following settings`	471	`* buffer size and the throttle delay. With the following settings`
472	`* HTTP_Download will sleep a second after each 25 K of data sent.`	472	`* HTTP_Download will sleep a second after each 25 K of data sent.`
473	`*`	473	`*`
474	`* <code>`	474	`* <code>`
475	`* Array(`	475	`* Array(`
476	`* 'throttledelay' => 1,`	476	`* 'throttledelay' => 1,`
477	`* 'buffersize' => 1024 * 25,`	477	`* 'buffersize' => 1024 * 25,`
478	`* )`	478	`* )`
479	`* </code>`	479	`* </code>`
480	`*`	480	`*`
481	`* Just be aware that if gzipp'ing is enabled, decreasing the chunk size`	481	`* Just be aware that if gzipp'ing is enabled, decreasing the chunk size`
482	`* too much leads to proportionally increased network traffic due to added`	482	`* too much leads to proportionally increased network traffic due to added`
483	`* gzip header and bottom bytes around each chunk.`	483	`* gzip header and bottom bytes around each chunk.`
484	`*`	484	`*`
485	`* @access public`	485	`* @access public`
486	`* @return void`	486	`* @return void`
487	`* @param float $seconds Amount of seconds to sleep after each`	487	`* @param float $seconds Amount of seconds to sleep after each`
488	`* chunk that has been sent.`	488	`* chunk that has been sent.`
489	`*/`	489	`*/`
490	`function setThrottleDelay($seconds = 0)`	490	`function setThrottleDelay($seconds = 0)`
491	`{`	491	`{`
492	`$this->throttleDelay = abs($seconds) * 1000;`	492	`$this->throttleDelay = abs($seconds) * 1000;`
493	`}`	493	`}`
494		494
495	`/**`	495	`/**`
496	`* Set "Last-Modified"`	496	`* Set "Last-Modified"`
497	`*`	497	`*`
498	`* This is usually determined by filemtime() in HTTP_Download::setFile()`	498	`* This is usually determined by filemtime() in HTTP_Download::setFile()`
499	`* If you set raw data for download with HTTP_Download::setData() and you`	499	`* If you set raw data for download with HTTP_Download::setData() and you`
500	`* want do send an appropiate "Last-Modified" header, you should call this`	500	`* want do send an appropiate "Last-Modified" header, you should call this`

Subversion Repositories Sites.obs-saisons.fr

(root)/trunk/applications/jrest/lib/HTTP/Download.php @ 282 – Rev 31 → 316