file.php

This is the script which used on 10minutemail.com for temporary email.

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * File
 * 
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to [e-mail] so we can mail you a copy immediately.
 *
 * @category    File
 * @package     File
 * @author      Richard Heyes <[e-mail]>
 * @author      Tal Peer <[e-mail]>
 * @author      Michael Wallner <[e-mail]>
 * @copyright   2002-2005 The Authors
 * @license     http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version     CVS: $Id: File.php,v 1.29 2005/03/30 18:23:58 mike Exp $
 * @link        http://pear.php.net/package/File
 */

/**
 * Requires PEAR
 */
require_once 'PEAR.php';

/**
 * The default number of bytes for reading
 */
if (!defined('FILE_DEFAULT_READSIZE')) {
    define('FILE_DEFAULT_READSIZE', 1024, true);
}

/**
 * The maximum number of bytes for reading lines
 */
if (!defined('FILE_MAX_LINE_READSIZE')) {
    define('FILE_MAX_LINE_READSIZE', 8192000, true);
}

/**
 * Whether file locks should block
 */
if (!defined('FILE_LOCKS_BLOCK')) {
    define('FILE_LOCKS_BLOCK', true, true);
}

/**
 * Mode to use for reading from files
 */
define('FILE_MODE_READ', 'rb', true);

/**
 * Mode to use for truncating files, then writing
 */
define('FILE_MODE_WRITE', 'wb', true);

/**
 * Mode to use for appending to files
 */
define('FILE_MODE_APPEND', 'ab', true);

/**
 * Use this when a shared (read) lock is required
 */
define('FILE_LOCK_SHARED', LOCK_SH | (FILE_LOCKS_BLOCK ? 0 : LOCK_NB), true);

/**
 * Use this when an exclusive (write) lock is required
 */
define('FILE_LOCK_EXCLUSIVE', LOCK_EX | (FILE_LOCKS_BLOCK ? 0 : LOCK_NB), true);

/**
 * Class for handling files
 * 
 * A class with common functions for writing,
 * reading and handling files and directories
 * 
 * @author  Richard Heyes <[e-mail]>
 * @author  Tal Peer <[e-mail]>
 * @author  Michael Wallner <[e-mail]>
 * @access  public 
 * @package File
 * 
 * @static
 */
class File extends PEAR 
{
    /**
     * Destructor
     * 
     * Unlocks any locked file pointers and closes all filepointers
     * 
     * @access private 
     */
    function _File()
    {
        File::closeAll();
    }
    
    /**
     * Handles file pointers. If a file pointer needs to be opened,
     * it will be. If it already exists (based on filename and mode)
     * then the existing one will be returned.
     * 
     * @access  private 
     * @param   string  $filename Filename to be used
     * @param   string  $mode Mode to open the file in
     * @param   mixed   $lock Type of lock to use
     * @return  mixed   PEAR_Error on error or file pointer resource on success
     */
    function &_getFilePointer($filename, $mode, $lock = false)
    {
        $filePointers = &PEAR::getStaticProperty('File', 'filePointers');
        
        // Win32 is case-insensitive
        if (OS_WINDOWS) {
            $filename = strToLower($filename);
        }
        
        // check if file pointer already exists
        if (    !isset($filePointers[$filename][$mode]) || 
                !is_resource($filePointers[$filename][$mode])) {
            
            // check if we can open the file in the desired mode
            switch ($mode)
            {
                case FILE_MODE_READ:
                    if (    !preg_match('/^.+(?<!file):\/\//i', $filename) &&
                            !file_exists($filename)) {
                        return PEAR::raiseError("File does not exist: $filename");
                    }
                break;
                
                case FILE_MODE_APPEND:
                case FILE_MODE_WRITE:
                    if (file_exists($filename)) {
                        if (!is_writable($filename)) {
                            return PEAR::raiseError("File is not writable: $filename");
                        }
                    } elseif (!is_writable($dir = dirname($filename))) {
                        return PEAR::raiseError("Cannot create file in directory: $dir");
                    }
                break;
                
                default:
                    return PEAR::raiseError("Invalid access mode: $mode");
            }
            
            // open file
            $filePointers[$filename][$mode] = @fopen($filename, $mode);
            if (!is_resource($filePointers[$filename][$mode])) {
                return PEAR::raiseError('Failed to open file: ' . $filename);
            }
        }
        
        // lock file
        if ($lock) {
            $lock = $mode == FILE_MODE_READ ? FILE_LOCK_SHARED : FILE_LOCK_EXCLUSIVE;
            $locks = &PEAR::getStaticProperty('File', 'locks');
            if (@flock($filePointers[$filename][$mode], $lock)) {
                $locks[] = &$filePointers[$filename][$mode];
            } elseif (FILE_LOCKS_BLOCK) {
                return PEAR::raiseError("File already locked: $filename");
            } else {
                return PEAR::raiseError("Could not lock file: $filename");
            }
        }
        
        return $filePointers[$filename][$mode];
    } 

