Home > php教程 > PHP源码 > CodeIgniter多文件上传

CodeIgniter多文件上传

PHP中文网
Release: 2016-05-25 16:59:59
Original
1100 people have browsed it

CodeIgniter多文件上传

<?php if(!defined("BASEPATH")){ exit("No direct script access allowed"); }
 
    /**
     * Multi-Upload
     * 
     * Extends CodeIgniters native Upload class to add support for multiple
     * uploads.
     *
     * @package     CodeIgniter
     * @subpackage  Libraries
     * @category    Uploads
     * @author      Conveyor Group <steven@conveyorgroup.com>
     * @link        https://github.com/stvnthomas/CodeIgniter-2.1-Multi-Upload
     */
        class MY_Upload extends CI_Upload {
 
 
            /**
             * Properties
             */
                protected $_multi_upload_data           = array();
                protected $_multi_file_name_override    = "";
 
 
            /**
             * Initialize preferences
             *
             * @access  public
             * @param   array
             * @return  void
             */
                public function initialize($config = array()){
                    //Upload default settings.
                    $defaults = array(
                                    "max_size"          => 0,
                                    "max_width"         => 0,
                                    "max_height"        => 0,
                                    "max_filename"      => 0,
                                    "allowed_types"     => "",
                                    "file_temp"         => "",
                                    "file_name"         => "",
                                    "orig_name"         => "",
                                    "file_type"         => "",
                                    "file_size"         => "",
                                    "file_ext"          => "",
                                    "upload_path"       => "",
                                    "overwrite"         => FALSE,
                                    "encrypt_name"      => FALSE,
                                    "is_image"          => FALSE,
                                    "image_width"       => "",
                                    "image_height"      => "",
                                    "image_type"        => "",
                                    "image_size_str"    => "",
                                    "error_msg"         => array(),
                                    "mimes"             => array(),
                                    "remove_spaces"     => TRUE,
                                    "xss_clean"         => FALSE,
                                    "temp_prefix"       => "temp_file_",
                                    "client_name"       => ""
                                );
 
                    //Set each configuration.
                    foreach($defaults as $key => $val){
                        if(isset($config[$key])){
                            $method = "set_{$key}";
                            if(method_exists($this, $method)){
                                $this->$method($config[$key]);
                            } else {
                                $this->$key = $config[$key];
                            }
                        } else {
                            $this->$key = $val;
                        }
                    }
 
                    //Check if file_name was provided.
                    if(!empty($this->file_name)){
                        //Multiple file upload.
                        if(is_array($this->file_name)){
                            //Clear file name override.
                            $this->_file_name_override = "";
 
                            //Set multiple file name override.
                            $this->_multi_file_name_override = $this->file_name;
                        //Single file upload.
                        } else {
                            //Set file name override.
                            $this->_file_name_override = $this->file_name;
 
                            //Clear multiple file name override.
                            $this->_multi_file_name_override = "";
                        }
                    }
                }
 
 
            /**
             * File MIME Type
             * 
             * Detects the (actual) MIME type of the uploaded file, if possible.
             * The input array is expected to be $_FILES[$field].
             * 
             * In the case of multiple uploads, a optional second argument may be
             * passed specifying which array element of the $_FILES[$field] array
             * elements should be referenced (name, type, tmp_name, etc).
             *
             * @access  protected
             * @param   $file   array
             * @param   $count  int
             * @return  void
             */
                protected function _file_mime_type($file, $count=0){
                    //Mutliple file?
                    if(is_array($file["name"])){
                        $tmp_name = $file["tmp_name"][$count];
                        $type = $file["type"][$count];
                    //Single file.
                    } else {
                        $tmp_name = $file["tmp_name"];
                        $type = $file["type"];
                    }
 
                    //We&#39;ll need this to validate the MIME info string (e.g. text/plain; charset=us-ascii).
                    $regexp = "/^([a-z\-]+\/[a-z0-9\-\.\+]+)(;\s.+)?$/";
 
                    /* Fileinfo Extension - most reliable method.
                     * 
                     * Unfortunately, prior to PHP 5.3 - it&#39;s only available as a PECL extension and the
                     * more convenient FILEINFO_MIME_TYPE flag doesn&#39;t exist.
                     */
                        if(function_exists("finfo_file")){
                            $finfo = finfo_open(FILEINFO_MIME);
                            if(is_resource($finfo)){
                                $mime = @finfo_file($finfo, $tmp_name);
                                finfo_close($finfo);
 
                                /* According to the comments section of the PHP manual page,
                                 * it is possible that this function returns an empty string
                                 * for some files (e.g. if they don&#39;t exist in the magic MIME database).
                                 */
                                    if(is_string($mime) && preg_match($regexp, $mime, $matches)){
                                        $this->file_type = $matches[1];
                                        return;
                                    }
                            }
                        }
 
               /* This is an ugly hack, but UNIX-type systems provide a "native" way to detect the file type,
              * which is still more secure than depending on the value of $_FILES[$field][&#39;type&#39;], and as it
                 * was reported in issue #750 (https://github.com/EllisLab/CodeIgniter/issues/750) - it&#39;s better
                     * than mime_content_type() as well, hence the attempts to try calling the command line with
                     * three different functions.
                     *
                     * Notes:
                     *  - the DIRECTORY_SEPARATOR comparison ensures that we&#39;re not on a Windows system
                     *  - many system admins would disable the exec(), shell_exec(), popen() and similar functions
                     *    due to security concerns, hence the function_exists() checks
                     */
                        if(DIRECTORY_SEPARATOR !== "\\"){
                            $cmd = "file --brief --mime ".escapeshellarg($tmp_name)." 2>&1";
 
                            if(function_exists("exec")){
                                /* This might look confusing, as $mime is being populated with all of the output when set in the second parameter.
                                 * However, we only neeed the last line, which is the actual return value of exec(), and as such - it overwrites
                                 * anything that could already be set for $mime previously. This effectively makes the second parameter a dummy
                                 * value, which is only put to allow us to get the return status code.
                                 */
                                    $mime = @exec($cmd, $mime, $return_status);
                                    if($return_status === 0 && is_string($mime) && preg_match($regexp, $mime, $matches)){
                                        $this->file_type = $matches[1];
                                        return;
                                    }
                            }
                        }
 
                        if((bool)@ini_get("safe_mode") === FALSE && function_exists("shell_exec")){
                            $mime = @shell_exec($cmd);
                            if(strlen($mime) > 0){
                                $mime = explode("\n", trim($mime));
                                if(preg_match($regexp, $mime[(count($mime) - 1)], $matches)){
                                    $this->file_type = $matches[1];
                                    return;
                                }
                            }
                        }
 
                        if(function_exists("popen")){
                            $proc = @popen($cmd, "r");
                            if(is_resource($proc)){
                                $mime = @fread($proc, 512);
                                @pclose($proc);
                                if($mime !== FALSE){
                                    $mime = explode("\n", trim($mime));
                                    if(preg_match($regexp, $mime[(count($mime) - 1)], $matches)){
                                        $this->file_type = $matches[1];
                                        return;
                                    }
                                }
                            }
                        }
 
                        //Fall back to the deprecated mime_content_type(), if available (still better than $_FILES[$field]["type"])
                        if(function_exists("mime_content_type")){
                            $this->file_type = @mime_content_type($tmp_name);
                            //It&#39;s possible that mime_content_type() returns FALSE or an empty string.
                            if(strlen($this->file_type) > 0){
                                return;
                            }
                        }
 
                        //If all else fails, use $_FILES default mime type.
                        $this->file_type = $type;
                }
 
 
            /**
             * Set Multiple Upload Data
             *
             * @access  protected
             * @return  void
             */
                protected function set_multi_upload_data(){
                    $this->_multi_upload_data[] = array(
                        "file_name"         => $this->file_name,
                        "file_type"         => $this->file_type,
                        "file_path"         => $this->upload_path,
                        "full_path"         => $this->upload_path.$this->file_name,
                        "raw_name"          => str_replace($this->file_ext, "", $this->file_name),
                        "orig_name"         => $this->orig_name,
                        "client_name"       => $this->client_name,
                        "file_ext"          => $this->file_ext,
                        "file_size"         => $this->file_size,
                        "is_image"          => $this->is_image(),
                        "image_width"       => $this->image_width,
                        "image_height"      => $this->image_height,
                        "image_type"        => $this->image_type,
                        "image_size_str"    => $this->image_size_str
                    );
                }
 
 
            /**
             * Get Multiple Upload Data
             *
             * @access  public
             * @return  array
             */
                public function get_multi_upload_data(){
                    return $this->_multi_upload_data;
                }
 
 
            /**
             * Multile File Upload
             *
             * @access  public
             * @param   string
             * @return  mixed
             */
                public function do_multi_upload($field){
                    //Is $_FILES[$field] set? If not, no reason to continue.
                    if(!isset($_FILES[$field])){ return false; }
 
                    //Is this really a multi upload?
                    if(!is_array($_FILES[$field]["name"])){
                        //Fallback to do_upload method.
                        return $this->do_upload($field);
                    }
 
                    //Is the upload path valid?
                    if(!$this->validate_upload_path()){
                        //Errors will already be set by validate_upload_path() so just return FALSE
                        return FALSE;
                    }
 
                    //Every file will have a separate entry in each of the $_FILES associative array elements (name, type, etc).
                    //Loop through $_FILES[$field]["name"] as representative of total number of files. Use count as key in
                    //corresponding elements of the $_FILES[$field] elements.
                    for($i=0; $i<count($_FILES[$field]["name"]); $i++){
                        //Was the file able to be uploaded? If not, determine the reason why.
                        if(!is_uploaded_file($_FILES[$field]["tmp_name"][$i])){
                            //Determine error number.
                            $error = (!isset($_FILES[$field]["error"][$i])) ? 4 : $_FILES[$field]["error"][$i];
 
                            //Set error.
                            switch($error){
                                //UPLOAD_ERR_INI_SIZE
                                case 1:
                                    $this->set_error("upload_file_exceeds_limit");
                                break;
                                //UPLOAD_ERR_FORM_SIZE
                                case 2:
                                    $this->set_error("upload_file_exceeds_form_limit");
                                break;
                                //UPLOAD_ERR_PARTIAL
                                case 3:
                                    $this->set_error("upload_file_partial");
                                break;
                                //UPLOAD_ERR_NO_FILE
                                case 4:
                                    $this->set_error("upload_no_file_selected");
                                break;
                                //UPLOAD_ERR_NO_TMP_DIR
                                case 6:
                                    $this->set_error("upload_no_temp_directory");
                                break;
                                //UPLOAD_ERR_CANT_WRITE
                                case 7:
                                    $this->set_error("upload_unable_to_write_file");
                                break;
                                //UPLOAD_ERR_EXTENSION
                                case 8:
                                    $this->set_error("upload_stopped_by_extension");
                                break;
                                default:
                                    $this->set_error("upload_no_file_selected");
                                break;
                            }
 
                            //Return failed upload.
                            return FALSE;
                        }
 
                        //Set current file data as class variables.
                        $this->file_temp = $_FILES[$field]["tmp_name"][$i];
                        $this->file_size = $_FILES[$field]["size"][$i];
                        $this->_file_mime_type($_FILES[$field], $i);
                        $this->file_type = preg_replace("/^(.+?);.*$/", "\\1", $this->file_type);
                        $this->file_type = strtolower(trim(stripslashes($this->file_type), &#39;"&#39;));
                        $this->file_name = $this->_prep_filename($_FILES[$field]["name"][$i]);
                        $this->file_ext      = $this->get_extension($this->file_name);
                        $this->client_name   = $this->file_name;
 
                        //Is the file type allowed to be uploaded?
                        if(!$this->is_allowed_filetype()){
                            $this->set_error("upload_invalid_filetype");
                            return FALSE;
                        }
 
                        //If we&#39;re overriding, let&#39;s now make sure the new name and type is allowed.
                        //Check if a filename was supplied for the current file. Otherwise, use it&#39;s given name.
                        if(!empty($this->_multi_file_name_override[$i])){
                            $this->file_name = $this->_prep_filename($this->_multi_file_name_override[$i]);
 
                            //If no extension was provided in the file_name config item, use the uploaded one.
                            if(strpos($this->_multi_file_name_override[$i], ".") === FALSE){
                                $this->file_name .= $this->file_ext;
                            //An extension was provided, lets have it!
                            } else {
                                $this->file_ext = $this->get_extension($this->_multi_file_name_override[$i]);
                            }
 
                            if(!$this->is_allowed_filetype(TRUE)){
                                $this->set_error("upload_invalid_filetype");
                                return FALSE;
                            }
                        }
 
                        //Convert the file size to kilobytes.
                        if($this->file_size > 0){
                            $this->file_size = round($this->file_size/1024, 2);
                        }
 
                        //Is the file size within the allowed maximum?
                        if(!$this->is_allowed_filesize()){
                            $this->set_error("upload_invalid_filesize");
                            return FALSE;
                        }
 
                        //Are the image dimensions within the allowed size?
                        //Note: This can fail if the server has an open_basdir restriction.
                        if(!$this->is_allowed_dimensions()){
                            $this->set_error("upload_invalid_dimensions");
                            return FALSE;
                        }
 
                        //Sanitize the file name for security.
                        $this->file_name = $this->clean_file_name($this->file_name);
 
                        //Truncate the file name if it&#39;s too long
                        if($this->max_filename > 0){
                            $this->file_name = $this->limit_filename_length($this->file_name, $this->max_filename);
                        }
 
                        //Remove white spaces in the name
                        if($this->remove_spaces == TRUE){
                            $this->file_name = preg_replace("/\s+/", "_", $this->file_name);
                        }
 
                        /* Validate the file name
                         * This function appends an number onto the end of
                         * the file if one with the same name already exists.
                         * If it returns false there was a problem.
                         */
                            $this->orig_name = $this->file_name;
                            if($this->overwrite == FALSE){
                                $this->file_name = $this->set_filename($this->upload_path, $this->file_name);
                                if($this->file_name === FALSE){
                                    return FALSE;
                                }
                            }
 
                        /* Run the file through the XSS hacking filter
                         * This helps prevent malicious code from being
                         * embedded within a file.  Scripts can easily
                         * be disguised as images or other file types.
                         */
                            if($this->xss_clean){
                                if($this->do_xss_clean() === FALSE){
                                    $this->set_error("upload_unable_to_write_file");
                                    return FALSE;
                                }
                            }
 
                        /* Move the file to the final destination
                         * To deal with different server configurations
                         * we&#39;ll attempt to use copy() first.  If that fails
                         * we&#39;ll use move_uploaded_file().  One of the two should
                         * reliably work in most environments
                         */
                            if(!@copy($this->file_temp, $this->upload_path.$this->file_name)){
                                if(!@move_uploaded_file($this->file_temp, $this->upload_path.$this->file_name)){
                                    $this->set_error("upload_destination_error");
                                    return FALSE;
                                }
                            }
 
                        /* Set the finalized image dimensions
                         * This sets the image width/height (assuming the
                         * file was an image).  We use this information
                         * in the "data" function.
                         */
                            $this->set_image_properties($this->upload_path.$this->file_name);
 
                        //Set current file data to multi_file_upload_data.
                        $this->set_multi_upload_data();
                    }
 
                    //Return all file upload data.
                    return TRUE;
            }
        }
Copy after login

 以上就是CodeIgniter多文件上传的内容,更多相关内容请关注PHP中文网(www.php.cn)! 


Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Recommendations
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template