CodeIgniter - MY_upload - upload multiple files

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');

    /*
    Class: MY_Upload (Helper)

    Description:
        A helper class that extends the CI_Upload class.
    */
    class MY_Upload extends CI_Upload {

        public $ip_address = '';
        /*
            Function: upload_files()

            Description:
                Uploads the files.

            Parameters:
                $files - An array files we are trying to upload

            Returns:
                Object -> status
                        TRUE - If all the files have been uploaded successfully
                        FALSE - IF nothing was uploaded or there was an error
                Object -> file_info
                        An array containing the file information as returned from this->data

            See Also:
                <do_upload_array>
                <data>
        */
        public function upload_files($files)
        {
            $response = new stdClass();
            $response->status = FALSE;

            if (isset($files))
            {
                foreach ($files as $field => $file)
                {
                    foreach($file as $key => $config)
                    {
                        $this->initialize($config);
                        $upload = $this->do_upload_array($field, $key);

                            if($upload->status)
                            {
                                $response->status = TRUE;
                                $response->file_info[] = $upload->file_info;
                            }else{
                                $response->status = FALSE;
                            }
                    }
                }
            }
            return $response;
        }


        // --------------------------------------------------------------------

        /**
         * Initialize preferences
         *
         * @param   array
         * @return  void
         */
        public function initialize($config = array())
        {
            $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'       => '',
                'ip_address'         => $_SERVER['REMOTE_ADDR']
            );


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

            // if a file_name was provided in the config, use it instead of the user input
            // supplied file name for all uploads until initialized again
            $this->_file_name_override = $this->file_name;
        }

        // --------------------------------------------------------------------

        /**
         * Finalized Data Array
         *
         * Returns an associative array containing all of the information
         * related to the upload, allowing the developer easy access in one array.
         *
         * @return  array
         */
        public function data()
        {
            return 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,
                'ip_address'         => $this->ip_address
            );
        }


        // --------------------------------------------------------------------
        /*
            Function: do_upload_array()

            Description:
                Uploads the files.

            Parameters:
                $field - Refers to the name of the field element
                $key - Refers to the array of the field element

            Returns:
                Object -> status
                    TRUE - If all the files have been uploaded successfully
                    FALSE - If there are errors
                Object -> file_info
                        An array containing the file information as returned from this->data

            See Also:
                <upload_files>
                <validate_upload_path>
        */
        public function do_upload_array($field, $key, $index='')
        {
            $response = new stdClass();
            $response->status = FALSE;

            // Is $_FILES[$field] set? If not, no reason to continue.
            if (!isset($_FILES[$field]))
            {
                $this->set_error('upload_no_file_selected');
                return $response;
            }

            // Is the upload path valid?
            if ( ! $this->validate_upload_path())
            {
                // errors will already be set by validate_upload_path() so just return $response
                return $response;
            }

            if($index !== ''){
                // Was the file able to be uploaded? If not, determine the reason why.
                if ( ! is_uploaded_file($_FILES[$field]['tmp_name'][$index][$key]))
                {
                    $error = ( ! isset($_FILES[$field]['error'][$index][$key])) ? 4 : $_FILES[$field]['error'][$index][$key];

                    switch($error)
                    {
                        case 1: // UPLOAD_ERR_INI_SIZE
                            $this->set_error('upload_file_exceeds_limit');
                            break;
                        case 2: // UPLOAD_ERR_FORM_SIZE
                            $this->set_error('upload_file_exceeds_form_limit');
                            break;
                        case 3: // UPLOAD_ERR_PARTIAL
                            $this->set_error('upload_file_partial');
                            break;
                        case 4: // UPLOAD_ERR_NO_FILE
                            $this->set_error('upload_no_file_selected');
                            break;
                        case 6: // UPLOAD_ERR_NO_TMP_DIR
                            $this->set_error('upload_no_temp_directory');
                            break;
                        case 7: // UPLOAD_ERR_CANT_WRITE
                            $this->set_error('upload_unable_to_write_file');
                            break;
                        case 8: // UPLOAD_ERR_EXTENSION
                            $this->set_error('upload_stopped_by_extension');
                            break;
                        default :   $this->set_error('upload_no_file_selected');
                        break;
                    }

                    return $response;
                }


                // Set the uploaded data as class variables
                $this->file_temp = $_FILES[$field]['tmp_name'][$index][$key];
                $this->file_size = $_FILES[$field]['size'][$index][$key];
                $this->file_type = preg_replace("/^(.+?);.*$/", "\\1", $_FILES[$field]['type'][$index][$key]);
                $this->file_type = strtolower(trim(stripslashes($this->file_type), '"'));
                $this->file_name = $this->_prep_filename($_FILES[$field]['name'][$index][$key]);
                $this->file_ext  = $this->get_extension($this->file_name);
                $this->client_name = $this->file_name;
            }else{
                // Was the file able to be uploaded? If not, determine the reason why.
                if ( ! is_uploaded_file($_FILES[$field]['tmp_name'][$key]))
                {
                    $error = ( ! isset($_FILES[$field]['error'][$key])) ? 4 : $_FILES[$field]['error'][$key];

                    switch($error)
                    {
                        case 1: // UPLOAD_ERR_INI_SIZE
                            $this->set_error('upload_file_exceeds_limit');
                            break;
                        case 2: // UPLOAD_ERR_FORM_SIZE
                            $this->set_error('upload_file_exceeds_form_limit');
                            break;
                        case 3: // UPLOAD_ERR_PARTIAL
                            $this->set_error('upload_file_partial');
                            break;
                        case 4: // UPLOAD_ERR_NO_FILE
                            $this->set_error('upload_no_file_selected');
                            break;
                        case 6: // UPLOAD_ERR_NO_TMP_DIR
                            $this->set_error('upload_no_temp_directory');
                            break;
                        case 7: // UPLOAD_ERR_CANT_WRITE
                            $this->set_error('upload_unable_to_write_file');
                            break;
                        case 8: // UPLOAD_ERR_EXTENSION
                            $this->set_error('upload_stopped_by_extension');
                            break;
                        default :   $this->set_error('upload_no_file_selected');
                        break;
                    }

                    return $response;
                }


                // Set the uploaded data as class variables
                $this->file_temp = $_FILES[$field]['tmp_name'][$key];
                $this->file_size = $_FILES[$field]['size'][$key];
                $this->file_type = preg_replace("/^(.+?);.*$/", "\\1", $_FILES[$field]['type'][$key]);
                $this->file_type = strtolower(trim(stripslashes($this->file_type), '"'));
                $this->file_name = $this->_prep_filename($_FILES[$field]['name'][$key]);
                $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 $response;
            }

            // if we're overriding, let's now make sure the new name and type is allowed
            if ($this->_file_name_override != '')
            {
                $this->file_name = $this->_prep_filename($this->_file_name_override);

                // If no extension was provided in the file_name config item, use the uploaded one
                if (strpos($this->_file_name_override, '.') === FALSE)
                {
                    $this->file_name .= $this->file_ext;
                }

                // An extension was provided, lets have it!
                else
                {
                    $this->file_ext  = $this->get_extension($this->_file_name_override);
                }

                if ( ! $this->is_allowed_filetype(TRUE))
                {
                    $this->set_error('upload_invalid_filetype');
                    return $response;
                }
            }

            // 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 $response;
            }

            // 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 $response;
            }

            // Sanitize the file name for security
            $this->file_name = $this->clean_file_name($this->file_name);

            // Truncate the file name if it'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 $response;
                }
            }

            /*
             * 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 $response;
                }
            }

            /*
             * Move the file to the final destination
             * To deal with different server configurations
             * we'll attempt to use copy() first.  If that fails
             * we'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 $response;
                }
            }

            /*
             * 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);

            $response->status = TRUE;
            $response->file_info = $this->data();
            return $response;
        }

        /**
         * Validate Upload Path
         *
         * Verifies that it is a valid upload path with proper permissions.
         *
         * ADDED: Creates directory if the directory doesn't exist
         *
         * @return  bool
         */
        public function validate_upload_path()
        {
            if ($this->upload_path == '')
            {
                $this->set_error('upload_no_filepath');
                return FALSE;
            }

            if (function_exists('realpath') AND @realpath($this->upload_path) !== FALSE)
            {
                $this->upload_path = str_replace("\\", "/", realpath($this->upload_path));
            }

            if ( ! @is_dir($this->upload_path))
            {
                if(!mkdir($this->upload_path, 0777, true))
                {
                    $this->set_error('upload_no_filepath');
                    return FALSE;
                }
            }

            if ( ! is_really_writable($this->upload_path))
            {
                $this->set_error('upload_not_writable');
                return FALSE;
            }

            $this->upload_path = preg_replace("/(.+?)\/*$/", "\\1/",  $this->upload_path);
            return TRUE;
        }
    }