    /**
     * Reads an entire file and returns it.
     * Uses file_get_contents if available.
     * 
     * @access  public 
     * @param   string  $filename Name of file to read from
     * @param   mixed   $lock Type of lock to use
     * @return  mixed   PEAR_Error if an error has occured or a string with the contents of the the file
     */
    function readAll($filename, $lock = false)
    {
        if (function_exists('file_get_contents')) {
            if (false === $file = @file_get_contents($filename)) {
                return PEAR::raiseError("Cannot read file: $filename");
            }
            return $file;
        }
        
        $file = '';
        while (false !== $buf = File::read($filename, FILE_DEFAULT_READSIZE, $lock)) {
            if (PEAR::isError($buf)) {
                return $buf;
            }
            $file .= $buf;
        }
        
        // close the file pointer
        File::close($filename, FILE_MODE_READ);
        
        return $file;
    }

    /**
     * Returns a specified number of bytes of a file. 
     * Defaults to FILE_DEFAULT_READSIZE.  If $size is 0, all file will be read.
     * 
     * @access  public 
     * @param   string  $filename Name of file to read from
     * @param   integer $size Bytes to read
     * @param   mixed   $lock Type of lock to use
     * @return  mixed   PEAR_Error on error or a string which contains the data read
     *                  Will also return false upon EOF
     */
    function read($filename, $size = FILE_DEFAULT_READSIZE, $lock = false)
    {
        static $filePointers;
        
        if (0 == $size) {
            return File::readAll($filename, $lock);
        } 

        if (    !isset($filePointers[$filename]) || 
                !is_resource($filePointers[$filename])) {
            if (PEAR::isError($fp = &File::_getFilePointer($filename, FILE_MODE_READ, $lock))) {
                return $fp;
            } 

            $filePointers[$filename] = &$fp;
        } else {
            $fp = &$filePointers[$filename];
        } 

        return !feof($fp) ? fread($fp, $size) : false;
    } 

    /**
     * Writes the given data to the given filename. 
     * Defaults to no lock, append mode.
     * 
     * @access  public 
     * @param   string  $filename Name of file to write to
     * @param   string  $data Data to write to file
     * @param   string  $mode Mode to open file in
     * @param   mixed   $lock Type of lock to use
     * @return  mixed   PEAR_Error on error or number of bytes written to file.
     */
    function write($filename, $data, $mode = FILE_MODE_APPEND, $lock = false)
    {
        if (PEAR::isError($fp = &File::_getFilePointer($filename, $mode, $lock))) {
            return $fp;
        }
        if (-1 === $bytes = @fwrite($fp, $data, strlen($data))) {
            return PEAR::raiseError("Cannot write data: '$data' to file: '$filename'");
        }
        return $bytes;
    } 

    /**
     * Reads and returns a single character from given filename
     *